code: def token_network_connect(
              self,
              registry_address: PaymentNetworkID,
              token_address: TokenAddress,
              funds: TokenAmount,
              initial_channel_target: int = 3,
              joinable_funds_target: float = 0.4,
      ) -> None:
          
          if not is_binary_address(registry_address):
              raise InvalidAddress('registry_address must be a valid address in binary')
          if not is_binary_address(token_address):
              raise InvalidAddress('token_address must be a valid address in binary')
  
          token_network_identifier = views.get_token_network_identifier_by_token_address(
              chain_state=views.state_from_raiden(self.raiden),
              payment_network_id=registry_address,
              token_address=token_address,
          )
  
          connection_manager = self.raiden.connection_manager_for_token_network(
              token_network_identifier,
          )
  
          has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
              raiden=self.raiden,
              channels_to_open=initial_channel_target,
          )
  
          if not has_enough_reserve:
              raise InsufficientGasReserve((
                  'The account balance is below the estimated amount necessary to '
                  'finish the lifecycles of all active channels. A balance of at '
                  f'least {estimated_required_reserve} wei is required.'
              ))
  
          connection_manager.connect(
              funds=funds,
              initial_channel_target=initial_channel_target,
              joinable_funds_target=joinable_funds_target,
          )
docs: Automatically maintain channels open for the given token network.
  
          Args:
              token_address: the ERC20 token network to connect to.
              funds: the amount of funds that can be used by the ConnectionMananger.
              initial_channel_target: number of channels to open proactively.
              joinable_funds_target: fraction of the funds that will be used to join
                  channels opened by other participants.