coinbase-sdk 0.0.10 → 0.0.14

data/lib/coinbase/middleware.rb

@@ -3,6 +3,7 @@
 require_relative 'authenticator'
 require_relative 'client/configuration'
 require 'faraday'
+require 'faraday/retry'
 
 module Coinbase
   # A module for middleware that can be used with Faraday.
@@ -18,6 +19,17 @@ module Coinbase
         config.host = uri.host + (uri.port ? ":#{uri.port}" : '')
         config.scheme = uri.scheme if uri.scheme
         config.request(:authenticator)
+        retry_options = {
+          max: Coinbase.configuration.max_network_tries,
+          interval: 0.05,
+          interval_randomness: 0.5,
+          backoff_factor: 2,
+          methods: %i[get],
+          retry_statuses: [500, 502, 503, 504]
+        }
+        config.configure_faraday_connection do |conn|
+          conn.request :retry, retry_options
+        end
       end
     end
   end

data/lib/coinbase/staking_operation.rb

@@ -9,6 +9,67 @@ module Coinbase
   class StakingOperation
     attr_reader :transactions
 
+    # Builds an ephemeral staking operation this is intended to be called via an Address or Wallet.
+    # @param amount [BigDecimal] The amount to stake, in the primary denomination of the asset
+    # @param network_id [Symbol] The Network ID
+    # @param asset_id [Symbol] The Asset ID
+    # @param address_id [String] The Address ID
+    # @param action [Symbol] The action to perform
+    # @param mode [Symbol] The staking mode
+    # @param options [Hash] Additional options
+    # @return [Coinbase::StakingOperation] The staking operation
+    def self.build(amount, network_id, asset_id, address_id, action, mode, options)
+      model = Coinbase.call_api do
+        asset = Coinbase::Asset.fetch(network_id, asset_id)
+        stake_api.build_staking_operation(
+          {
+            asset_id: asset.primary_denomination.to_s,
+            address_id: address_id,
+            action: action,
+            network_id: Coinbase.normalize_network(network_id),
+            options: {
+              amount: asset.to_atomic_amount(amount).to_i.to_s,
+              mode: mode
+            }.merge(options)
+          }
+        )
+      end
+
+      new(model)
+    end
+
+    # Creates a persisted staking operation this is intended to be called via an Address or Wallet.
+    # @param amount [BigDecimal] The amount to stake, in the primary denomination of the asset
+    # @param network_id [Symbol] The Network ID
+    # @param asset_id [Symbol] The Asset ID
+    # @param address_id [String] The Address ID
+    # @param wallet_id [String] The Wallet ID
+    # @param action [Symbol] The action to perform
+    # @param mode [Symbol] The staking mode
+    # @param options [Hash] Additional options
+    # @return [Coinbase::StakingOperation] The staking operation
+    def self.create(amount, network_id, asset_id, address_id, wallet_id, action, mode, options)
+      model = Coinbase.call_api do
+        asset = Coinbase::Asset.fetch(network_id, asset_id)
+        stake_api.create_staking_operation(
+          wallet_id,
+          address_id,
+          {
+            asset_id: asset.primary_denomination.to_s,
+            address_id: address_id,
+            action: action,
+            network_id: Coinbase.normalize_network(network_id),
+            options: {
+              amount: asset.to_atomic_amount(amount).to_i.to_s,
+              mode: mode
+            }.merge(options)
+          }
+        )
+      end
+
+      new(model)
+    end
+
     # Returns a new StakingOperation object.
     # @param model [Coinbase::Client::StakingOperation] The underlying StakingOperation object
     def initialize(model)
@@ -39,6 +100,12 @@ module Coinbase
       @model.status
     end
 
+    # Returns the Wallet ID of the Staking Operation.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
     # Waits until the Staking Operation is completed or failed by polling its status at the given interval. Raises a
     # Timeout::Error if the Staking Operation takes longer than the given timeout.
     # @param interval_seconds [Integer] The interval at which to poll, in seconds
@@ -66,13 +133,18 @@ module Coinbase
     # @param network_id [Symbol] The Network ID
     # @param address_id [Symbol] The Address ID
     # @param id [String] The ID of the StakingOperation
+    # @param wallet_id [String] The optional Wallet ID
     # @return [Coinbase::StakingOperation] The staking operation
-    def self.fetch(network_id, address_id, id)
+    def self.fetch(network_id, address_id, id, wallet_id: nil)
       staking_operation_model = Coinbase.call_api do
-        stake_api.get_external_staking_operation(network_id, address_id, id)
+        if wallet_id.nil?
+          stake_api.get_external_staking_operation(network_id, address_id, id)
+        else
+          stake_api.get_staking_operation(wallet_id, address_id, id)
+        end
       end
 
-      from_model(staking_operation_model)
+      new(staking_operation_model)
     end
 
     # Signs the Open Transactions with the provided key
@@ -87,7 +159,11 @@ module Coinbase
     # @return [Coinbase::StakingOperation] The updated staking operation
     def reload
       @model = Coinbase.call_api do
-        stake_api.get_external_staking_operation(network_id, address_id, id)
+        if wallet_id.nil?
+          stake_api.get_external_staking_operation(network_id, address_id, id)
+        else
+          stake_api.get_staking_operation(wallet_id, address_id, id)
+        end
       end
 
       from_model(@model)
@@ -108,10 +184,33 @@ module Coinbase
       signed_voluntary_exit_messages
     end
 
+    # Broadcasts the Staking Operation transactions to the network
+    # @return [Coinbase::StakingOperation]
+    def broadcast!
+      transactions.each_with_index do |transaction, i|
+        raise TransactionNotSignedError unless transaction.signed?
+
+        Coinbase.call_api do
+          stake_api.broadcast_staking_operation(
+            wallet_id,
+            address_id,
+            id,
+            { signed_payload: transaction.raw.hex, transaction_index: i }
+          )
+        end
+      end
+
+      self
+    end
+
+    def self.stake_api
+      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+    end
+
     private
 
     def stake_api
-      @stake_api ||= Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+      @stake_api ||= self.class.stake_api
     end
 
     def from_model(model)
@@ -120,6 +219,8 @@ module Coinbase
       @transactions = model.transactions.map do |transaction_model|
         Transaction.new(transaction_model)
       end
+
+      self
     end
   end
 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_transaction_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
@@ -69,20 +125,19 @@ module Coinbase
     # Returns the link to the transaction on the blockchain explorer.
     # @return [String] The link to the transaction on the blockchain explorer
     def transaction_link
-      # TODO: Parameterize this by Network.
-      "https://sepolia.basescan.org/tx/#{transaction_hash}"
+      transaction.transaction_link
     end
 
     # Returns the Unsigned Payload of the Transfer.
     # @return [String] The Unsigned Payload
     def unsigned_payload
-      @model.unsigned_payload
+      transaction.unsigned_payload
     end
 
     # Returns the Signed Payload of the Transfer.
     # @return [String] The Signed Payload
     def signed_payload
-      @model.signed_payload
+      transaction.signed_payload
     end
 
     # Returns the Transfer transaction.
@@ -94,7 +149,7 @@ module Coinbase
     # Returns the Transaction Hash of the Transfer.
     # @return [String] The Transaction Hash
     def transaction_hash
-      @model.transaction_hash
+      transaction.transaction_hash
     end
 
     # Returns the status of the Transfer.
@@ -103,6 +158,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 +186,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 +232,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
 
@@ -297,6 +294,82 @@ module Coinbase
       default_address.trade(amount, from_asset_id, to_asset_id)
     end
 
+    # Stakes the given amount of the given Asset.
+    # Currently only the default_address is used to source the Stake.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to stake.
+    # @param asset_id [Symbol] The ID of the Asset to stake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the staking operation.
+    # @return [Coinbase::StakingOperation] The stake operation
+    def stake(amount, asset_id, mode: :default, options: {})
+      default_address.stake(amount, asset_id, mode: mode, options: options)
+    end
+
+    # Unstakes the given amount of the given Asset.
+    # Currently only the default_address is used to source the Unstake.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to unstake.
+    # @param asset_id [Symbol] The ID of the Asset to unstake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the unstaking operation.
+    # @return [Coinbase::StakingOperation] The unstake operation
+    def unstake(amount, asset_id, mode: :default, options: {})
+      default_address.unstake(amount, asset_id, mode: mode, options: options)
+    end
+
+    # Claims stake of the given amount of the given Asset.
+    # Currently only the default_address is used as the source for claim_stake.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to claim_stake.
+    # @param asset_id [Symbol] The ID of the Asset to claim_stake.
+    # @param mode [Symbol] (Optional) The staking mode. Defaults to :default.
+    # @param options [Hash] (Optional) Additional options for the unstaking operation.
+    # @return [Coinbase::StakingOperation] The claim_stake operation
+    def claim_stake(amount, asset_id, mode: :default, options: {})
+      default_address.claim_stake(amount, asset_id, mode: mode, options: options)
+    end
+
+    # Retrieves the balances used for staking for the supplied asset.
+    # Currently only the default_address is used to source the staking balances.
+    # @param asset_id [Symbol] The asset to retrieve staking balances for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [Hash] The staking balances
+    # @return [BigDecimal] :stakeable_balance The amount of the asset that can be staked
+    # @return [BigDecimal] :unstakeable_balance The amount of the asset that is currently staked and cannot be unstaked
+    # @return [BigDecimal] :claimable_balance The amount of the asset that can be claimed
+    def staking_balances(asset_id, mode: :default, options: {})
+      default_address.staking_balances(asset_id, mode: mode, options: options)
+    end
+
+    # Retrieves the stakeable balance for the supplied asset.
+    # Currently only the default_address is used to source the stakeable balance.
+    # @param asset_id [Symbol] The asset to retrieve the stakeable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The stakeable balance
+    def stakeable_balance(asset_id, mode: :default, options: {})
+      default_address.stakeable_balance(asset_id, mode: mode, options: options)
+    end
+
+    # Retrieves the unstakeable balance for the supplied asset.
+    # Currently only the default_address is used to source the unstakeable balance.
+    # @param asset_id [Symbol] The asset to retrieve the unstakeable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The unstakeable balance
+    def unstakeable_balance(asset_id, mode: :default, options: {})
+      default_address.unstakeable_balance(asset_id, mode: mode, options: options)
+    end
+
+    # Retrieves the claimable balance for the supplied asset.
+    # Currently only the default_address is used to source the claimable balance.
+    # @param asset_id [Symbol] The asset to retrieve the claimable balance for
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the staking operation
+    # @return [BigDecimal] The claimable balance
+    def claimable_balance(asset_id, mode: :default, options: {})
+      default_address.claimable_balance(asset_id, mode: mode, options: options)
+    end
+
     # Exports the Wallet's data to a Data object.
     # @return [Data] The Wallet data
     def export

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'
@@ -61,13 +62,14 @@ module Coinbase
 
   # Configuration object for the Coinbase SDK.
   class Configuration
-    attr_accessor :api_url, :api_key_name, :api_key_private_key, :debug_api, :use_server_signer
+    attr_accessor :api_url, :api_key_name, :api_key_private_key, :debug_api, :use_server_signer, :max_network_tries
 
     # Initializes the configuration object.
     def initialize
       @api_url = 'https://api.cdp.coinbase.com'
       @debug_api = false
       @use_server_signer = false
+      @max_network_tries = 3
     end
 
     # Sets configuration values based on the provided CDP API Key JSON file.