honeymaker 0.1.0 → 0.2.0

data/lib/honeymaker/clients/bitrue.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bitrue < Client
+      URL = "https://openapi.bitrue.com"
+
+      def exchange_information
+        get_public("/api/v1/exchangeInfo")
+      end
+
+      def symbol_price_ticker(symbol: nil)
+        get_public("/api/v1/ticker/price", { symbol: symbol })
+      end
+
+      def symbol_order_book_ticker(symbol: nil)
+        get_public("/api/v1/ticker/bookTicker", { symbol: symbol })
+      end
+
+      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, limit: 500)
+        get_public("/api/v1/market/kline", {
+          symbol: symbol, scale: interval, startTime: start_time,
+          endTime: end_time, limit: limit
+        })
+      end
+
+      def account_information(recv_window: 5000)
+        get_signed("/api/v1/account", { recvWindow: recv_window })
+      end
+
+      def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
+        get_signed("/api/v1/order", {
+          symbol: symbol, orderId: order_id,
+          origClientOrderId: orig_client_order_id, recvWindow: recv_window
+        })
+      end
+
+      def new_order(symbol:, side:, type:, time_in_force: nil, quantity: nil, quote_order_qty: nil,
+                    price: nil, new_client_order_id: nil, recv_window: 5000)
+        post_signed("/api/v1/order", {
+          symbol: symbol, side: side, type: type,
+          timeInForce: time_in_force, quantity: quantity,
+          quoteOrderQty: quote_order_qty, price: price,
+          newClientOrderId: new_client_order_id, recvWindow: recv_window
+        })
+      end
+
+      def cancel_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
+        delete_signed("/api/v1/order", {
+          symbol: symbol, orderId: order_id,
+          origClientOrderId: orig_client_order_id, recvWindow: recv_window
+        })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_signed(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = auth_headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, params = {})
+        with_rescue do
+          response = connection.post do |req|
+            req.url path
+            req.headers = auth_headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def delete_signed(path, params = {})
+        with_rescue do
+          response = connection.delete do |req|
+            req.url path
+            req.headers = auth_headers
+            req.params = params.compact.merge(timestamp: timestamp_ms)
+            req.params[:signature] = sign_params(req.params)
+          end
+          response.body
+        end
+      end
+
+      def auth_headers
+        { "X-MBX-APIKEY": @api_key, Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def sign_params(params)
+        return unless @api_secret
+        query = Faraday::Utils.build_query(params)
+        hmac_sha256(@api_secret, query)
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/bitvavo.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bitvavo < Client
+      URL = "https://api.bitvavo.com"
+      ACCESS_WINDOW = "10000"
+
+      def get_assets
+        get_public("/v2/assets")
+      end
+
+      def get_markets(market: nil)
+        get_public("/v2/markets", { market: market })
+      end
+
+      def get_ticker_price(market: nil)
+        get_public("/v2/ticker/price", { market: market })
+      end
+
+      def get_ticker_book(market: nil)
+        get_public("/v2/ticker/book", { market: market })
+      end
+
+      def get_candles(market:, interval:, start_time: nil, end_time: nil, limit: nil)
+        get_public("/v2/#{market}/candles", {
+          interval: interval, start: start_time, end: end_time, limit: limit
+        })
+      end
+
+      def get_balance(symbol: nil)
+        get_signed("/v2/balance", { symbol: symbol })
+      end
+
+      def place_order(market:, side:, order_type:, amount: nil, amount_quote: nil, price: nil,
+                      time_in_force: nil, client_order_id: nil)
+        post_signed("/v2/order", {
+          market: market, side: side, orderType: order_type,
+          amount: amount, amountQuote: amount_quote, price: price,
+          timeInForce: time_in_force, clientOrderId: client_order_id
+        })
+      end
+
+      def get_order(market:, order_id:)
+        get_signed("/v2/order", { market: market, orderId: order_id })
+      end
+
+      def cancel_order(market:, order_id:)
+        delete_signed("/v2/order", { market: market, orderId: order_id })
+      end
+
+      def withdraw(symbol:, amount:, address:, payment_id: nil)
+        post_signed("/v2/withdrawal", {
+          symbol: symbol, amount: amount, address: address, paymentId: payment_id
+        })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = unauthenticated_headers
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_signed(path, params = {})
+        with_rescue do
+          params = params.compact
+          query_string = params.any? ? "?#{Faraday::Utils.build_query(params)}" : ""
+          ts = timestamp_ms.to_s
+          payload = "#{ts}GET#{path}#{query_string}"
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, payload)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          body = body.compact
+          body_string = body.to_json
+          ts = timestamp_ms.to_s
+          payload = "#{ts}POST#{path}#{body_string}"
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers(ts, payload)
+            req.body = body
+          end
+          response.body
+        end
+      end
+
+      def delete_signed(path, params = {})
+        with_rescue do
+          params = params.compact
+          query_string = params.any? ? "?#{Faraday::Utils.build_query(params)}" : ""
+          ts = timestamp_ms.to_s
+          payload = "#{ts}DELETE#{path}#{query_string}"
+
+          response = connection.delete do |req|
+            req.url path
+            req.headers = signed_headers(ts, payload)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(timestamp, payload)
+        signature = hmac_sha256(@api_secret, payload)
+        {
+          "BITVAVO-ACCESS-KEY": @api_key,
+          "BITVAVO-ACCESS-SIGNATURE": signature,
+          "BITVAVO-ACCESS-TIMESTAMP": timestamp,
+          "BITVAVO-ACCESS-WINDOW": ACCESS_WINDOW,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/bybit.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bybit < Client
+      URL = "https://api.bybit.com"
+      RECV_WINDOW = "5000"
+
+      def get_coin_query_info
+        get_authenticated("/v5/asset/coin/query-info")
+      end
+
+      def instruments_info(category:, symbol: nil, status: nil, base_coin: nil, limit: nil, cursor: nil)
+        get_public("/v5/market/instruments-info", {
+          category: category, symbol: symbol, status: status,
+          baseCoin: base_coin, limit: limit, cursor: cursor
+        })
+      end
+
+      def tickers(category:, symbol: nil, base_coin: nil, exp_date: nil)
+        get_public("/v5/market/tickers", {
+          category: category, symbol: symbol, baseCoin: base_coin, expDate: exp_date
+        })
+      end
+
+      def orderbook(category:, symbol:, limit: nil)
+        get_public("/v5/market/orderbook", { category: category, symbol: symbol, limit: limit })
+      end
+
+      def kline(category:, symbol:, interval:, start: nil, end_time: nil, limit: nil)
+        get_public("/v5/market/kline", {
+          category: category, symbol: symbol, interval: interval,
+          start: start, end: end_time, limit: limit
+        })
+      end
+
+      def wallet_balance(account_type:, coin: nil)
+        get_authenticated("/v5/account/wallet-balance", { accountType: account_type, coin: coin })
+      end
+
+      def get_order(category:, order_id: nil, symbol: nil, order_link_id: nil)
+        get_authenticated("/v5/order/realtime", {
+          category: category, orderId: order_id, symbol: symbol, orderLinkId: order_link_id
+        })
+      end
+
+      def create_order(category:, symbol:, side:, order_type:, qty:, price: nil,
+                       time_in_force: nil, market_unit: nil, order_link_id: nil)
+        post_authenticated("/v5/order/create", {
+          category: category, symbol: symbol, side: side,
+          orderType: order_type, qty: qty, price: price,
+          timeInForce: time_in_force, marketUnit: market_unit,
+          orderLinkId: order_link_id
+        })
+      end
+
+      def cancel_order(category:, symbol:, order_id: nil, order_link_id: nil)
+        post_authenticated("/v5/order/cancel", {
+          category: category, symbol: symbol,
+          orderId: order_id, orderLinkId: order_link_id
+        })
+      end
+
+      def withdraw(coin:, chain:, address:, amount:, tag: nil, force_chain: nil)
+        post_authenticated("/v5/asset/withdraw/create", {
+          coin: coin, chain: chain, address: address, amount: amount,
+          tag: tag, forceChain: force_chain, timestamp: timestamp_ms
+        })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = unauthenticated_headers
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def get_authenticated(path, params = {})
+        with_rescue do
+          params = params.compact
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers("GET", params)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_authenticated(path, body = {})
+        with_rescue do
+          body = body.compact
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers("POST", body)
+            req.body = body
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(method, params_or_body)
+        return unauthenticated_headers unless authenticated?
+
+        ts = timestamp_ms
+        payload = if method == "GET"
+                    query_string = Faraday::Utils.build_query(params_or_body)
+                    "#{ts}#{@api_key}#{RECV_WINDOW}#{query_string}"
+                  else
+                    "#{ts}#{@api_key}#{RECV_WINDOW}#{params_or_body.to_json}"
+                  end
+
+        signature = hmac_sha256(@api_secret, payload)
+
+        {
+          "X-BAPI-API-KEY": @api_key,
+          "X-BAPI-SIGN": signature,
+          "X-BAPI-TIMESTAMP": ts.to_s,
+          "X-BAPI-RECV-WINDOW": RECV_WINDOW,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/coinbase.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "jwt"
+
+module Honeymaker
+  module Clients
+    class Coinbase < Client
+      URL = "https://api.coinbase.com"
+
+      def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
+        super
+        @api_secret = @api_secret&.gsub('\n', "\n")
+      end
+
+      def get_order(order_id:)
+        get("/api/v3/brokerage/orders/historical/#{order_id}")
+      end
+
+      def list_orders(order_ids: nil, product_ids: nil, product_type: nil, order_status: nil,
+                      time_in_forces: nil, order_types: nil, order_side: nil, start_date: nil,
+                      end_date: nil, order_placement_source: nil, contract_expiry_type: nil,
+                      asset_filters: nil, limit: nil, cursor: nil, sort_by: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/brokerage/orders/historical/batch"
+            req.headers = auth_headers(req)
+            req.params = {
+              order_ids: order_ids, product_ids: product_ids, product_type: product_type,
+              order_status: order_status, time_in_forces: time_in_forces,
+              order_types: order_types, order_side: order_side,
+              start_date: start_date, end_date: end_date,
+              order_placement_source: order_placement_source,
+              contract_expiry_type: contract_expiry_type,
+              asset_filters: asset_filters, limit: limit, cursor: cursor, sort_by: sort_by
+            }.compact
+            req.options.params_encoder = Faraday::FlatParamsEncoder
+          end
+          response.body
+        end
+      end
+
+      def create_order(client_order_id:, product_id:, side:, order_configuration:)
+        post("/api/v3/brokerage/orders", {
+          client_order_id: client_order_id, product_id: product_id,
+          side: side, order_configuration: order_configuration
+        })
+      end
+
+      def cancel_orders(order_ids:)
+        post("/api/v3/brokerage/orders/batch_cancel", { order_ids: order_ids })
+      end
+
+      def list_public_products(limit: nil, offset: nil, product_type: nil, product_ids: nil,
+                               contract_expiry_type: nil, expiring_contract_status: nil,
+                               get_tradability_status: nil, get_all_products: nil)
+        get("/api/v3/brokerage/market/products", {
+          limit: limit, offset: offset, product_type: product_type, product_ids: product_ids,
+          contract_expiry_type: contract_expiry_type,
+          expiring_contract_status: expiring_contract_status,
+          get_tradability_status: get_tradability_status, get_all_products: get_all_products
+        })
+      end
+
+      def get_public_product(product_id:, get_tradability_status: nil)
+        get("/api/v3/brokerage/market/products/#{product_id}", { get_tradability_status: get_tradability_status })
+      end
+
+      def get_public_product_book(product_id:, limit: nil, aggregation_price_increment: nil)
+        with_rescue do
+          response = connection.get do |req|
+            req.url "/api/v3/brokerage/market/product_book"
+            req.headers = auth_headers(req)
+            req.params = {
+              product_id: product_id, limit: limit,
+              aggregation_price_increment: aggregation_price_increment
+            }.compact
+            req.options.params_encoder = Faraday::FlatParamsEncoder
+          end
+          response.body
+        end
+      end
+
+      def get_public_product_candles(product_id:, start_time:, end_time:, granularity:, limit: nil)
+        get("/api/v3/brokerage/market/products/#{product_id}/candles", {
+          start: start_time, end: end_time, granularity: granularity, limit: limit
+        })
+      end
+
+      def get_api_key_permissions
+        get("/api/v3/brokerage/key_permissions")
+      end
+
+      def list_accounts
+        get("/api/v3/brokerage/accounts")
+      end
+
+      def list_portfolios
+        get("/api/v3/brokerage/portfolios")
+      end
+
+      def get_portfolio_breakdown(portfolio_uuid:, currency: nil)
+        get("/api/v3/brokerage/portfolios/#{portfolio_uuid}", { currency: currency })
+      end
+
+      def send_money(account_id:, to:, amount:, currency:, idem: nil)
+        post("/v2/accounts/#{account_id}/transactions", {
+          type: "send", to: to, amount: amount, currency: currency, idem: idem
+        })
+      end
+
+      private
+
+      def get(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.headers = auth_headers(req)
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post(path, body = {})
+        with_rescue do
+          response = connection.post do |req|
+            req.url path
+            req.headers = auth_headers(req)
+            req.body = body.compact
+          end
+          response.body
+        end
+      end
+
+      def auth_headers(req)
+        return unauthenticated_headers unless authenticated?
+
+        timestamp = Time.now.utc.to_i
+        method = req.http_method.to_s.upcase
+        request_host = URI(URL).host
+        request_path = req.path
+
+        jwt_payload = {
+          sub: @api_key,
+          iss: "coinbase-cloud",
+          nbf: timestamp,
+          exp: timestamp + 120,
+          uri: "#{method} #{request_host}#{request_path}"
+        }
+
+        signing_key = ecdsa_key? ? ecdsa_signing_key : ed25519_signing_key
+        return unauthenticated_headers if signing_key.nil?
+
+        algorithm = ecdsa_key? ? "ES256" : "EdDSA"
+        jwt = JWT.encode(jwt_payload, signing_key, algorithm, { kid: @api_key, nonce: SecureRandom.hex })
+
+        { Authorization: "Bearer #{jwt}", Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def ecdsa_key?
+        @api_secret&.start_with?("-----BEGIN EC PRIVATE KEY-----")
+      end
+
+      def ecdsa_signing_key
+        OpenSSL::PKey::EC.new(@api_secret)
+      rescue OpenSSL::PKey::ECError
+        nil
+      end
+
+      def ed25519_signing_key
+        require "rbnacl"
+        decoded_key = Base64.decode64(@api_secret)
+        seed = decoded_key[0...32]
+        RbNaCl::Signatures::Ed25519::SigningKey.new(seed)
+      rescue LoadError, RbNaCl::LengthError
+        nil
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/gemini.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Gemini < Client
+      URL = "https://api.gemini.com"
+
+      def get_symbols
+        get_public("/v1/symbols")
+      end
+
+      def get_symbol_details(symbol:)
+        get_public("/v1/symbols/details/#{symbol}")
+      end
+
+      def get_ticker(symbol:)
+        get_public("/v1/pubticker/#{symbol}")
+      end
+
+      def get_candles(symbol:, time_frame:)
+        get_public("/v2/candles/#{symbol}/#{time_frame}")
+      end
+
+      def get_balances
+        post_signed("/v1/balances")
+      end
+
+      def new_order(symbol:, amount:, price:, side:, type:, client_order_id: nil, options: [])
+        post_signed("/v1/order/new", {
+          symbol: symbol, amount: amount, price: price,
+          side: side, type: type, client_order_id: client_order_id,
+          options: options
+        })
+      end
+
+      def order_status(order_id:)
+        post_signed("/v1/order/status", { order_id: order_id })
+      end
+
+      def cancel_order(order_id:)
+        post_signed("/v1/order/cancel", { order_id: order_id })
+      end
+
+      def withdraw(currency:, address:, amount:)
+        post_signed("/v1/withdraw/#{currency}", { address: address, amount: amount })
+      end
+
+      private
+
+      def get_public(path, params = {})
+        with_rescue do
+          response = connection.get do |req|
+            req.url path
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          payload = body.compact.merge(request: path, nonce: timestamp_ms.to_s)
+          encoded_payload = Base64.strict_encode64(payload.to_json)
+          signature = hmac_sha256(@api_secret, encoded_payload)
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = {
+              "X-GEMINI-APIKEY": @api_key,
+              "X-GEMINI-PAYLOAD": encoded_payload,
+              "X-GEMINI-SIGNATURE": signature,
+              Accept: "application/json",
+              "Content-Type": "text/plain"
+            }
+          end
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/hyperliquid.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Hyperliquid < Client
+      URL = "https://api.hyperliquid.xyz"
+
+      def spot_meta
+        post_info({ type: "spotMeta" })
+      end
+
+      def spot_meta_and_asset_ctxs
+        post_info({ type: "spotMetaAndAssetCtxs" })
+      end
+
+      def spot_clearinghouse_state(user:)
+        post_info({ type: "spotClearinghouseState", user: user })
+      end
+
+      def order_status(user:, oid:)
+        post_info({ type: "orderStatus", user: user, oid: oid })
+      end
+
+      def open_orders(user:)
+        post_info({ type: "openOrders", user: user })
+      end
+
+      private
+
+      def post_info(body)
+        with_rescue do
+          response = connection.post do |req|
+            req.url "/info"
+            req.headers = { Accept: "application/json", "Content-Type": "application/json" }
+            req.body = body.to_json
+          end
+          response.body
+        end
+      end
+    end
+  end
+end