coinbase-sdk 0.0.13 → 0.0.16

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/staking_reward.rb

@@ -53,6 +53,24 @@ module Coinbase
       @model.address_id
     end
 
+    # Returns the USD value of the StakingReward.
+    # @return [BigDecimal] The USD value
+    def usd_value
+      BigDecimal(@model.usd_value.amount.to_i) / BigDecimal(100)
+    end
+
+    # Returns the USD conversion price of the StakingReward.
+    # @return [BigDecimal] The USD conversion price
+    def usd_conversion_price
+      BigDecimal(@model.usd_value.conversion_price.to_i) / BigDecimal(100)
+    end
+
+    # Returns the USD conversion time of the StakingReward.
+    # @return [Time] The USD conversion time
+    def usd_conversion_time
+      @model.usd_value.conversion_time
+    end
+
     # Returns a string representation of the StakingReward.
     # @return [String] a string representation of the StakingReward
     def to_s

data/lib/coinbase/trade.rb

@@ -147,7 +147,7 @@ module Coinbase
 
       payloads = { signed_payload: transaction.raw.hex }
 
-      payloads[:approve_tx_signed_payload] = approve_transaction.raw.hex unless approve_transaction.nil?
+      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)

data/lib/coinbase/transaction.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'constants'
-require 'bigdecimal'
 require 'eth'
 require 'json'
 
@@ -113,12 +111,18 @@ module Coinbase
       @raw = Eth::Tx::Eip1559.new(Eth::Tx.validate_eip1559_params(params))
     end
 
+    # Returns the signature of the Transaction.
+    # @return [String] The hex-encode signature
+    def signature
+      raw.hex
+    end
+
     # Signs the Transaction with the provided key and returns the hex signing payload.
     # @return [String] The hex-encoded signed payload
     def sign(key)
       raw.sign(key)
 
-      raw.hex
+      signature
     end
 
     # Returns whether the Transaction has been signed.

data/lib/coinbase/transfer.rb

@@ -3,7 +3,6 @@
 require_relative 'constants'
 require 'bigdecimal'
 require 'eth'
-require 'json'
 
 module Coinbase
   # A representation of a Transfer, which moves an amount of an Asset from
@@ -25,7 +24,7 @@ module Coinbase
       # @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:)
+      def create(address_id:, amount:, asset_id:, destination:, network_id:, wallet_id:, gasless: false)
         asset = Asset.fetch(network_id, asset_id)
 
         model = Coinbase.call_api do
@@ -36,7 +35,8 @@ module Coinbase
               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)
+              network_id: Coinbase.normalize_network(network_id),
+              gasless: gasless
             }
           )
         end
@@ -122,41 +122,52 @@ module Coinbase
       BigDecimal(@model.amount) / BigDecimal(10).power(@model.asset.decimals)
     end
 
-    # 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}"
-    end
+    # Signs the Transfer with the given key. This is required before broadcasting the Transfer.
+    # @param key [Eth::Key] The key to sign the Transfer with
+    # @raise [RuntimeError] If the key is not an Eth::Key
+    # @return [Transfer] The Transfer object
+    def sign(key)
+      raise unless key.is_a?(Eth::Key)
 
-    # Returns the Unsigned Payload of the Transfer.
-    # @return [String] The Unsigned Payload
-    def unsigned_payload
-      @model.unsigned_payload
-    end
+      unless sponsored_send.nil?
+        sponsored_send.sign(key)
+
+        return
+      end
 
-    # Returns the Signed Payload of the Transfer.
-    # @return [String] The Signed Payload
-    def signed_payload
-      @model.signed_payload
+      transaction.sign(key)
+
+      self
     end
 
     # Returns the Transfer transaction.
     # @return [Coinbase::Transaction] The Transfer transaction
     def transaction
-      @transaction ||= Coinbase::Transaction.new(@model.transaction)
+      @transaction ||= @model.transaction.nil? ? nil : Coinbase::Transaction.new(@model.transaction)
     end
 
-    # Returns the Transaction Hash of the Transfer.
-    # @return [String] The Transaction Hash
-    def transaction_hash
-      @model.transaction_hash
+    # Returns the SponsoredSend of the Transfer, if the transfer is gasless.
+    # @return [Coinbase::SponsoredSend] The SponsoredSend object
+    def sponsored_send
+      @sponsored_send ||= @model.sponsored_send.nil? ? nil : Coinbase::SponsoredSend.new(@model.sponsored_send)
     end
 
     # Returns the status of the Transfer.
     # @return [Symbol] The status
     def status
-      transaction.status
+      send_tx_delegate.status
+    end
+
+    # Returns the link to the transaction on the blockchain explorer.
+    # @return [String] The link to the transaction on the blockchain explorer
+    def transaction_link
+      send_tx_delegate.transaction_link
+    end
+
+    # Returns the Transaction Hash of the Transfer.
+    # @return [String] The Transaction Hash
+    def transaction_hash
+      send_tx_delegate.transaction_hash
     end
 
     # Broadcasts the Transfer to the Network.
@@ -164,18 +175,19 @@ module Coinbase
     # @raise [RuntimeError] If the Transfer is not signed
     # @return [Transfer] The Transfer object
     def broadcast!
-      raise TransactionNotSignedError unless transaction.signed?
+      raise TransactionNotSignedError unless send_tx_delegate.signed?
 
       @model = Coinbase.call_api do
         transfers_api.broadcast_transfer(
           wallet_id,
           from_address_id,
           id,
-          { signed_payload: transaction.raw.hex }
+          { signed_payload: send_tx_delegate.signature }
         )
       end
 
-      update_transaction(@model)
+      update_transaction(@model) unless @model.transaction.nil?
+      update_sponsored_send(@model) unless @model.sponsored_send.nil?
 
       self
     end
@@ -187,7 +199,8 @@ module Coinbase
         transfers_api.get_transfer(wallet_id, from_address_id, id)
       end
 
-      update_transaction(@model)
+      update_transaction(@model) unless @model.transaction.nil?
+      update_sponsored_send(@model) unless @model.sponsored_send.nil?
 
       self
     end
@@ -203,7 +216,7 @@ module Coinbase
       loop do
         reload
 
-        return self if transaction.terminal_state?
+        return self if terminal_state?
 
         raise Timeout::Error, 'Transfer timed out' if Time.now - start_time > timeout_seconds
 
@@ -230,6 +243,16 @@ module Coinbase
 
     private
 
+    def terminal_state?
+      send_tx_delegate.terminal_state?
+    end
+
+    def send_tx_delegate
+      return sponsored_send unless sponsored_send.nil?
+
+      transaction
+    end
+
     def transfers_api
       @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
     end
@@ -237,5 +260,9 @@ module Coinbase
     def update_transaction(model)
       @transaction = Coinbase::Transaction.new(model.transaction)
     end
+
+    def update_sponsored_send(model)
+      @sponsored_send = Coinbase::SponsoredSend.new(model.sponsored_send)
+    end
   end
 end

data/lib/coinbase/wallet/data.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coinbase
+  class Wallet
+    # The data required to recreate a Wallet.
+    class Data
+      attr_reader :wallet_id, :seed
+
+      # Returns a new Data object.
+      # @param wallet_id [String] The ID of the Wallet
+      # @param seed [String] The seed of the Wallet
+      def initialize(wallet_id:, seed:)
+        @wallet_id = wallet_id
+        @seed = seed
+      end
+
+      # Converts the Data object to a Hash.
+      # @return [Hash] The Hash representation of the Data object
+      def to_hash
+        { wallet_id: wallet_id, seed: seed }
+      end
+
+      # Creates a Data object from the given Hash.
+      # @param data [Hash] The Hash to create the Data object from
+      # @return [Data] The new Data object
+      def self.from_hash(data)
+        Data.new(wallet_id: data['wallet_id'], seed: data['seed'])
+      end
+    end
+  end
+end

data/lib/coinbase/wallet.rb

@@ -5,6 +5,8 @@ require 'json'
 require 'money-tree'
 require 'securerandom'
 
+require_relative 'wallet/data'
+
 module Coinbase
   # A representation of a Wallet. Wallets come with a single default Address, but can expand to have a set of Addresses,
   # each of which can hold a balance of one or more Assets. Wallets can create new Addresses, list their addresses,
@@ -13,17 +15,6 @@ module Coinbase
     # The maximum number of addresses in a Wallet.
     MAX_ADDRESSES = 20
 
-    # A representation of ServerSigner status in a Wallet.
-    module ServerSignerStatus
-      # The Wallet is awaiting seed creation by the ServerSigner. At this point,
-      # the Wallet cannot create addresses or sign transactions.
-      PENDING = 'pending_seed_creation'
-
-      # The Wallet has an associated seed created by the ServerSigner. It is ready
-      # to create addresses and sign transactions.
-      ACTIVE = 'active_seed'
-    end
-
     class << self
       # Imports a Wallet from previously exported wallet data.
       # @param data [Coinbase::Wallet::Data] the Wallet data to import
@@ -43,7 +34,7 @@ module Coinbase
       # converted to an array, etc...
       # @return [Enumerable<Coinbase::Wallet>] Enumerator that returns wallets
       def list
-        Coinbase::Pagination.enumerate(lambda(&method(:fetch_wallets_page))) do |wallet|
+        Coinbase::Pagination.enumerate(method(:fetch_wallets_page)) do |wallet|
           Coinbase::Wallet.new(wallet, seed: '')
         end
       end
@@ -107,7 +98,7 @@ module Coinbase
             wallets_api.get_wallet(wallet_id)
           end
 
-          return self if model.server_signer_status == ServerSignerStatus::ACTIVE
+          return self if model.server_signer_status == ServerSigner::Status::ACTIVE
 
           if Time.now - start_time > timeout_seconds
             raise Timeout::Error, 'Wallet creation timed out. Check status of your Server-Signer'
@@ -278,9 +269,15 @@ module Coinbase
     # @param asset_id [Symbol] The ID of the Asset to send
     # @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.
+    # @param gasless [Boolean] Whether gas fee for the transfer should be covered by Coinbase.
+    #   Defaults to false. Check the API documentation for network and asset support.
     # @return [Coinbase::Transfer] The Transfer object.
-    def transfer(amount, asset_id, destination)
-      default_address.transfer(amount, asset_id, destination)
+    def transfer(amount, asset_id, destination, options = {})
+      # For ruby 2.7 compatibility we cannot pass in keyword args when the create wallet
+      # options is empty
+      return default_address.transfer(amount, asset_id, destination) if options.empty?
+
+      default_address.transfer(amount, asset_id, destination, **options)
     end
 
     # Trades the given amount of the given Asset for another Asset.
@@ -294,8 +291,84 @@ 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
+    # @return [Coinbase::Wallet::Data] The Wallet data
     def export
       # TODO: Improve this check by relying on the backend data to decide whether a wallet is server-signer backed.
       raise 'Cannot export data for Server-Signer backed Wallet' if Coinbase.use_server_signer?
@@ -357,9 +430,7 @@ module Coinbase
         iv: iv
       }
 
-      File.open(file_path, 'w') do |file|
-        file.write(JSON.pretty_generate(existing_seeds_in_store))
-      end
+      File.write(file_path, JSON.pretty_generate(existing_seeds_in_store))
 
       "Successfully saved seed for wallet #{id} to #{file_path}."
     end
@@ -416,32 +487,6 @@ module Coinbase
       to_s
     end
 
-    # The data required to recreate a Wallet.
-    class Data
-      attr_reader :wallet_id, :seed
-
-      # Returns a new Data object.
-      # @param wallet_id [String] The ID of the Wallet
-      # @param seed [String] The seed of the Wallet
-      def initialize(wallet_id:, seed:)
-        @wallet_id = wallet_id
-        @seed = seed
-      end
-
-      # Converts the Data object to a Hash.
-      # @return [Hash] The Hash representation of the Data object
-      def to_hash
-        { wallet_id: wallet_id, seed: seed }
-      end
-
-      # Creates a Data object from the given Hash.
-      # @param data [Hash] The Hash to create the Data object from
-      # @return [Data] The new Data object
-      def self.from_hash(data)
-        Data.new(wallet_id: data['wallet_id'], seed: data['seed'])
-      end
-    end
-
     private
 
     # Reloads the Wallet with the latest data.
@@ -464,7 +509,7 @@ module Coinbase
     def address_path_prefix
       # TODO: Push this logic to the backend.
       @address_path_prefix ||= case network_id.to_s.split('_').first
-                               when 'base', 'ethereum'
+                               when 'base', 'ethereum', 'polygon'
                                  "m/44'/60'/0'/0"
                                else
                                  raise ArgumentError, "Unsupported network ID: #{network_id}"

data/lib/coinbase.rb

@@ -7,6 +7,7 @@ require_relative 'coinbase/asset'
 require_relative 'coinbase/authenticator'
 require_relative 'coinbase/balance'
 require_relative 'coinbase/balance_map'
+require_relative 'coinbase/historical_balance'
 require_relative 'coinbase/client'
 require_relative 'coinbase/constants'
 require_relative 'coinbase/destination'
@@ -21,6 +22,8 @@ require_relative 'coinbase/transaction'
 require_relative 'coinbase/user'
 require_relative 'coinbase/wallet'
 require_relative 'coinbase/server_signer'
+require_relative 'coinbase/sponsored_send'
+require_relative 'coinbase/staking_balance'
 require_relative 'coinbase/staking_operation'
 require_relative 'coinbase/staking_reward'
 require_relative 'coinbase/validator'
@@ -62,13 +65,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.
@@ -110,7 +114,7 @@ module Coinbase
   # @param network_sym [Symbol] the network symbol to convert
   # @return [String] the converted string
   def self.normalize_network(network_sym)
-    network_sym.to_s.gsub(/_/, '-')
+    network_sym.to_s.gsub('_', '-')
   end
 
   # Loads the default user.
@@ -127,8 +131,17 @@ module Coinbase
     yield
   rescue Coinbase::Client::ApiError => e
     raise Coinbase::APIError.from_error(e), cause: nil
-  rescue StandardError => e
-    raise e
+  end
+
+  # Returns a pretty-printed object string that contains the object's class name and
+  # the details of the object, filtering out nil values.
+  # @param klass [Class] the class of the object
+  # @param details [Hash] the details of the object
+  # @return [String] the pretty-printed object string
+  def self.pretty_print_object(klass, **details)
+    filtered_details = details.filter { |_, v| !v.nil? }.map { |k, v| "#{k}: '#{v}'" }
+
+    "#{klass}{#{filtered_details.join(', ')}}"
   end
 
   # Returns whether to use a server signer to manage private keys.