code: def register_token(
              self,
              registry_address_hex: typing.AddressHex,
              token_address_hex: typing.AddressHex,
              retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
      ) -> TokenNetwork:
          
          registry_address = decode_hex(registry_address_hex)
          token_address = decode_hex(token_address_hex)
  
          registry = self._raiden.chain.token_network_registry(registry_address)
          contracts_version = self._raiden.contract_manager.contracts_version
  
          if contracts_version == DEVELOPMENT_CONTRACT_VERSION:
              token_network_address = registry.add_token_with_limits(
                  token_address=token_address,
                  channel_participant_deposit_limit=UINT256_MAX,
                  token_network_deposit_limit=UINT256_MAX,
              )
          else:
              token_network_address = registry.add_token_without_limits(
                  token_address=token_address,
              )
  
          # Register the channel manager with the raiden registry
          waiting.wait_for_payment_network(
              self._raiden,
              registry.address,
              token_address,
              retry_timeout,
          )
  
          return self._raiden.chain.token_network(token_network_address)
docs: Register a token with the raiden token manager.
  
          Args:
              registry_address: registry address
              token_address_hex (string): a hex encoded token address.
  
          Returns:
  
              The token network proxy.