coinbase-sdk 0.0.7 → 0.0.9

data/lib/coinbase/errors.rb

@@ -6,97 +6,63 @@ require 'json'
 module Coinbase
   # A wrapper for API errors to provide more context.
   class APIError < StandardError
-    attr_reader :http_code, :api_code, :api_message
+    attr_reader :http_code, :api_code, :api_message, :handled
 
     # Initializes a new APIError object.
     # @param err [Coinbase::Client::APIError] The underlying error object.
-    def initialize(err)
-      super
+    def initialize(err, code: nil, message: nil, unhandled: false)
       @http_code = err.code
+      @api_code = code
+      @api_message = message
+      @handled = code && message && !unhandled
 
-      return unless err.response_body
-
-      body = JSON.parse(err.response_body)
-      @api_code = body['code']
-      @api_message = body['message']
+      super(err)
     end
 
     # Creates a specific APIError based on the API error code.
     # @param err [Coinbase::Client::APIError] The underlying error object.
     # @return [APIError] The specific APIError object.
-    # rubocop:disable Metrics/MethodLength
     def self.from_error(err)
       raise ArgumentError, 'Argument must be a Coinbase::Client::APIError' unless err.is_a? Coinbase::Client::ApiError
       return APIError.new(err) unless err.response_body
 
-      body = JSON.parse(err.response_body)
+      begin
+        body = JSON.parse(err.response_body)
+      rescue JSON::ParserError
+        return APIError.new(err)
+      end
 
-      case body['code']
-      when 'unimplemented'
-        UnimplementedError.new(err)
-      when 'unauthorized'
-        UnauthorizedError.new(err)
-      when 'internal'
-        InternalError.new(err)
-      when 'not_found'
-        NotFoundError.new(err)
-      when 'invalid_wallet_id'
-        InvalidWalletIDError.new(err)
-      when 'invalid_address_id'
-        InvalidAddressIDError.new(err)
-      when 'invalid_wallet'
-        InvalidWalletError.new(err)
-      when 'invalid_address'
-        InvalidAddressError.new(err)
-      when 'invalid_amount'
-        InvalidAmountError.new(err)
-      when 'invalid_transfer_id'
-        InvalidTransferIDError.new(err)
-      when 'invalid_page_token'
-        InvalidPageError.new(err)
-      when 'invalid_page_limit'
-        InvalidLimitError.new(err)
-      when 'already_exists'
-        AlreadyExistsError.new(err)
-      when 'malformed_request'
-        MalformedRequestError.new(err)
-      when 'unsupported_asset'
-        UnsupportedAssetError.new(err)
-      when 'invalid_asset_id'
-        InvalidAssetIDError.new(err)
-      when 'invalid_destination'
-        InvalidDestinationError.new(err)
-      when 'invalid_network_id'
-        InvalidNetworkIDError.new(err)
-      when 'resource_exhausted'
-        ResourceExhaustedError.new(err)
-      when 'faucet_limit_reached'
-        FaucetLimitReachedError.new(err)
-      when 'invalid_signed_payload'
-        InvalidSignedPayloadError.new(err)
-      when 'invalid_transfer_status'
-        InvalidTransferStatusError.new(err)
-      when 'network_feature_unsupported'
-        NetworkFeatureUnsupportedError.new(err)
+      message = body['message']
+      code = body['code']
+
+      if ERROR_CODE_TO_ERROR_CLASS.key?(code)
+        ERROR_CODE_TO_ERROR_CLASS[code].new(err, code: code, message: message)
       else
-        APIError.new(err)
+        APIError.new(err, code: code, message: message, unhandled: true)
       end
     end
-    # rubocop:enable Metrics/MethodLength
 
-    # Returns a String representation of the APIError.
-    # @return [String] a String representation of the APIError
+    # Override to_s to display a friendly error message
     def to_s
-      "APIError{http_code: #{@http_code}, api_code: #{@api_code}, api_message: #{@api_message}}"
+      # For handled errors, display just the API message as that provides sufficient context.
+      return api_message if handled
+
+      # For unhandled errors, display the full error message
+      super
     end
 
-    # Same as to_s.
-    # @return [String] a String representation of the APIError
     def inspect
       to_s
     end
   end
 
+  # An error raised when an operation is attempted with insufficient funds.
+  class InsufficientFundsError < StandardError
+    def initialize(expected, exact, msg = 'Insufficient funds')
+      super("#{msg}: have #{exact}, need #{expected}.")
+    end
+  end
+
   class UnimplementedError < APIError; end
   class UnauthorizedError < APIError; end
   class InternalError < APIError; end
@@ -120,4 +86,30 @@ module Coinbase
   class InvalidSignedPayloadError < APIError; end
   class InvalidTransferStatusError < APIError; end
   class NetworkFeatureUnsupportedError < APIError; end
+
+  ERROR_CODE_TO_ERROR_CLASS = {
+    'unimplemented' => UnimplementedError,
+    'unauthorized' => UnauthorizedError,
+    'internal' => InternalError,
+    'not_found' => NotFoundError,
+    'invalid_wallet_id' => InvalidWalletIDError,
+    'invalid_address_id' => InvalidAddressIDError,
+    'invalid_wallet' => InvalidWalletError,
+    'invalid_address' => InvalidAddressError,
+    'invalid_amount' => InvalidAmountError,
+    'invalid_transfer_id' => InvalidTransferIDError,
+    'invalid_page_token' => InvalidPageError,
+    'invalid_page_limit' => InvalidLimitError,
+    'already_exists' => AlreadyExistsError,
+    'malformed_request' => MalformedRequestError,
+    'unsupported_asset' => UnsupportedAssetError,
+    'invalid_asset_id' => InvalidAssetIDError,
+    'invalid_destination' => InvalidDestinationError,
+    'invalid_network_id' => InvalidNetworkIDError,
+    'resource_exhausted' => ResourceExhaustedError,
+    'faucet_limit_reached' => FaucetLimitReachedError,
+    'invalid_signed_payload' => InvalidSignedPayloadError,
+    'invalid_transfer_status' => InvalidTransferStatusError,
+    'network_feature_unsupported' => NetworkFeatureUnsupportedError
+  }.freeze
 end

data/lib/coinbase/faucet_transaction.rb

@@ -12,8 +12,6 @@ module Coinbase
       @model = model
     end
 
-    attr_reader :model
-
     # Returns the transaction hash.
     # @return [String] The onchain transaction hash
     def transaction_hash
@@ -23,8 +21,7 @@ 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}"
+      model.transaction_link
     end
 
     # Returns a String representation of the FaucetTransaction.
@@ -38,5 +35,9 @@ module Coinbase
     def inspect
       to_s
     end
+
+    private
+
+    attr_reader :model
   end
 end

data/lib/coinbase/network.rb

@@ -12,31 +12,15 @@ module Coinbase
     # @param protocol_family [String] The protocol family to which the Network belongs
     #   (e.g., "evm")
     # @param is_testnet [Boolean] Whether the Network is a testnet
-    # @param assets [Array<Asset>] The Assets supported by the Network
     # @param native_asset_id [String] The ID of the Network's native Asset
     # @param chain_id [Integer] The Chain ID of the Network
-    def initialize(network_id:, display_name:, protocol_family:, is_testnet:, assets:, native_asset_id:, chain_id:)
+    def initialize(network_id:, display_name:, protocol_family:, is_testnet:, native_asset_id:, chain_id:)
       @network_id = network_id
       @display_name = display_name
       @protocol_family = protocol_family
       @is_testnet = is_testnet
+      @native_asset_id = native_asset_id
       @chain_id = chain_id
-
-      @asset_map = {}
-      assets.each do |asset|
-        @asset_map[asset.asset_id] = asset
-      end
-
-      raise ArgumentError, 'Native Asset not found' unless @asset_map.key?(native_asset_id)
-
-      @native_asset = @asset_map[native_asset_id]
-    end
-
-    # Lists the Assets supported by the Network.
-    #
-    # @return [Array<Asset>] The Assets supported by the Network
-    def list_assets
-      @asset_map.values
     end
 
     # Gets the Asset with the given ID.
@@ -44,12 +28,14 @@ module Coinbase
     # @param asset_id [Symbol] The ID of the Asset
     # @return [Asset] The Asset with the given ID
     def get_asset(asset_id)
-      @asset_map[asset_id]
+      Asset.fetch(@network_id, asset_id)
     end
 
     # Gets the native Asset of the Network.
     #
     # @return [Asset] The native Asset of the Network
-    attr_reader :native_asset
+    def native_asset
+      @native_asset ||= get_asset(@native_asset_id)
+    end
   end
 end

data/lib/coinbase/pagination.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A module of helper methods for paginating through resources.
+  module Pagination
+    def self.enumerate(fetcher, &build_resource)
+      Enumerator.new do |yielder|
+        page = nil
+
+        loop do
+          response = Coinbase.call_api { fetcher.call(page) }
+
+          break if response.data.empty?
+
+          response.data.each do |model|
+            yielder << build_resource.call(model)
+          end
+
+          break unless response.has_more
+
+          page = response.next_page
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/staking_operation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A representation of a staking operation (stake, unstake, claim rewards, etc). It
+  # may have multiple steps with some being transactions to sign, and others to wait.
+  # @attr_reader [Array<Coinbase::Transaction>] transactions The list of current
+  #   transactions associated with the operation
+  class StakingOperation
+    attr_reader :transactions
+
+    # Returns a new StakingOperation object.
+    # @param model [Coinbase::Client::StakingOperation] The underlying StakingOperation object
+    def initialize(model)
+      @model = model
+
+      @transactions = model.transactions.map do |transaction_model|
+        Transaction.new(transaction_model)
+      end
+    end
+
+    # Signs the Open Transactions with the provided key
+    # @param key [Eth::Key] The key to sign the transactions with
+    def sign(key)
+      transactions.each do |transaction|
+        transaction.sign(key) unless transaction.signed?
+      end
+    end
+  end
+end

data/lib/coinbase/staking_reward.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Coinbase
+  # A representation of a staking reward earned on a network for a given asset.
+  class StakingReward
+    # Returns a list of StakingRewards for the provided network, asset, and addresses.
+    # @param network_id [Symbol] The network ID
+    # @param asset_id [Symbol] The asset ID
+    # @param address_ids [Array<String>] The address IDs
+    # @param start_time [Time] The start time. Defaults to one month ago.
+    # @param end_time [Time] The end time. Defaults to the current time.
+    # @param format [Symbol] The format to return the rewards in. (:usd, :native) Defaults to :usd.
+    # @return [Enumerable<Coinbase::StakingReward>] The staking rewards
+    def self.list(network_id, asset_id, address_ids, start_time: DateTime.now.prev_month(1), end_time: DateTime.now,
+                  format: :usd)
+      asset = Coinbase.call_api do
+        Asset.fetch(network_id, asset_id)
+      end
+      Coinbase::Pagination.enumerate(
+        ->(page) { list_page(network_id, asset_id, address_ids, start_time, end_time, page, format) }
+      ) do |staking_reward|
+        new(staking_reward, asset, format)
+      end
+    end
+
+    # Returns a new StakingReward object.
+    # @param model [Coinbase::Client::StakingReward] The underlying StakingReward object
+    def initialize(model, asset, format)
+      @model = model
+      @asset = asset
+      @format = format
+    end
+
+    # Returns the amount of the StakingReward.
+    # @return [BigDecimal] The amount
+    def amount
+      return BigDecimal(@model.amount.to_i) / BigDecimal(100) if @format == :usd
+
+      @asset.from_atomic_amount(@model.amount.to_i)
+    end
+
+    # Returns the date of the StakingReward.
+    # @return [Time] The date
+    def date
+      @model.date
+    end
+
+    # Returns a string representation of the StakingReward.
+    # @return [String] a string representation of the StakingReward
+    def to_s
+      "Coinbase::StakingReward{amount: '#{amount}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the StakingReward
+    def inspect
+      to_s
+    end
+
+    def self.stake_api
+      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+    end
+
+    def self.list_page(network_id, asset_id, address_ids, start_time, end_time, page, format)
+      req = {
+        network_id: Coinbase.normalize_network(network_id),
+        asset_id: asset_id,
+        address_ids: address_ids,
+        start_time: start_time.iso8601,
+        end_time: end_time.iso8601,
+        format: format,
+        next_page: page
+      }
+      stake_api.fetch_staking_rewards(req)
+    end
+  end
+end

data/lib/coinbase/transaction.rb

@@ -110,6 +110,12 @@ module Coinbase
       raw.hex
     end
 
+    # Returns whether the Transaction has been signed.
+    # @return [Boolean] Whether the Transaction has been signed
+    def signed?
+      Eth::Tx.signed?(raw)
+    end
+
     # Returns a String representation of the Transaction.
     # @return [String] a String representation of the Transaction
     def to_s

data/lib/coinbase/user.rb

@@ -37,53 +37,17 @@ module Coinbase
       Wallet.import(data)
     end
 
-    # Lists the Wallets belonging to the User.
-    # @param page_size [Integer] (Optional) the number of Wallets to return per page. Defaults to 10
-    # @param next_page_token [String] (Optional) the token for the next page of Wallets
-    # @return [Array<Coinbase::Wallet, String>] the Wallets belonging to the User and the pagination token, if
-    #   any.
-    def wallets(page_size: 10, next_page_token: nil)
-      opts = {
-        limit: page_size
-      }
-
-      opts[:page] = next_page_token unless next_page_token.nil?
-
-      wallet_list = Coinbase.call_api do
-        wallets_api.list_wallets(opts)
-      end
-
-      # A map from wallet_id to address models.
-      address_model_map = {}
-
-      wallet_list.data.each do |wallet_model|
-        addresses_list = Coinbase.call_api do
-          addresses_api.list_addresses(wallet_model.id, { limit: Coinbase::Wallet::MAX_ADDRESSES })
-        end
-
-        address_model_map[wallet_model.id] = addresses_list.data
-      end
-
-      wallets = wallet_list.data.map do |wallet_model|
-        Wallet.new(wallet_model, seed: '', address_models: address_model_map[wallet_model.id])
-      end
-
-      [wallets, wallet_list.next_page]
+    # Enumerates the Wallets belonging to the User.
+    # @return [Enumerator<Coinbase::Wallet>] the Wallets belonging to the User
+    def wallets
+      Wallet.list
     end
 
     # Returns the Wallet with the given ID.
     # @param wallet_id [String] the ID of the Wallet
     # @return [Coinbase::Wallet] the unhydrated Wallet
     def wallet(wallet_id)
-      wallet_model = Coinbase.call_api do
-        wallets_api.get_wallet(wallet_id)
-      end
-
-      addresses_list = Coinbase.call_api do
-        addresses_api.list_addresses(wallet_model.id, { limit: Coinbase::Wallet::MAX_ADDRESSES })
-      end
-
-      Wallet.new(wallet_model, seed: '', address_models: addresses_list.data)
+      Wallet.fetch(wallet_id)
     end
 
     # Returns a string representation of the User.
@@ -97,15 +61,5 @@ module Coinbase
     def inspect
       to_s
     end
-
-    private
-
-    def addresses_api
-      @addresses_api ||= Coinbase::Client::AddressesApi.new(Coinbase.configuration.api_client)
-    end
-
-    def wallets_api
-      @wallets_api ||= Coinbase::Client::WalletsApi.new(Coinbase.configuration.api_client)
-    end
   end
 end