coinbase-sdk 0.0.1 → 0.0.3

checksums.yaml

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

data/lib/coinbase/address.rb

@@ -2,65 +2,77 @@
 
 require_relative 'balance_map'
 require_relative 'constants'
+require_relative 'wallet'
 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.
+  # send and receive Assets, and should be created using Wallet#create_address. Addresses require an
+  # 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
+    # Returns a new Address object. Do not use this method directly. Instead, use Wallet#create_address, or use
+    # the Wallet's default_address.
+    # @param model [Coinbase::Client::Address] The underlying Address object
     # @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
+    def initialize(model, key)
+      @model = model
       @key = key
-      @client = client
     end
 
-    # Returns the balances of the Address. Currently only ETH balances are supported.
+    # Returns the Network ID of the Address.
+    # @return [Symbol] The Network ID
+    def network_id
+      Coinbase.to_sym(@model.network_id)
+    end
+
+    # Returns the Wallet ID of the Address.
+    # @return [String] The Wallet ID
+    def wallet_id
+      @model.wallet_id
+    end
+
+    # Returns the Address ID.
+    # @return [String] The Address ID
+    def address_id
+      @model.address_id
+    end
+
+    # Returns the balances of the Address.
     # @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))
+      response = Coinbase.call_api do
+        addresses_api.list_address_balances(wallet_id, address_id)
+      end
 
-      BalanceMap.new({ eth: eth_balance })
+      Coinbase.to_balance_map(response)
     end
 
-    # Returns the balance of the provided Asset. Currently only ETH is supported.
+    # Returns the balance of the provided Asset.
     # @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
+      normalized_asset_id = normalize_asset_id(asset_id)
+
+      response = Coinbase.call_api do
+        addresses_api.get_address_balance(wallet_id, address_id, normalized_asset_id.to_s)
+      end
+
+      return BigDecimal('0') if response.nil?
 
-      eth_balance = list_balances[normalized_asset_id] || BigDecimal(0)
+      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
 
@@ -71,15 +83,14 @@ module Coinbase
     #  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
+        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
+        raise ArgumentError, 'Transfer must be on the same Network' if destination.network_id != network_id
 
         destination = destination.address_id
       end
@@ -89,39 +100,129 @@ module Coinbase
         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)
+      normalized_amount = normalize_asset_amount(amount, asset_id)
+
+      normalized_asset_id = normalize_asset_id(asset_id)
+
+      create_transfer_request = {
+        amount: normalized_amount.to_i.to_s,
+        network_id: network_id,
+        asset_id: normalized_asset_id.to_s,
+        destination: destination
+      }
+
+      transfer_model = Coinbase.call_api do
+        transfers_api.create_transfer(wallet_id, address_id, create_transfer_request)
+      end
+
+      transfer = Coinbase::Transfer.new(transfer_model)
 
       transaction = transfer.transaction
       transaction.sign(@key)
-      @client.eth_sendRawTransaction("0x#{transaction.hex}")
 
-      transfer
+      signed_payload = transaction.hex
+
+      broadcast_transfer_request = {
+        signed_payload: signed_payload
+      }
+
+      transfer_model = Coinbase.call_api do
+        transfers_api.broadcast_transfer(wallet_id, address_id, transfer.transfer_id, broadcast_transfer_request)
+      end
+
+      Coinbase::Transfer.new(transfer_model)
     end
 
-    # Returns the address as a string.
-    # @return [String] The address
+    # Returns a String representation of the Address.
+    # @return [String] a String representation of the Address
     def to_s
-      @address_id
+      "Coinbase::Address{address_id: '#{address_id}', network_id: '#{network_id}', wallet_id: '#{wallet_id}'}"
+    end
+
+    # Same as to_s.
+    # @return [String] a String representation of the Address
+    def inspect
+      to_s
+    end
+
+    # Requests funds for the address from the faucet and returns the faucet transaction.
+    # This is only supported on testnet networks.
+    # @return [Coinbase::FaucetTransaction] The successful faucet transaction
+    # @raise [Coinbase::FaucetLimitReached] If the faucet limit has been reached for the address or user.
+    # @raise [Coinbase::Client::ApiError] If an unexpected error occurs while requesting faucet funds.
+    def faucet
+      Coinbase.call_api do
+        Coinbase::FaucetTransaction.new(addresses_api.request_faucet_funds(wallet_id, address_id))
+      end
+    end
+
+    # Exports the Address's private key to a hex string.
+    # @return [String] The Address's private key as a hex String
+    def export
+      @key.private_hex
+    end
+
+    # Lists the IDs of all Transfers associated with the given Wallet and Address.
+    # @return [Array<String>] The IDs of all Transfers belonging to the Wallet and Address
+    def list_transfer_ids
+      transfer_ids = []
+      page = nil
+
+      loop do
+        response = Coinbase.call_api do
+          transfers_api.list_transfers(wallet_id, address_id, { limit: 100, page: page })
+        end
+
+        transfer_ids.concat(response.data.map(&:transfer_id)) if response.data
+
+        break unless response.has_more
+
+        page = response.next_page
+      end
+
+      transfer_ids
     end
 
     private
 
-    # Normalizes the amount of ETH to send based on the asset ID.
+    # Normalizes the amount of the Asset to send to the atomic unit.
     # @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)
+    # @return [BigDecimal] The normalized amount in atomic units
+    def normalize_asset_amount(amount, asset_id)
+      big_amount = BigDecimal(amount.to_s)
+
       case asset_id
       when :eth
-        amount.is_a?(BigDecimal) ? amount : BigDecimal(amount.to_s)
+        big_amount * Coinbase::WEI_PER_ETHER
       when :gwei
-        BigDecimal(amount / Coinbase::GWEI_PER_ETHER)
-      when :wei
-        BigDecimal(amount / Coinbase::WEI_PER_ETHER)
+        big_amount * Coinbase::WEI_PER_GWEI
+      when :usdc
+        big_amount * Coinbase::ATOMIC_UNITS_PER_USDC
+      when :weth
+        big_amount * Coinbase::WEI_PER_ETHER
       else
-        raise ArgumentError, "Unsupported asset: #{asset_id}"
+        big_amount
       end
     end
+
+    # Normalizes the asset ID to use during requests.
+    # @param asset_id [Symbol] The asset ID to normalize
+    # @return [Symbol] The normalized asset ID
+    def normalize_asset_id(asset_id)
+      if %i[wei gwei].include?(asset_id)
+        :eth
+      else
+        asset_id
+      end
+    end
+
+    def addresses_api
+      @addresses_api ||= Coinbase::Client::AddressesApi.new(Coinbase.configuration.api_client)
+    end
+
+    def transfers_api
+      @transfers_api ||= Coinbase::Client::TransfersApi.new(Coinbase.configuration.api_client)
+    end
   end
 end

data/lib/coinbase/asset.rb

@@ -5,7 +5,8 @@ module Coinbase
   class Asset
     attr_reader :network_id, :asset_id, :display_name, :address_id
 
-    # Returns a new Asset object.
+    # Returns a new Asset object. Do not use this method. Instead, use the Asset constants defined in
+    # the Coinbase module.
     # @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

data/lib/coinbase/authenticator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'jwt'
+require 'openssl'
+require 'securerandom'
+
+module Coinbase
+  # A class that builds JWTs for authenticating with the Coinbase Platform APIs.
+  class Authenticator < Faraday::Middleware
+    # Initializes the Authenticator.
+    # @param app [Faraday::Connection] The Faraday connection
+    def initialize(app)
+      super(app)
+      @app = app
+    end
+
+    # Processes the request by adding the JWT to the Authorization header.
+    # @param env [Faraday::Env] The Faraday request environment
+    def call(env)
+      method = env.method.downcase.to_sym
+      uri = env.url.to_s
+      uri_without_protocol = URI(uri).host
+      token = build_jwt("#{method.upcase} #{uri_without_protocol}#{env.url.path}")
+      env.request_headers['Authorization'] = "Bearer #{token}"
+      @app.call(env)
+    end
+
+    # Builds the JWT for the given API endpoint URI. The JWT is signed with the API key's private key.
+    # @param uri [String] The API endpoint URI
+    # @return [String] The JWT
+    def build_jwt(uri)
+      header = {
+        typ: 'JWT',
+        kid: Coinbase.configuration.api_key_name,
+        nonce: SecureRandom.hex(16)
+      }
+
+      claims = {
+        sub: Coinbase.configuration.api_key_name,
+        iss: 'coinbase-cloud',
+        aud: ['cdp_service'],
+        nbf: Time.now.to_i,
+        exp: Time.now.to_i + 60, # Expiration time: 1 minute from now.
+        uris: [uri]
+      }
+
+      private_key = OpenSSL::PKey.read(Coinbase.configuration.api_key_private_key)
+      JWT.encode(claims, private_key, 'ES256', header)
+    end
+  end
+end

data/lib/coinbase/balance_map.rb

@@ -3,7 +3,7 @@
 require 'bigdecimal'
 
 module Coinbase
-  # A convenience class for printing out crypto asset balances in a human-readable format.
+  # A convenience class for printing out 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
@@ -42,7 +42,7 @@ module Coinbase
         result[asset_id] = str
       end
 
-      result
+      result.to_s
     end
   end
 end