coinbase 0.0.1 → 4.0.7

data/lib/coinbase/wallet/client.rb

@@ -0,0 +1,101 @@
+module Coinbase
+  module Wallet
+    BASE_API_URL  = "https://api.coinbase.com"
+    API_VERSION   = '2015-06-16'
+
+    class Client < NetHTTPClient
+      def initialize(options={})
+        [ :api_key, :api_secret ].each do |opt|
+          raise unless options.has_key? opt
+        end
+        @api_key = options[:api_key]
+        @api_secret = options[:api_secret]
+        @api_uri = URI.parse(options[:api_url] || BASE_API_URL)
+        super(@api_uri, options)
+      end
+
+      def auth_headers(method, path, body)
+        ts = Time.now.to_i.to_s
+        signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'),
+                                            @api_secret,
+                                            ts + method + path + body.to_s)
+        { 'CB-ACCESS-KEY' => @api_key,
+          'CB-ACCESS-SIGN' => signature,
+          'CB-ACCESS-TIMESTAMP' => ts,
+          'CB-VERSION' => API_VERSION }
+      end
+    end
+
+    class OAuthClient < NetHTTPClient
+      attr_accessor :access_token, :refresh_token
+
+      def initialize(options={})
+        raise unless options.has_key? :access_token
+        @access_token = options[:access_token]
+        @refresh_token = options[:refresh_token]
+        @oauth_uri = URI.parse(options[:api_url] || BASE_API_URL)
+        super(@oauth_uri, options)
+      end
+
+      def auth_headers(method, path, body)
+        { 'Authorization' => "Bearer #{@access_token}",
+          'CB-VERSION' => API_VERSION }
+      end
+
+      def authorize!(redirect_url, params = {})
+        raise NotImplementedError
+      end
+
+      def revoke!(params = {})
+        params[:token] ||= @access_token
+
+        out = nil
+        post("/oauth/revoke", params) do |resp|
+          out = APIObject.new(self, resp.body)
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      def refresh!(params = {})
+        params[:grant_type] = 'refresh_token'
+        params[:refresh_token] ||= @refresh_token
+
+        raise "Missing Parameter: refresh_token" unless params.has_key?(:refresh_token)
+
+        out = nil
+        post("/oauth/token", params) do |resp|
+          out = APIObject.new(self, resp.body)
+          # Update tokens to current instance
+          # Developer should always persist them
+          @access_token = out.access_token
+          @refresh_token = out.refresh_token
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+    end
+
+    class AsyncClient < EMHTTPClient
+      def initialize(options={})
+        [ :api_key, :api_secret ].each do |opt|
+          raise unless options.has_key? opt
+        end
+        @api_key = options[:api_key]
+        @api_secret = options[:api_secret]
+        @api_uri = URI.parse(options[:api_url] || BASE_API_URL)
+      end
+
+      def auth_headers(method, path, body)
+        ts = Time.now.to_i.to_s
+        signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'),
+                                            @api_secret,
+                                            ts + method + path + body.to_s)
+        { 'CB-ACCESS-KEY' => @api_key,
+          'CB-ACCESS-SIGN' => signature,
+          'CB-ACCESS-TIMESTAMP' => ts,
+          'CB-VERSION' => API_VERSION }
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/account.rb

@@ -0,0 +1,187 @@
+module Coinbase
+  module Wallet
+    class Account < APIObject
+      def update!(params = {})
+        @client.update_account(self['id'], params) do |data, resp|
+          update(data)
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def make_primary!(params = {})
+        @client.set_primary_account(self['id'], params) do |data, resp|
+          update(data)
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def delete!(params = {})
+        @client.delete_account(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Addresses
+      #
+      def addresses(params = {})
+        @client.addresses(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def address(address_id, params = {})
+        @client.address(self['id'], address_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def create_address(params = {})
+        @client.create_address(self['id']) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Transactions
+      #
+      def transactions(params = {})
+        @client.transactions(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def transaction(transaction_id, params = {})
+        @client.transaction(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def send(params = {})
+        @client.send(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def transfer(params = {})
+        @client.transfer(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def request(params = {})
+        @client.request(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Buys
+      #
+      def list_buys(params = {})
+        @client.list_buys(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def list_buy(transaction_id, params = {})
+        @client.list_buy(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def buy(params = {})
+        @client.buy(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def commit_buy(transaction_id, params = {})
+        @client.commit_buy(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Sells
+      #
+      def list_sells(params = {})
+        @client.list_sells(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def list_sell(transaction_id, params = {})
+        @client.list_sell(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def sell(params = {})
+        @client.sell(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def commit_sell(transaction_id, params = {})
+        @client.commit_sell(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Deposit
+      #
+      def list_deposits(params = {})
+        @client.list_deposits(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def list_deposit(transaction_id, params = {})
+        @client.list_deposit(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def deposit(params = {})
+        @client.deposit(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def commit_deposit(transaction_id, params = {})
+        @client.commit_deposit(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      #
+      # Withdrawals
+      #
+      def list_withdrawals(params = {})
+        @client.list_withdrawals(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def list_withdrawal(transaction_id, params = {})
+        @client.list_withdrawal(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def withdraw(params = {})
+        @client.withdraw(self['id'], params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+
+      def commit_withdrawal(transaction_id, params = {})
+        @client.commit_withdrawal(self['id'], transaction_id, params) do |data, resp|
+          yield(data, resp) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/address.rb

@@ -0,0 +1,12 @@
+module Coinbase
+  module Wallet
+    class Address < APIObject
+      def transactions(params = {})
+        @client.get("#{self['resource_path']}/transactions", params) do |resp|
+          out = resp.data.map { |item| Transaction.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/api_object.rb

@@ -0,0 +1,46 @@
+module Coinbase
+  module Wallet
+    # Response item abstract model
+    class APIObject < Hash
+      def initialize(client, data)
+        super()
+        update(data)
+        @client = client
+      end
+
+      def refresh!(params = {})
+        @client.get(self['resource_path'], params) do |resp|
+          update(resp.data)
+          yield(resp.data, resp) if block_given?
+        end
+      end
+
+      def update(data)
+        return if data.nil?
+        data.each { |key, val| self[key] = val } if data.is_a?(Hash)
+      end
+
+      def format(key, val)
+        return if val.nil?
+        # Looks like a number or currency
+        if val.class == Hash
+          APIObject.new(@client, val)
+        elsif key =~ /_at$/ && (Time.iso8601(val) rescue nil)
+          Time.parse(val)
+        elsif key == "amount" && val =~ /^.{0,1}\s*[0-9,]*\.{0,1}[0-9]*$/
+          BigDecimal(val.gsub(/[^0-9\.]/, ''))
+        else
+          val
+        end
+      end
+
+      def method_missing(method, *args, &blk)
+        format(method.to_s, self[method.to_s]) || super
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        self.key?(method.to_s) || super
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/checkout.rb

@@ -0,0 +1,19 @@
+module Coinbase
+  module Wallet
+    class Checkout < APIObject
+      def orders(params = {})
+        @client.get("#{self['resource_path']}/orders", params) do |resp|
+          out = resp.data.map { |item| Order.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+      end
+
+      def create_order(params = {})
+        @client.post("#{self['resource_path']}/orders", params) do |resp|
+          out = Order.new(self, resp.data)
+          yield(out, resp) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/order.rb

@@ -0,0 +1,12 @@
+module Coinbase
+  module Wallet
+    class Order < APIObject
+      def refund!(params = {})
+        @client.post("#{self['resource_path']}/refund", params) do |resp|
+          update(resp.data)
+          yield(resp.data, resp) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/models/transaction.rb

@@ -0,0 +1,21 @@
+module Coinbase
+  module Wallet
+    class Transaction < APIObject
+    end
+
+    class Request < Transaction
+      def resend!(params = {})
+        @client.post("#{self['resource_path']}/resend", params) do |resp|
+          yield(resp.data, resp) if block_given?
+        end
+      end
+
+      def cancel!(params = {})
+        @client.delete("#{self['resource_path']}", params) do |resp|
+          yield(resp.data, resp) if block_given?
+        end
+      end
+    end
+  end
+end
+

data/lib/coinbase/wallet/models/transfer.rb

@@ -0,0 +1,13 @@
+module Coinbase
+  module Wallet
+    class Transfer < APIObject
+      def commit!(params = {})
+        @client.post("#{self['resource_path']}/commit", params) do |resp|
+          update(resp.data)
+          yield(resp.data, resp) if block_given?
+        end
+      end
+    end
+  end
+end
+

data/lib/coinbase/wallet/models/user.rb

@@ -0,0 +1,15 @@
+module Coinbase
+  module Wallet
+    class User < APIObject
+    end
+
+    class CurrentUser < User
+      def update!(params = {})
+        @client.update_current_user(params) do |data, resp|
+          update(resp.data)
+          yield(resp.data, resp) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/wallet/version.rb

@@ -0,0 +1,5 @@
+module Coinbase
+  module Wallet
+    VERSION = "4.0.7"
+  end
+end

data/lib/coinbase/wallet.rb

@@ -1,160 +1,27 @@
-# frozen_string_literal: true
-
-require 'jimson'
-require 'money-tree'
-require 'securerandom'
+require "coinbase/wallet/version"
+
+require "base64"
+require "bigdecimal"
+require "json"
+require "uri"
+require "net/https"
+
+require "coinbase/wallet/api_errors"
+require "coinbase/wallet/api_response"
+require "coinbase/wallet/api_client"
+require "coinbase/wallet/adapters/net_http.rb"
+require "coinbase/wallet/adapters/em_http.rb"
+require "coinbase/wallet/models/api_object"
+require "coinbase/wallet/models/account"
+require "coinbase/wallet/models/address"
+require "coinbase/wallet/models/user"
+require "coinbase/wallet/models/transaction"
+require "coinbase/wallet/models/transfer"
+require "coinbase/wallet/models/order"
+require "coinbase/wallet/models/checkout"
+require "coinbase/wallet/client"
 
 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
+  module Wallet
   end
 end