coinbase-sdk 0.0.5 → 0.0.7

data/lib/coinbase/server_signer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module Coinbase
+  # A representation of a Server-Signer. Server-Signers are assigned to sign transactions for a Wallet.
+  class ServerSigner
+    # Returns a new Server-Signer object. Do not use this method directly. Instead, use ServerSigner.default.
+    def initialize(model)
+      @model = model
+    end
+
+    class << self
+      # Returns the default ServerSigner for the CDP Project.
+      # @return [Coinbase::ServerSigner] the default Server-Signer
+      def default
+        response = Coinbase.call_api do
+          server_signers_api.list_server_signers
+        end
+
+        raise 'No Server-Signer is associated with the project' if response.data.empty?
+
+        new(response.data.first)
+      end
+
+      private
+
+      def server_signers_api
+        Coinbase::Client::ServerSignersApi.new(Coinbase.configuration.api_client)
+      end
+    end
+
+    # Returns the Server-Signer ID.
+    # @return [String] the Server-Signer ID
+    def id
+      @model.server_signer_id
+    end
+
+    # Returns the IDs of the Wallet's the Server-Signer can sign for.
+    # @return [Array<String>] the wallet IDs
+    def wallets
+      @model.wallets
+    end
+
+    # Returns a string representation of the Server-Signer.
+    # @return [String] a string representation of the Server-Signer
+    def to_s
+      "Coinbase::ServerSigner{server_signer_id: '#{id}', wallets: [#{wallets.join(', ')}]}"
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the Server-Signer
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/coinbase/trade.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require 'bigdecimal'
+require 'eth'
+
+module Coinbase
+  # A representation of a Trade, which trades an amount of an Asset to another Asset on a Network.
+  # The fee is assumed to be paid in the native Asset of the Network.
+  # Trades should be created through Wallet#trade or # Address#trade.
+  class Trade
+    # Returns a new Trade object. Do not use this method directly. Instead, use Wallet#trade or
+    # Address#trade.
+    # @param model [Coinbase::Client::Trade] The underlying Trade object
+    def initialize(model)
+      raise unless model.is_a?(Coinbase::Client::Trade)
+
+      @model = model
+    end
+
+    # Returns the Trade ID.
+    # @return [String] The Trade ID
+    def id
+      @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)
+    end
+
+    # Returns the Wallet ID of the Trade.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the Address ID of the Trade.
+    # @return [String] The Address ID
+    def address_id
+      @model.address_id
+    end
+
+    # Returns the From Asset ID of the Trade.
+    # @return [Symbol] The From Asset ID
+    def from_asset_id
+      @model.from_asset.asset_id.to_sym
+    end
+
+    # Returns the amount of the from asset for the Trade.
+    # @return [BigDecimal] The amount of the from asset
+    def from_amount
+      BigDecimal(@model.from_amount) / BigDecimal(10).power(@model.from_asset.decimals)
+    end
+
+    # Returns the To Asset ID of the Trade.
+    # @return [Symbol] The To Asset ID
+    def to_asset_id
+      @model.to_asset.asset_id.to_sym
+    end
+
+    # Returns the amount of the to asset for the Trade.
+    # @return [BigDecimal] The amount of the to asset
+    def to_amount
+      BigDecimal(@model.to_amount) / BigDecimal(10).power(@model.to_asset.decimals)
+    end
+
+    # Returns the Trade transaction.
+    # @return [Coinbase::Transaction] The Trade transaction
+    def transaction
+      @transaction ||= Coinbase::Transaction.new(@model.transaction)
+    end
+
+    def approve_transaction
+      @approve_transaction ||= @model.approve_transaction ? Coinbase::Transaction.new(@model.approve_transaction) : nil
+    end
+
+    # Returns the status of the Trade.
+    # @return [Symbol] The status
+    def status
+      transaction.status
+    end
+
+    # Waits until the Trade is completed or failed by polling the Network at the given interval. Raises a
+    # Timeout::Error if the Trade takes longer than the given timeout.
+    # @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 Trade to complete, in seconds
+    # @return [Trade] The completed Trade object
+    def wait!(interval_seconds = 0.2, timeout_seconds = 10)
+      start_time = Time.now
+
+      loop do
+        reload
+
+        # Wait for the trade transaction to be in a terminal state.
+        # The approve transaction is optional and must last first, so we don't need to wait for it.
+        # We may want to handle a situation where the approve transaction fails and the
+        # trade transaction does not ever get broadcast.
+        break if transaction.terminal_state?
+
+        raise Timeout::Error, 'Trade timed out' if Time.now - start_time > timeout_seconds
+
+        self.sleep interval_seconds
+      end
+
+      self
+    end
+
+    # Reloads the Trade model with the latest version from the server side.
+    # @return [Trade] The most recent version of Trade from the server.
+    def reload
+      @model = Coinbase.call_api do
+        trades_api.get_trade(wallet_id, address_id, id)
+      end
+
+      # Update the memoized transaction.
+      @transaction = Coinbase::Transaction.new(@model.transaction)
+
+      # Update the memoized approve transaction if it exists.
+      @approve_transaction = @model.approve_transaction ? Coinbase::Transaction.new(@model.approve_transaction) : nil
+
+      self
+    end
+
+    # 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}', " \
+        "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}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Trade
+    def inspect
+      to_s
+    end
+
+    private
+
+    def trades_api
+      @trades_api ||= Coinbase::Client::TradesApi.new(Coinbase.configuration.api_client)
+    end
+  end
+end

data/lib/coinbase/transaction.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require 'bigdecimal'
+require 'eth'
+require 'json'
+
+module Coinbase
+  # A representation of an onchain Transaction.
+  # Transactions should be constructed via higher level abstractions like Trade or Transfer.
+  class Transaction
+    # A representation of a Transaction status.
+    module Status
+      # The Transaction is awaiting being broadcast to the Network.
+      # At this point, transaction hashes may not yet be assigned.
+      PENDING = 'pending'
+
+      # The Transaction has been broadcast to the Network.
+      # At this point, at least the transaction hash should be assigned.
+      BROADCAST = 'broadcast'
+
+      # The Transaction is complete and has confirmed on the Network.
+      COMPLETE = 'complete'
+
+      # The Transaction has failed for some reason.
+      FAILED = 'failed'
+
+      # The states that are considered terminal on-chain.
+      TERMINAL_STATES = [COMPLETE, FAILED].freeze
+    end
+
+    # Returns a new Transaction object. Do not use this method directly.
+    # @param model [Coinbase::Client::Transaction] The underlying Transaction object
+    def initialize(model)
+      raise unless model.is_a?(Coinbase::Client::Transaction)
+
+      @model = model
+    end
+
+    # Returns the Unsigned Payload of the Transaction.
+    # @return [String] The Unsigned Payload
+    def unsigned_payload
+      @model.unsigned_payload
+    end
+
+    # Returns the Signed Payload of the Transaction.
+    # @return [String] The Signed Payload
+    def signed_payload
+      @model.signed_payload
+    end
+
+    # Returns the Transaction Hash of the Transaction.
+    # @return [String] The Transaction Hash
+    def transaction_hash
+      @model.transaction_hash
+    end
+
+    # Returns the status of the Transaction.
+    # @return [Symbol] The status
+    def status
+      @model.status
+    end
+
+    # Returns the from address for the Transaction.
+    # @return [String] The from address
+    def from_address_id
+      @model.from_address_id
+    end
+
+    # Returns whether the Transaction 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 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 the underlying raw transaction.
+    # @return [Eth::Tx::Eip1559] The raw transaction
+    def raw
+      return @raw unless @raw.nil?
+
+      raw_payload = [unsigned_payload].pack('H*')
+      parsed_payload = JSON.parse(raw_payload)
+
+      params = {
+        chain_id: parsed_payload['chainId'].to_i(16),
+        nonce: parsed_payload['nonce'].to_i(16),
+        priority_fee: parsed_payload['maxPriorityFeePerGas'].to_i(16),
+        max_gas_fee: parsed_payload['maxFeePerGas'].to_i(16),
+        gas_limit: parsed_payload['gas'].to_i(16), # TODO: Handle multiple currencies.
+        from: Eth::Address.new(from_address_id),
+        to: Eth::Address.new(parsed_payload['to']),
+        value: parsed_payload['value'].to_i(16),
+        data: parsed_payload['input'] || ''
+      }
+
+      @raw = Eth::Tx::Eip1559.new(Eth::Tx.validate_eip1559_params(params))
+    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
+    end
+
+    # Returns a String representation of the Transaction.
+    # @return [String] a String representation of the Transaction
+    def to_s
+      "Coinbase::Transaction{transaction_hash: '#{transaction_hash}', status: '#{status}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Transaction
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/coinbase/transfer.rb

@@ -11,27 +11,12 @@ module Coinbase
   # in the native Asset of the Network. Transfers should be created through Wallet#transfer or
   # Address#transfer.
   class Transfer
-    # A representation of a Transfer status.
-    module Status
-      # The Transfer is awaiting being broadcast to the Network. At this point, transaction
-      # hashes may not yet be assigned.
-      PENDING = :pending
-
-      # The Transfer has been broadcast to the Network. At this point, at least the transaction hash
-      # should be assigned.
-      BROADCAST = :broadcast
-
-      # The Transfer is complete, and has confirmed on the Network.
-      COMPLETE = :complete
-
-      # The Transfer has failed for some reason.
-      FAILED = :failed
-    end
-
     # Returns a new Transfer object. Do not use this method directly. Instead, use Wallet#transfer or
     # Address#transfer.
     # @param model [Coinbase::Client::Transfer] The underlying Transfer object
     def initialize(model)
+      raise unless model.is_a?(Coinbase::Client::Transfer)
+
       @model = model
     end
 
@@ -65,6 +50,10 @@ module Coinbase
       @model.destination
     end
 
+    def asset
+      @asset ||= Coinbase::Asset.from_model(@model.asset)
+    end
+
     # Returns the Asset ID of the Transfer.
     # @return [Symbol] The Asset ID
     def asset_id
@@ -74,12 +63,7 @@ module Coinbase
     # Returns the amount of the asset for the Transfer.
     # @return [BigDecimal] The amount of the asset
     def amount
-      case asset_id
-      when :eth
-        BigDecimal(@model.amount) / BigDecimal(Coinbase::WEI_PER_ETHER.to_s)
-      else
-        BigDecimal(@model.amount)
-      end
+      BigDecimal(@model.amount) / BigDecimal(10).power(@model.asset.decimals)
     end
 
     # Returns the link to the transaction on the blockchain explorer.
@@ -101,60 +85,35 @@ module Coinbase
       @model.signed_payload
     end
 
+    # Returns the Transfer transaction.
+    # @return [Coinbase::Transaction] The Transfer transaction
+    def transaction
+      @transaction ||= Coinbase::Transaction.new(@model.transaction)
+    end
+
     # Returns the Transaction Hash of the Transfer.
     # @return [String] The Transaction Hash
     def transaction_hash
       @model.transaction_hash
     end
 
-    # Returns the underlying Transfer transaction, creating it if it has not been yet.
-    # @return [Eth::Tx::Eip1559] The Transfer transaction
-    def transaction
-      return @transaction unless @transaction.nil?
-
-      raw_payload = [unsigned_payload].pack('H*')
-      parsed_payload = JSON.parse(raw_payload)
-
-      params = {
-        chain_id: parsed_payload['chainId'].to_i(16),
-        nonce: parsed_payload['nonce'].to_i(16),
-        priority_fee: parsed_payload['maxPriorityFeePerGas'].to_i(16),
-        max_gas_fee: parsed_payload['maxFeePerGas'].to_i(16),
-        gas_limit: parsed_payload['gas'].to_i(16), # TODO: Handle multiple currencies.
-        from: Eth::Address.new(from_address_id),
-        to: Eth::Address.new(parsed_payload['to']),
-        value: parsed_payload['value'].to_i(16),
-        data: parsed_payload['input'] || ''
-      }
-
-      @transaction = Eth::Tx::Eip1559.new(Eth::Tx.validate_eip1559_params(params))
-      @transaction
-    end
-
     # Returns the status of the Transfer.
     # @return [Symbol] The status
     def status
-      # Check if the transfer has been signed yet.
-      return Status::PENDING if transaction_hash.nil?
-
-      onchain_transaction = Coinbase.configuration.base_sepolia_client.eth_getTransactionByHash(transaction_hash)
-
-      if onchain_transaction.nil?
-        # If the transaction has not been broadcast, it is still pending.
-        Status::PENDING
-      elsif onchain_transaction['blockHash'].nil?
-        # If the transaction has been broadcast but hasn't been included in a block, it is
-        # broadcast.
-        Status::BROADCAST
-      else
-        transaction_receipt = Coinbase.configuration.base_sepolia_client.eth_getTransactionReceipt(transaction_hash)
-
-        if transaction_receipt['status'].to_i(16) == 1
-          Status::COMPLETE
-        else
-          Status::FAILED
-        end
+      transaction.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
+        transfers_api.get_transfer(wallet_id, from_address_id, id)
       end
+
+      # Update memoized transaction.
+      @transaction = Coinbase::Transaction.new(@model.transaction)
+
+      self
     end
 
     # Waits until the Transfer is completed or failed by polling the Network at the given interval. Raises a
@@ -162,11 +121,13 @@ module Coinbase
     # @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 Transfer to complete, in seconds
     # @return [Transfer] The completed Transfer object
-    def wait!(interval_seconds = 0.2, timeout_seconds = 10)
+    def wait!(interval_seconds = 0.2, timeout_seconds = 20)
       start_time = Time.now
 
       loop do
-        return self if status == Status::COMPLETE || status == Status::FAILED
+        reload
+
+        return self if transaction.terminal_state?
 
         raise Timeout::Error, 'Transfer timed out' if Time.now - start_time > timeout_seconds
 
@@ -181,8 +142,8 @@ module Coinbase
     def to_s
       "Coinbase::Transfer{transfer_id: '#{id}', network_id: '#{network_id}', " \
         "from_address_id: '#{from_address_id}', destination_address_id: '#{destination_address_id}', " \
-        "asset_id: '#{asset_id}', amount: '#{amount}', transaction_hash: '#{transaction_hash}', " \
-        "transaction_link: '#{transaction_link}', status: '#{status}'}"
+        "asset_id: '#{asset_id}', amount: '#{amount}', transaction_link: '#{transaction_link}', " \
+        "status: '#{status}'}"
     end
 
     # Same as to_s.
@@ -190,5 +151,11 @@ module Coinbase
     def inspect
       to_s
     end
+
+    private
+
+    def transfers_api
+      @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
+    end
   end
 end

data/lib/coinbase/user.rb

@@ -40,7 +40,8 @@ module Coinbase
     # 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 [Coinbase::Wallet] the Wallets belonging to the User
+    # @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
@@ -63,85 +64,26 @@ module Coinbase
         address_model_map[wallet_model.id] = addresses_list.data
       end
 
-      wallet_list.data.map do |wallet_model|
+      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]
     end
 
-    # Saves a wallet to local file system. Wallet saved this way can be re-instantiated with load_wallets_from_local
-    # function, provided the backup_file is available. This is an insecure method of storing wallet seeds and should
-    # only be used for development purposes. If you call save_wallet_locally! twice with wallets containing the same
-    # wallet_id, the backup will be overwritten during the second attempt.
-    # The default backup_file is `seeds.json` in the root folder. It can be configured by changing
-    # Coinbase.configuration.backup_file_path.
-    #
-    # @param wallet [Coinbase::Wallet] The wallet model to save.
-    # @param encrypt [bool] (Optional) Boolean representing whether the backup persisted to local file system should be
-    # encrypted or not. Data is unencrypted by default.
-    # @return [Coinbase::Wallet] the saved wallet.
-    def save_wallet_locally!(wallet, encrypt: false)
-      existing_seeds_in_store = existing_seeds
-      data = wallet.export
-      seed_to_store = data.seed
-      auth_tag = ''
-      iv = ''
-      if encrypt
-        shared_secret = store_encryption_key
-        cipher = OpenSSL::Cipher.new('aes-256-gcm').encrypt
-        cipher.key = OpenSSL::Digest.digest('SHA256', shared_secret)
-        iv = cipher.random_iv
-        cipher.iv = iv
-        cipher.auth_data = ''
-        encrypted_data = cipher.update(data.seed) + cipher.final
-        auth_tag = cipher.auth_tag.unpack1('H*')
-        iv = iv.unpack1('H*')
-        seed_to_store = encrypted_data.unpack1('H*')
+    # 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
 
-      existing_seeds_in_store[data.wallet_id] = {
-        seed: seed_to_store,
-        encrypted: encrypt,
-        auth_tag: auth_tag,
-        iv: iv
-      }
-
-      File.open(Coinbase.configuration.backup_file_path, 'w') do |file|
-        file.write(JSON.pretty_generate(existing_seeds_in_store))
+      addresses_list = Coinbase.call_api do
+        addresses_api.list_addresses(wallet_model.id, { limit: Coinbase::Wallet::MAX_ADDRESSES })
       end
-      wallet
-    end
 
-    # Loads all wallets belonging to the User with backup persisted to the local file system.
-    # @return [Map<String>Coinbase::Wallet] the map of wallet_ids to the wallets.
-    def load_wallets_from_local
-      existing_seeds_in_store = existing_seeds
-      raise ArgumentError, 'Backup file not found' if existing_seeds_in_store == {}
-
-      wallets = {}
-      existing_seeds_in_store.each do |wallet_id, seed_data|
-        seed = seed_data['seed']
-        raise ArgumentError, 'Malformed backup data' if seed.nil? || seed == ''
-
-        if seed_data['encrypted']
-          shared_secret = store_encryption_key
-          raise ArgumentError, 'Malformed encrypted seed data' if seed_data['iv'] == '' ||
-                                                                  seed_data['auth_tag'] == ''
-
-          cipher = OpenSSL::Cipher.new('aes-256-gcm').decrypt
-          cipher.key = OpenSSL::Digest.digest('SHA256', shared_secret)
-          iv = [seed_data['iv']].pack('H*')
-          cipher.iv = iv
-          auth_tag = [seed_data['auth_tag']].pack('H*')
-          cipher.auth_tag = auth_tag
-          cipher.auth_data = ''
-          hex_decoded_data = [seed_data['seed']].pack('H*')
-          seed = cipher.update(hex_decoded_data) + cipher.final
-        end
-
-        data = Coinbase::Wallet::Data.new(wallet_id: wallet_id, seed: seed)
-        wallets[wallet_id] = import_wallet(data)
-      end
-      wallets
+      Wallet.new(wallet_model, seed: '', address_models: addresses_list.data)
     end
 
     # Returns a string representation of the User.
@@ -165,22 +107,5 @@ module Coinbase
     def wallets_api
       @wallets_api ||= Coinbase::Client::WalletsApi.new(Coinbase.configuration.api_client)
     end
-
-    def existing_seeds
-      existing_seed_data = '{}'
-      file_path = Coinbase.configuration.backup_file_path
-      existing_seed_data = File.read(file_path) if File.exist?(file_path)
-      output = JSON.parse(existing_seed_data)
-
-      raise ArgumentError, 'Malformed backup data' unless output.is_a?(Hash)
-
-      output
-    end
-
-    def store_encryption_key
-      pk = OpenSSL::PKey.read(Coinbase.configuration.api_key_private_key)
-      public_key = pk.public_key # use own public key to generate the shared secret.
-      pk.dh_compute_key(public_key)
-    end
   end
 end