coinbase-sdk 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2952835a61e4e744db044ab91e1cf58000d578967783d6faf9da77e495790172
-  data.tar.gz: '00378e6bfb704f649d3943bd26da6712e41a9852ca2e4650c168ea098061a8b1'
+  metadata.gz: c18b015a028c3b795a618318ab244f31d58861f66f67e6d76a7b70ee3b664e2f
+  data.tar.gz: c82577524824f743ac16624ffc042c2017183d366a5c849d1baa3d2028b85c96
 SHA512:
-  metadata.gz: 10a9d9e6288bc1ab73b94be7e0cab8a37e64fa0398e644e570d385c342dd4a46d084e454f56acff0692c82424801ad92479a3ca7e4745d860c51086f28f559dd
-  data.tar.gz: 131176725ada80cb046882a5fce27ec6355dd7395adf33cadace6f17507b326563ae4f945ceebc4566a10f94e815fda0fbcc3d735e7f7959d4a0b1da65e29b1e
+  metadata.gz: 92efa9bc82a0d753698bae8de9e60768c696ce6ef5019cbb3eab6ae7bd25d9257f289dd95164a6440a7f25f0cd90b02a0d267b07ea1d82ebe6b0d4cb142fe82f
+  data.tar.gz: 204120f5e22ec7bfd4b87f0e09bdd8600740106d11a0e7d04264d39f650b8a1154472de209537da510cef03daeb669e6a84c5ee5f212c82d9eda66207f5f8e81

data/lib/coinbase/address.rb

@@ -2,65 +2,72 @@
 
 require_relative 'balance_map'
 require_relative 'constants'
+require_relative 'wallet'
 require 'bigdecimal'
 require 'eth'
 require 'jimson'
 
 module Coinbase
   # A representation of a blockchain Address, which is a user-controlled account on a Network. Addresses are used to
-  # send and receive Assets, and should be created using {link:Wallet#create_address}. Addresses require a
-  # {link:Eth::Key} to sign transaction data.
+  # send and receive Assets, and should be created using Wallet#create_address. Addresses require an
+  # Eth::Key to sign transaction data.
   class Address
-    attr_reader :network_id, :address_id, :wallet_id
-
-    # Returns a new Address object.
-    # @param network_id [Symbol] The ID of the Network on which the Address exists
-    # @param address_id [String] The ID of the Address. On EVM Networks, for example, this is a hash of the public key.
-    # @param wallet_id [String] The ID of the Wallet to which the Address belongs
+    # Returns a new Address object. Do not use this method directly. Instead, use Wallet#create_address, or use
+    # the Wallet's default_address.
+    # @param model [Coinbase::Client::Address] The underlying Address object
     # @param key [Eth::Key] The key backing the Address
-    # @param client [Jimson::Client] (Optional) The JSON RPC client to use for interacting with the Network
-    def initialize(network_id, address_id, wallet_id, key,
-                   client: Jimson::Client.new(Coinbase.base_sepolia_rpc_url))
-      # TODO: Don't require key.
-      @network_id = network_id
-      @address_id = address_id
-      @wallet_id = wallet_id
+    def initialize(model, key)
+      @model = model
       @key = key
-      @client = client
     end
 
-    # Returns the balances of the Address. Currently only ETH balances are supported.
+    # Returns the Network ID of the Address.
+    # @return [Symbol] The Network ID
+    def network_id
+      Coinbase.to_sym(@model.network_id)
+    end
+
+    # Returns the Wallet ID of the Address.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the Address ID.
+    # @return [String] The Address ID
+    def address_id
+      @model.address_id
+    end
+
+    # Returns the balances of the Address.
     # @return [BalanceMap] The balances of the Address, keyed by asset ID. Ether balances are denominated
     #  in ETH.
     def list_balances
-      # TODO: Handle multiple currencies.
-      eth_balance_in_wei = BigDecimal(@client.eth_getBalance(@address_id, 'latest').to_i(16).to_s)
-      eth_balance = BigDecimal(eth_balance_in_wei / BigDecimal(Coinbase::WEI_PER_ETHER.to_s))
-
-      BalanceMap.new({ eth: eth_balance })
+      response = addresses_api.list_address_balances(wallet_id, address_id)
+      Coinbase.to_balance_map(response)
     end
 
-    # Returns the balance of the provided Asset. Currently only ETH is supported.
+    # Returns the balance of the provided Asset.
     # @param asset_id [Symbol] The Asset to retrieve the balance for
     # @return [BigDecimal] The balance of the Asset
     def get_balance(asset_id)
-      normalized_asset_id = if %i[wei gwei].include?(asset_id)
-                              :eth
-                            else
-                              asset_id
-                            end
+      normalized_asset_id = normalize_asset_id(asset_id)
+
+      response = addresses_api.get_address_balance(wallet_id, address_id, normalized_asset_id.to_s)
 
-      eth_balance = list_balances[normalized_asset_id] || BigDecimal(0)
+      return BigDecimal('0') if response.nil?
+
+      amount = BigDecimal(response.amount)
 
       case asset_id
       when :eth
-        eth_balance
+        amount / BigDecimal(Coinbase::WEI_PER_ETHER.to_s)
       when :gwei
-        eth_balance * Coinbase::GWEI_PER_ETHER
-      when :wei
-        eth_balance * Coinbase::WEI_PER_ETHER
+        amount / BigDecimal(Coinbase::GWEI_PER_ETHER.to_s)
+      when :usdc
+        amount / BigDecimal(Coinbase::ATOMIC_UNITS_PER_USDC.to_s)
       else
-        BigDecimal(0)
+        amount
       end
     end
 
@@ -71,15 +78,14 @@ module Coinbase
     #  default address. If a String, interprets it as the address ID.
     # @return [String] The hash of the Transfer transaction.
     def transfer(amount, asset_id, destination)
-      # TODO: Handle multiple currencies.
       raise ArgumentError, "Unsupported asset: #{asset_id}" unless Coinbase::SUPPORTED_ASSET_IDS[asset_id]
 
       if destination.is_a?(Wallet)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
+        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != network_id
 
         destination = destination.default_address.address_id
       elsif destination.is_a?(Address)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
+        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != network_id
 
         destination = destination.address_id
       end
@@ -89,12 +95,24 @@ module Coinbase
         raise ArgumentError, "Insufficient funds: #{amount} requested, but only #{current_balance} available"
       end
 
-      transfer = Coinbase::Transfer.new(@network_id, @wallet_id, @address_id, amount, asset_id, destination,
-                                        client: @client)
+      normalized_amount = normalize_asset_amount(amount, asset_id)
+
+      normalized_asset_id = normalize_asset_id(asset_id)
+
+      create_transfer_request = {
+        amount: normalized_amount.to_i.to_s,
+        network_id: network_id,
+        asset_id: normalized_asset_id.to_s,
+        destination: destination
+      }
+
+      transfer_model = transfers_api.create_transfer(wallet_id, address_id, create_transfer_request)
+
+      transfer = Coinbase::Transfer.new(transfer_model)
 
       transaction = transfer.transaction
       transaction.sign(@key)
-      @client.eth_sendRawTransaction("0x#{transaction.hex}")
+      Coinbase.configuration.base_sepolia_client.eth_sendRawTransaction("0x#{transaction.hex}")
 
       transfer
     end
@@ -102,26 +120,47 @@ module Coinbase
     # Returns the address as a string.
     # @return [String] The address
     def to_s
-      @address_id
+      address_id
     end
 
     private
 
-    # Normalizes the amount of ETH to send based on the asset ID.
+    # Normalizes the amount of the Asset to send to the atomic unit.
     # @param amount [Integer, Float, BigDecimal] The amount to normalize
     # @param asset_id [Symbol] The ID of the Asset being transferred
-    # @return [BigDecimal] The normalized amount in units of ETH
-    def normalize_eth_amount(amount, asset_id)
+    # @return [BigDecimal] The normalized amount in atomic units
+    def normalize_asset_amount(amount, asset_id)
+      big_amount = BigDecimal(amount.to_s)
+
       case asset_id
       when :eth
-        amount.is_a?(BigDecimal) ? amount : BigDecimal(amount.to_s)
+        big_amount * Coinbase::WEI_PER_ETHER
       when :gwei
-        BigDecimal(amount / Coinbase::GWEI_PER_ETHER)
-      when :wei
-        BigDecimal(amount / Coinbase::WEI_PER_ETHER)
+        big_amount * Coinbase::WEI_PER_GWEI
+      when :usdc
+        big_amount * Coinbase::ATOMIC_UNITS_PER_USDC
       else
-        raise ArgumentError, "Unsupported asset: #{asset_id}"
+        big_amount
       end
     end
+
+    # Normalizes the asset ID to use during requests.
+    # @param asset_id [Symbol] The asset ID to normalize
+    # @return [Symbol] The normalized asset ID
+    def normalize_asset_id(asset_id)
+      if %i[wei gwei].include?(asset_id)
+        :eth
+      else
+        asset_id
+      end
+    end
+
+    def addresses_api
+      @addresses_api ||= Coinbase::Client::AddressesApi.new(Coinbase.configuration.api_client)
+    end
+
+    def transfers_api
+      @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
+    end
   end
 end

data/lib/coinbase/asset.rb

@@ -5,7 +5,8 @@ module Coinbase
   class Asset
     attr_reader :network_id, :asset_id, :display_name, :address_id
 
-    # Returns a new Asset object.
+    # Returns a new Asset object. Do not use this method. Instead, use the Asset constants defined in
+    # the Coinbase module.
     # @param network_id [Symbol] The ID of the Network to which the Asset belongs
     # @param asset_id [Symbol] The Asset ID
     # @param display_name [String] The Asset's display name

data/lib/coinbase/authenticator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'jwt'
+require 'openssl'
+require 'securerandom'
+
+module Coinbase
+  # A class that builds JWTs for authenticating with the Coinbase Platform APIs.
+  class Authenticator < Faraday::Middleware
+    # Initializes the Authenticator.
+    # @param app [Faraday::Connection] The Faraday connection
+    def initialize(app)
+      super(app)
+      @app = app
+    end
+
+    # Processes the request by adding the JWT to the Authorization header.
+    # @param env [Faraday::Env] The Faraday request environment
+    def call(env)
+      method = env.method.downcase.to_sym
+      uri = env.url.to_s
+      uri_without_protocol = URI(uri).host
+      token = build_jwt("#{method.upcase} #{uri_without_protocol}#{env.url.path}")
+      env.request_headers['Authorization'] = "Bearer #{token}"
+      @app.call(env)
+    end
+
+    # Builds the JWT for the given API endpoint URI. The JWT is signed with the API key's private key.
+    # @param uri [String] The API endpoint URI
+    # @return [String] The JWT
+    def build_jwt(uri)
+      header = {
+        typ: 'JWT',
+        kid: Coinbase.configuration.api_key_name,
+        nonce: SecureRandom.hex(16)
+      }
+
+      claims = {
+        sub: Coinbase.configuration.api_key_name,
+        iss: 'coinbase-cloud',
+        aud: ['cdp_service'],
+        nbf: Time.now.to_i,
+        exp: Time.now.to_i + 60, # Expiration time: 1 minute from now.
+        uris: [uri]
+      }
+
+      private_key = OpenSSL::PKey.read(Coinbase.configuration.api_key_private_key)
+      JWT.encode(claims, private_key, 'ES256', header)
+    end
+  end
+end

data/lib/coinbase/balance_map.rb

@@ -3,7 +3,7 @@
 require 'bigdecimal'
 
 module Coinbase
-  # A convenience class for printing out crypto asset balances in a human-readable format.
+  # A convenience class for printing out Asset balances in a human-readable format.
   class BalanceMap < Hash
     # Returns a new BalanceMap object.
     # @param hash [Map<Symbol, BigDecimal>] The hash to initialize with

data/lib/coinbase/client/api/addresses_api.rb

@@ -0,0 +1,385 @@
+=begin
+#Coinbase Platform API
+
+#This is the OpenAPI 3.0 specification for the Coinbase Platform APIs, used in conjunction with the Coinbase Platform SDKs.
+
+The version of the OpenAPI document: 0.0.1-alpha
+Contact: yuga.cohler@coinbase.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.5.0
+
+=end
+
+require 'cgi'
+
+module Coinbase::Client
+  class AddressesApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Create a new address
+    # Create a new address scoped to the wallet.
+    # @param wallet_id [String] The ID of the wallet to create the address in.
+    # @param [Hash] opts the optional parameters
+    # @option opts [CreateAddressRequest] :create_address_request 
+    # @return [Address]
+    def create_address(wallet_id, opts = {})
+      data, _status_code, _headers = create_address_with_http_info(wallet_id, opts)
+      data
+    end
+
+    # Create a new address
+    # Create a new address scoped to the wallet.
+    # @param wallet_id [String] The ID of the wallet to create the address in.
+    # @param [Hash] opts the optional parameters
+    # @option opts [CreateAddressRequest] :create_address_request 
+    # @return [Array<(Address, Integer, Hash)>] Address data, response status code and response headers
+    def create_address_with_http_info(wallet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AddressesApi.create_address ...'
+      end
+      # verify the required parameter 'wallet_id' is set
+      if @api_client.config.client_side_validation && wallet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'wallet_id' when calling AddressesApi.create_address"
+      end
+      # resource path
+      local_var_path = '/v1/wallets/{wallet_id}/addresses'.sub('{' + 'wallet_id' + '}', CGI.escape(wallet_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:'create_address_request'])
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Address'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AddressesApi.create_address",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AddressesApi#create_address\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get address by onchain address
+    # Get address
+    # @param wallet_id [String] The ID of the wallet the address belongs to.
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param [Hash] opts the optional parameters
+    # @return [Address]
+    def get_address(wallet_id, address_id, opts = {})
+      data, _status_code, _headers = get_address_with_http_info(wallet_id, address_id, opts)
+      data
+    end
+
+    # Get address by onchain address
+    # Get address
+    # @param wallet_id [String] The ID of the wallet the address belongs to.
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Address, Integer, Hash)>] Address data, response status code and response headers
+    def get_address_with_http_info(wallet_id, address_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AddressesApi.get_address ...'
+      end
+      # verify the required parameter 'wallet_id' is set
+      if @api_client.config.client_side_validation && wallet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'wallet_id' when calling AddressesApi.get_address"
+      end
+      # verify the required parameter 'address_id' is set
+      if @api_client.config.client_side_validation && address_id.nil?
+        fail ArgumentError, "Missing the required parameter 'address_id' when calling AddressesApi.get_address"
+      end
+      # resource path
+      local_var_path = '/v1/wallets/{wallet_id}/addresses/{address_id}'.sub('{' + 'wallet_id' + '}', CGI.escape(wallet_id.to_s)).sub('{' + 'address_id' + '}', CGI.escape(address_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Address'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AddressesApi.get_address",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AddressesApi#get_address\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get address balance for asset
+    # Get address balance
+    # @param wallet_id [String] The ID of the wallet to fetch the balance for
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param asset_id [String] The symbol of the asset to fetch the balance for
+    # @param [Hash] opts the optional parameters
+    # @return [Balance]
+    def get_address_balance(wallet_id, address_id, asset_id, opts = {})
+      data, _status_code, _headers = get_address_balance_with_http_info(wallet_id, address_id, asset_id, opts)
+      data
+    end
+
+    # Get address balance for asset
+    # Get address balance
+    # @param wallet_id [String] The ID of the wallet to fetch the balance for
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param asset_id [String] The symbol of the asset to fetch the balance for
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Balance, Integer, Hash)>] Balance data, response status code and response headers
+    def get_address_balance_with_http_info(wallet_id, address_id, asset_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AddressesApi.get_address_balance ...'
+      end
+      # verify the required parameter 'wallet_id' is set
+      if @api_client.config.client_side_validation && wallet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'wallet_id' when calling AddressesApi.get_address_balance"
+      end
+      # verify the required parameter 'address_id' is set
+      if @api_client.config.client_side_validation && address_id.nil?
+        fail ArgumentError, "Missing the required parameter 'address_id' when calling AddressesApi.get_address_balance"
+      end
+      # verify the required parameter 'asset_id' is set
+      if @api_client.config.client_side_validation && asset_id.nil?
+        fail ArgumentError, "Missing the required parameter 'asset_id' when calling AddressesApi.get_address_balance"
+      end
+      # resource path
+      local_var_path = '/v1/wallets/{wallet_id}/addresses/{address_id}/balances/{asset_id}'.sub('{' + 'wallet_id' + '}', CGI.escape(wallet_id.to_s)).sub('{' + 'address_id' + '}', CGI.escape(address_id.to_s)).sub('{' + 'asset_id' + '}', CGI.escape(asset_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Balance'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AddressesApi.get_address_balance",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AddressesApi#get_address_balance\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Get all balances for address
+    # Get address balances
+    # @param wallet_id [String] The ID of the wallet to fetch the balances for
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :page A cursor for pagination across multiple pages of results. Don&#39;t include this parameter on the first call. Use the next_page value returned in a previous response to request subsequent results.
+    # @return [AddressBalanceList]
+    def list_address_balances(wallet_id, address_id, opts = {})
+      data, _status_code, _headers = list_address_balances_with_http_info(wallet_id, address_id, opts)
+      data
+    end
+
+    # Get all balances for address
+    # Get address balances
+    # @param wallet_id [String] The ID of the wallet to fetch the balances for
+    # @param address_id [String] The onchain address of the address that is being fetched.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :page A cursor for pagination across multiple pages of results. Don&#39;t include this parameter on the first call. Use the next_page value returned in a previous response to request subsequent results.
+    # @return [Array<(AddressBalanceList, Integer, Hash)>] AddressBalanceList data, response status code and response headers
+    def list_address_balances_with_http_info(wallet_id, address_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AddressesApi.list_address_balances ...'
+      end
+      # verify the required parameter 'wallet_id' is set
+      if @api_client.config.client_side_validation && wallet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'wallet_id' when calling AddressesApi.list_address_balances"
+      end
+      # verify the required parameter 'address_id' is set
+      if @api_client.config.client_side_validation && address_id.nil?
+        fail ArgumentError, "Missing the required parameter 'address_id' when calling AddressesApi.list_address_balances"
+      end
+      if @api_client.config.client_side_validation && !opts[:'page'].nil? && opts[:'page'].to_s.length > 5000
+        fail ArgumentError, 'invalid value for "opts[:"page"]" when calling AddressesApi.list_address_balances, the character length must be smaller than or equal to 5000.'
+      end
+
+      # resource path
+      local_var_path = '/v1/wallets/{wallet_id}/addresses/{address_id}/balances'.sub('{' + 'wallet_id' + '}', CGI.escape(wallet_id.to_s)).sub('{' + 'address_id' + '}', CGI.escape(address_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'AddressBalanceList'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AddressesApi.list_address_balances",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AddressesApi#list_address_balances\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # List addresses in a wallet.
+    # List addresses in the wallet.
+    # @param wallet_id [String] The ID of the wallet whose addresses to fetch
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :limit A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+    # @option opts [String] :page A cursor for pagination across multiple pages of results. Don&#39;t include this parameter on the first call. Use the next_page value returned in a previous response to request subsequent results.
+    # @return [AddressList]
+    def list_addresses(wallet_id, opts = {})
+      data, _status_code, _headers = list_addresses_with_http_info(wallet_id, opts)
+      data
+    end
+
+    # List addresses in a wallet.
+    # List addresses in the wallet.
+    # @param wallet_id [String] The ID of the wallet whose addresses to fetch
+    # @param [Hash] opts the optional parameters
+    # @option opts [Integer] :limit A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+    # @option opts [String] :page A cursor for pagination across multiple pages of results. Don&#39;t include this parameter on the first call. Use the next_page value returned in a previous response to request subsequent results.
+    # @return [Array<(AddressList, Integer, Hash)>] AddressList data, response status code and response headers
+    def list_addresses_with_http_info(wallet_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AddressesApi.list_addresses ...'
+      end
+      # verify the required parameter 'wallet_id' is set
+      if @api_client.config.client_side_validation && wallet_id.nil?
+        fail ArgumentError, "Missing the required parameter 'wallet_id' when calling AddressesApi.list_addresses"
+      end
+      if @api_client.config.client_side_validation && !opts[:'page'].nil? && opts[:'page'].to_s.length > 5000
+        fail ArgumentError, 'invalid value for "opts[:"page"]" when calling AddressesApi.list_addresses, the character length must be smaller than or equal to 5000.'
+      end
+
+      # resource path
+      local_var_path = '/v1/wallets/{wallet_id}/addresses'.sub('{' + 'wallet_id' + '}', CGI.escape(wallet_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
+      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'AddressList'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AddressesApi.list_addresses",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AddressesApi#list_addresses\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end