coinbase-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2952835a61e4e744db044ab91e1cf58000d578967783d6faf9da77e495790172
+  data.tar.gz: '00378e6bfb704f649d3943bd26da6712e41a9852ca2e4650c168ea098061a8b1'
+SHA512:
+  metadata.gz: 10a9d9e6288bc1ab73b94be7e0cab8a37e64fa0398e644e570d385c342dd4a46d084e454f56acff0692c82424801ad92479a3ca7e4745d860c51086f28f559dd
+  data.tar.gz: 131176725ada80cb046882a5fce27ec6355dd7395adf33cadace6f17507b326563ae4f945ceebc4566a10f94e815fda0fbcc3d735e7f7959d4a0b1da65e29b1e

data/lib/coinbase/address.rb

@@ -0,0 +1,127 @@
+# 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(Coinbase.base_sepolia_rpc_url))
+      # 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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,48 @@
+# 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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,55 @@
+# 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

@@ -0,0 +1,153 @@
+# 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(Coinbase.base_sepolia_rpc_url))
+
+      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

@@ -0,0 +1,160 @@
+# 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(Coinbase.base_sepolia_rpc_url))
+      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

data/lib/coinbase.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'coinbase/address'
+require_relative 'coinbase/asset'
+require_relative 'coinbase/balance_map'
+require_relative 'coinbase/constants'
+require_relative 'coinbase/network'
+require_relative 'coinbase/transfer'
+require_relative 'coinbase/wallet'
+
+# The Coinbase SDK.
+module Coinbase
+  @base_sepolia_rpc_url = 'https://sepolia.base.org'
+
+  # Returns the Base Sepolia RPC URL.
+  # @return [String] the Base Sepolia RPC URL
+  def self.base_sepolia_rpc_url
+    @base_sepolia_rpc_url
+  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
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: coinbase-sdk
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuga Cohler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  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: eth
+  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: jimson
+  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: money-tree
+  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: securerandom
+  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: pry
+  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: rake
+  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: rspec
+  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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.63.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.63.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.36
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.36
+description: Coinbase Ruby SDK for accessing Coinbase Platform APIs
+email: yuga.cohler@coinbase.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/coinbase.rb
+- lib/coinbase/address.rb
+- lib/coinbase/asset.rb
+- lib/coinbase/balance_map.rb
+- lib/coinbase/constants.rb
+- lib/coinbase/network.rb
+- lib/coinbase/transfer.rb
+- lib/coinbase/wallet.rb
+homepage: https://github.com/coinbase/coinbase-sdk-ruby
+licenses:
+- Apache-2.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Coinbase Ruby SDK
+test_files: []