coinbase-sdk 0.0.10 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20237f97b110d59cc508ab2bf8d12c50e03de8c99722caf7c8afc0b44ae14d6f
-  data.tar.gz: a94842743529bd1171179dbbe690034fcd04911fe16046c27b48b4aae2354a30
+  metadata.gz: e6e9201f406c2e00680635ef5a35745b7e0163590ca3f54b0b54e33ef0c6d677
+  data.tar.gz: c46b18a0a974942a1b81fb7c0fd240b7e8c5ce9fe4761932866141cc44b26c07
 SHA512:
-  metadata.gz: b9affa919b3835243affb7ada3935280c4249348082055e79d598ff04b3df65979401078bebadbbd3c1e0ab32499a6eb00acb82221654c2f6a7e9474653436b7
-  data.tar.gz: aa868c4e37d612a0727f05826ec2275f434f23ecccb6edffab13e553b1c1bafec1573793fe6a983c5c9572a21fdbcdae778e83de7907472109d6861c0a101a04
+  metadata.gz: b74ce16758ba14308beaf7166ad5162c808d984549cf029084f2b3f2f3758f6a97e3a1be4d619f0cb24002d9ec721754bef4c8a7cb363bf4f7d947bf529b2cc3
+  data.tar.gz: c03d22d0685413d4d732f75ef3216132af6ad0d3cd3fa2985378f559637a62c0490310da73f9607961321be4b60effb43d2ff8a063b1fba083f8c7e365322909

data/lib/coinbase/address/external_address.rb

@@ -3,171 +3,8 @@
 require 'date'
 
 module Coinbase
-  # A representation of a blockchain Address that do not belong to a Coinbase::Wallet.
-  # External addresses can be used to fetch balances, request funds from the faucet, etc...,
+  # A representation of a blockchain Address that does not belong to a Coinbase::Wallet.
+  # External addresses can be used to fetch balances, request funds from the faucet, etc.,
   # but cannot be used to sign transactions.
-  class ExternalAddress < Address
-    # Builds a stake operation for the supplied asset. The stake operation
-    # may take a few minutes to complete in the case when infrastructure is spun up.
-    # @param amount [Integer,String,BigDecimal] The amount of the asset to stake
-    # @param asset_id [Symbol] The asset to stake
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the stake operation
-    # @return [Coinbase::StakingOperation] The stake operation
-    def build_stake_operation(amount, asset_id, mode: :default, options: {})
-      validate_can_stake!(amount, asset_id, mode, options)
-
-      build_staking_operation(amount, asset_id, 'stake', mode: mode, options: options)
-    end
-
-    # Builds an unstake operation for the supplied asset.
-    # @param amount [Integer,String,BigDecimal] The amount of the asset to unstake
-    # @param asset_id [Symbol] The asset to unstake
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the unstake operation
-    # @return [Coinbase::StakingOperation] The unstake operation
-    def build_unstake_operation(amount, asset_id, mode: :default, options: {})
-      validate_can_unstake!(amount, asset_id, mode, options)
-
-      build_staking_operation(amount, asset_id, 'unstake', mode: mode, options: options)
-    end
-
-    # Builds an claim_stake operation for the supplied asset.
-    # @param amount [Integer,String,BigDecimal] The amount of the asset to claim
-    # @param asset_id [Symbol] The asset to claim
-    # @param mode [Symbol] The staking mode. Defaults to :default.
-    # @param options [Hash] Additional options for the claim_stake operation
-    # @return [Coinbase::StakingOperation] The claim_stake operation
-    def build_claim_stake_operation(amount, asset_id, mode: :default, options: {})
-      validate_can_claim_stake!(amount, asset_id, mode, options)
-
-      build_staking_operation(amount, asset_id, 'claim_stake', mode: mode, options: options)
-    end
-
-    # Retrieves the balances used for staking for the supplied asset.
-    # @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: {})
-      context_model = Coinbase.call_api do
-        stake_api.get_staking_context(
-          {
-            asset_id: asset_id,
-            network_id: Coinbase.normalize_network(network_id),
-            address_id: id,
-            options: {
-              mode: mode
-            }.merge(options)
-          }
-        )
-      end.context
-
-      {
-        stakeable_balance: Coinbase::Balance.from_model_and_asset_id(
-          context_model.stakeable_balance,
-          asset_id
-        ).amount,
-        unstakeable_balance: Coinbase::Balance.from_model_and_asset_id(
-          context_model.unstakeable_balance,
-          asset_id
-        ).amount,
-        claimable_balance: Coinbase::Balance.from_model_and_asset_id(
-          context_model.claimable_balance,
-          asset_id
-        ).amount
-      }
-    end
-
-    # Retrieves the stakeable balance for the supplied asset.
-    # @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: {})
-      staking_balances(asset_id, mode: mode, options: options)[:stakeable_balance]
-    end
-
-    # Retrieves the unstakeable balance for the supplied asset.
-    # @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: {})
-      staking_balances(asset_id, mode: mode, options: options)[:unstakeable_balance]
-    end
-
-    # Retrieves the claimable balance for the supplied asset.
-    # @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: {})
-      staking_balances(asset_id, mode: mode, options: options)[:claimable_balance]
-    end
-
-    # Lists the staking rewards for the address.
-    # @param asset_id [Symbol] The asset to retrieve staking rewards for
-    # @param start_time [Time] The start time for the rewards. Defaults to 1 month ago.
-    # @param end_time [Time] The end time for the rewards. Defaults to the current time.
-    # @param format [Symbol] The format to return the rewards in. Defaults to :usd.
-    # @return [Enumerable<Coinbase::StakingReward>] The staking rewards
-    def staking_rewards(asset_id, start_time: DateTime.now.prev_month(1), end_time: DateTime.now, format: :usd)
-      StakingReward.list(
-        network_id,
-        asset_id,
-        [id],
-        start_time: start_time,
-        end_time: end_time,
-        format: format
-      )
-    end
-
-    private
-
-    def validate_can_stake!(amount, asset_id, mode, options)
-      stakeable_balance = stakeable_balance(asset_id, mode: mode, options: options)
-
-      raise InsufficientFundsError.new(amount, stakeable_balance) unless stakeable_balance >= amount
-    end
-
-    def validate_can_unstake!(amount, asset_id, mode, options)
-      unstakeable_balance = unstakeable_balance(asset_id, mode: mode, options: options)
-
-      raise InsufficientFundsError.new(amount, unstakeable_balance) unless unstakeable_balance >= amount
-    end
-
-    def validate_can_claim_stake!(amount, asset_id, mode, options)
-      claimable_balance = claimable_balance(asset_id, mode: mode, options: options)
-
-      raise InsufficientFundsError.new(amount, claimable_balance) unless claimable_balance >= amount
-    end
-
-    def build_staking_operation(amount, asset_id, action, mode: :default, options: {})
-      operation_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: 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
-
-      StakingOperation.new(operation_model)
-    end
-
-    def stake_api
-      @stake_api ||= Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
-    end
-  end
+  class ExternalAddress < Address; end
 end

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,63 @@ 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)
+      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
 
-      validate_can_trade!(amount, from_asset)
+      trade.broadcast!
+      trade
+    end
+
+    # Stakes the given amount of the given Asset
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to stake.
+    # @param asset_id [Symbol] The ID of the Asset to stake. For Ether, :eth, :gwei, and :wei are supported.
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the stake operation
+    # @return [Coinbase::StakingOperation] The staking operation
+    def stake(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'stakeable_balance', mode, options)
 
-      trade = create_trade(amount, from_asset, to_asset)
+      complete_staking_operation(amount, asset_id, 'stake', mode: mode, options: options)
+    end
 
-      # NOTE: Trading does not yet support server signers at this point.
+    # Unstakes the given amount of the given Asset
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to unstake.
+    # @param asset_id [Symbol] The ID of the Asset to stake. For Ether, :eth, :gwei, and :wei are supported.
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the stake operation
+    # @return [Coinbase::StakingOperation] The staking operation
+    def unstake(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'unstakeable_balance', mode, options)
 
-      payloads = { signed_payload: trade.transaction.sign(@key) }
+      complete_staking_operation(amount, asset_id, 'unstake', mode: mode, options: options)
+    end
 
-      payloads[:approve_tx_signed_payload] = trade.approve_transaction.sign(@key) unless trade.approve_transaction.nil?
+    # Claims the given amount of the given Asset
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to claim.
+    # @param asset_id [Symbol] The ID of the Asset to stake. For Ether, :eth, :gwei, and :wei are supported.
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the stake operation
+    # @return [Coinbase::StakingOperation] The staking operation
+    def claim_stake(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'claimable_balance', mode, options)
 
-      broadcast_trade(trade, **payloads)
+      complete_staking_operation(amount, asset_id, 'claim_stake', mode: mode, options: options)
     end
 
     # Returns whether the Address has a private key backing it to sign transactions.
@@ -99,9 +147,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 +155,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 +166,27 @@ 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 ensure_can_sign!
+      return if Coinbase.use_server_signer?
+      return if can_sign?
 
-    def transfers_api
-      @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
+      raise AddressCannotSignError
     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, 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"
+      raise InsufficientFundsError.new(amount, current_balance)
     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)
+    def complete_staking_operation(amount, asset_id, action, mode: :default, options: {})
+      op = StakingOperation.create(amount, network_id, asset_id, id, wallet_id, action, mode, options)
+      op.transactions.each do |transaction|
+        transaction.sign(@key)
       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)
+      op.broadcast!
     end
   end
 end

data/lib/coinbase/address.rb

@@ -75,10 +75,138 @@ module Coinbase
       end
     end
 
+    # Builds a stake operation for the supplied asset. The stake operation
+    # may take a few minutes to complete in the case when infrastructure is spun up.
+    # @param amount [Integer,String,BigDecimal] The amount of the asset to stake
+    # @param asset_id [Symbol] The asset to stake
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the stake operation
+    # @return [Coinbase::StakingOperation] The stake operation
+    def build_stake_operation(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'stakeable_balance', mode, options)
+
+      StakingOperation.build(amount, network_id, asset_id, id, 'stake', mode, options)
+    end
+
+    # Builds an unstake operation for the supplied asset.
+    # @param amount [Integer,String,BigDecimal] The amount of the asset to unstake
+    # @param asset_id [Symbol] The asset to unstake
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the unstake operation
+    # @return [Coinbase::StakingOperation] The unstake operation
+    def build_unstake_operation(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'unstakeable_balance', mode, options)
+
+      StakingOperation.build(amount, network_id, asset_id, id, 'unstake', mode, options)
+    end
+
+    # Builds a claim_stake operation for the supplied asset.
+    # @param amount [Integer,String,BigDecimal] The amount of the asset to claim
+    # @param asset_id [Symbol] The asset to claim
+    # @param mode [Symbol] The staking mode. Defaults to :default.
+    # @param options [Hash] Additional options for the claim_stake operation
+    # @return [Coinbase::StakingOperation] The claim_stake operation
+    def build_claim_stake_operation(amount, asset_id, mode: :default, options: {})
+      validate_can_perform_staking_action!(amount, asset_id, 'claimable_balance', mode, options)
+
+      StakingOperation.build(amount, network_id, asset_id, id, 'claim_stake', mode, options)
+    end
+
+    # Retrieves the balances used for staking for the supplied asset.
+    # @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: {})
+      context_model = Coinbase.call_api do
+        stake_api.get_staking_context(
+          {
+            asset_id: asset_id,
+            network_id: Coinbase.normalize_network(network_id),
+            address_id: id,
+            options: {
+              mode: mode
+            }.merge(options)
+          }
+        )
+      end.context
+
+      {
+        stakeable_balance: Coinbase::Balance.from_model_and_asset_id(
+          context_model.stakeable_balance,
+          asset_id
+        ).amount,
+        unstakeable_balance: Coinbase::Balance.from_model_and_asset_id(
+          context_model.unstakeable_balance,
+          asset_id
+        ).amount,
+        claimable_balance: Coinbase::Balance.from_model_and_asset_id(
+          context_model.claimable_balance,
+          asset_id
+        ).amount
+      }
+    end
+
+    # Retrieves the stakeable balance for the supplied asset.
+    # @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: {})
+      staking_balances(asset_id, mode: mode, options: options)[:stakeable_balance]
+    end
+
+    # Retrieves the unstakeable balance for the supplied asset.
+    # @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: {})
+      staking_balances(asset_id, mode: mode, options: options)[:unstakeable_balance]
+    end
+
+    # Retrieves the claimable balance for the supplied asset.
+    # @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: {})
+      staking_balances(asset_id, mode: mode, options: options)[:claimable_balance]
+    end
+
+    # Lists the staking rewards for the address.
+    # @param asset_id [Symbol] The asset to retrieve staking rewards for
+    # @param start_time [Time] The start time for the rewards. Defaults to 1 week ago.
+    # @param end_time [Time] The end time for the rewards. Defaults to the current time.
+    # @param format [Symbol] The format to return the rewards in. Defaults to :usd.
+    # @return [Enumerable<Coinbase::StakingReward>] The staking rewards
+    def staking_rewards(asset_id, start_time: DateTime.now.prev_week(1), end_time: DateTime.now, format: :usd)
+      StakingReward.list(
+        network_id,
+        asset_id,
+        [id],
+        start_time: start_time,
+        end_time: end_time,
+        format: format
+      )
+    end
+
     private
 
+    def validate_can_perform_staking_action!(amount, asset_id, balance_type, mode, options)
+      current_staking_balance = staking_balances(asset_id, mode: mode, options: options)[balance_type.to_sym]
+      raise InsufficientFundsError.new(amount, current_staking_balance) unless current_staking_balance >= amount
+    end
+
     def addresses_api
       @addresses_api ||= Coinbase::Client::ExternalAddressesApi.new(Coinbase.configuration.api_client)
     end
+
+    def stake_api
+      @stake_api ||= Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+    end
   end
 end

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.6.0
+Generator version: 7.7.0
 
 =end
 

data/lib/coinbase/client/api/assets_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.6.0
+Generator version: 7.7.0
 
 =end
 
@@ -22,7 +22,7 @@ module Coinbase::Client
     # 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 asset_id [String] The ID of the asset to fetch. This could be a symbol or an ERC20 contract address.
     # @param [Hash] opts the optional parameters
     # @return [Asset]
     def get_asset(network_id, asset_id, opts = {})
@@ -33,7 +33,7 @@ module Coinbase::Client
     # 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 asset_id [String] The ID of the asset to fetch. This could be a symbol or an ERC20 contract address.
     # @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 = {})