coinbase-sdk 0.0.14 → 0.1.0

data/lib/coinbase/smart_contract.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Coinbase
+  # A representation of a SmartContract on the blockchain.
+  class SmartContract
+    # Returns a list of ContractEvents for the provided network, contract, and event details.
+    # @param network_id [Symbol] The network ID
+    # @param protocol_name [String] The protocol name
+    # @param contract_address [String] The contract address
+    # @param contract_name [String] The contract name
+    # @param event_name [String] The event name
+    # @param from_block_height [Integer] The start block height
+    # @param to_block_height [Integer] The end block height
+    # @return [Enumerable<Coinbase::ContractEvent>] The contract events
+    def self.list_events(
+      network_id:,
+      protocol_name:,
+      contract_address:,
+      contract_name:,
+      event_name:,
+      from_block_height:,
+      to_block_height:
+    )
+      Coinbase::Pagination.enumerate(
+        lambda { |page|
+          list_events_page(network_id, protocol_name, contract_address, contract_name, event_name, from_block_height,
+                           to_block_height, page)
+        }
+      ) do |contract_event|
+        Coinbase::ContractEvent.new(contract_event)
+      end
+    end
+
+    # Returns a new SmartContract object.
+    # @param model [Coinbase::Client::SmartContract] The underlying SmartContract object
+    def initialize(model)
+      @model = model
+    end
+
+    # Returns the network ID of the SmartContract.
+    # @return [String] The network ID
+    def network_id
+      Coinbase.to_sym(@model.network_id)
+    end
+
+    # Returns the protocol name of the SmartContract.
+    # @return [String] The protocol name
+    def protocol_name
+      @model.protocol_name
+    end
+
+    # Returns the contract name of the SmartContract.
+    # @return [String] The contract name
+    def contract_name
+      @model.contract_name
+    end
+
+    # Returns the address of the SmartContract.
+    # @return [String] The contract address
+    def address
+      @model.address
+    end
+
+    # Returns a string representation of the SmartContract.
+    # @return [String] a string representation of the SmartContract
+    def to_s
+      "Coinbase::SmartContract{
+        network_id: '#{network_id}',
+        protocol_name: '#{protocol_name}',
+        contract_name: '#{contract_name}',
+        address: '#{address}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the SmartContract
+    def inspect
+      to_s
+    end
+
+    def self.contract_events_api
+      Coinbase::Client::ContractEventsApi.new(Coinbase.configuration.api_client)
+    end
+
+    def self.list_events_page(
+      network_id,
+      protocol_name,
+      contract_address,
+      contract_name,
+      event_name,
+      from_block_height,
+      to_block_height,
+      page
+    )
+      contract_events_api.list_contract_events(
+        Coinbase.normalize_network(network_id),
+        protocol_name,
+        contract_address,
+        contract_name,
+        event_name,
+        from_block_height,
+        to_block_height,
+        { next_page: page }
+      )
+    end
+  end
+end

data/lib/coinbase/sponsored_send.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'eth'
+
+module Coinbase
+  # A representation of an onchain Sponsored Send.
+  # Sponsored Sends should be constructed via higher level abstractions like Transfer.
+  class SponsoredSend
+    # A representation of a Transaction status.
+    module Status
+      # The SponsoredSend is awaiting being signed.
+      PENDING = 'pending'
+
+      # The Sponsored Send has been signed, but has not been submitted to be
+      # built into a transaction yet.
+      SIGNED = 'signed'
+
+      # The Sponsored Send has been submitted to be built into a transaction,
+      # that the sponsor will sign and submit to the network.
+      # At this point, transaction hashes may not yet be assigned.
+      SUBMITTED = 'submitted'
+
+      # The Sponsored Send's corresponding transaction is complete and has
+      # confirmed on the Network.
+      COMPLETE = 'complete'
+
+      # The Sponsored Send has failed for some reason.
+      FAILED = 'failed'
+
+      # The states that are considered terminal on-chain.
+      TERMINAL_STATES = [COMPLETE, FAILED].freeze
+    end
+
+    # Returns a new SponsoredSend object. Do not use this method directly.
+    # @param model [Coinbase::Client::SponsoredSend] The underlying SponsoredSend object
+    def initialize(model)
+      raise unless model.is_a?(Coinbase::Client::SponsoredSend)
+
+      @model = model
+    end
+
+    # Returns the Keccak256 hash of the typed data. This payload must be signed
+    # by the sender to be used as an approval in the EIP-3009 transaction.
+    # @return [String] The Keccak256 hash of the typed data
+    def typed_data_hash
+      @model.typed_data_hash
+    end
+
+    # Returns the signature of the typed data.
+    def signature
+      @signature ||= @model.signature
+    end
+
+    # Signs the Transaction with the provided key and returns the hex signing payload.
+    # @return [String] The hex-encoded signed payload
+    def sign(key)
+      raise unless key.is_a?(Eth::Key)
+      raise Coinbase::AlreadySignedError if signed?
+
+      @signature = Eth::Util.prefix_hex(key.sign(Eth::Util.hex_to_bin(typed_data_hash)))
+    end
+
+    # Returns whether the Transaction has been signed.
+    # @return [Boolean] Whether the Transaction has been signed
+    def signed?
+      !signature.nil?
+    end
+
+    # Returns the status of the Transaction.
+    # @return [Symbol] The status
+    def status
+      @model.status
+    end
+
+    # Returns whether the Sponsored Send is in a terminal state.
+    # @return [Boolean] Whether the Transaction is in a terminal state
+    def terminal_state?
+      Status::TERMINAL_STATES.include?(status)
+    end
+
+    # Returns the Transaction Hash of the Transaction.
+    # @return [String] The Transaction Hash
+    def transaction_hash
+      @model.transaction_hash
+    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
+      @model.transaction_link
+    end
+
+    # Returns a String representation of the SponsoredSend.
+    # @return [String] a String representation of the SponsoredSend
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        status: status,
+        transaction_hash: transaction_hash,
+        transaction_link: transaction_link
+      )
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the SponsoredSend
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/coinbase/staking_balance.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Coinbase
+  # A representation of a staking balance on a network for a given asset.
+  class StakingBalance
+    # Returns a list of StakingBalance for the provided network, asset, and addresses.
+    # @param network [Coinbase::Network, Symbol] The Network or Network ID
+    # @param asset_id [Symbol] The asset ID
+    # @param address_id [String] The address ID
+    # @param start_time [Time] The start time. Defaults to one month ago.
+    # @param end_time [Time] The end time. Defaults to the current time.
+    # @return [Enumerable<Coinbase::StakingBalance>] The staking balances
+    def self.list(network, asset_id, address_id, start_time: DateTime.now.prev_month(1), end_time: DateTime.now)
+      network = Coinbase::Network.from_id(network)
+
+      Coinbase::Pagination.enumerate(
+        ->(page) { list_page(network, asset_id, address_id, start_time, end_time, page) }
+      ) do |staking_balance|
+        new(staking_balance)
+      end
+    end
+
+    # Returns a new StakingBalance object.
+    # @param model [Coinbase::Client::StakingBalance] The underlying StakingBalance object
+    def initialize(model)
+      @model = model
+    end
+
+    # Returns the date of the StakingBalance.
+    # @return [Time] The date
+    def date
+      @model.date
+    end
+
+    # Returns the onchain address of the StakingBalance.
+    # @return [Time] The onchain address
+    def address
+      @model.address
+    end
+
+    # Returns the bonded stake as a Balance
+    # @return [Balance] The bonded stake
+    def bonded_stake
+      @bonded_stake ||= Balance.from_model(@model.bonded_stake)
+    end
+
+    # Returns the unbonded balance as a Balance
+    # @return [Balance] The unbonded balance
+    def unbonded_balance
+      @unbonded_balance ||= Balance.from_model(@model.unbonded_balance)
+    end
+
+    # Returns the participant type of the StakingBalance.
+    # @return [String] The participant type
+    def participant_type
+      @model.participant_type
+    end
+
+    # Returns a string representation of the StakingBalance.
+    # @return [String] a string representation of the StakingBalance
+    def to_s
+      "Coinbase::StakingBalance{date: '#{date}' address: '#{address}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the StakingBalance
+    def inspect
+      to_s
+    end
+
+    def self.stake_api
+      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+    end
+
+    private_class_method :stake_api
+
+    def self.list_page(network, asset_id, address_id, start_time, end_time, page)
+      stake_api.fetch_historical_staking_balances(
+        network.normalized_id,
+        asset_id,
+        address_id,
+        start_time.iso8601,
+        end_time.iso8601,
+        { next_page: page }
+      )
+    end
+
+    private_class_method :list_page
+  end
+end

data/lib/coinbase/staking_operation.rb

@@ -11,22 +11,24 @@ module Coinbase
 
     # 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 network [Coinbase::Network, Symbol] The Network or 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)
+    def self.build(amount, network, asset_id, address_id, action, mode, options)
+      network = Coinbase::Network.from_id(network)
+      asset = network.get_asset(asset_id)
+
       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),
+            network_id: Coinbase.normalize_network(network),
             options: {
               amount: asset.to_atomic_amount(amount).to_i.to_s,
               mode: mode
@@ -40,7 +42,7 @@ module Coinbase
 
     # 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 network [Coinbase::Network, Symbol] The Network or Network ID
     # @param asset_id [Symbol] The Asset ID
     # @param address_id [String] The Address ID
     # @param wallet_id [String] The Wallet ID
@@ -48,17 +50,19 @@ module Coinbase
     # @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)
+    def self.create(amount, network, asset_id, address_id, wallet_id, action, mode, options)
+      network = Coinbase::Network.from_id(network)
+      asset = network.get_asset(asset_id)
+
       model = Coinbase.call_api do
-        asset = Coinbase::Asset.fetch(network_id, asset_id)
-        stake_api.create_staking_operation(
+        wallet_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),
+            network_id: Coinbase.normalize_network(network),
             options: {
               amount: asset.to_atomic_amount(amount).to_i.to_s,
               mode: mode
@@ -70,10 +74,24 @@ module Coinbase
       new(model)
     end
 
+    def self.stake_api
+      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
+    end
+
+    private_class_method :stake_api
+
+    def self.wallet_stake_api
+      Coinbase::Client::WalletStakeApi.new(Coinbase.configuration.api_client)
+    end
+
+    private_class_method :wallet_stake_api
+
     # Returns a new StakingOperation object.
     # @param model [Coinbase::Client::StakingOperation] The underlying StakingOperation object
     def initialize(model)
-      from_model(model)
+      @model = model
+      @transactions ||= []
+      update_transactions(model.transactions)
     end
 
     # Returns the Staking Operation ID.
@@ -82,10 +100,10 @@ module Coinbase
       @model.id
     end
 
-    # Returns the Network ID of the Staking Operation.
-    # @return [Symbol] The Network ID
-    def network_id
-      Coinbase.to_sym(@model.network_id)
+    # Returns the Network of the Staking Operation.
+    # @return [Coinbase::Network] The Network
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
     end
 
     # Returns the Address ID of the Staking Operation.
@@ -100,18 +118,48 @@ module Coinbase
       @model.status
     end
 
+    # Returns whether the Staking Operation is in a terminal state.
+    # @return [Boolean] Whether the Staking Operation is in a terminal state
+    def terminal_state?
+      failed? || completed?
+    end
+
+    # Returns whether the Staking Operation is in a failed state.
+    # @return [Boolean] Whether the Staking Operation is in a failed state
+    def failed?
+      status == 'failed'
+    end
+
+    # Returns whether the Staking Operation is in a complete state.
+    # @return [Boolean] Whether the Staking Operation is in a complete state
+    def completed?
+      status == 'complete'
+    end
+
+    # Returns a String representation of the Staking Operation.
+    # @return [String] a String representation of the Staking Operation
+    def to_s
+      Coinbase.pretty_print_object(
+        self.class,
+        id: id,
+        status: status,
+        network_id: network.id,
+        address_id: address_id
+      )
+    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.
+    # Waits until the Staking Operation is completed or failed by polling its status at the given interval.
     # @param interval_seconds [Integer] The interval at which to poll, in seconds
     # @param timeout_seconds [Integer] The maximum amount of time
     #   to wait for the StakingOperation to complete, in seconds
     # @return [StakingOperation] The completed StakingOperation object
+    # @raise [Timeout::Error] if the Staking Operation takes longer than the given timeout.
     def wait!(interval_seconds = 5, timeout_seconds = 3600)
       start_time = Time.now
 
@@ -119,7 +167,7 @@ module Coinbase
         reload
 
         # Wait for the Staking Operation to be in a terminal state.
-        break if status == 'complete'
+        break if terminal_state?
 
         raise Timeout::Error, 'Staking Operation timed out' if Time.now - start_time > timeout_seconds
 
@@ -129,18 +177,58 @@ module Coinbase
       self
     end
 
+    # Complete helps the Staking Operation reach complete state, by polling its status at the given interval, signing
+    # and broadcasting any available transaction.
+    # @param key [Eth::Key] The key to sign the Staking Operation transactions with
+    # @param interval_seconds [Integer] The interval at which to poll, in seconds
+    # @param timeout_seconds [Integer] The maximum amount of time
+    #   to wait for the StakingOperation to complete, in seconds
+    # @return [StakingOperation] The completed StakingOperation object
+    # @raise [Timeout::Error] if the Staking Operation takes longer than the given timeout.
+    def complete(key, interval_seconds: 5, timeout_seconds: 600)
+      start_time = Time.now
+
+      loop do
+        @transactions.each_with_index do |transaction, i|
+          next if transaction.signed?
+
+          transaction.sign(key)
+          @model = Coinbase.call_api do
+            stake_api.broadcast_staking_operation(
+              wallet_id,
+              address_id,
+              id,
+              { signed_payload: transaction.raw.hex, transaction_index: i }
+            )
+          end
+        end
+
+        return self if terminal_state?
+
+        reload
+
+        raise Timeout::Error, 'Staking Operation timed out' if Time.now - start_time > timeout_seconds
+
+        sleep interval_seconds
+      end
+
+      self
+    end
+
     # Fetch the StakingOperation with the provided network, address and staking operation ID.
-    # @param network_id [Symbol] The Network ID
+    # @param network [Coinbase::Network, Symbol] The Network or 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, wallet_id: nil)
+    def self.fetch(network, address_id, id, wallet_id: nil)
+      network = Coinbase::Network.from_id(network)
+
       staking_operation_model = Coinbase.call_api do
         if wallet_id.nil?
-          stake_api.get_external_staking_operation(network_id, address_id, id)
+          stake_api.get_external_staking_operation(network.id, address_id, id)
         else
-          stake_api.get_staking_operation(wallet_id, address_id, id)
+          wallet_stake_api.get_staking_operation(wallet_id, address_id, id)
         end
       end
 
@@ -160,13 +248,15 @@ module Coinbase
     def reload
       @model = Coinbase.call_api do
         if wallet_id.nil?
-          stake_api.get_external_staking_operation(network_id, address_id, id)
+          stake_api.get_external_staking_operation(network.id, address_id, id)
         else
-          stake_api.get_staking_operation(wallet_id, address_id, id)
+          wallet_stake_api.get_staking_operation(wallet_id, address_id, id)
         end
       end
 
-      from_model(@model)
+      update_transactions(@model.transactions)
+
+      self
     end
 
     # Fetches the presigned_voluntary exit messages for the staking operation
@@ -191,7 +281,7 @@ module Coinbase
         raise TransactionNotSignedError unless transaction.signed?
 
         Coinbase.call_api do
-          stake_api.broadcast_staking_operation(
+          wallet_stake_api.broadcast_staking_operation(
             wallet_id,
             address_id,
             id,
@@ -203,24 +293,32 @@ module Coinbase
       self
     end
 
-    def self.stake_api
-      Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
-    end
-
     private
 
     def stake_api
-      @stake_api ||= self.class.stake_api
+      @stake_api ||= Coinbase::Client::StakeApi.new(Coinbase.configuration.api_client)
     end
 
-    def from_model(model)
-      @model = model
-      @status = model.status
-      @transactions = model.transactions.map do |transaction_model|
-        Transaction.new(transaction_model)
+    def wallet_stake_api
+      @wallet_stake_api ||= Coinbase::Client::WalletStakeApi.new(Coinbase.configuration.api_client)
+    end
+
+    def update_transactions(transactions)
+      # Only overwrite the transactions if the response is populated.
+      return unless transactions && !transactions.empty?
+
+      # Create a set of existing unsigned payloads to avoid duplicates.
+      existing_unsigned_payloads = Set.new
+      @transactions.each do |transaction|
+        existing_unsigned_payloads.add(transaction.unsigned_payload)
       end
 
-      self
+      # Add transactions that are not already in the transactions array.
+      transactions.each do |transaction_model|
+        unless existing_unsigned_payloads.include?(transaction_model.unsigned_payload)
+          @transactions << Transaction.new(transaction_model)
+        end
+      end
     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)
+    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

@@ -15,12 +15,13 @@ module Coinbase
       # @param from_asset_id [Symbol] The Asset ID of the Asset to trade from
       # @param to_asset_id [Symbol] The Asset ID of the Asset to trade to
       # @param amount [BigDecimal] The amount of the Asset to send
-      # @param network_id [Symbol] The Network ID of the Asset
+      # @param network [Coinbase::Network, Symbol] The Network or Network ID of the Asset
       # @param wallet_id [String] The Wallet ID of the sending Wallet
       # @return [Send] The new pending Send object
-      def create(address_id:, from_asset_id:, to_asset_id:, amount:, network_id:, wallet_id:)
-        from_asset = Asset.fetch(network_id, from_asset_id)
-        to_asset = Asset.fetch(network_id, to_asset_id)
+      def create(address_id:, from_asset_id:, to_asset_id:, amount:, network:, wallet_id:)
+        network = Coinbase::Network.from_id(network)
+        from_asset = network.get_asset(from_asset_id)
+        to_asset = network.get_asset(to_asset_id)
 
         model = Coinbase.call_api do
           trades_api.create_trade(
@@ -75,10 +76,10 @@ module Coinbase
       @model.trade_id
     end
 
-    # Returns the Network ID of the Trade.
-    # @return [Symbol] The Network ID
-    def network_id
-      Coinbase.to_sym(@model.network_id)
+    # Returns the Network of the Trade.
+    # @return [Coinbase::Network] The Network the Trade is on
+    def network
+      @network ||= Coinbase::Network.from_id(@model.network_id)
     end
 
     # Returns the Wallet ID of the Trade.
@@ -198,7 +199,7 @@ module Coinbase
     # Returns a String representation of the Trade.
     # @return [String] a String representation of the Trade
     def to_s
-      "Coinbase::Trade{transfer_id: '#{id}', network_id: '#{network_id}', " \
+      "Coinbase::Trade{transfer_id: '#{id}', network_id: '#{network.id}', " \
         "address_id: '#{address_id}', from_asset_id: '#{from_asset_id}', " \
         "to_asset_id: '#{to_asset_id}', from_amount: '#{from_amount}', " \
         "to_amount: '#{to_amount}' status: '#{status}'}"