honeymaker 0.1.0 → 0.3.0

data/lib/honeymaker/clients/bitget.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class Bitget < Client
+      URL = "https://api.bitget.com"
+
+      attr_reader :passphrase
+
+      def initialize(api_key: nil, api_secret: nil, passphrase: nil, proxy: nil, logger: nil)
+        super(api_key: api_key, api_secret: api_secret, proxy: proxy, logger: logger)
+        @passphrase = passphrase
+      end
+
+      def get_coins
+        get_public("/api/v2/spot/public/coins")
+      end
+
+      def get_symbols
+        get_public("/api/v2/spot/public/symbols")
+      end
+
+      def get_tickers(symbol: nil)
+        get_public("/api/v2/spot/market/tickers", { symbol: symbol })
+      end
+
+      def get_orderbook(symbol:, limit: nil)
+        get_public("/api/v2/spot/market/orderbook", { symbol: symbol, limit: limit })
+      end
+
+      def get_candles(symbol:, granularity:, start_time: nil, end_time: nil, limit: nil)
+        get_public("/api/v2/spot/market/candles", {
+          symbol: symbol, granularity: granularity,
+          startTime: start_time, endTime: end_time, limit: limit
+        })
+      end
+
+      def get_account_assets(coin: nil)
+        get_signed("/api/v2/spot/account/assets", { coin: coin })
+      end
+
+      def place_order(symbol:, side:, order_type:, size: nil, quote_size: nil, price: nil, force: nil, client_oid: nil)
+        post_signed("/api/v2/spot/trade/place-order", {
+          symbol: symbol, side: side, orderType: order_type,
+          size: size, quoteSize: quote_size, price: price, force: force, clientOid: client_oid
+        })
+      end
+
+      def get_order(order_id: nil, client_oid: nil)
+        get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
+      end
+
+      def cancel_order(symbol:, order_id: nil, client_oid: nil)
+        post_signed("/api/v2/spot/trade/cancel-order", {
+          symbol: symbol, orderId: order_id, clientOid: client_oid
+        })
+      end
+
+      def get_fills(symbol: nil, order_id: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/trade/fills", {
+          symbol: symbol, orderId: order_id,
+          startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def deposit_list(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/wallet/deposit-records", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def withdrawal_list(coin: nil, start_time: nil, end_time: nil, limit: nil, id_less_than: nil)
+        get_signed("/api/v2/spot/wallet/withdrawal-records", {
+          coin: coin, startTime: start_time, endTime: end_time, limit: limit, idLessThan: id_less_than
+        })
+      end
+
+      def withdraw(coin:, address:, size:, transfer_type: nil, chain: nil, tag: nil, client_oid: nil)
+        post_signed("/api/v2/spot/wallet/withdrawal", {
+          coin: coin, transferType: transfer_type, address: address,
+          size: size, chain: chain, tag: tag, clientOid: client_oid
+        })
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_account_assets
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        result.data["code"] == "00000" ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      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.empty? ? "" : "?#{Faraday::Utils.build_query(params)}"
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}GET#{path}#{query_string}"
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          body = body.compact
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}POST#{path}#{body.to_json}"
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.body = body
+          end
+          response.body
+        end
+      end
+
+      def unauthenticated_headers
+        { Accept: "application/json", "Content-Type": "application/json" }
+      end
+
+      def signed_headers(timestamp, pre_sign)
+        mac = Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", @api_secret, pre_sign))
+        {
+          "ACCESS-KEY": @api_key,
+          "ACCESS-SIGN": mac,
+          "ACCESS-TIMESTAMP": timestamp,
+          "ACCESS-PASSPHRASE": @passphrase,
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          locale: "en-US"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/bitmart.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Honeymaker
+  module Clients
+    class BitMart < Client
+      URL = "https://api-cloud.bitmart.com"
+
+      attr_reader :memo
+
+      def initialize(api_key: nil, api_secret: nil, memo: nil, proxy: nil, logger: nil)
+        super(api_key: api_key, api_secret: api_secret, proxy: proxy, logger: logger)
+        @memo = memo
+      end
+
+      def get_symbols_details
+        get_public("/spot/v1/symbols/details")
+      end
+
+      def get_ticker(symbol: nil)
+        get_public("/spot/quotation/v3/ticker", { symbol: symbol })
+      end
+
+      def get_depth(symbol:, limit: nil)
+        get_public("/spot/quotation/v3/books", { symbol: symbol, limit: limit })
+      end
+
+      def get_klines(symbol:, step:, before: nil, after_time: nil, limit: nil)
+        get_public("/spot/quotation/v3/lite-klines", {
+          symbol: symbol, step: step, before: before, after: after_time, limit: limit
+        })
+      end
+
+      def get_wallet
+        get_signed("/spot/v1/wallet")
+      end
+
+      def submit_order(symbol:, side:, type:, size: nil, notional: nil, price: nil, client_order_id: nil)
+        post_signed("/spot/v2/submit_order", {
+          symbol: symbol, side: side, type: type,
+          size: size, notional: notional, price: price,
+          client_order_id: client_order_id
+        })
+      end
+
+      def get_order(order_id:)
+        post_signed("/spot/v2/order_detail", { orderId: order_id })
+      end
+
+      def cancel_order(symbol:, order_id: nil, client_order_id: nil)
+        post_signed("/spot/v3/cancel_order", {
+          symbol: symbol, order_id: order_id, client_order_id: client_order_id
+        })
+      end
+
+      def get_trades(symbol:, order_mode: nil, start_time: nil, end_time: nil, limit: nil, recv_window: nil)
+        get_signed("/spot/v2/trades", {
+          symbol: symbol, orderMode: order_mode,
+          startTime: start_time, endTime: end_time, N: limit, recvWindow: recv_window
+        })
+      end
+
+      def deposit_list(currency: nil, n: nil, status: nil)
+        get_signed("/account/v1/deposit-withdraw/detail", {
+          currency: currency, N: n, type: "deposit", operation_type: "deposit", status: status
+        })
+      end
+
+      def withdraw_list(currency: nil, n: nil, status: nil)
+        get_signed("/account/v1/deposit-withdraw/detail", {
+          currency: currency, N: n, type: "withdraw", operation_type: "withdraw", status: status
+        })
+      end
+
+      def withdraw(currency:, amount:, address:, address_memo: nil, destination: nil)
+        post_signed("/account/v1/withdraw/apply", {
+          currency: currency, amount: amount,
+          destination: destination || "To Digital Address",
+          address: address, address_memo: address_memo
+        })
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_wallet
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        result.data["code"] == 1000 ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      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
+          ts = timestamp_ms.to_s
+          query_string = params.compact.empty? ? "" : "?#{Faraday::Utils.build_query(params.compact)}"
+          pre_sign = "#{ts}##{@memo}##{query_string}"
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params.compact
+          end
+          response.body
+        end
+      end
+
+      def post_signed(path, body = {})
+        with_rescue do
+          ts = timestamp_ms.to_s
+          body_json = body.compact.to_json
+          pre_sign = "#{ts}##{@memo}##{body_json}"
+
+          response = connection.post do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.body = body.compact
+          end
+          response.body
+        end
+      end
+
+      def signed_headers(timestamp, pre_sign)
+        signature = hmac_sha256(@api_secret, pre_sign)
+        {
+          "X-BM-KEY": @api_key,
+          "X-BM-SIGN": signature,
+          "X-BM-TIMESTAMP": timestamp,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/bitrue.rb

@@ -0,0 +1,130 @@
+# 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
+
+      def account_trade_list(symbol:, start_time: nil, end_time: nil, from_id: nil, limit: 500, recv_window: 5000)
+        get_signed("/api/v1/myTrades", {
+          symbol: symbol, startTime: start_time, endTime: end_time,
+          fromId: from_id, limit: limit, recvWindow: recv_window
+        })
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = account_information
+        result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      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,160 @@
+# 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 get_trades(market:, limit: nil, start_time: nil, end_time: nil, trade_id_from: nil, trade_id_to: nil)
+        get_signed("/v2/trades", {
+          market: market, limit: limit, start: start_time, end: end_time,
+          tradeIdFrom: trade_id_from, tradeIdTo: trade_id_to
+        })
+      end
+
+      def get_deposit_history(symbol: nil, limit: nil, start_time: nil, end_time: nil)
+        get_signed("/v2/deposit", { symbol: symbol, limit: limit, start: start_time, end: end_time })
+      end
+
+      def get_withdrawal_history(symbol: nil, limit: nil, start_time: nil, end_time: nil)
+        get_signed("/v2/withdrawal", { symbol: symbol, limit: limit, start: start_time, end: end_time })
+      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 validate_trading_credentials
+        result = get_balance
+        result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")
+      end
+
+      def validate_read_credentials
+        validate_trading_credentials
+      end
+
+      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