coinbase-sdk 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee1676ef79c89fd46c217eacbffecf507bed15a7362b8550d3110df96d45cd47
-  data.tar.gz: 21627d8b1bd0aefd94f33e5638eb514d8984aea244fb353c21e6fc17e899bf8d
+  metadata.gz: c52613ebb145609813f96508c0eff76721ee6afebf3f3207394dad4c91b51635
+  data.tar.gz: d7f86c6cfbc02b6dd8866717cc9a89439b81da9ae8838dc34855dd10bf9f3fa9
 SHA512:
-  metadata.gz: 8b4ea7efb7b44a82b7b508ae8145ac7df6f467c55a17b27c10fe66aed6a72a7d4408d24ff1253b9ab9cbd6eca19d46def359d094673a066eb6479656ed47d30a
-  data.tar.gz: 79557441fda3a63c564976f8568cb0ab5b724063dd793fc5ad32085e2eb533355720d1084cace42d3b7a92e3bdf3748434389c0f1f8a7989c402b7191054be2f
+  metadata.gz: 6fa544e18af4ad42457ec8615e7a6e652fb15e1ae00cfa14924dcb86c53aab1ba90b21a8e1b7b29f193b1e0039d030cba1f45631b8dac23b287617105b88478b
+  data.tar.gz: 3625e897b9681e208cd921e8118275bd012996c17fb62fc235eac8624e6742ce18cff8d8177a1d379bfb5fa71ebec3db02a70d2bb683aeb067ccac7f89345945

data/lib/coinbase/address.rb

@@ -77,20 +77,43 @@ module Coinbase
     # @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 [String] The hash of the Transfer transaction.
+    # @return [Coinbase::Transfer] The Transfer object.
     def transfer(amount, asset_id, destination)
+      asset = Asset.fetch(network_id, asset_id)
+
       destination_address, destination_network = destination_address_and_network(destination)
 
-      validate_can_transfer!(amount, asset_id, destination_network)
+      validate_can_transfer!(amount, asset, destination_network)
 
-      transfer = create_transfer(amount, asset_id, destination_address)
+      transfer = create_transfer(amount, asset, 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?
 
-      signed_payload = sign_transfer(transfer)
+      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)
+      from_asset = Asset.fetch(network_id, from_asset_id)
+      to_asset = Asset.fetch(network_id, to_asset_id)
+
+      validate_can_trade!(amount, from_asset)
+
+      trade = create_trade(amount, from_asset, to_asset)
+
+      # 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_transfer(transfer, signed_payload)
+      broadcast_trade(trade, **payloads)
     end
 
     # Returns whether the Address has a private key backing it to sign transactions.
@@ -163,6 +186,10 @@ module Coinbase
       @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)
@@ -170,25 +197,23 @@ module Coinbase
       [destination, network_id]
     end
 
-    def validate_can_transfer!(amount, asset_id, destination_network_id)
+    def validate_can_transfer!(amount, asset, 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)
+      current_balance = balance(asset.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)
+    def create_transfer(amount, asset, destination)
       create_transfer_request = {
-        amount: Coinbase::Asset.to_atomic_amount(amount, asset_id).to_i.to_s,
+        amount: asset.to_atomic_amount(amount).to_i.to_s,
         network_id: network_id,
-        asset_id: Coinbase::Asset.primary_denomination(asset_id).to_s,
+        asset_id: asset.primary_denomination.to_s,
         destination: destination
       }
 
@@ -199,13 +224,6 @@ module Coinbase
       Coinbase::Transfer.new(transfer_model)
     end
 
-    def sign_transfer(transfer)
-      transaction = transfer.transaction
-      transaction.sign(@key)
-
-      transaction.hex
-    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 })
@@ -213,5 +231,41 @@ module Coinbase
 
       Coinbase::Transfer.new(transfer_model)
     end
+
+    def validate_can_trade!(amount, from_asset)
+      raise 'Cannot trade from address without private key loaded' unless can_sign?
+
+      current_balance = balance(from_asset.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, to_asset)
+      create_trade_request = {
+        amount: from_asset.to_atomic_amount(amount).to_i.to_s,
+        from_asset_id: from_asset.primary_denomination.to_s,
+        to_asset_id: to_asset.primary_denomination.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)
+    end
   end
 end

data/lib/coinbase/asset.rb

@@ -3,84 +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 && 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
+        from_model(asset_model, asset_id: asset_id)
+      end
+
+      private
+
+      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] The Asset's display name
     # @param address_id [String] (Optional) The Asset's address ID, if one exists
-    def initialize(network_id:, asset_id:, display_name:, address_id: nil)
+    # @param decimals [Integer] (Optional) The number of decimal places the Asset uses
+    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
+    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}'}")
+      "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/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/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.5.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

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

@@ -0,0 +1,97 @@
+=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 BalancesApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Get the balance of an asset in an external address
+    # Get the balance of an asset in an external address
+    # @param network_id [String] The ID of the blockchain network
+    # @param address_id [String] The ID of the address to fetch the balance for
+    # @param asset_id [String] The ID of the asset to fetch the balance for
+    # @param [Hash] opts the optional parameters
+    # @return [Balance]
+    def get_external_address_balance(network_id, address_id, asset_id, opts = {})
+      data, _status_code, _headers = get_external_address_balance_with_http_info(network_id, address_id, asset_id, opts)
+      data
+    end
+
+    # Get the balance of an asset in an external address
+    # Get the balance of an asset in an external address
+    # @param network_id [String] The ID of the blockchain network
+    # @param address_id [String] The ID of the address to fetch the balance for
+    # @param asset_id [String] The ID 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_external_address_balance_with_http_info(network_id, address_id, asset_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: BalancesApi.get_external_address_balance ...'
+      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 BalancesApi.get_external_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 BalancesApi.get_external_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 BalancesApi.get_external_address_balance"
+      end
+      # resource path
+      local_var_path = '/v1/networks/{network_id}/addresses/{address_id}/balances/{asset_id}'.sub('{' + 'network_id' + '}', CGI.escape(network_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 => :"BalancesApi.get_external_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: BalancesApi#get_external_address_balance\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end