coinbase-sdk 0.0.7 → 0.0.9

data/lib/coinbase/address.rb

@@ -1,50 +1,37 @@
 # frozen_string_literal: true
 
-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 Wallet#create_address. Addresses require an
-  # Eth::Key to sign transaction data.
+  # send and receive Assets.
+  # @attr_reader [Symbol] network_id The Network ID
+  # @attr_reader [String] id The onchain Address ID
   class Address
-    # 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. Can be nil.
-    def initialize(model, key)
-      @model = model
-      @key = key
-    end
+    attr_reader :network_id, :id
 
-    # Returns the Network ID of the Address.
-    # @return [Symbol] The Network ID
-    def network_id
-      Coinbase.to_sym(@model.network_id)
+    # Returns a new Address object.
+    # @param network_id [Symbol] The Network ID
+    # @param id [String] The onchain Address ID
+    def initialize(network_id, id)
+      @network_id = Coinbase.to_sym(network_id)
+      @id = id
     end
 
-    # Returns the Wallet ID of the Address.
-    # @return [String] The Wallet ID
-    def wallet_id
-      @model.wallet_id
+    # Returns a String representation of the Address.
+    # @return [String] a String representation of the Address
+    def to_s
+      "Coinbase::Address{id: '#{id}', network_id: '#{network_id}'}"
     end
 
-    # Returns the Address ID.
-    # @return [String] The Address ID
-    def id
-      @model.address_id
+    # Same as to_s.
+    # @return [String] a String representation of the Address
+    def inspect
+      to_s
     end
 
-    # Sets the private key backing the Address. This key is used to sign transactions.
-    # @param key [Eth::Key] The key backing the Address
-    def key=(key)
-      raise 'Private key is already set' unless @key.nil?
-
-      @key = key
+    # Returns true if the Address can sign transactions.
+    # @return [Boolean] true if the Address can sign transactions
+    def can_sign?
+      false
     end
 
     # Returns the balances of the Address.
@@ -52,7 +39,7 @@ module Coinbase
     #  in ETH.
     def balances
       response = Coinbase.call_api do
-        addresses_api.list_address_balances(wallet_id, id)
+        addresses_api.list_external_address_balances(Coinbase.normalize_network(network_id), id)
       end
 
       Coinbase::BalanceMap.from_balances(response.data)
@@ -63,7 +50,11 @@ module Coinbase
     # @return [BigDecimal] The balance of the Asset
     def balance(asset_id)
       response = Coinbase.call_api do
-        addresses_api.get_address_balance(wallet_id, id, Coinbase::Asset.primary_denomination(asset_id).to_s)
+        addresses_api.get_external_address_balance(
+          Coinbase.normalize_network(network_id),
+          id,
+          Coinbase::Asset.primary_denomination(asset_id).to_s
+        )
       end
 
       return BigDecimal('0') if response.nil?
@@ -71,64 +62,6 @@ module Coinbase
       Coinbase::Balance.from_model_and_asset_id(response, asset_id).amount
     end
 
-    # Transfers the given amount of the given Asset to the specified address or wallet.
-    # Only same-network Transfers are supported.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send.
-    # @param asset_id [Symbol] The ID of the Asset to send. For Ether, :eth, :gwei, and :wei are supported.
-    # @param destination [Wallet | Address | String] The destination of the transfer. If a Wallet, sends to the Wallet's
-    #  default address. If a String, interprets it as the address ID.
-    # @return [Coinbase::Transfer] The Transfer object.
-    def transfer(amount, asset_id, destination)
-      destination_address, destination_network = destination_address_and_network(destination)
-
-      validate_can_transfer!(amount, asset_id, destination_network)
-
-      transfer = create_transfer(amount, asset_id, destination_address)
-
-      # If a server signer is managing keys, it will sign and broadcast the underlying transfer transaction out of band.
-      return transfer if Coinbase.use_server_signer?
-
-      broadcast_transfer(transfer, transfer.transaction.sign(@key))
-    end
-
-    # Trades the given amount of the given Asset for another Asset.
-    # Only same-network Trades are supported.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send.
-    # @param from_asset_id [Symbol] The ID of the Asset to trade from. For Ether, :eth, :gwei, and :wei are supported.
-    # @param to_asset_id [Symbol] The ID of the Asset to trade to. For Ether, :eth, :gwei, and :wei are supported.
-    # @return [Coinbase::Trade] The Trade object.
-    def trade(amount, from_asset_id, to_asset_id)
-      validate_can_trade!(amount, from_asset_id, to_asset_id)
-
-      trade = create_trade(amount, from_asset_id, to_asset_id)
-
-      # NOTE: Trading does not yet support server signers at this point.
-
-      payloads = { signed_payload: trade.transaction.sign(@key) }
-
-      payloads[:approve_tx_signed_payload] = trade.approve_transaction.sign(@key) unless trade.approve_transaction.nil?
-
-      broadcast_trade(trade, **payloads)
-    end
-
-    # Returns whether the Address has a private key backing it to sign transactions.
-    # @return [Boolean] Whether the Address has a private key backing it to sign transactions.
-    def can_sign?
-      !@key.nil?
-    end
-
-    # Returns a String representation of the Address.
-    # @return [String] a String representation of the Address
-    def to_s
-      "Coinbase::Address{id: '#{id}', network_id: '#{network_id}', wallet_id: '#{wallet_id}'}"
-    end
-
-    # Same as to_s.
-    # @return [String] a String representation of the Address
-    def inspect
-      to_s
-    end
-
     # Requests funds for the address from the faucet and returns the faucet transaction.
     # This is only supported on testnet networks.
     # @return [Coinbase::FaucetTransaction] The successful faucet transaction
@@ -136,136 +69,16 @@ module Coinbase
     # @raise [Coinbase::Client::ApiError] If an unexpected error occurs while requesting faucet funds.
     def faucet
       Coinbase.call_api do
-        Coinbase::FaucetTransaction.new(addresses_api.request_faucet_funds(wallet_id, id))
-      end
-    end
-
-    # Exports the Address's private key to a hex string.
-    # @return [String] The Address's private key as a hex String
-    def export
-      raise 'Cannot export key without private key loaded' if @key.nil?
-
-      @key.private_hex
-    end
-
-    # Returns all of the transfers associated with the address.
-    # @return [Array<Coinbase::Transfer>] The transfers associated with the address
-    def transfers
-      transfers = []
-      page = nil
-
-      loop do
-        response = Coinbase.call_api do
-          transfers_api.list_transfers(wallet_id, id, { limit: 100, page: page })
-        end
-
-        break if response.data.empty?
-
-        transfers.concat(response.data.map { |transfer| Coinbase::Transfer.new(transfer) })
-
-        break unless response.has_more
-
-        page = response.next_page
+        Coinbase::FaucetTransaction.new(
+          addresses_api.request_external_faucet_funds(Coinbase.normalize_network(network_id), id)
+        )
       end
-
-      transfers
     end
 
     private
 
     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
-
-    def trades_api
-      @trades_api ||= Coinbase::Client::TradesApi.new(Coinbase.configuration.api_client)
-    end
-
-    def destination_address_and_network(destination)
-      return [destination.default_address.id, destination.network_id] if destination.is_a?(Wallet)
-      return [destination.id, destination.network_id] if destination.is_a?(Address)
-
-      [destination, network_id]
-    end
-
-    def validate_can_transfer!(amount, asset_id, destination_network_id)
-      raise 'Cannot transfer from address without private key loaded' unless can_sign? || Coinbase.use_server_signer?
-
-      raise ArgumentError, "Unsupported asset: #{asset_id}" unless Coinbase::Asset.supported?(asset_id)
-
-      raise ArgumentError, 'Transfer must be on the same Network' unless destination_network_id == network_id
-
-      current_balance = balance(asset_id)
-
-      return unless current_balance < amount
-
-      raise ArgumentError, "Insufficient funds: #{amount} requested, but only #{current_balance} available"
-    end
-
-    def create_transfer(amount, asset_id, destination)
-      create_transfer_request = {
-        amount: Coinbase::Asset.to_atomic_amount(amount, asset_id).to_i.to_s,
-        network_id: network_id,
-        asset_id: Coinbase::Asset.primary_denomination(asset_id).to_s,
-        destination: destination
-      }
-
-      transfer_model = Coinbase.call_api do
-        transfers_api.create_transfer(wallet_id, id, create_transfer_request)
-      end
-
-      Coinbase::Transfer.new(transfer_model)
-    end
-
-    def broadcast_transfer(transfer, signed_payload)
-      transfer_model = Coinbase.call_api do
-        transfers_api.broadcast_transfer(wallet_id, id, transfer.id, { signed_payload: signed_payload })
-      end
-
-      Coinbase::Transfer.new(transfer_model)
-    end
-
-    def validate_can_trade!(amount, from_asset_id, to_asset_id)
-      raise 'Cannot trade from address without private key loaded' unless can_sign?
-
-      raise ArgumentError, "Unsupported from asset: #{from_asset_id}" unless Coinbase::Asset.supported?(from_asset_id)
-      raise ArgumentError, "Unsupported to asset: #{to_asset_id}" unless Coinbase::Asset.supported?(to_asset_id)
-
-      current_balance = balance(from_asset_id)
-
-      return unless current_balance < amount
-
-      raise ArgumentError, "Insufficient funds: #{amount} requested, but only #{current_balance} available"
-    end
-
-    def create_trade(amount, from_asset_id, to_asset_id)
-      create_trade_request = {
-        amount: Coinbase::Asset.to_atomic_amount(amount, from_asset_id).to_i.to_s,
-        from_asset_id: Coinbase::Asset.primary_denomination(from_asset_id).to_s,
-        to_asset_id: Coinbase::Asset.primary_denomination(to_asset_id).to_s
-      }
-
-      trade_model = Coinbase.call_api do
-        trades_api.create_trade(wallet_id, id, create_trade_request)
-      end
-
-      Coinbase::Trade.new(trade_model)
-    end
-
-    def broadcast_trade(trade, signed_payload:, approve_tx_signed_payload: nil)
-      req = { signed_payload: signed_payload }
-
-      req[:approve_transaction_signed_payload] = approve_tx_signed_payload unless approve_tx_signed_payload.nil?
-
-      trade_model = Coinbase.call_api do
-        trades_api.broadcast_trade(wallet_id, id, trade.id, req)
-      end
-
-      Coinbase::Trade.new(trade_model)
+      @addresses_api ||= Coinbase::Client::ExternalAddressesApi.new(Coinbase.configuration.api_client)
     end
   end
 end

data/lib/coinbase/asset.rb

@@ -3,98 +3,108 @@
 module Coinbase
   # A representation of an Asset.
   class Asset
-    # Retuns whether the provided asset ID is supported.
-    # @param asset_id [Symbol] The Asset ID
-    # @return [Boolean] Whether the Asset ID is supported
-    def self.supported?(asset_id)
-      !!Coinbase::SUPPORTED_ASSET_IDS[asset_id]
-    end
+    class << self
+      # Returns the primary denomination for the provided Asset ID.
+      # For assets with multiple denominations, e.g. eth can also be denominated in wei and gwei,
+      # this method will return the primary denomination.
+      # e.g. eth.
+      # @param asset_id [Symbol] The Asset ID
+      # @return [Symbol] The primary denomination for the Asset ID
+      def primary_denomination(asset_id)
+        return :eth if %i[wei gwei].include?(asset_id)
 
-    # Converts the amount of the Asset to the atomic units of the primary denomination of the Asset.
-    # @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 atomic units
-    def self.to_atomic_amount(amount, asset_id)
-      case asset_id
-      when :eth
-        amount * BigDecimal(Coinbase::WEI_PER_ETHER.to_s)
-      when :gwei
-        amount * BigDecimal(Coinbase::WEI_PER_GWEI.to_s)
-      when :usdc
-        amount * BigDecimal(Coinbase::ATOMIC_UNITS_PER_USDC.to_s)
-      when :weth
-        amount * BigDecimal(Coinbase::WEI_PER_ETHER)
-      else
-        amount
+        asset_id
       end
-    end
 
-    # Converts an amount from the atomic value of the primary denomination of the provided Asset ID
-    # to whole units of the specified asset ID.
-    # @param atomic_amount [BigDecimal] The amount in atomic units
-    # @param asset_id [Symbol] The Asset ID
-    # @return [BigDecimal] The amount in whole units of the specified asset ID
-    def self.from_atomic_amount(atomic_amount, asset_id)
-      case asset_id
-      when :eth
-        atomic_amount / BigDecimal(Coinbase::WEI_PER_ETHER.to_s)
-      when :gwei
-        atomic_amount / BigDecimal(Coinbase::WEI_PER_GWEI.to_s)
-      when :usdc
-        atomic_amount / BigDecimal(Coinbase::ATOMIC_UNITS_PER_USDC.to_s)
-      when :weth
-        atomic_amount / BigDecimal(Coinbase::WEI_PER_ETHER)
-      else
-        atomic_amount
+      def from_model(asset_model, asset_id: nil)
+        raise unless asset_model.is_a?(Coinbase::Client::Asset)
+
+        decimals = asset_model.decimals
+
+        # Handle the non-primary denomination case at the asset level.
+        # TODO: Push this logic down to the backend.
+        if asset_id && Coinbase.to_sym(asset_id) != Coinbase.to_sym(asset_model.asset_id)
+          case asset_id
+          when :gwei
+            decimals = GWEI_DECIMALS
+          when :wei
+            decimals = 0
+          else
+            raise ArgumentError, "Unsupported asset ID: #{asset_id}"
+          end
+        end
+
+        new(
+          network_id: Coinbase.to_sym(asset_model.network_id),
+          asset_id: asset_id || Coinbase.to_sym(asset_model.asset_id),
+          address_id: asset_model.contract_address,
+          decimals: decimals
+        )
       end
-    end
 
-    # Returns the primary denomination for the provided Asset ID.
-    # For assets with multiple denominations, e.g. eth can also be denominated in wei and gwei,
-    # this method will return the primary denomination.
-    # e.g. eth.
-    # @param asset_id [Symbol] The Asset ID
-    # @return [Symbol] The primary denomination for the Asset ID
-    def self.primary_denomination(asset_id)
-      return :eth if %i[wei gwei].include?(asset_id)
+      # Fetches the Asset with the provided Asset ID.
+      # @param asset_id [Symbol] The Asset ID
+      # @return [Coinbase::Asset] The Asset
+      def fetch(network_id, asset_id)
+        asset_model = Coinbase.call_api do
+          assets_api.get_asset(
+            Coinbase.normalize_network(network_id),
+            primary_denomination(asset_id).to_s
+          )
+        end
 
-      asset_id
-    end
+        from_model(asset_model, asset_id: asset_id)
+      end
 
-    def self.from_model(asset_model)
-      raise unless asset_model.is_a?(Coinbase::Client::Asset)
+      private
 
-      new(
-        network_id: Coinbase.to_sym(asset_model.network_id),
-        asset_id: Coinbase.to_sym(asset_model.asset_id),
-        address_id: asset_model.contract_address,
-        decimals: asset_model.decimals
-      )
+      def assets_api
+        Coinbase::Client::AssetsApi.new(Coinbase.configuration.api_client)
+      end
     end
 
     # 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] (Optional) The Asset's display name
     # @param address_id [String] (Optional) The Asset's address ID, if one exists
     # @param decimals [Integer] (Optional) The number of decimal places the Asset uses
-    def initialize(network_id:, asset_id:, display_name: nil, address_id: nil, decimals: nil)
+    def initialize(network_id:, asset_id:, decimals:, address_id: nil)
       @network_id = network_id
       @asset_id = asset_id
-      @display_name = display_name
       @address_id = address_id
       @decimals = decimals
     end
 
-    attr_reader :network_id, :asset_id, :display_name, :address_id, :decimals
+    attr_reader :network_id, :asset_id, :address_id, :decimals
+
+    # Converts the amount of the Asset from atomic to whole units.
+    # @param atomic_amount [Integer, Float, BigDecimal] The atomic amount to convert to whole units.
+    # @return [BigDecimal] The amount in whole units
+    def from_atomic_amount(atomic_amount)
+      BigDecimal(atomic_amount) / BigDecimal(10).power(decimals)
+    end
+
+    # Converts the amount of the Asset from whole to atomic units.
+    # @param whole_amount [Integer, Float, BigDecimal] The whole amount to convert to atomic units.
+    # @return [BigDecimal] The amount in atomic units
+    def to_atomic_amount(whole_amount)
+      whole_amount * BigDecimal(10).power(decimals)
+    end
+
+    # Returns the primary denomination for the Asset.
+    # For `gwei` and `wei` the primary denomination is `eth`.
+    # For all other assets, the primary denomination is the same asset ID.
+    # @return [Symbol] The primary denomination for the Asset
+    def primary_denomination
+      self.class.primary_denomination(asset_id)
+    end
 
     # Returns a string representation of the Asset.
     # @return [String] a string representation of the Asset
     def to_s
-      "Coinbase::Asset{network_id: '#{network_id}', asset_id: '#{asset_id}', display_name: '#{display_name}'" +
-        (address_id.nil? ? '}' : ", address_id: '#{address_id}'}") +
-        (decimals.nil? ? '}' : ", decimals: '#{decimals}'}")
+      "Coinbase::Asset{network_id: '#{network_id}', asset_id: '#{asset_id}', decimals: '#{decimals}'" \
+        "#{address_id.nil? ? '' : ", address_id: '#{address_id}'"}}"
     end
 
     # Same as to_s.

data/lib/coinbase/authenticator.rb

@@ -45,6 +45,8 @@ module Coinbase
         uris: [uri]
       }
 
+      raise Coinbase::InvalidConfiguration, 'API key not configured' unless Coinbase.configured?
+
       private_key = OpenSSL::PKey.read(Coinbase.configuration.api_key_private_key)
       JWT.encode(claims, private_key, 'ES256', header)
     end

data/lib/coinbase/balance.rb

@@ -7,9 +7,9 @@ module Coinbase
     # @param balance_model [Coinbase::Client::Balance] The balance fetched from the API.
     # @return [Balance] The converted Balance object.
     def self.from_model(balance_model)
-      asset_id = Coinbase.to_sym(balance_model.asset.asset_id.downcase)
+      asset = Coinbase::Asset.from_model(balance_model.asset)
 
-      from_model_and_asset_id(balance_model, asset_id)
+      new(amount: asset.from_atomic_amount(balance_model.amount), asset: asset)
     end
 
     # Converts a Coinbase::Client::Balance model and asset ID to a Coinbase::Balance
@@ -19,8 +19,11 @@ module Coinbase
     # @param asset_id [Symbol] The Asset ID of the denomination we want returned.
     # @return [Balance] The converted Balance object.
     def self.from_model_and_asset_id(balance_model, asset_id)
+      asset = Coinbase::Asset.from_model(balance_model.asset, asset_id: asset_id)
+
       new(
-        amount: Coinbase::Asset.from_atomic_amount(BigDecimal(balance_model.amount), asset_id),
+        amount: asset.from_atomic_amount(balance_model.amount),
+        asset: asset,
         asset_id: asset_id
       )
     end
@@ -29,12 +32,13 @@ module Coinbase
     # Balance.from_model_and_asset_id.
     # @param amount [BigDecimal] The amount of the Asset
     # @param asset_id [Symbol] The Asset ID
-    def initialize(amount:, asset_id:)
+    def initialize(amount:, asset:, asset_id: nil)
       @amount = amount
-      @asset_id = asset_id
+      @asset = asset
+      @asset_id = asset_id || asset.asset_id
     end
 
-    attr_reader :amount, :asset_id
+    attr_reader :amount, :asset, :asset_id
 
     # Returns a string representation of the Balance.
     # @return [String] a string representation of the Balance

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

@@ -6,7 +6,7 @@
 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
+Generator version: 7.6.0
 
 =end
 

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

@@ -0,0 +1,91 @@
+=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.6.0
+
+=end
+
+require 'cgi'
+
+module Coinbase::Client
+  class AssetsApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Get the asset for the specified asset ID.
+    # Get the asset for the specified asset ID.
+    # @param network_id [String] The ID of the blockchain network
+    # @param asset_id [String] The ID of the asset to fetch
+    # @param [Hash] opts the optional parameters
+    # @return [Asset]
+    def get_asset(network_id, asset_id, opts = {})
+      data, _status_code, _headers = get_asset_with_http_info(network_id, asset_id, opts)
+      data
+    end
+
+    # Get the asset for the specified asset ID.
+    # Get the asset for the specified asset ID.
+    # @param network_id [String] The ID of the blockchain network
+    # @param asset_id [String] The ID of the asset to fetch
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Asset, Integer, Hash)>] Asset data, response status code and response headers
+    def get_asset_with_http_info(network_id, asset_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AssetsApi.get_asset ...'
+      end
+      # verify the required parameter 'network_id' is set
+      if @api_client.config.client_side_validation && network_id.nil?
+        fail ArgumentError, "Missing the required parameter 'network_id' when calling AssetsApi.get_asset"
+      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 AssetsApi.get_asset"
+      end
+      # resource path
+      local_var_path = '/v1/networks/{network_id}/assets/{asset_id}'.sub('{' + 'network_id' + '}', CGI.escape(network_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] || 'Asset'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"AssetsApi.get_asset",
+        :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: AssetsApi#get_asset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end