coinbase 0.0.1 → 1.3.0

data/lib/coinbase/address.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'balance_map'
-require_relative 'constants'
-require 'bigdecimal'
-require 'eth'
-require 'jimson'
-
-module Coinbase
-  # A representation of a blockchain Address, which is a user-controlled account on a Network. Addresses are used to
-  # send and receive Assets, and should be created using {link:Wallet#create_address}. Addresses require a
-  # {link:Eth::Key} to sign transaction data.
-  class Address
-    attr_reader :network_id, :address_id, :wallet_id
-
-    # Returns a new Address object.
-    # @param network_id [Symbol] The ID of the Network on which the Address exists
-    # @param address_id [String] The ID of the Address. On EVM Networks, for example, this is a hash of the public key.
-    # @param wallet_id [String] The ID of the Wallet to which the Address belongs
-    # @param key [Eth::Key] The key backing the Address
-    # @param client [Jimson::Client] (Optional) The JSON RPC client to use for interacting with the Network
-    def initialize(network_id, address_id, wallet_id, key,
-                   client: Jimson::Client.new(ENV.fetch('BASE_SEPOLIA_RPC_URL', nil)))
-      # TODO: Don't require key.
-      @network_id = network_id
-      @address_id = address_id
-      @wallet_id = wallet_id
-      @key = key
-      @client = client
-    end
-
-    # Returns the balances of the Address. Currently only ETH balances are supported.
-    # @return [BalanceMap] The balances of the Address, keyed by asset ID. Ether balances are denominated
-    #  in ETH.
-    def list_balances
-      # TODO: Handle multiple currencies.
-      eth_balance_in_wei = BigDecimal(@client.eth_getBalance(@address_id, 'latest').to_i(16).to_s)
-      eth_balance = BigDecimal(eth_balance_in_wei / BigDecimal(Coinbase::WEI_PER_ETHER.to_s))
-
-      BalanceMap.new({ eth: eth_balance })
-    end
-
-    # Returns the balance of the provided Asset. Currently only ETH is supported.
-    # @param asset_id [Symbol] The Asset to retrieve the balance for
-    # @return [BigDecimal] The balance of the Asset
-    def get_balance(asset_id)
-      normalized_asset_id = if %i[wei gwei].include?(asset_id)
-                              :eth
-                            else
-                              asset_id
-                            end
-
-      eth_balance = list_balances[normalized_asset_id] || BigDecimal(0)
-
-      case asset_id
-      when :eth
-        eth_balance
-      when :gwei
-        eth_balance * Coinbase::GWEI_PER_ETHER
-      when :wei
-        eth_balance * Coinbase::WEI_PER_ETHER
-      else
-        BigDecimal(0)
-      end
-    end
-
-    # Transfers the given amount of the given Asset to the given address. Only same-Network Transfers are supported.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send.
-    # @param asset_id [Symbol] The ID of the Asset to send. For Ether, :eth, :gwei, and :wei are supported.
-    # @param destination [Wallet | Address | String] The destination of the transfer. If a Wallet, sends to the Wallet's
-    #  default address. If a String, interprets it as the address ID.
-    # @return [String] The hash of the Transfer transaction.
-    def transfer(amount, asset_id, destination)
-      # TODO: Handle multiple currencies.
-      raise ArgumentError, "Unsupported asset: #{asset_id}" unless Coinbase::SUPPORTED_ASSET_IDS[asset_id]
-
-      if destination.is_a?(Wallet)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
-
-        destination = destination.default_address.address_id
-      elsif destination.is_a?(Address)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
-
-        destination = destination.address_id
-      end
-
-      current_balance = get_balance(asset_id)
-      if current_balance < amount
-        raise ArgumentError, "Insufficient funds: #{amount} requested, but only #{current_balance} available"
-      end
-
-      transfer = Coinbase::Transfer.new(@network_id, @wallet_id, @address_id, amount, asset_id, destination,
-                                        client: @client)
-
-      transaction = transfer.transaction
-      transaction.sign(@key)
-      @client.eth_sendRawTransaction("0x#{transaction.hex}")
-
-      transfer
-    end
-
-    # Returns the address as a string.
-    # @return [String] The address
-    def to_s
-      @address_id
-    end
-
-    private
-
-    # Normalizes the amount of ETH to send based on the asset ID.
-    # @param amount [Integer, Float, BigDecimal] The amount to normalize
-    # @param asset_id [Symbol] The ID of the Asset being transferred
-    # @return [BigDecimal] The normalized amount in units of ETH
-    def normalize_eth_amount(amount, asset_id)
-      case asset_id
-      when :eth
-        amount.is_a?(BigDecimal) ? amount : BigDecimal(amount.to_s)
-      when :gwei
-        BigDecimal(amount / Coinbase::GWEI_PER_ETHER)
-      when :wei
-        BigDecimal(amount / Coinbase::WEI_PER_ETHER)
-      else
-        raise ArgumentError, "Unsupported asset: #{asset_id}"
-      end
-    end
-  end
-end

data/lib/coinbase/asset.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Coinbase
-  # A representation of an Asset.
-  class Asset
-    attr_reader :network_id, :asset_id, :display_name, :address_id
-
-    # Returns a new Asset object.
-    # @param network_id [Symbol] The ID of the Network to which the Asset belongs
-    # @param asset_id [Symbol] The Asset ID
-    # @param display_name [String] The Asset's display name
-    # @param address_id [String] (Optional) The Asset's address ID, if one exists
-    def initialize(network_id:, asset_id:, display_name:, address_id: nil)
-      @network_id = network_id
-      @asset_id = asset_id
-      @display_name = display_name
-      @address_id = address_id
-    end
-  end
-end

data/lib/coinbase/balance_map.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'bigdecimal'
-
-module Coinbase
-  # A convenience class for printing out crypto asset balances in a human-readable format.
-  class BalanceMap < Hash
-    # Returns a new BalanceMap object.
-    # @param hash [Map<Symbol, BigDecimal>] The hash to initialize with
-    def initialize(hash = {})
-      super()
-      hash.each do |key, value|
-        self[key] = value
-      end
-    end
-
-    # Returns a string representation of the balance map.
-    # @return [String] The string representation of the balance
-    def to_s
-      to_string
-    end
-
-    # Returns a string representation of the balance map.
-    # @return [String] The string representation of the balance
-    def inspect
-      to_string
-    end
-
-    private
-
-    # Returns a string representation of the balance.
-    # @return [String] The string representation of the balance
-    def to_string
-      result = {}
-
-      each do |asset_id, balance|
-        # Convert to floating-point number (not scientific notation)
-        str = balance.to_s('F')
-
-        str = balance.to_i.to_s if balance.frac.zero?
-
-        result[asset_id] = str
-      end
-
-      result
-    end
-  end
-end

data/lib/coinbase/constants.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'asset'
-require_relative 'network'
-
-module Coinbase
-  # The Assets supported on Base Sepolia by the Coinbase SDK.
-  ETH = Asset.new(network_id: :base_sepolia, asset_id: :eth, display_name: 'Ether')
-  USDC = Asset.new(network_id: :base_sepolia, asset_id: :usdc, display_name: 'USD Coin',
-                   address_id: '0x036CbD53842c5426634e7929541eC2318f3dCF7e')
-
-  # The Base Sepolia Network.
-  BASE_SEPOLIA = Network.new(
-    network_id: :base_sepolia,
-    display_name: 'Base Sepolia',
-    protocol_family: :evm,
-    is_testnet: true,
-    assets: [ETH, USDC],
-    native_asset_id: :eth,
-    chain_id: 84_532
-  )
-
-  # The amount of Wei per Ether.
-  WEI_PER_ETHER = 1_000_000_000_000_000_000
-
-  # The amount of Wei per Gwei.
-  WEI_PER_GWEI = 1_000_000_000
-
-  # The amount of Gwei per Ether.
-  GWEI_PER_ETHER = 1_000_000_000
-
-  # A map of supported Asset IDs.
-  SUPPORTED_ASSET_IDS = {
-    eth: true, # Ether, the native asset of most EVM networks.
-    gwei: true, # A medium denomination of Ether, typically used in gas prices.
-    wei: true # The smallest denomination of Ether.
-  }.freeze
-end

data/lib/coinbase/network.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Coinbase
-  # A blockchain network.
-  class Network
-    attr_reader :chain_id
-
-    # Returns a new Network object.
-    #
-    # @param network_id [Symbol] The Network ID
-    # @param display_name [String] The Network's display name
-    # @param protocol_family [String] The protocol family to which the Network belongs
-    #   (e.g., "evm")
-    # @param is_testnet [Boolean] Whether the Network is a testnet
-    # @param assets [Array<Asset>] The Assets supported by the Network
-    # @param native_asset_id [String] The ID of the Network's native Asset
-    # @param chain_id [Integer] The Chain ID of the Network
-    def initialize(network_id:, display_name:, protocol_family:, is_testnet:, assets:, native_asset_id:, chain_id:)
-      @network_id = network_id
-      @display_name = display_name
-      @protocol_family = protocol_family
-      @is_testnet = is_testnet
-      @chain_id = chain_id
-
-      @asset_map = {}
-      assets.each do |asset|
-        @asset_map[asset.asset_id] = asset
-      end
-
-      raise ArgumentError, 'Native Asset not found' unless @asset_map.key?(native_asset_id)
-
-      @native_asset = @asset_map[native_asset_id]
-    end
-
-    # Lists the Assets supported by the Network.
-    #
-    # @return [Array<Asset>] The Assets supported by the Network
-    def list_assets
-      @asset_map.values
-    end
-
-    # Gets the Asset with the given ID.
-    #
-    # @param asset_id [Symbol] The ID of the Asset
-    # @return [Asset] The Asset with the given ID
-    def get_asset(asset_id)
-      @asset_map[asset_id]
-    end
-
-    # Gets the native Asset of the Network.
-    #
-    # @return [Asset] The native Asset of the Network
-    attr_reader :native_asset
-  end
-end

data/lib/coinbase/transfer.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'constants'
-require 'bigdecimal'
-require 'eth'
-
-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}.
-  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
-      # 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.
-    # @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(ENV.fetch('BASE_SEPOLIA_RPC_URL', nil)))
-
-      raise ArgumentError, "Unsupported asset: #{asset_id}" if asset_id != :eth
-
-      @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
-    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?
-
-      nonce = @client.eth_getTransactionCount(@from_address_id.to_s, 'latest').to_i(16)
-      gas_price = @client.eth_gasPrice.to_i(16)
-
-      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
-      }
-
-      @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
-      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
-
-      onchain_transaction = @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 = @client.eth_getTransactionReceipt(transaction_hash)
-
-        if transaction_receipt['status'].to_i(16) == 1
-          Status::COMPLETE
-        else
-          Status::FAILED
-        end
-      end
-    end
-
-    # Waits until the Transfer is completed or failed by polling the Network at the given interval. Raises a
-    # Timeout::Error if the Transfer 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 Transfer to complete, in seconds
-    # @return [Transfer] The completed Transfer object
-    def wait!(interval_seconds = 0.2, timeout_seconds = 10)
-      start_time = Time.now
-
-      loop do
-        return self if status == Status::COMPLETE || status == Status::FAILED
-
-        raise Timeout::Error, 'Transfer timed out' if Time.now - start_time > timeout_seconds
-
-        self.sleep interval_seconds
-      end
-
-      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
-    end
-  end
-end

data/lib/coinbase/wallet.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require 'jimson'
-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.
-  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.
-    # @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(ENV.fetch('BASE_SEPOLIA_RPC_URL', nil)))
-      raise ArgumentError, 'Seed must be 32 bytes' if !seed.nil? && seed.length != 64
-      raise ArgumentError, 'Address count must be positive' if address_count < 1
-
-      @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 = []
-
-      # TODO: Adjust derivation path prefix based on network protocol.
-      @address_path_prefix = "m/44'/60'/0'/0"
-      @address_index = 0
-
-      @client = client
-
-      address_count.times { create_address }
-    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
-    end
-
-    # Returns the default address of the Wallet.
-    # @return [Address] The default address
-    def default_address
-      @addresses.first
-    end
-
-    # Returns the Address with the given ID.
-    # @param address_id [String] The ID of the Address to retrieve
-    # @return [Address] The Address
-    def get_address(address_id)
-      @addresses.find { |address| address.address_id == address_id }
-    end
-
-    # 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
-      end
-
-      balance_map
-    end
-
-    # Returns the balance of the provided Asset. Balances are aggregated across all Addresses in the Wallet.
-    # @param asset_id [Symbol] The ID of the Asset to retrieve the balance for
-    # @return [BigDecimal] The balance of the Asset
-    def get_balance(asset_id)
-      normalized_asset_id = if %i[wei gwei].include?(asset_id)
-                              :eth
-                            else
-                              asset_id
-                            end
-
-      eth_balance = list_balances[normalized_asset_id] || BigDecimal(0)
-
-      case asset_id
-      when :eth
-        eth_balance
-      when :gwei
-        eth_balance * Coinbase::GWEI_PER_ETHER
-      when :wei
-        eth_balance * Coinbase::WEI_PER_ETHER
-      else
-        BigDecimal(0)
-      end
-    end
-
-    # Transfers the given amount of the given Asset to the given address. Only same-Network Transfers are supported.
-    # Currently only the default_address is used to source the Transfer.
-    # @param amount [Integer, Float, BigDecimal] The amount of the Asset to send
-    # @param asset_id [Symbol] The ID of the Asset to send
-    # @param destination [Wallet | Address | String] The destination of the transfer. If a Wallet, sends to the Wallet's
-    #  default address. If a String, interprets it as the address ID.
-    # @return [Transfer] The hash of the Transfer transaction.
-    def transfer(amount, asset_id, destination)
-      if destination.is_a?(Wallet)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
-
-        destination = destination.default_address.address_id
-      elsif destination.is_a?(Address)
-        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != @network_id
-
-        destination = destination.address_id
-      end
-
-      default_address.transfer(amount, asset_id, destination)
-    end
-
-    # Exports the Wallet's data to a WalletData object.
-    # @return [WalletData] The Wallet data
-    def export
-      WalletData.new(@master.seed_hex, @addresses.length)
-    end
-
-    # The data required to recreate a Wallet.
-    class WalletData
-      attr_reader :seed, :address_count
-
-      # Returns a new WalletData object.
-      # @param seed [String] The seed of the Wallet
-      # @param address_count [Integer] The number of addresses in the Wallet
-      def initialize(seed, address_count)
-        @seed = seed
-        @address_count = address_count
-      end
-    end
-
-    # Returns the data required to recreate the Wallet.
-    # @return [WalletData] The Wallet data
-    def to_data
-      WalletData.new(@master.seed_hex, @addresses.length)
-    end
-  end
-end