coinbase-sdk 0.0.1 → 0.0.3

data/lib/coinbase/transfer.rb

@@ -3,15 +3,14 @@
 require_relative 'constants'
 require 'bigdecimal'
 require 'eth'
+require 'json'
 
 module Coinbase
   # A representation of a Transfer, which moves an amount of an Asset from
   # a user-controlled Wallet to another address. The fee is assumed to be paid
-  # in the native Asset of the Network. Currently only ETH transfers are supported. Transfers
-  # should be created through {link:Wallet#transfer} or {link:Address#transfer}.
+  # in the native Asset of the Network. Transfers should be created through Wallet#transfer or
+  # Address#transfer.
   class Transfer
-    attr_reader :network_id, :wallet_id, :from_address_id, :amount, :asset_id, :to_address_id
-
     # A representation of a Transfer status.
     module Status
       # The Transfer is awaiting being broadcast to the Network. At this point, transaction
@@ -29,28 +28,83 @@ module Coinbase
       FAILED = :failed
     end
 
-    # Returns a new Transfer object.
-    # @param network_id [Symbol] The ID of the Network on which the Transfer originated
-    # @param wallet_id [String] The ID of the Wallet from which the Transfer originated
-    # @param from_address_id [String] The ID of the address from which the Transfer originated
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send. Integers are interpreted as
-    #  the smallest denomination of the Asset (e.g. Wei for Ether). Floats and BigDecimals are interpreted as the Asset
-    #  itself (e.g. Ether).
-    # @param asset_id [Symbol] The ID of the Asset being transferred. Currently only ETH is supported.
-    # @param to_address_id [String] The address to which the Transfer is being sent
-    # @param client [Jimson::Client] (Optional) The JSON RPC client to use for interacting with the Network
-    def initialize(network_id, wallet_id, from_address_id, amount, asset_id, to_address_id,
-                   client: Jimson::Client.new(Coinbase.base_sepolia_rpc_url))
+    # 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)
+      @model = model
+    end
+
+    # Returns the Transfer ID.
+    # @return [String] The Transfer ID
+    def transfer_id
+      @model.transfer_id
+    end
+
+    # Returns the Network ID of the Transfer.
+    # @return [Symbol] The Network ID
+    def network_id
+      Coinbase.to_sym(@model.network_id)
+    end
+
+    # Returns the Wallet ID of the Transfer.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the From Address ID of the Transfer.
+    # @return [String] The From Address ID
+    def from_address_id
+      @model.address_id
+    end
+
+    # Returns the Destination Address ID of the Transfer.
+    # @return [String] The Destination Address ID
+    def destination_address_id
+      @model.destination
+    end
+
+    # Returns the Asset ID of the Transfer.
+    # @return [Symbol] The Asset ID
+    def asset_id
+      @model.asset_id.to_sym
+    end
+
+    # 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
+    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
 
-      raise ArgumentError, "Unsupported asset: #{asset_id}" if asset_id != :eth
+    # Returns the Unsigned Payload of the Transfer.
+    # @return [String] The Unsigned Payload
+    def unsigned_payload
+      @model.unsigned_payload
+    end
 
-      @network_id = network_id
-      @wallet_id = wallet_id
-      @from_address_id = from_address_id
-      @amount = normalize_eth_amount(amount)
-      @asset_id = asset_id
-      @to_address_id = to_address_id
-      @client = client
+    # Returns the Signed Payload of the Transfer.
+    # @return [String] The Signed Payload
+    def signed_payload
+      @model.signed_payload
+    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.
@@ -58,18 +112,19 @@ module Coinbase
     def transaction
       return @transaction unless @transaction.nil?
 
-      nonce = @client.eth_getTransactionCount(@from_address_id.to_s, 'latest').to_i(16)
-      gas_price = @client.eth_gasPrice.to_i(16)
+      raw_payload = [unsigned_payload].pack('H*')
+      parsed_payload = JSON.parse(raw_payload)
 
       params = {
-        chain_id: BASE_SEPOLIA.chain_id, # TODO: Don't hardcode Base Sepolia.
-        nonce: nonce,
-        priority_fee: gas_price, # TODO: Optimize this.
-        max_gas_fee: gas_price,
-        gas_limit: 21_000, # TODO: Handle multiple currencies.
-        from: Eth::Address.new(@from_address_id),
-        to: Eth::Address.new(@to_address_id),
-        value: (@amount * Coinbase::WEI_PER_ETHER).to_i
+        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))
@@ -79,15 +134,10 @@ module Coinbase
     # Returns the status of the Transfer.
     # @return [Symbol] The status
     def status
-      begin
-        # Create the transaction, and attempt to get the hash to see if it has been signed.
-        transaction.hash
-      rescue Eth::Signature::SignatureError
-        # If the transaction has not been signed, it is still pending.
-        return Status::PENDING
-      end
+      # Check if the transfer has been signed yet.
+      return Status::PENDING if transaction_hash.nil?
 
-      onchain_transaction = @client.eth_getTransactionByHash(transaction_hash)
+      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.
@@ -97,7 +147,7 @@ module Coinbase
         # broadcast.
         Status::BROADCAST
       else
-        transaction_receipt = @client.eth_getTransactionReceipt(transaction_hash)
+        transaction_receipt = Coinbase.configuration.base_sepolia_client.eth_getTransactionReceipt(transaction_hash)
 
         if transaction_receipt['status'].to_i(16) == 1
           Status::COMPLETE
@@ -126,28 +176,19 @@ module Coinbase
       self
     end
 
-    # Returns the transaction hash of the Transfer, or nil if not yet available.
-    # @return [String] The transaction hash
-    def transaction_hash
-      "0x#{transaction.hash}"
-    rescue Eth::Signature::SignatureError
-      nil
-    end
-
-    private
-
-    # Normalizes the given Ether amount into a BigDecimal.
-    # @param amount [Integer, Float, BigDecimal] The amount to normalize
-    # @return [BigDecimal] The normalized amount
-    def normalize_eth_amount(amount)
-      case amount
-      when BigDecimal
-        amount
-      when Integer, Float
-        BigDecimal(amount.to_s)
-      else
-        raise ArgumentError, "Invalid amount: #{amount}"
-      end
+    # Returns a String representation of the Transfer.
+    # @return [String] a String representation of the Transfer
+    def to_s
+      "Coinbase::Transfer{transfer_id: '#{transfer_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}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Transfer
+    def inspect
+      to_s
     end
   end
 end

data/lib/coinbase/user.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+require_relative 'wallet'
+
+module Coinbase
+  # A representation of a User. Users have Wallets, which can hold balances of Assets. Access the default User through
+  # Coinbase#default_user.
+  class User
+    # Returns a new User object. Do not use this method directly. Instead, use Coinbase#default_user.
+    # @param model [Coinbase::Client::User] the underlying User object
+    def initialize(model)
+      @model = model
+    end
+
+    # Returns the User ID.
+    # @return [String] the User ID
+    def user_id
+      @model.id
+    end
+
+    # Creates a new Wallet belonging to the User.
+    # @return [Coinbase::Wallet] the new Wallet
+    def create_wallet
+      create_wallet_request = {
+        wallet: {
+          # TODO: Don't hardcode this.
+          network_id: 'base-sepolia'
+        }
+      }
+      opts = { create_wallet_request: create_wallet_request }
+
+      model = Coinbase.call_api do
+        wallets_api.create_wallet(opts)
+      end
+
+      Wallet.new(model)
+    end
+
+    # Imports a Wallet belonging to the User.
+    # @param data [Coinbase::Wallet::Data] the Wallet data to import
+    # @return [Coinbase::Wallet] the imported Wallet
+    def import_wallet(data)
+      model = Coinbase.call_api do
+        wallets_api.get_wallet(data.wallet_id)
+      end
+
+      address_count = Coinbase.call_api do
+        addresses_api.list_addresses(model.id).total_count
+      end
+
+      Wallet.new(model, seed: data.seed, address_count: address_count)
+    end
+
+    # Lists the IDs of the Wallets belonging to the User.
+    # @return [Array<String>] the IDs of the Wallets belonging to the User
+    def list_wallet_ids
+      wallets = Coinbase.call_api do
+        wallets_api.list_wallets
+      end
+
+      wallets.data.map(&:id)
+    end
+
+    # Saves a wallet to local file system. Wallet saved this way can be re-instantiated with `load_wallets` 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 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(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*')
+      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))
+      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
+      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
+    end
+
+    # Returns a string representation of the User.
+    # @return [String] a string representation of the User
+    def to_s
+      "Coinbase::User{user_id: '#{user_id}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a string representation of the User
+    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
+
+    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