coinbase-sdk 0.7.0 → 0.11.0

data/lib/coinbase/fiat_amount.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A representation of a FiatAmount that includes the amount and fiat.
+  class FiatAmount
+    # Converts a Coinbase::Client::FiatAmount model to a Coinbase::FiatAmount
+    # @param model [Coinbase::Client::FiatAmount] The crypto amount from the API.
+    # @return [FiatAmount] The converted FiatAmount object.
+    def self.from_model(model)
+      unless model.is_a?(Coinbase::Client::FiatAmount)
+        raise ArgumentError,
+              'model must be a Coinbase::Client::FiatAmount'
+      end
+
+      new(amount: model.amount, currency: model.currency)
+    end
+
+    # Returns a new FiatAmount object.
+    # @param amount [BigDecimal, String] The amount of the Fiat Currency
+    # @param currency [Symbol, String] The currency of the Fiat Amount
+    def initialize(amount:, currency:)
+      @amount = BigDecimal(amount)
+      @currency = Coinbase.to_sym(currency)
+    end
+
+    attr_reader :amount, :currency
+
+    # Returns a string representation of the FiatAmount.
+    # @return [String] a string representation of the FiatAmount
+    def to_s
+      Coinbase.pretty_print_object(self.class, amount: amount.to_s('F'), currency: currency)
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the FiatAmount
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/coinbase/fund_operation.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require 'bigdecimal'
+require 'eth'
+
+module Coinbase
+  # A representation of a Fund Operation, which buys funds from the Coinbase platform,
+  # and sends then to the developer's address.
+  class FundOperation
+    # A representation of a Fund Operation status.
+    module Status
+      # The Fund Operation is being processed.
+      PENDING = 'pending'
+
+      # The Fund Operation is complete.
+      COMPLETE = 'complete'
+
+      # The Fund Operation has failed for some reason.
+      FAILED = 'failed'
+
+      # The states that are considered terminal on-chain.
+      TERMINAL_STATES = [COMPLETE, FAILED].freeze
+    end
+
+    class << self
+      # Creates a new Fund Operation object.
+      # This takes an optional FundQuote object that can be used to lock in the rate and fees.
+      # Without an explicit quote, we will use the current rate and fees.
+      # @param address_id [String] The Address ID of the sending Address
+      # @param wallet_id [String] The Wallet ID of the sending Wallet
+      # @param amount [BigDecimal] The amount of the Asset to send
+      # @param network [Coinbase::Network, Symbol] The Network or Network ID of the Asset
+      # @param asset_id [Symbol] The Asset ID of the Asset to send
+      # @param quote [Coinbase::FundQuote, String] The optional FundQuote to use for the Fund Operation
+      # @return [FundOperation] The new pending Fund Operation object
+      # @raise [Coinbase::ApiError] If the Fund Operation fails
+      def create(wallet_id:, address_id:, amount:, asset_id:, network:, quote: nil)
+        network = Coinbase::Network.from_id(network)
+        asset = network.get_asset(asset_id)
+
+        model = Coinbase.call_api do
+          fund_api.create_fund_operation(
+            wallet_id,
+            address_id,
+            {
+              amount: asset.to_atomic_amount(amount).to_i.to_s,
+              asset_id: asset.primary_denomination.to_s,
+              fund_quote_id: quote_id(quote)
+            }.compact
+          )
+        end
+
+        new(model)
+      end
+
+      # Enumerates the fund operation 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::FundOperation>] Enumerator that returns fund operations
+      def list(wallet_id:, address_id:)
+        Coinbase::Pagination.enumerate(
+          ->(page) { fetch_page(wallet_id, address_id, page) }
+        ) do |fund_operation|
+          new(fund_operation)
+        end
+      end
+
+      private
+
+      def fund_api
+        Coinbase::Client::FundApi.new(Coinbase.configuration.api_client)
+      end
+
+      def fetch_page(wallet_id, address_id, page)
+        fund_api.list_fund_operations(
+          wallet_id,
+          address_id,
+          limit: DEFAULT_PAGE_LIMIT,
+          page: page
+        )
+      end
+
+      def quote_id(quote)
+        return nil if quote.nil?
+        return quote.id if quote.is_a?(FundQuote)
+        return quote if quote.is_a?(String)
+
+        raise ArgumentError, 'quote must be a FundQuote object or ID'
+      end
+    end
+
+    # Returns a new Fund Operation object. Do not use this method directly. Instead, use
+    # Wallet#fund or Address#fund.
+    # @param model [Coinbase::Client::FundOperation] The underlying Fund Operation object
+    def initialize(model)
+      raise ArgumentError, 'must be a FundOperation' unless model.is_a?(Coinbase::Client::FundOperation)
+
+      @model = model
+    end
+
+    # Returns the Fund Operation ID.
+    # @return [String] The Fund Operation ID
+    def id
+      @model.fund_operation_id
+    end
+
+    # Returns the Network of the Fund Operation.
+    # @return [Coinbase::Network] The Network
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
+    end
+
+    # Returns the Wallet ID that the fund quote was created for.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the Address ID that the fund quote was created for.
+    # @return [String] The Address ID
+    def address_id
+      @model.address_id
+    end
+
+    # Returns the Asset of the Fund Operation.
+    # @return [Coinbase::Asset] The Asset
+    def asset
+      amount.asset
+    end
+
+    # Returns the amount that the wallet will receive in crypto.
+    # @return [Coinbase::CryptoAmount] The crypto amount
+    def amount
+      @amount ||= CryptoAmount.from_model(@model.crypto_amount)
+    end
+
+    # Returns the amount that the wallet's owner will pay in fiat.
+    # @return [Coinbase::FiatAmount] The fiat amount
+    def fiat_amount
+      @fiat_amount ||= FiatAmount.from_model(@model.fiat_amount)
+    end
+
+    # Returns the fee that the wallet's owner will pay in fiat.
+    # @return [Coinbase::FiatAmount] The fiat buy fee
+    def buy_fee
+      @buy_fee ||= FiatAmount.from_model(@model.fees.buy_fee)
+    end
+
+    # Returns the fee that the wallet's owner will pay in crypto.
+    # @return [Coinbase::CryptoAmount] The crypto transfer fee
+    def transfer_fee
+      @transfer_fee ||= CryptoAmount.from_model(@model.fees.transfer_fee)
+    end
+
+    # Returns the status of the Fund Operation.
+    # @return [Symbol] The status
+    def status
+      @model.status
+    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
+      @model = Coinbase.call_api do
+        fund_api.get_fund_operation(wallet_id, address_id, id)
+      end
+
+      self
+    end
+
+    # Waits until the Fund Operation is completed or failed by polling the at the given interval.
+    # @param interval_seconds [Integer] The interval at which to poll the Network, in seconds
+    # @param timeout_seconds [Integer] The maximum amount of time to wait for the Fund Operation to complete, in seconds
+    # @return [Coinbase::FundOperation] The completed or failed Fund Operation object
+    # @raise [Timeout::Error] If the Fund Operation takes longer than the given timeout
+    def wait!(interval_seconds = 1, timeout_seconds = 60)
+      start_time = Time.now
+
+      loop do
+        reload
+
+        return self if terminal_state?
+
+        raise Timeout::Error, 'Fund Operation timed out' if Time.now - start_time > timeout_seconds
+
+        self.sleep interval_seconds
+      end
+
+      self
+    end
+
+    # Returns a String representation of the Fund Operation.
+    # @return [String] a String representation of the Fund Operation
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        id: id,
+        network_id: network.id,
+        wallet_id: wallet_id,
+        address_id: address_id,
+        status: status,
+        crypto_amount: amount,
+        fiat_amount: fiat_amount,
+        buy_fee: buy_fee,
+        transfer_fee: transfer_fee
+      )
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Fund Operation.
+    def inspect
+      to_s
+    end
+
+    private
+
+    # Returns whether the Fund Operation is in a terminal state.
+    # @return [Boolean] Whether the Fund Operation is in a terminal state
+    def terminal_state?
+      Status::TERMINAL_STATES.include?(status)
+    end
+
+    def fund_api
+      @fund_api ||= Coinbase::Client::FundApi.new(Coinbase.configuration.api_client)
+    end
+  end
+end

data/lib/coinbase/fund_quote.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require 'bigdecimal'
+require 'eth'
+
+module Coinbase
+  # A representation of a Fund Operation Quote, which is a quote for a fund operation
+  # that buys funds from the Coinbase platform and sends then to the developer's address.
+  class FundQuote
+    class << self
+      # Creates a new Fund Operation Quote object.
+      # @param address_id [String] The Address ID of the sending Address
+      # @param wallet_id [String] The Wallet ID of the sending Wallet
+      # @param amount [BigDecimal] The amount of the Asset to send
+      # @param network [Coinbase::Network, Symbol] The Network or Network ID of the Asset
+      # @param asset_id [Symbol] The Asset ID of the Asset to send
+      # @return [FundQuote] The new Fund Quote object
+      # @raise [Coinbase::ApiError] If the Fund Quote fails
+      def create(wallet_id:, address_id:, amount:, asset_id:, network:)
+        network = Coinbase::Network.from_id(network)
+        asset = network.get_asset(asset_id)
+
+        model = Coinbase.call_api do
+          fund_api.create_fund_quote(
+            wallet_id,
+            address_id,
+            {
+              asset_id: asset.primary_denomination.to_s,
+              amount: asset.to_atomic_amount(amount).to_i.to_s
+            }
+          )
+        end
+
+        new(model)
+      end
+
+      private
+
+      def fund_api
+        Coinbase::Client::FundApi.new(Coinbase.configuration.api_client)
+      end
+    end
+
+    # Returns a new Fund Quote object. Do not use this method directly.
+    # Instead, use Wallet#quote_fund or Address#quote_fund.
+    # @param model [Coinbase::Client::FundQuote] The underlying Fund Quote object
+    def initialize(model)
+      raise ArgumentError, 'must be a FundQuote' unless model.is_a?(Coinbase::Client::FundQuote)
+
+      @model = model
+    end
+
+    # Returns the ID of the Fund Quote.
+    # @return [String] The Fund Quote ID
+    def id
+      @model.fund_quote_id
+    end
+
+    # Executes a fund operation using the quote.
+    # @return [Coinbase::FundOperation] The FundOperation object
+    # @raise [Coinbase::ApiError] If the FundOperation fails
+    def execute!
+      FundOperation.create(
+        wallet_id: wallet_id,
+        address_id: address_id,
+        amount: amount.amount,
+        asset_id: asset.asset_id,
+        network: network.id,
+        quote: self
+      )
+    end
+
+    # Returns the Network the fund quote was created on.
+    # @return [Coinbase::Network] The Network
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
+    end
+
+    # Returns the Wallet ID that the fund quote was created for.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the Address ID that the fund quote was created for.
+    # @return [String] The Address ID
+    def address_id
+      @model.address_id
+    end
+
+    # Returns the Asset of the FundOperation.
+    # @return [Coinbase::Asset] The Asset
+    def asset
+      amount.asset
+    end
+
+    # Returns the amount that the wallet will receive in crypto.
+    # @return [Coinbase::CryptoAmount] The crypto amount
+    def amount
+      @amount ||= CryptoAmount.from_model(@model.crypto_amount)
+    end
+
+    # Returns the amount that the wallet's owner will pay in fiat.
+    # @return [Coinbase::FiatAmount] The fiat amount
+    def fiat_amount
+      @fiat_amount ||= FiatAmount.from_model(@model.fiat_amount)
+    end
+
+    # Returns the fee that the wallet's owner will pay in fiat.
+    # @return [Coinbase::FiatAmount] The fiat buy fee
+    def buy_fee
+      @buy_fee ||= FiatAmount.from_model(@model.fees.buy_fee)
+    end
+
+    # Returns the fee that the wallet's owner will pay in crypto.
+    # @return [Coinbase::CryptoAmount] The crypto transfer fee
+    def transfer_fee
+      @transfer_fee ||= CryptoAmount.from_model(@model.fees.transfer_fee)
+    end
+
+    # Returns a String representation of the Fund Operation.
+    # @return [String] a String representation of the Fund Operation
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        network_id: network.id,
+        wallet_id: wallet_id,
+        address_id: address_id,
+        crypto_amount: amount,
+        fiat_amount: fiat_amount,
+        buy_fee: buy_fee,
+        transfer_fee: transfer_fee
+      )
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Transfer
+    def inspect
+      to_s
+    end
+
+    private
+
+    def fund_api
+      @fund_api ||= Coinbase::Client::FundApi.new(Coinbase.configuration.api_client)
+    end
+  end
+end

data/lib/coinbase/smart_contract.rb

@@ -105,6 +105,12 @@ module Coinbase
       new(contract)
     end
 
+    # Creates a new ERC1155 multi-token contract, that can subsequently be deployed to
+    # the blockchain.
+    # @param address_id [String] The address ID of deployer
+    # @param wallet_id [String] The wallet ID of the deployer
+    # @param uri [String] The URI for the token metadata
+    # @return [SmartContract] The new ERC1155 Multi-Token SmartContract object
     def self.create_multi_token_contract(
       address_id:,
       wallet_id:,
@@ -126,6 +132,95 @@ module Coinbase
       new(contract)
     end
 
+    # Reads data from a deployed smart contract.
+    #
+    # @param network [Coinbase::Network, Symbol] The Network or Network ID of the Asset
+    # @param contract_address [String] The address of the deployed contract
+    # @param method [String] The name of the method to call on the contract
+    # @param abi [Array, nil] The ABI of the contract. If nil, the method will attempt to use a cached ABI
+    # @param args [Hash] The arguments to pass to the contract method.
+    #   The keys should be the argument names, and the values should be the argument values.
+    # @return [Object] The result of the contract call, converted to an appropriate Ruby type
+    # @raise [Coinbase::ApiError] If there's an error in the API call
+    def self.read(
+      contract_address:,
+      method:,
+      network: Coinbase.default_network,
+      abi: nil,
+      args: {}
+    )
+      network = Coinbase::Network.from_id(network)
+
+      response = Coinbase.call_api do
+        smart_contracts_api.read_contract(
+          network.normalized_id,
+          contract_address,
+          {
+            method: method,
+            args: (args || {}).to_json,
+            abi: abi&.to_json
+          }.compact
+        )
+      end
+
+      convert_solidity_value(response)
+    end
+
+    # Converts a Solidity value to an appropriate Ruby type.
+    #
+    # @param solidity_value [Coinbase::Client::SolidityValue] The Solidity value to convert
+    # @return [Object] The converted Ruby value
+    # @raise [ArgumentError] If an unsupported Solidity type is encountered
+    #
+    # This method handles the following Solidity types:
+    # - Integers (uint8, uint16, uint32, uint64, uint128, uint256, int8, int16, int32, int64, int128, int256)
+    # - Address
+    # - String
+    # - Bytes (including fixed-size byte arrays)
+    # - Boolean
+    # - Array
+    # - Tuple (converted to a Hash)
+    #
+    # For complex types like arrays and tuples, the method recursively converts nested values.
+    def self.convert_solidity_value(solidity_value)
+      return nil if solidity_value.nil?
+
+      type = solidity_value.type
+      value = solidity_value.value
+      values = solidity_value.values
+
+      case type
+      when 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',
+       'int8', 'int16', 'int32', 'int64', 'int128', 'int256'
+        value&.to_i
+      when 'address', 'string', /^bytes/
+        value
+      when 'bool'
+        if value.is_a?(String)
+          value == 'true'
+        else
+          !value.nil?
+        end
+      when 'array'
+        values ? values.map { |v| convert_solidity_value(v) } : []
+      when 'tuple'
+        if values
+          result = {}
+          values.each do |v|
+            raise ArgumentError, 'Error: Tuple value without a name' unless v.respond_to?(:name)
+
+            result[v.name] = convert_solidity_value(v)
+          end
+          result
+        else
+          {}
+        end
+      else
+        raise ArgumentError, "Unsupported Solidity type: #{type}"
+      end
+    end
+    private_class_method :convert_solidity_value
+
     def self.contract_events_api
       Coinbase::Client::ContractEventsApi.new(Coinbase.configuration.api_client)
     end

data/lib/coinbase/staking_operation.rb

@@ -107,7 +107,7 @@ module Coinbase
     private_class_method :stake_api
 
     def self.wallet_stake_api
-      Coinbase::Client::WalletStakeApi.new(Coinbase.configuration.api_client)
+      Coinbase::Client::MPCWalletStakeApi.new(Coinbase.configuration.api_client)
     end
 
     private_class_method :wallet_stake_api
@@ -324,7 +324,7 @@ module Coinbase
     end
 
     def wallet_stake_api
-      @wallet_stake_api ||= Coinbase::Client::WalletStakeApi.new(Coinbase.configuration.api_client)
+      @wallet_stake_api ||= Coinbase::Client::MPCWalletStakeApi.new(Coinbase.configuration.api_client)
     end
 
     def update_transactions(transactions)

data/lib/coinbase/transaction.rb

@@ -41,6 +41,12 @@ module Coinbase
       @model = model
     end
 
+    # Returns the Network of the Transaction.
+    # @return [Coinbase::Network] The Network
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
+    end
+
     # Returns the Unsigned Payload of the Transaction.
     # @return [String] The Unsigned Payload
     def unsigned_payload
@@ -101,8 +107,8 @@ module Coinbase
       @model.transaction_link
     end
 
-    # Returns the block height of which the Transaction is recorded.
-    # @return [String] The to block_height
+    # Returns detailed content the Transaction.
+    # @return [EthereumTransaction] The transaction content
     def content
       @model.content
     end

data/lib/coinbase/validator.rb

@@ -33,12 +33,9 @@ module Coinbase
       network = Coinbase::Network.from_id(network)
 
       validator = Coinbase.call_api do
-        validators_api.get_validator(
-          network.normalized_id,
-          asset_id,
-          validator_id
-        )
+        stake_api.get_validator(network.normalized_id, asset_id, validator_id)
       end
+
       new(validator)
     end
 
@@ -57,7 +54,7 @@ module Coinbase
     # Returns a string representation of the Validator.
     # @return [String] a string representation of the Validator
     def to_s
-      "Coinbase::Validator{id: '#{validator_id}' status: '#{status}'}"
+      Coinbase.pretty_print_object(self, validator_id: validator_id, status: status)
     end
 
     # Same as to_s.
@@ -68,7 +65,7 @@ module Coinbase
 
     def self.list_page(network, asset_id, status, page)
       Coinbase.call_api do
-        validators_api.list_validators(
+        stake_api.list_validators(
           network.normalized_id,
           asset_id,
           {
@@ -81,10 +78,10 @@ module Coinbase
 
     private_class_method :list_page
 
-    def self.validators_api
-      Coinbase::Client::ValidatorsApi.new(Coinbase.configuration.api_client)
+    def self.stake_api
+      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
     end
 
-    private_class_method :validators_api
+    private_class_method :stake_api
   end
 end

data/lib/coinbase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coinbase
-  VERSION = '0.7.0'
+  VERSION = '0.11.0'
 end

data/lib/coinbase/wallet.rb

@@ -258,9 +258,21 @@ module Coinbase
     # @return [Coinbase::SmartContract] The deployed multi-token contract.
     # @raise [AddressCannotSignError] if the Address does not have a private key backing it.
 
+    # @!method quote_fund
+    # Gets a quote for a fund operation to fund the address from your Coinbase platform,
+    # account for the amount of the specified Asset.
+    # @param asset_id [Symbol] The ID of the Asset to trade from. For Ether, :eth, :gwei, and :wei are supported.
+    # @return [Coinbase::FundQuote] The FundQuote object.
+
+    # @!method fund
+    # Funds the address from your account on the Coinbase Platform for the given amount of the given Asset.
+    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to fund the wallet with.
+    # @param asset_id [Symbol] The ID of the Asset to trade from. For Ether, :eth, :gwei, and :wei are supported.
+    # @return [Coinbase::FundOperation] The FundOperation object.
+
     def_delegators :default_address, :transfer, :trade, :faucet, :stake, :unstake, :claim_stake, :staking_balances,
                    :stakeable_balance, :unstakeable_balance, :claimable_balance, :sign_payload, :invoke_contract,
-                   :deploy_token, :deploy_nft, :deploy_multi_token
+                   :deploy_token, :deploy_nft, :deploy_multi_token, :quote_fund, :fund
 
     # Returns the addresses belonging to the Wallet.
     # @return [Array<Coinbase::WalletAddress>] The addresses belonging to the Wallet

data/lib/coinbase.rb

@@ -13,11 +13,15 @@ require_relative 'coinbase/client'
 require_relative 'coinbase/constants'
 require_relative 'coinbase/contract_event'
 require_relative 'coinbase/contract_invocation'
+require_relative 'coinbase/crypto_amount'
 require_relative 'coinbase/destination'
 require_relative 'coinbase/errors'
 require_relative 'coinbase/faucet_transaction'
+require_relative 'coinbase/fiat_amount'
 require_relative 'coinbase/middleware'
 require_relative 'coinbase/network'
+require_relative 'coinbase/fund_operation'
+require_relative 'coinbase/fund_quote'
 require_relative 'coinbase/pagination'
 require_relative 'coinbase/payload_signature'
 require_relative 'coinbase/trade'