coinbase-advanced 0.1.1

data/lib/coinbase/advanced/rest/resources/futures.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module Futures
+          def get_futures_balance_summary # rubocop:disable Naming/AccessorMethodName
+            get("cfm/balance_summary")
+          end
+
+          def get_intraday_margin_setting # rubocop:disable Naming/AccessorMethodName
+            get("cfm/intraday/margin_setting")
+          end
+
+          def set_intraday_margin_setting(params = {})
+            post("cfm/intraday/margin_setting", params)
+          end
+
+          def get_current_margin_window(params = {})
+            get("cfm/intraday/current_margin_window", params)
+          end
+
+          def list_futures_positions
+            get("cfm/positions")
+          end
+
+          def get_futures_position(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+
+            get("cfm/positions/#{params[:position_id]}")
+          end
+
+          def schedule_futures_sweep(params = {})
+            post("cfm/sweeps/schedule", params)
+          end
+
+          def list_futures_sweeps
+            get("cfm/sweeps")
+          end
+
+          def cancel_pending_futures_sweep
+            delete("cfm/sweeps")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/orders.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        # https://docs.cdp.coinbase.com/advanced-trade/reference/retailbrokerageapi_postorder
+        module Orders
+          def create_order(params = {})
+            raise ArgumentError, "Missing client_order_id" unless params.key? :client_order_id
+            raise ArgumentError, "Missing product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing side" unless params.key? :side
+            raise ArgumentError, "Missing order_configuration" unless params.key? :order_configuration
+
+            post("orders", params)
+          end
+
+          def cancel_orders(params = {})
+            raise ArgumentError, "Missing order_ids" unless params.key? :order_ids
+
+            post("orders/batch_cancel", params)
+          end
+
+          def edit_order(params = {})
+            raise ArgumentError, "Missing order_id" unless params.key? :order_id
+            raise ArgumentError, "Missing price" unless params.key? :price
+            raise ArgumentError, "Missing size" unless params.key? :size
+
+            post("orders/edit", params)
+          end
+
+          def edit_order_preview(params = {})
+            raise ArgumentError, "Missing order_id" unless params.key? :order_id
+            raise ArgumentError, "Missing price" unless params.key? :price
+            raise ArgumentError, "Missing size" unless params.key? :size
+
+            post("orders/edit_preview", params)
+          end
+
+          def get_order(params = {})
+            raise ArgumentError, "Missing order_id" unless params.key? :order_id
+
+            order_id = params.delete(:order_id)
+            get("orders/historical/#{order_id}", params)
+          end
+
+          def list_orders(params = {})
+            get("orders/historical/batch", params)
+          end
+
+          def list_fills(params = {})
+            get("orders/historical/fills", params)
+          end
+
+          def preview_order(params = {})
+            raise ArgumentError, "Missing product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing side" unless params.key? :side
+            raise ArgumentError, "Missing order_configuration" unless params.key? :order_configuration
+
+            post("orders/preview", params)
+          end
+
+          def close_position(params = {})
+            raise ArgumentError, "Missing client_order_id" unless params.key? :client_order_id
+            raise ArgumentError, "Missing product_id" unless params.key? :product_id
+
+            post("orders/close_position", params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/payment_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module PaymentMethods
+          def list_payment_methods
+            get("/payment_methods")
+          end
+
+          def get_payment_method(params = {})
+            raise ArgumentError, "Missing :payment_method_id" unless params.key? :payment_method_id
+
+            get("payment_methods/#{params[:payment_method_id]}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/perpetuals.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module Perpetuals
+          def allocate_portfolio(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+            raise ArgumentError, "Missing :symbol" unless params.key? :symbol
+            raise ArgumentError, "Missing :amount" unless params.key? :amount
+            raise ArgumentError, "Missing :currency" unless params.key? :currency
+
+            post("intx/allocate", params)
+          end
+
+          def get_perpetuals_portfolio_summary(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+
+            get("intx/portfolio/#{params[:portfolio_uuid]}")
+          end
+
+          def list_perpetuals_positions(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+
+            get("intx/positions/#{params[:portfolio_uuid]}")
+          end
+
+          def get_perpetuals_position(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+            raise ArgumentError, "Missing :symbol" unless params.key? :symbol
+
+            get("intx/positions/#{params[:portfolio_uuid]}/#{params[:symbol]}")
+          end
+
+          def get_portfolios_balances(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+
+            get("intx/balances/#{params[:portfolio_uuid]}")
+          end
+
+          def opt_in_or_out_of_multi_asset_collateral(params = {})
+            post("intx/multi_asset_collateral", params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/portfolios.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module Portfolios
+          def list_portfolios(params = {})
+            get("portfolios", params)
+          end
+
+          def create_portfolio(params = {})
+            raise ArgumentError, "Missing :name" unless params.key? :name
+
+            post("portfolios", params)
+          end
+
+          def move_portfolio_funds(params = {})
+            raise ArgumentError, "Missing :funds" unless params.key? :funds
+            raise ArgumentError, "Missing :funds[:value]" unless params[:funds].key? :value
+            raise ArgumentError, "Missing :funds[:currency]" unless params[:funds].key? :currency
+            raise ArgumentError, "Missing :source_portfolio_uuid" unless params.key? :source_portfolio_uuid
+            raise ArgumentError, "Missing :target_portfolio_uuid" unless params.key? :target_portfolio_uuid
+
+            post("portfolios/move_funds", params)
+          end
+
+          def get_portfolio_funds(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+
+            portfolio_uuid = params.delete(:portfolio_uuid)
+            get("portfolios/#{portfolio_uuid}", params)
+          end
+
+          def delete_portfolio(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+
+            delete("portfolios/#{params[:portfolio_uuid]}")
+          end
+
+          def edit_portfolio(params = {})
+            raise ArgumentError, "Missing :portfolio_uuid" unless params.key? :portfolio_uuid
+            raise ArgumentError, "Missing :name" unless params.key? :name
+
+            portfolio_uuid = params.delete(:portfolio_uuid)
+            put("portfolios/#{portfolio_uuid}", params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/products.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module Products
+          def get_best_bid_ask(params = {})
+            get("best_bid_ask", params)
+          end
+
+          def get_product_book(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+
+            get("product_book", params)
+          end
+
+          def list_products(params = {})
+            get("products", params)
+          end
+
+          def get_product(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+
+            product_id = params.delete(:product_id)
+            get("products/#{product_id}", params)
+          end
+
+          def get_product_candles(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing :start" unless params.key? :start
+            raise ArgumentError, "Missing :end" unless params.key? :end
+            raise ArgumentError, "Missing :granularity" unless params.key? :granularity
+
+            product_id = params.delete(:product_id)
+            get("products/#{product_id}/candles", params)
+          end
+
+          def get_market_trades(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing :limit" unless params.key? :limit
+
+            product_id = params.delete(:product_id)
+            get("products/#{product_id}/ticker", params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/resources/public.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      module Resources
+        module Public
+          def get_server_time # rubocop:disable Naming/AccessorMethodName
+            get("time", {}, auth_required: false)
+          end
+
+          def get_public_product_book(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+
+            get("market/product_book", params, auth_required: false)
+          end
+
+          def list_public_products(params = {})
+            get("market/products", params, auth_required: false)
+          end
+
+          def get_public_product(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+
+            product_id = params.delete(:product_id)
+            get("market/products/#{product_id}", params, auth_required: false)
+          end
+
+          def get_public_product_candles(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing :start" unless params.key? :start
+            raise ArgumentError, "Missing :end" unless params.key? :end
+            raise ArgumentError, "Missing :granularity" unless params.key? :granularity
+
+            product_id = params.delete(:product_id)
+            get("market/products/#{product_id}/candles", params, auth_required: false)
+          end
+
+          def get_public_market_trades(params = {})
+            raise ArgumentError, "Missing :product_id" unless params.key? :product_id
+            raise ArgumentError, "Missing :limit" unless params.key? :limit
+
+            product_id = params.delete(:product_id)
+            get("market/products/#{product_id}/ticker", params, auth_required: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/rest/rest_base.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    module REST
+      # RESTBase sets up, executes, and appropriately handles errors strictly within context of HTTP + REST communication
+      class RESTBase < APIBase
+        attr_reader :session
+
+        include Resources::Accounts
+        include Resources::Products
+        include Resources::Orders
+        include Resources::Portfolios
+        include Resources::Futures
+        include Resources::Perpetuals
+        include Resources::Converts
+        include Resources::Fees
+        include Resources::Public
+        include Resources::PaymentMethods
+        include Resources::DataAPI
+
+        AUTH_ERROR_MESSAGE = <<~HEREDOC
+          Unauthenticated request to private endpoint. If you wish to access private endpoints, you must \
+          provide your API key and secret when initializing the RESTClient.
+        HEREDOC
+
+        def initialize(config = Coinbase::Advanced.config)
+          super
+          @session = Faraday.new
+        end
+
+        def set_headers(method, path)
+          @session.headers = {
+            "User-Agent" => Coinbase::Advanced::USER_AGENT,
+            "Content-Type" => "application/json"
+          }
+
+          return unless @authenticated
+
+          uri = "#{method} #{@base_url}#{path}"
+          @session.headers["Authorization"] = "Bearer #{build_jwt(uri)}"
+        end
+
+        # copied rb sample from https://docs.cdp.coinbase.com/advanced-trade/docs/ws-auth#code-samples
+        # See README if confused why this method is here
+        def build_jwt(uri = nil)
+          header = {
+            typ: "JWT",
+            kid: @api_key,
+            nonce: SecureRandom.hex(16)
+          }
+
+          claims = {
+            sub: @api_key,
+            iss: "cdp",
+            aud: ["cdp_service"],
+            nbf: Time.now.to_i,
+            exp: Time.now.to_i + 120 # Expiration time: 2 minute from now.
+          }
+
+          claims[:uri] = uri if uri
+
+          private_key = OpenSSL::PKey.read(@api_secret)
+          JWT.encode(claims, private_key, "ES256", header)
+        end
+
+        def prepare_and_send_request(http_method, url_path, params = {}, data = {}, auth_required: true)
+          raise AuthenticationError, AUTH_ERROR_MESSAGE if auth_required && !@authenticated
+
+          url_path = "#{@api_prefix}/#{url_path.dup}"
+
+          set_headers(http_method, url_path)
+          @session.params = params unless params.empty?
+          url_path.insert(0, "/") if url_path[0] != "/"
+
+          send_request(http_method, url_path, data)
+        end
+
+        # def send_request(http_method, url_path, params, headers, data = None) - py method signature, lot of redundant shit
+        def send_request(http_method, url_path, data = {})
+          url = URI::HTTPS.build(host: @base_url, path: url_path).to_s
+
+          @config.log("Sending #{http_method.to_s.upcase}:#{url} with body #{data.to_json}") if @verbose
+
+          response = case http_method
+                     when :get then @session.get(url)
+                     when :post then @session.post(url, data.to_json)
+                     when :put then @session.put(url, data.to_json)
+                     when :delete then @session.delete(url, data.to_json)
+                     else
+                       raise URI::BadURIError, "Unknown HTTP method / verb: '#{http_method}'"
+                     end
+
+          @config.log("Response object:\n\n#{response.pretty_inspect}") if @verbose
+
+          BaseResponse.new(JSON.parse(response.body))
+        end
+
+        def get(url_path, params = {}, auth_required: true)
+          prepare_and_send_request(:get, url_path, params, {}, auth_required: auth_required)
+        end
+
+        def post(url_path, params = {}, data = {}, auth_required: true)
+          prepare_and_send_request(:post, url_path, params, data, auth_required: auth_required)
+        end
+
+        def put(url_path, params = {}, data = {}, auth_required: true)
+          prepare_and_send_request(:put, url_path, params, data, auth_required: auth_required)
+        end
+
+        def delete(url_path, params = {}, data = {}, auth_required: true)
+          prepare_and_send_request(:delete, url_path, params, data, auth_required: auth_required)
+        end
+      end
+
+      class AuthenticationError < StandardError
+      end
+    end
+  end
+end

data/lib/coinbase/advanced/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Coinbase
+  module Advanced
+    VERSION = "0.1.1"
+  end
+end

data/lib/coinbase/advanced.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+require "faraday"
+
+require "jwt"
+require "openssl"
+require "time"
+require "securerandom"
+
+require_relative "advanced/concerns/filter_param"
+
+require_relative "advanced/constants"
+require_relative "advanced/api_base"
+require_relative "advanced/version"
+
+require_relative "advanced/rest/resources/accounts"
+require_relative "advanced/rest/resources/products"
+require_relative "advanced/rest/resources/orders"
+require_relative "advanced/rest/resources/portfolios"
+require_relative "advanced/rest/resources/futures"
+require_relative "advanced/rest/resources/perpetuals"
+require_relative "advanced/rest/resources/converts"
+require_relative "advanced/rest/resources/fees"
+require_relative "advanced/rest/resources/public"
+require_relative "advanced/rest/resources/payment_methods"
+require_relative "advanced/rest/resources/data_api"
+
+require_relative "advanced/rest/base_response"
+require_relative "advanced/rest/rest_base"
+
+class Configuration
+  DEFAULT_API_BASE_URL = "api.coinbase.com"
+  DEFAULT_API_PREFIX = "/api/v3/brokerage"
+
+  DEFAULT_LOGGER = Logger.new($stdout)
+  DEFAULT_LOG_LEVEL = Logger::INFO
+
+  DEFAULT_SENSITIVE_PARAMS = %i[@api_key @api_secret].freeze
+
+  include Coinbase::Advanced::Concerns::FilterParam
+
+  attr_accessor :base_url, :api_prefix, :key_file, :api_key, :api_secret,
+                :timeout, :verbose, :filter_params
+
+  attr_reader :logger, :log_level
+
+  def initialize
+    @base_url = DEFAULT_API_BASE_URL
+    @api_prefix = DEFAULT_API_PREFIX
+    @timeout = 30
+
+    @key_file = ENV.fetch("COINBASE_JSON_KEY_FILE", nil)
+    @api_key = ENV.fetch("COINBASE_API_KEY", nil)
+    @api_secret = ENV.fetch("COINBASE_API_SECRET", nil)&.gsub('\n', "\n")
+
+    @logger = DEFAULT_LOGGER
+    @logger.level = DEFAULT_LOG_LEVEL
+    @verbose = false
+    @filter_params = DEFAULT_SENSITIVE_PARAMS
+  end
+
+  def setup
+    yield(self) if block_given?
+  end
+
+  # Currently only supporting default logger
+  def logger=(logger)
+    raise ArgumentError, "Only default logger supported" unless logger.is_a?(Logger)
+
+    @logger = logger
+  end
+
+  def log_level=(level)
+    valid_levels = %i[debug info warn error fatal]
+    raise ArgumentError, "Invalid log level" unless valid_levels.include?(level)
+
+    @log_level = level
+  end
+
+  def log(message, level = :info)
+    return unless @logger
+
+    @logger.send(level, message)
+  end
+end
+
+# inspired by https://github.com/stripe/stripe-ruby/blob/master/lib/stripe.rb
+# TODO: this probably is redundant because:
+# A. configuration class is defined right above
+# B. def_delegators here are equivalent to attr_accessor
+# Keeping it here for time being until a Stripe engineer gets back to me
+module Coinbase
+  module Advanced
+    @config = Configuration.new
+
+    class << self
+      extend Forwardable
+
+      attr_reader :config
+
+      # User configurable options
+      def_delegators :@config, :base_url, :base_url=
+      def_delegators :@config, :api_prefix, :api_prefix=
+      def_delegators :@config, :key_file, :key_file=
+      def_delegators :@config, :api_key, :api_key=
+      def_delegators :@config, :api_secret, :api_secret=
+      def_delegators :@config, :timeout, :timeout=
+      def_delegators :@config, :verbose, :verbose=
+      def_delegators :@config, :logger, :log_level=
+      def_delegators :@config, :log_level, :log_level=
+      def_delegators :@config, :filter_params, :filter_params=
+
+      def configure
+        yield(@config) if block_given?
+      end
+    end
+  end
+end