coinbase-sdk 0.0.10 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20237f97b110d59cc508ab2bf8d12c50e03de8c99722caf7c8afc0b44ae14d6f
-  data.tar.gz: a94842743529bd1171179dbbe690034fcd04911fe16046c27b48b4aae2354a30
+  metadata.gz: 6ea6f3f49e4b03f6131d891a1e628b9bed3a60b40b0a640358b5cc85ff4075ab
+  data.tar.gz: 92d2b00b3dac22f12173f9b6a7860889b7d9e64966e55cf7ba175a3728f43be3
 SHA512:
-  metadata.gz: b9affa919b3835243affb7ada3935280c4249348082055e79d598ff04b3df65979401078bebadbbd3c1e0ab32499a6eb00acb82221654c2f6a7e9474653436b7
-  data.tar.gz: aa868c4e37d612a0727f05826ec2275f434f23ecccb6edffab13e553b1c1bafec1573793fe6a983c5c9572a21fdbcdae778e83de7907472109d6861c0a101a04
+  metadata.gz: c4a96ebe5f58f569419d2911aab739706d4176fb403b2283d8b44d29f36768bcf2588088f1870cbabc7a7f4941d12a9d796565e60c126014c48b318725fb8d13
+  data.tar.gz: d97661b3ab9abb774561a307bb228c1d3795077777001ca5b6657f2205cf81f8674f68ef4bb9dff4b01623cfffa5c2835e26e58d26dbbf51a8bfcd70b13edc52

data/lib/coinbase/address/wallet_address.rb

@@ -8,8 +8,6 @@ module Coinbase
   # 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.
   class WalletAddress < Address
-    PAGE_LIMIT = 100
-
     # 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
@@ -43,18 +41,25 @@ module Coinbase
     #  default address. If a String, interprets it as the address ID.
     # @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, destination_network)
-
-      transfer = create_transfer(amount, asset, destination_address)
+      ensure_can_sign!
+      ensure_sufficient_balance!(amount, asset_id)
+
+      transfer = Transfer.create(
+        address_id: id,
+        amount: amount,
+        asset_id: asset_id,
+        destination: destination,
+        network_id: network_id,
+        wallet_id: wallet_id
+      )
 
       # 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))
+      transfer.transaction.sign(@key)
+
+      transfer.broadcast!
+      transfer
     end
 
     # Trades the given amount of the given Asset for another Asset.
@@ -64,20 +69,27 @@ module Coinbase
     # @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?
+      ensure_can_sign!
+      ensure_sufficient_balance!(amount, from_asset_id)
+
+      trade = Trade.create(
+        address_id: id,
+        amount: amount,
+        from_asset_id: from_asset_id,
+        to_asset_id: to_asset_id,
+        network_id: network_id,
+        wallet_id: wallet_id
+      )
+
+      # If a server signer is managing keys, it will sign and broadcast the underlying trade transaction out of band.
+      return trade if Coinbase.use_server_signer?
+
+      trade.transactions.each do |tx|
+        tx.sign(@key)
+      end
 
-      broadcast_trade(trade, **payloads)
+      trade.broadcast!
+      trade
     end
 
     # Returns whether the Address has a private key backing it to sign transactions.
@@ -99,9 +111,7 @@ module Coinbase
     # converted to an array, etc...
     # @return [Enumerable<Coinbase::Transfer>] Enumerator that returns the address's transfers
     def transfers
-      Coinbase::Pagination.enumerate(lambda(&method(:fetch_transfers_page))) do |transfer|
-        Coinbase::Transfer.new(transfer)
-      end
+      Transfer.list(wallet_id: wallet_id, address_id: id)
     end
 
     # Enumerates the trades associated with the address.
@@ -109,9 +119,7 @@ module Coinbase
     # converted to an array, etc...
     # @return [Enumerable<Coinbase::Trade>] Enumerator that returns the address's trades
     def trades
-      Coinbase::Pagination.enumerate(lambda(&method(:fetch_trades_page))) do |trade|
-        Coinbase::Trade.new(trade)
-      end
+      Trade.list(wallet_id: wallet_id, address_id: id)
     end
 
     # Returns a String representation of the WalletAddress.
@@ -122,98 +130,19 @@ module Coinbase
 
     private
 
-    def fetch_transfers_page(page)
-      transfers_api.list_transfers(wallet_id, id, { limit: PAGE_LIMIT, page: page })
-    end
-
-    def fetch_trades_page(page)
-      trades_api.list_trades(wallet_id, id, { limit: PAGE_LIMIT, page: page })
-    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)
+    def ensure_can_sign!
+      return if Coinbase.use_server_signer?
+      return if can_sign?
 
-      [destination, network_id]
+      raise AddressCannotSignError
     end
 
-    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, 'Transfer must be on the same Network' unless destination_network_id == network_id
-
-      current_balance = balance(asset.asset_id)
+    def ensure_sufficient_balance!(amount, asset_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, destination)
-      create_transfer_request = {
-        amount: asset.to_atomic_amount(amount).to_i.to_s,
-        network_id: Coinbase.normalize_network(network_id),
-        asset_id: asset.primary_denomination.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)
-      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)
+      raise InsufficientFundsError.new(amount, current_balance)
     end
   end
 end

data/lib/coinbase/constants.rb

@@ -16,4 +16,7 @@ module Coinbase
 
   # The number of decimal places in Gwei.
   GWEI_DECIMALS = 9
+
+  # The default page limit for paginated API requests.
+  DEFAULT_PAGE_LIMIT = 100
 end

data/lib/coinbase/destination.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A representation of the intended recipient of an onchain interaction. For example, a simple
+  # Transfer has a single destination, which is the address that will receive the transferred funds.
+  # This class is used to handle the several different types that we can use as a destination,
+  # namely a Coinbase::Wallet, a Coinbase::Address, a String.
+  # This also ensures that the destination is valid for the network that is being interacted with.
+  # If a Coinbase::Wallet is used, the default address of the wallet is used as the destination.
+  # If a Coinbase::Address is used, the address ID is used as the destination.
+  # If a String is used, the string is used as the destination.
+  # If an existing Coinbase::Destination is used, the same address ID is used as the destination.
+  class Destination
+    # Returns a new Destination object.
+    # @param model [Coinbase::Destination, Coinbase::Wallet, Coinbase::Address, String]
+    #   The object which the `address_id` will be derived from.
+    #   If the destination is a Destination, it uses the same address ID.
+    #   If the destination is a Wallet, it uses the default Address of the Wallet.
+    #   If the destination is an Address, it uses the Address's ID.
+    #   If the destination is a String, it uses it as the Address ID.
+    # @param network_id [Symbol] The ID of the Network to which the Destination belongs
+    # @return [Destination] The Destination object
+    def initialize(model, network_id: nil)
+      case model
+      when Coinbase::Destination
+        raise ArgumentError, 'destination network must match destination' unless model.network_id == network_id
+
+        @address_id = model.address_id
+        @network_id = model.network_id
+      when Coinbase::Wallet
+        raise ArgumentError, 'destination network must match wallet' unless model.network_id == network_id
+        raise ArgumentError, 'destination wallet must have default address' if model.default_address.nil?
+
+        @address_id = model.default_address.id
+        @network_id = model.network_id
+      when Coinbase::Address
+        raise ArgumentError, 'destination network must match address' unless model.network_id == network_id
+
+        @address_id = model.id
+        @network_id = model.network_id
+      when String
+        @address_id = model
+        @network_id = network_id
+      else
+        raise ArgumentError, "unsupported destination type: #{model.class}"
+      end
+    end
+
+    attr_reader :address_id, :network_id
+  end
+end

data/lib/coinbase/errors.rb

@@ -63,6 +63,20 @@ module Coinbase
     end
   end
 
+  # An error raised when a transaction is not signed.
+  class TransactionNotSignedError < StandardError
+    def initialize(msg = 'Transaction must be signed')
+      super(msg)
+    end
+  end
+
+  # An error raised when an address attempts to sign a transaction without a private key.
+  class AddressCannotSignError < StandardError
+    def initialize(msg = 'Address cannot sign transaction without private key loaded')
+      super(msg)
+    end
+  end
+
   class UnimplementedError < APIError; end
   class UnauthorizedError < APIError; end
   class InternalError < APIError; end

data/lib/coinbase/trade.rb

@@ -9,6 +9,57 @@ module Coinbase
   # The fee is assumed to be paid in the native Asset of the Network.
   # Trades should be created through Wallet#trade or # Address#trade.
   class Trade
+    class << self
+      # Creates a new Trade object.
+      # @param address_id [String] The Address ID of the sending Address
+      # @param from_asset_id [Symbol] The Asset ID of the Asset to trade from
+      # @param to_asset_id [Symbol] The Asset ID of the Asset to trade to
+      # @param amount [BigDecimal] The amount of the Asset to send
+      # @param network_id [Symbol] The Network ID of the Asset
+      # @param wallet_id [String] The Wallet ID of the sending Wallet
+      # @return [Send] The new pending Send object
+      def create(address_id:, from_asset_id:, to_asset_id:, amount:, network_id:, wallet_id:)
+        from_asset = Asset.fetch(network_id, from_asset_id)
+        to_asset = Asset.fetch(network_id, to_asset_id)
+
+        model = Coinbase.call_api do
+          trades_api.create_trade(
+            wallet_id,
+            address_id,
+            {
+              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
+            }
+          )
+        end
+
+        new(model)
+      end
+
+      # Enumerates the trades for a given address belonging to a wallet.
+      # The result is an enumerator that lazily fetches from the server, and can be iterated over,
+      # converted to an array, etc...
+      # @return [Enumerable<Coinbase::Trade>] Enumerator that returns trades
+      def list(wallet_id:, address_id:)
+        Coinbase::Pagination.enumerate(
+          ->(page) { fetch_page(wallet_id, address_id, page) }
+        ) do |trade|
+          new(trade)
+        end
+      end
+
+      private
+
+      def trades_api
+        Coinbase::Client::TradesApi.new(Coinbase.configuration.api_client)
+      end
+
+      def fetch_page(wallet_id, address_id, page)
+        trades_api.list_trades(wallet_id, address_id, { limit: DEFAULT_PAGE_LIMIT, page: page })
+      end
+    end
+
     # Returns a new Trade object. Do not use this method directly. Instead, use Wallet#trade or
     # Address#trade.
     # @param model [Coinbase::Client::Trade] The underlying Trade object
@@ -76,12 +127,37 @@ module Coinbase
       @approve_transaction ||= @model.approve_transaction ? Coinbase::Transaction.new(@model.approve_transaction) : nil
     end
 
+    # Returns the list of Transactions for the Trade.
+    def transactions
+      [approve_transaction, transaction].compact
+    end
+
     # Returns the status of the Trade.
     # @return [Symbol] The status
     def status
       transaction.status
     end
 
+    # Broadcasts the Trade to the Network.
+    # This raises an error if the Trade is not signed.
+    # @raise [RuntimeError] If the Trade is not signed
+    # @return [Trade] The Trade object
+    def broadcast!
+      raise TransactionNotSignedError unless transactions.all?(&:signed?)
+
+      payloads = { signed_payload: transaction.raw.hex }
+
+      payloads[:approve_tx_signed_payload] = approve_transaction.raw.hex unless approve_transaction.nil?
+
+      @model = Coinbase.call_api do
+        trades_api.broadcast_trade(wallet_id, address_id, id, payloads)
+      end
+
+      update_transactions(@model)
+
+      self
+    end
+
     # Waits until the Trade is completed or failed by polling the Network at the given interval. Raises a
     # Timeout::Error if the Trade takes longer than the given timeout.
     # @param interval_seconds [Integer] The interval at which to poll the Network, in seconds
@@ -114,11 +190,7 @@ module Coinbase
         trades_api.get_trade(wallet_id, address_id, id)
       end
 
-      # Update the memoized transaction.
-      @transaction = Coinbase::Transaction.new(@model.transaction)
-
-      # Update the memoized approve transaction if it exists.
-      @approve_transaction = @model.approve_transaction ? Coinbase::Transaction.new(@model.approve_transaction) : nil
+      update_transactions(@model)
 
       self
     end
@@ -140,6 +212,16 @@ module Coinbase
 
     private
 
+    def update_transactions(model)
+      # Update the memoized transaction.
+      @transaction = Coinbase::Transaction.new(model.transaction)
+
+      return if model.approve_transaction.nil?
+
+      # Update the memoized approve transaction if it exists.
+      @approve_transaction = Coinbase::Transaction.new(model.approve_transaction)
+    end
+
     def trades_api
       @trades_api ||= Coinbase::Client::TradesApi.new(Coinbase.configuration.api_client)
     end

data/lib/coinbase/transaction.rb

@@ -15,6 +15,9 @@ module Coinbase
       # At this point, transaction hashes may not yet be assigned.
       PENDING = 'pending'
 
+      # The Transaction has been signed, but has not been successfully broadcast yet.
+      SIGNED = 'signed'
+
       # The Transaction has been broadcast to the Network.
       # At this point, at least the transaction hash should be assigned.
       BROADCAST = 'broadcast'
@@ -84,6 +87,14 @@ module Coinbase
     def raw
       return @raw unless @raw.nil?
 
+      # If the transaction is signed, decode the signed payload.
+      unless signed_payload.nil?
+        @raw = Eth::Tx::Eip1559.decode(signed_payload)
+
+        return @raw
+      end
+
+      # If the transaction is unsigned, parse the unsigned payload into an EIP-1559 transaction.
       raw_payload = [unsigned_payload].pack('H*')
       parsed_payload = JSON.parse(raw_payload)
 
@@ -93,8 +104,8 @@ module Coinbase
         priority_fee: parsed_payload['maxPriorityFeePerGas'].to_i(16),
         max_gas_fee: parsed_payload['maxFeePerGas'].to_i(16),
         gas_limit: parsed_payload['gas'].to_i(16), # TODO: Handle multiple currencies.
-        from: Eth::Address.new(from_address_id),
-        to: Eth::Address.new(parsed_payload['to']),
+        from: from_address_id,
+        to: parsed_payload['to'],
         value: parsed_payload['value'].to_i(16),
         data: parsed_payload['input'] || ''
       }

data/lib/coinbase/transfer.rb

@@ -11,6 +11,62 @@ module Coinbase
   # in the native Asset of the Network. Transfers should be created through Wallet#transfer or
   # Address#transfer.
   class Transfer
+    class << self
+      # Creates a new Transfer object.
+      # @param address_id [String] The Address ID of the sending Address
+      # @param amount [BigDecimal] The amount of the Asset to send
+      # @param asset_id [Symbol] The Asset ID of the Asset to send
+      # @param destination [Coinbase::Destination, Coinbase::Wallet, Coinbase::Address, String]
+      #   The destination of the transfer.
+      #   If the destination is a Wallet, it uses the default Address of the Wallet.
+      #   If the destination is an Address, it uses the Address's ID.
+      #   If the destination is a String, it uses it as the Address ID.
+      # @param network_id [Symbol] The Network ID of the Asset
+      # @param wallet_id [String] The Wallet ID of the sending Wallet
+      # @return [Transfer] The new pending Transfer object
+      # @raise [Coinbase::ApiError] If the Transfer fails
+      def create(address_id:, amount:, asset_id:, destination:, network_id:, wallet_id:)
+        asset = Asset.fetch(network_id, asset_id)
+
+        model = Coinbase.call_api do
+          transfers_api.create_transfer(
+            wallet_id,
+            address_id,
+            {
+              amount: asset.to_atomic_amount(amount).to_i.to_s,
+              asset_id: asset.primary_denomination.to_s,
+              destination: Coinbase::Destination.new(destination, network_id: network_id).address_id,
+              network_id: Coinbase.normalize_network(network_id)
+            }
+          )
+        end
+
+        new(model)
+      end
+
+      # Enumerates the transfers for a given address belonging to a wallet.
+      # The result is an enumerator that lazily fetches from the server, and can be iterated over,
+      # converted to an array, etc...
+      # @return [Enumerable<Coinbase::Transfer>] Enumerator that returns transfers
+      def list(wallet_id:, address_id:)
+        Coinbase::Pagination.enumerate(
+          ->(page) { fetch_page(wallet_id, address_id, page) }
+        ) do |transfer|
+          new(transfer)
+        end
+      end
+
+      private
+
+      def transfers_api
+        Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
+      end
+
+      def fetch_page(wallet_id, address_id, page)
+        transfers_api.list_transfers(wallet_id, address_id, { limit: DEFAULT_PAGE_LIMIT, page: page })
+      end
+    end
+
     # Returns a new Transfer object. Do not use this method directly. Instead, use Wallet#transfer or
     # Address#transfer.
     # @param model [Coinbase::Client::Transfer] The underlying Transfer object
@@ -103,6 +159,27 @@ module Coinbase
       transaction.status
     end
 
+    # Broadcasts the Transfer to the Network.
+    # This raises an error if the Transfer is not signed.
+    # @raise [RuntimeError] If the Transfer is not signed
+    # @return [Transfer] The Transfer object
+    def broadcast!
+      raise TransactionNotSignedError unless transaction.signed?
+
+      @model = Coinbase.call_api do
+        transfers_api.broadcast_transfer(
+          wallet_id,
+          from_address_id,
+          id,
+          { signed_payload: transaction.raw.hex }
+        )
+      end
+
+      update_transaction(@model)
+
+      self
+    end
+
     # Reload reloads the Transfer model with the latest version from the server side.
     # @return [Transfer] The most recent version of Transfer from the server.
     def reload
@@ -110,8 +187,7 @@ module Coinbase
         transfers_api.get_transfer(wallet_id, from_address_id, id)
       end
 
-      # Update memoized transaction.
-      @transaction = Coinbase::Transaction.new(@model.transaction)
+      update_transaction(@model)
 
       self
     end
@@ -157,5 +233,9 @@ module Coinbase
     def transfers_api
       @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
     end
+
+    def update_transaction(model)
+      @transaction = Coinbase::Transaction.new(model.transaction)
+    end
   end
 end

data/lib/coinbase/wallet.rb

@@ -13,9 +13,6 @@ module Coinbase
     # The maximum number of addresses in a Wallet.
     MAX_ADDRESSES = 20
 
-    # The maximum number of wallets to fetch in a single page.
-    PAGE_LIMIT = 100
-
     # A representation of ServerSigner status in a Wallet.
     module ServerSignerStatus
       # The Wallet is awaiting seed creation by the ServerSigner. At this point,
@@ -131,7 +128,7 @@ module Coinbase
       end
 
       def fetch_wallets_page(page)
-        wallets_api.list_wallets({ limit: PAGE_LIMIT, page: page })
+        wallets_api.list_wallets({ limit: DEFAULT_PAGE_LIMIT, page: page })
       end
     end
 

data/lib/coinbase.rb

@@ -9,6 +9,7 @@ require_relative 'coinbase/balance'
 require_relative 'coinbase/balance_map'
 require_relative 'coinbase/client'
 require_relative 'coinbase/constants'
+require_relative 'coinbase/destination'
 require_relative 'coinbase/errors'
 require_relative 'coinbase/faucet_transaction'
 require_relative 'coinbase/middleware'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coinbase-sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.13
 platform: ruby
 authors:
 - Yuga Cohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-23 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -301,6 +301,7 @@ files:
 - lib/coinbase/client/models/wallet_list.rb
 - lib/coinbase/client/version.rb
 - lib/coinbase/constants.rb
+- lib/coinbase/destination.rb
 - lib/coinbase/errors.rb
 - lib/coinbase/faucet_transaction.rb
 - lib/coinbase/middleware.rb