coinbase-sdk 0.0.1 → 0.0.3

data/lib/coinbase/wallet.rb

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'jimson'
+require 'json'
 require 'money-tree'
 require 'securerandom'
 
 module Coinbase
   # A representation of a Wallet. Wallets come with a single default Address, but can expand to have a set of Addresses,
   # each of which can hold a balance of one or more Assets. Wallets can create new Addresses, list their addresses,
-  # list their balances, and transfer Assets to other Addresses.
+  # list their balances, and transfer Assets to other Addresses. Wallets should be created through User#create_wallet or
+  # User#import_wallet.
   class Wallet
-    attr_reader :wallet_id, :network_id
-
-    # Returns a new Wallet object.
-    # @param seed [Integer] (Optional) The seed to use for the Wallet. Expects a 32-byte hexadecimal. If not provided,
-    #   a new seed will be generated.
-    # @param address_count [Integer] (Optional) The number of addresses to generate for the Wallet. If not provided,
-    #   a single address will be generated.
+    # Returns a new Wallet object. Do not use this method directly. Instead, use User#create_wallet or
+    # User#import_wallet.
+    # @param model [Coinbase::Client::Wallet] The underlying Wallet object
+    # @param seed [String] (Optional) The seed to use for the Wallet. Expects a 32-byte hexadecimal with no 0x prefix.
+    #   If not provided, a new seed will be generated.
+    # @param address_count [Integer] (Optional) The number of addresses already registered for the Wallet.
     # @param client [Jimson::Client] (Optional) The JSON RPC client to use for interacting with the Network
-    def initialize(seed: nil, address_count: 1, client: Jimson::Client.new(Coinbase.base_sepolia_rpc_url))
+    def initialize(model, seed: nil, address_count: 0)
       raise ArgumentError, 'Seed must be 32 bytes' if !seed.nil? && seed.length != 64
-      raise ArgumentError, 'Address count must be positive' if address_count < 1
+
+      @model = model
 
       @master = seed.nil? ? MoneyTree::Master.new : MoneyTree::Master.new(seed_hex: seed)
 
-      @wallet_id = SecureRandom.uuid
       # TODO: Make Network an argument to the constructor.
       @network_id = :base_sepolia
       @addresses = []
@@ -32,28 +34,51 @@ module Coinbase
       @address_path_prefix = "m/44'/60'/0'/0"
       @address_index = 0
 
-      @client = client
+      if address_count.positive?
+        address_count.times { derive_address }
+      else
+        create_address
+        # Update the model to reflect the new default address.
+        update_model
+      end
+    end
+
+    # Returns the Wallet ID.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.id
+    end
 
-      address_count.times { create_address }
+    # Returns the Network ID of the Wallet.
+    # @return [Symbol] The Network ID
+    def network_id
+      Coinbase.to_sym(@model.network_id)
     end
 
     # Creates a new Address in the Wallet.
     # @return [Address] The new Address
     def create_address
-      # TODO: Register with server.
-      path = "#{@address_path_prefix}/#{@address_index}"
-      private_key = @master.node_for_path(path).private_key.to_hex
-      key = Eth::Key.new(priv: private_key)
-      address = Address.new(@network_id, key.address.address, @wallet_id, key, client: @client)
-      @addresses << address
-      @address_index += 1
-      address
+      key = derive_key
+      attestation = create_attestation(key)
+      public_key = key.public_key.compressed.unpack1('H*')
+
+      opts = {
+        create_address_request: {
+          public_key: public_key,
+          attestation: attestation
+        }
+      }
+      address_model = Coinbase.call_api do
+        addresses_api.create_address(wallet_id, opts)
+      end
+
+      cache_address(address_model, key)
     end
 
     # Returns the default address of the Wallet.
     # @return [Address] The default address
     def default_address
-      @addresses.first
+      @addresses.find { |address| address.address_id == @model.default_address.address_id }
     end
 
     # Returns the Address with the given ID.
@@ -66,25 +91,17 @@ module Coinbase
     # Returns the list of Addresses in the Wallet.
     # @return [Array<Address>] The list of Addresses
     def list_addresses
-      # TODO: Register with server.
       @addresses
     end
 
     # Returns the list of balances of this Wallet. Balances are aggregated across all Addresses in the Wallet.
     # @return [BalanceMap] The list of balances. The key is the Asset ID, and the value is the balance.
     def list_balances
-      balance_map = BalanceMap.new
-
-      @addresses.each do |address|
-        address.list_balances.each do |asset_id, balance|
-          balance_map[asset_id] ||= BigDecimal(0)
-          current_balance = balance_map[asset_id]
-          new_balance = balance + current_balance
-          balance_map[asset_id] = new_balance
-        end
+      response = Coinbase.call_api do
+        wallets_api.list_wallet_balances(wallet_id)
       end
 
-      balance_map
+      Coinbase.to_balance_map(response)
     end
 
     # Returns the balance of the provided Asset. Balances are aggregated across all Addresses in the Wallet.
@@ -97,17 +114,23 @@ module Coinbase
                               asset_id
                             end
 
-      eth_balance = list_balances[normalized_asset_id] || BigDecimal(0)
+      response = Coinbase.call_api do
+        wallets_api.get_wallet_balance(wallet_id, normalized_asset_id.to_s)
+      end
+
+      return BigDecimal('0') if response.nil?
+
+      amount = BigDecimal(response.amount)
 
       case asset_id
       when :eth
-        eth_balance
+        amount / BigDecimal(Coinbase::WEI_PER_ETHER.to_s)
       when :gwei
-        eth_balance * Coinbase::GWEI_PER_ETHER
-      when :wei
-        eth_balance * Coinbase::WEI_PER_ETHER
+        amount / BigDecimal(Coinbase::GWEI_PER_ETHER.to_s)
+      when :usdc
+        amount / BigDecimal(Coinbase::ATOMIC_UNITS_PER_USDC.to_s)
       else
-        BigDecimal(0)
+        amount
       end
     end
 
@@ -132,29 +155,122 @@ module Coinbase
       default_address.transfer(amount, asset_id, destination)
     end
 
-    # Exports the Wallet's data to a WalletData object.
-    # @return [WalletData] The Wallet data
+    # Exports the Wallet's data to a Data object.
+    # @return [Data] The Wallet data
     def export
-      WalletData.new(@master.seed_hex, @addresses.length)
+      Data.new(wallet_id: wallet_id, seed: @master.seed_hex)
+    end
+
+    # Returns a String representation of the Wallet.
+    # @return [String] a String representation of the Wallet
+    def to_s
+      "Coinbase::Wallet{wallet_id: '#{wallet_id}', network_id: '#{network_id}', " \
+        "default_address: '#{default_address.address_id}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Wallet
+    def inspect
+      to_s
     end
 
     # The data required to recreate a Wallet.
-    class WalletData
-      attr_reader :seed, :address_count
+    class Data
+      attr_reader :wallet_id, :seed
 
-      # Returns a new WalletData object.
+      # Returns a new Data object.
+      # @param wallet_id [String] The ID of the Wallet
       # @param seed [String] The seed of the Wallet
-      # @param address_count [Integer] The number of addresses in the Wallet
-      def initialize(seed, address_count)
+      def initialize(wallet_id:, seed:)
+        @wallet_id = wallet_id
         @seed = seed
-        @address_count = address_count
       end
+
+      # Converts the Data object to a Hash.
+      # @return [Hash] The Hash representation of the Data object
+      def to_hash
+        { wallet_id: wallet_id, seed: seed }
+      end
+
+      # Creates a Data object from the given Hash.
+      # @param data [Hash] The Hash to create the Data object from
+      # @return [Data] The new Data object
+      def self.from_hash(data)
+        Data.new(wallet_id: data['wallet_id'], seed: data['seed'])
+      end
+    end
+
+    private
+
+    # Derives an already registered Address in the Wallet.
+    # @return [Address] The new Address
+    def derive_address
+      key = derive_key
+
+      address_id = key.address.to_s
+      address_model = Coinbase.call_api do
+        addresses_api.get_address(wallet_id, address_id)
+      end
+
+      cache_address(address_model, key)
+    end
+
+    # Derives a key for an already registered Address in the Wallet.
+    # @return [Eth::Key] The new key
+    def derive_key
+      path = "#{@address_path_prefix}/#{@address_index}"
+      private_key = @master.node_for_path(path).private_key.to_hex
+      Eth::Key.new(priv: private_key)
+    end
+
+    # Caches an Address on the client-side and increments the address index.
+    # @param address_model [Coinbase::Client::Address] The Address model
+    # @param key [Eth::Key] The private key of the Address
+    # @return [Address] The new Address
+    def cache_address(address_model, key)
+      address = Address.new(address_model, key)
+      @addresses << address
+      @address_index += 1
+      address
+    end
+
+    # Creates an attestation for the Address currently being created.
+    # @param key [Eth::Key] The private key of the Address
+    # @return [String] The attestation
+    def create_attestation(key)
+      public_key = key.public_key.compressed.unpack1('H*')
+      payload = {
+        wallet_id: wallet_id,
+        public_key: public_key
+      }.to_json
+      hashed_payload = Digest::SHA256.digest(payload)
+      signature = key.sign(hashed_payload)
+
+      # The secp256k1 library serializes the signature as R, S, V.
+      # The server expects the signature as V, R, S in the format:
+      # <(byte of 27+public key solution)+4 if compressed >< padded bytes for signature R><padded bytes for signature S>
+      # Ruby gem does not add 4 to the recovery byte, so we need to add it here.
+      # Take the last byte (V) and add 4 to it to show signature is compressed.
+      signature_bytes = [signature].pack('H*').unpack('C*')
+      last_byte = signature_bytes.last
+      compressed_last_byte = last_byte + 4
+      new_signature_bytes = [compressed_last_byte] + signature_bytes[0..-2]
+      new_signature_bytes.pack('C*').unpack1('H*')
+    end
+
+    # Updates the Wallet model with the latest data.
+    def update_model
+      @model = Coinbase.call_api do
+        wallets_api.get_wallet(wallet_id)
+      end
+    end
+
+    def addresses_api
+      @addresses_api ||= Coinbase::Client::AddressesApi.new(Coinbase.configuration.api_client)
     end
 
-    # Returns the data required to recreate the Wallet.
-    # @return [WalletData] The Wallet data
-    def to_data
-      WalletData.new(@master.seed_hex, @addresses.length)
+    def wallets_api
+      @wallets_api ||= Coinbase::Client::WalletsApi.new(Coinbase.configuration.api_client)
     end
   end
 end

data/lib/coinbase.rb

@@ -2,25 +2,143 @@
 
 require_relative 'coinbase/address'
 require_relative 'coinbase/asset'
+require_relative 'coinbase/authenticator'
 require_relative 'coinbase/balance_map'
+require_relative 'coinbase/client'
 require_relative 'coinbase/constants'
+require_relative 'coinbase/errors'
+require_relative 'coinbase/faucet_transaction'
+require_relative 'coinbase/middleware'
 require_relative 'coinbase/network'
 require_relative 'coinbase/transfer'
+require_relative 'coinbase/user'
 require_relative 'coinbase/wallet'
+require 'json'
 
 # The Coinbase SDK.
 module Coinbase
-  @base_sepolia_rpc_url = 'https://sepolia.base.org'
+  class InvalidConfiguration < StandardError; end
+  class FaucetLimitReached < StandardError; end
 
-  # Returns the Base Sepolia RPC URL.
-  # @return [String] the Base Sepolia RPC URL
-  def self.base_sepolia_rpc_url
-    @base_sepolia_rpc_url
+  # Returns the configuration object.
+  # @return [Configuration] the configuration object
+  def self.configuration
+    @configuration ||= Configuration.new
   end
 
-  # Sets the Base Sepolia RPC URL.
-  # @param value [String] the Base Sepolia RPC URL
-  def self.base_sepolia_rpc_url=(value)
-    @base_sepolia_rpc_url = value
+  # Configures the Coinbase SDK.
+  def self.configure
+    yield(configuration)
+
+    raise InvalidConfiguration, 'API key private key is not set' unless configuration.api_key_private_key
+    raise InvalidConfiguration, 'API key name is not set' unless configuration.api_key_name
+  end
+
+  # Configures the Coinbase SDK from the given CDP API Key JSON file.
+  # @param file_path [String] (Optional) the path to the CDP API Key JSON file
+  # file in the root directory by default.
+  def self.configure_from_json(file_path = 'coinbase_cloud_api_key.json')
+    configuration.from_json(file_path)
+
+    raise InvalidConfiguration, 'API key private key is not set' unless configuration.api_key_private_key
+    raise InvalidConfiguration, 'API key name is not set' unless configuration.api_key_name
+  end
+
+  # Configuration object for the Coinbase SDK.
+  class Configuration
+    attr_reader :base_sepolia_rpc_url, :base_sepolia_client
+    attr_accessor :api_url, :api_key_name, :api_key_private_key, :debug_api, :backup_file_path
+
+    # Initializes the configuration object.
+    def initialize
+      @base_sepolia_rpc_url = 'https://sepolia.base.org'
+      @base_sepolia_client = Jimson::Client.new(@base_sepolia_rpc_url)
+      @api_url = 'https://api.cdp.coinbase.com'
+      @debug_api = false
+      @backup_file_path = 'seeds.json'
+    end
+
+    # Sets configuration values based on the provided CDP API Key JSON file.
+    # @param file_path [String] (Optional) the path to the CDP API Key JSON file
+    # file in the root directory by default.
+    def from_json(file_path = 'coinbase_cloud_api_key.json')
+      # Expand paths to respect shortcuts like ~.
+      file_path = File.expand_path(file_path)
+
+      raise InvalidConfiguration, 'Invalid configuration file type' unless file_path.end_with?('.json')
+
+      file = File.read(file_path)
+      data = JSON.parse(file)
+      @api_key_name = data['name']
+      @api_key_private_key = data['privateKey']
+    end
+
+    # Sets the Base Sepolia RPC URL.
+    # @param new_base_sepolia_rpc_url [String] the new Base Sepolia RPC URL
+    def base_sepolia_rpc_url=(new_base_sepolia_rpc_url)
+      @base_sepolia_rpc_url = new_base_sepolia_rpc_url
+      @base_sepolia_client = Jimson::Client.new(@base_sepolia_rpc_url)
+    end
+
+    # Returns the API client.
+    # @return [Coinbase::Client::ApiClient] the API client
+    def api_client
+      @api_client ||= Coinbase::Client::ApiClient.new(Middleware.config)
+    end
+  end
+
+  # Returns the default user.
+  # @return [Coinbase::User] the default user
+  def self.default_user
+    @default_user ||= load_default_user
+  end
+
+  # Converts a string to a symbol, replacing hyphens with underscores.
+  # @param string [String] the string to convert
+  # @return [Symbol] the converted symbol
+  def self.to_sym(value)
+    value.to_s.gsub('-', '_').to_sym
+  end
+
+  # Converts a Coinbase::Client::AddressBalanceList to a BalanceMap.
+  # @param address_balance_list [Coinbase::Client::AddressBalanceList] The AddressBalanceList to convert
+  # @return [BalanceMap] The converted BalanceMap
+  def self.to_balance_map(address_balance_list)
+    balances = {}
+
+    address_balance_list.data.each do |balance|
+      asset_id = Coinbase.to_sym(balance.asset.asset_id.downcase)
+      amount = case asset_id
+               when :eth
+                 BigDecimal(balance.amount) / BigDecimal(Coinbase::WEI_PER_ETHER)
+               when :usdc
+                 BigDecimal(balance.amount) / BigDecimal(Coinbase::ATOMIC_UNITS_PER_USDC)
+               when :weth
+                 BigDecimal(balance.amount) / BigDecimal(Coinbase::WEI_PER_ETHER)
+               else
+                 BigDecimal(balance.amount)
+               end
+      balances[asset_id] = amount
+    end
+
+    BalanceMap.new(balances)
+  end
+
+  # Loads the default user.
+  # @return [Coinbase::User] the default user
+  def self.load_default_user
+    users_api = Coinbase::Client::UsersApi.new(configuration.api_client)
+    user_model = users_api.get_current_user
+    Coinbase::User.new(user_model)
+  end
+
+  # Wraps a call to the Platform API to ensure that the error is caught and
+  # wrapped as an APIError.
+  def self.call_api
+    yield
+  rescue Coinbase::Client::ApiError => e
+    raise Coinbase::APIError.from_error(e)
+  rescue StandardError => e
+    raise e
   end
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: coinbase-sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Yuga Cohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-19 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bigdecimal
+  name: eth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: eth
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +67,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: money-tree
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: marcel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: securerandom
+  name: money-tree
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +192,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.9.36
+- !ruby/object:Gem::Dependency
+  name: yard-markdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Coinbase Ruby SDK for accessing Coinbase Platform APIs
 email: yuga.cohler@coinbase.com
 executables: []
@@ -159,10 +215,40 @@ files:
 - lib/coinbase.rb
 - lib/coinbase/address.rb
 - lib/coinbase/asset.rb
+- lib/coinbase/authenticator.rb
 - lib/coinbase/balance_map.rb
+- lib/coinbase/client.rb
+- lib/coinbase/client/api/addresses_api.rb
+- lib/coinbase/client/api/transfers_api.rb
+- lib/coinbase/client/api/users_api.rb
+- lib/coinbase/client/api/wallets_api.rb
+- lib/coinbase/client/api_client.rb
+- lib/coinbase/client/api_error.rb
+- lib/coinbase/client/configuration.rb
+- lib/coinbase/client/models/address.rb
+- lib/coinbase/client/models/address_balance_list.rb
+- lib/coinbase/client/models/address_list.rb
+- lib/coinbase/client/models/asset.rb
+- lib/coinbase/client/models/balance.rb
+- lib/coinbase/client/models/broadcast_transfer_request.rb
+- lib/coinbase/client/models/create_address_request.rb
+- lib/coinbase/client/models/create_transfer_request.rb
+- lib/coinbase/client/models/create_wallet_request.rb
+- lib/coinbase/client/models/error.rb
+- lib/coinbase/client/models/faucet_transaction.rb
+- lib/coinbase/client/models/transfer.rb
+- lib/coinbase/client/models/transfer_list.rb
+- lib/coinbase/client/models/user.rb
+- lib/coinbase/client/models/wallet.rb
+- lib/coinbase/client/models/wallet_list.rb
+- lib/coinbase/client/version.rb
 - lib/coinbase/constants.rb
+- lib/coinbase/errors.rb
+- lib/coinbase/faucet_transaction.rb
+- lib/coinbase/middleware.rb
 - lib/coinbase/network.rb
 - lib/coinbase/transfer.rb
+- lib/coinbase/user.rb
 - lib/coinbase/wallet.rb
 homepage: https://github.com/coinbase/coinbase-sdk-ruby
 licenses: