honeymaker 0.9.12 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 486ed9c66cbdbb6ed5d7b0af03e9735c96ee848b922cacd9c89f950bd439c388
-  data.tar.gz: 561770ac9c32e64a2e1483fafab052d7175b3b51b655083ef70f6227804fb4a6
+  metadata.gz: c8386a3ce395f193a10d210d48e62f48ffb5f2c2cf6ab2dbf77cd8a6466700c9
+  data.tar.gz: 9a4bd23725e93deb9a4b8e6aad1f9e86f6b27f13ecf0507031a9fbd53b2f65ba
 SHA512:
-  metadata.gz: 955a0992f60da65640083364576f8dc6b7cf4a918815e12e40e3cde813628c267942e473c96b8846b404786dba0705ad7ea11bd895e8907341fc7e18905f691e
-  data.tar.gz: 12c6329f2c4f09282544c9188e22efabb4666311816d7a27d396ef5eb7b1c26f9a8b6b9799a59bef33ea69406f2c125d82e544c9be8c4f7d351ba129d6d7c930
+  metadata.gz: 76f414d30b7ae364453bdb8b0522e2c1be01adc6db1126addfc2d0f3fc7111df3d3de41714dab6ec98b25dba8116605f9a9c064a58fe907aba2a4eb24f3f81f5
+  data.tar.gz: b6d38bc14208cadd407faa789607deddba96a9bd0a5c63d0ed5efbbc6fc86bef6fadda21f30814051e0cae5c1ded2a1bba8a8f5e2a99f06074dffb9c545f9229

data/README.md

@@ -8,7 +8,7 @@ Ruby clients for cryptocurrency exchange APIs used by [Deltabadger](https://gith
 
 ## Supported Exchanges
 
-Binance, Binance US, Kraken, Kraken Futures, Coinbase, Bybit, KuCoin, Bitget, MEXC, Bitvavo, Gemini, Hyperliquid, BingX, Bitrue, BitMart.
+Binance, Binance US, Kraken, Kraken Futures, Coinbase, Bybit, KuCoin, Bitget, MEXC, Bitvavo, Gemini, Hyperliquid, BingX, Bitrue.
 
 ## Installation
 

data/lib/honeymaker/client.rb

@@ -74,6 +74,17 @@ module Honeymaker
       Result::Failure.new((msg && !msg.empty?) ? msg : "Unknown error")
     end
 
+    # A business error the exchange returned inside an HTTP-200 envelope (KuCoin's non-"200000"
+    # code, Bitget's non-"00000"). Keep the exchange's own code and message: callers classify on
+    # this text to tell insufficient funds from a bad key from a stale timestamp, so collapsing it
+    # to a bare constant silently disables every one of those checks and leaves the operator with
+    # an unactionable log line. Falls back to the constant only when the body carries no detail.
+    def api_error(exchange, body)
+      detail = body.is_a?(Hash) ? [body["code"], body["msg"] || body["message"]] : []
+      detail = detail.compact.map(&:to_s).reject(&:empty?).join(": ")
+      Result::Failure.new(detail.empty? ? "#{exchange} API error" : "#{exchange} API error #{detail}")
+    end
+
     def connection
       @connection ||= build_client_connection(self.class::URL)
     end

data/lib/honeymaker/clients/bingx.rb

@@ -57,6 +57,11 @@ module Honeymaker
         return result if result.failure?
 
         raw = result.data
+        # BingX rejects with HTTP 200 and a non-zero `code`. Without this the rejection fell
+        # through as a Success carrying order_id "#{symbol}-" (nil id): the bot recorded a trade
+        # that was never placed, then polled a malformed id forever.
+        return api_error("BingX", raw) unless raw.is_a?(Hash) && raw["code"].to_i.zero?
+
         order_id = raw.dig("data", "orderId") || raw.dig("data", "data", "orderId")
         Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: raw })
       end
@@ -66,8 +71,9 @@ module Honeymaker
           symbol: symbol, orderId: order_id, clientOrderID: client_order_id
         })
         return result if result.failure?
+        return api_error("BingX", result.data) unless result.data.is_a?(Hash) && result.data["code"].to_i.zero?
 
-        raw = result.data.is_a?(Hash) && result.data.key?("data") ? result.data["data"] : result.data
+        raw = result.data.key?("data") ? result.data["data"] : result.data
         Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
       end
 

data/lib/honeymaker/clients/bitget.rb

@@ -44,7 +44,7 @@ module Honeymaker
         result = get_account_assets
         return result if result.failure?
 
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         balances = {}
         (result.data["data"] || []).each do |asset|
@@ -64,7 +64,7 @@ module Honeymaker
           size: size, quoteSize: quote_size, price: price, force: force, clientOid: client_oid
         })
         return result if result.failure?
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         order_id = result.data.dig("data", "orderId")
         Result::Success.new({ order_id: "#{symbol}-#{order_id}", raw: result.data })
@@ -73,7 +73,7 @@ module Honeymaker
       def get_order(order_id: nil, client_oid: nil)
         result = get_signed("/api/v2/spot/trade/orderInfo", { orderId: order_id, clientOid: client_oid })
         return result if result.failure?
-        return Result::Failure.new("Bitget API error") unless result.data["code"] == "00000"
+        return api_error("Bitget", result.data) unless result.data["code"] == "00000"
 
         order_list = result.data["data"]
         raw = order_list.is_a?(Array) ? order_list.first : order_list

data/lib/honeymaker/clients/kucoin.rb

@@ -39,7 +39,7 @@ module Honeymaker
         result = get_accounts(type: type)
         return result if result.failure?
 
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         balances = {}
         (result.data["data"] || []).each do |account|
@@ -61,7 +61,7 @@ module Honeymaker
           timeInForce: time_in_force, stp: stp
         })
         return result if result.failure?
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         order_id = result.data.dig("data", "orderId")
         Result::Success.new({ order_id: order_id, raw: result.data })
@@ -70,7 +70,7 @@ module Honeymaker
       def get_order(order_id:)
         result = get_signed("/api/v1/orders/#{order_id}")
         return result if result.failure?
-        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+        return api_error("KuCoin", result.data) unless result.data["code"] == "200000"
 
         raw = result.data["data"]
         return Result::Failure.new("Order not found") unless raw

data/lib/honeymaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Honeymaker
-  VERSION = "0.9.12"
+  VERSION = "0.11.0"
 end

data/lib/honeymaker.rb

@@ -21,7 +21,6 @@ require_relative "honeymaker/clients/bitvavo"
 require_relative "honeymaker/clients/gemini"
 require_relative "honeymaker/clients/bingx"
 require_relative "honeymaker/clients/bitrue"
-require_relative "honeymaker/clients/bitmart"
 require_relative "honeymaker/clients/hyperliquid"
 require_relative "honeymaker/clients/kraken_futures"
 require_relative "honeymaker/exchanges/binance"
@@ -37,7 +36,6 @@ require_relative "honeymaker/exchanges/kucoin"
 require_relative "honeymaker/exchanges/hyperliquid"
 require_relative "honeymaker/exchanges/bingx"
 require_relative "honeymaker/exchanges/bitrue"
-require_relative "honeymaker/exchanges/bitmart"
 
 module Honeymaker
   class Error < StandardError; end
@@ -55,8 +53,7 @@ module Honeymaker
     "kucoin" => Exchanges::Kucoin,
     "hyperliquid" => Exchanges::Hyperliquid,
     "bingx" => Exchanges::BingX,
-    "bitrue" => Exchanges::Bitrue,
-    "bitmart" => Exchanges::BitMart
+    "bitrue" => Exchanges::Bitrue
   }.freeze
 
   CLIENTS = {
@@ -72,7 +69,6 @@ module Honeymaker
     "gemini" => Clients::Gemini,
     "bingx" => Clients::BingX,
     "bitrue" => Clients::Bitrue,
-    "bitmart" => Clients::BitMart,
     "hyperliquid" => Clients::Hyperliquid,
     "kraken_futures" => Clients::KrakenFutures
   }.freeze

data/test/honeymaker/clients/bingx_client_test.rb

@@ -41,6 +41,30 @@ class Honeymaker::Clients::BingXTest < Minitest::Test
     assert result.success?
   end
 
+  # BingX rejects with HTTP 200 and a non-zero `code`. Without a guard the rejection was read as
+  # a placed order and handed back as order_id "BTC-USDT-" (nil id), so a bot recorded a trade
+  # that does not exist and then polled a malformed id forever.
+  def test_place_order_fails_on_nonzero_code
+    stub_connection(:post, { "code" => 100004, "msg" => "insufficient balance" })
+    result = @client.place_order(symbol: "BTC-USDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.failure?
+    assert_includes result.errors.first, "insufficient balance"
+  end
+
+  def test_get_order_fails_on_nonzero_code
+    stub_connection(:get, { "code" => 80016, "msg" => "Order does not exist" })
+    result = @client.get_order(symbol: "BTC-USDT", order_id: "123")
+    assert result.failure?
+    assert_includes result.errors.first, "Order does not exist"
+  end
+
+  def test_place_order_succeeds_on_zero_code
+    stub_connection(:post, { "code" => 0, "data" => { "orderId" => "123" } })
+    result = @client.place_order(symbol: "BTC-USDT", side: "BUY", type: "MARKET", quantity: "0.001")
+    assert result.success?
+    assert_equal "BTC-USDT-123", result.data[:order_id]
+  end
+
   def test_cancel_order
     stub_connection(:post, { "data" => { "orderId" => "123" } })
     result = @client.cancel_order(symbol: "BTC-USDT", order_id: "123")

data/test/honeymaker/clients/bitget_client_test.rb

@@ -104,6 +104,37 @@ class Honeymaker::Clients::BitgetTest < Minitest::Test
     assert headers.key?(:"ACCESS-SIGN")
   end
 
+  # Bitget signals business errors in an HTTP-200 envelope. Callers classify on this text
+  # (insufficient funds, bad key, stale timestamp), so the code and msg must survive.
+  def test_place_order_keeps_api_code_and_message
+    stub_connection(:post, { "code" => "43012", "msg" => "Insufficient balance" })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
+    assert result.failure?
+    assert_includes result.errors.first, "Insufficient balance"
+    assert_includes result.errors.first, "43012"
+  end
+
+  def test_get_order_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "40008", "msg" => "Request timestamp expired" })
+    result = @client.get_order(order_id: "BTCUSDT-123")
+    assert result.failure?
+    assert_includes result.errors.first, "Request timestamp expired"
+  end
+
+  def test_get_balances_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "40012", "msg" => "Apikey does not exist" })
+    result = @client.get_balances
+    assert result.failure?
+    assert_includes result.errors.first, "Apikey does not exist"
+  end
+
+  def test_api_error_falls_back_when_body_carries_no_detail
+    stub_connection(:post, { "code" => nil })
+    result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
+    assert result.failure?
+    assert_equal "Bitget API error", result.errors.first
+  end
+
   private
 
   def stub_connection(method, body)

data/test/honeymaker/clients/honeymaker_client_registry_test.rb

@@ -18,7 +18,7 @@ class HoneymakerClientRegistryTest < Minitest::Test
   end
 
   def test_all_clients_registered
-    assert_equal 15, Honeymaker::CLIENTS.size
+    assert_equal 14, Honeymaker::CLIENTS.size
   end
 
   def test_client_passes_credentials
@@ -36,9 +36,4 @@ class HoneymakerClientRegistryTest < Minitest::Test
     client = Honeymaker.client("kucoin", api_key: "k", api_secret: "s", passphrase: "p")
     assert_equal "p", client.passphrase
   end
-
-  def test_bitmart_accepts_memo
-    client = Honeymaker.client("bitmart", api_key: "k", api_secret: "s", memo: "m")
-    assert_equal "m", client.memo
-  end
 end

data/test/honeymaker/clients/kucoin_client_test.rb

@@ -107,6 +107,37 @@ class Honeymaker::Clients::KucoinTest < Minitest::Test
     assert_equal expected, headers[:"KC-API-PASSPHRASE"]
   end
 
+  # KuCoin signals business errors in an HTTP-200 envelope. Callers classify on this text
+  # (insufficient funds, bad key, stale timestamp), so the code and msg must survive.
+  def test_place_order_keeps_api_code_and_message
+    stub_connection(:post, { "code" => "200004", "msg" => "Balance insufficient!" })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_includes result.errors.first, "Balance insufficient!"
+    assert_includes result.errors.first, "200004"
+  end
+
+  def test_get_order_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400002", "msg" => "Invalid KC-API-TIMESTAMP." })
+    result = @client.get_order(order_id: "123")
+    assert result.failure?
+    assert_includes result.errors.first, "Invalid KC-API-TIMESTAMP."
+  end
+
+  def test_get_balances_keeps_api_code_and_message
+    stub_connection(:get, { "code" => "400003", "msg" => "KC-API-KEY not exists" })
+    result = @client.get_balances
+    assert result.failure?
+    assert_includes result.errors.first, "KC-API-KEY not exists"
+  end
+
+  def test_api_error_falls_back_when_body_carries_no_detail
+    stub_connection(:post, { "code" => nil })
+    result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
+    assert result.failure?
+    assert_equal "KuCoin API error", result.errors.first
+  end
+
   private
 
   def stub_connection(method, body)

data/test/honeymaker/clients/validation_test.rb

@@ -148,21 +148,6 @@ class ValidationTest < Minitest::Test
     assert result.success?
   end
 
-  # BitMart
-  def test_bitmart_validate_trading_success
-    client = Honeymaker::Clients::BitMart.new(api_key: "k", api_secret: "s", memo: "m")
-    stub_connection(client, :get, { "code" => 1000, "data" => {} })
-    result = client.validate(:trading)
-    assert result.success?
-  end
-
-  def test_bitmart_validate_trading_failure
-    client = Honeymaker::Clients::BitMart.new(api_key: "k", api_secret: "s", memo: "m")
-    stub_connection(client, :get, { "code" => 30004, "message" => "Unauthorized" })
-    result = client.validate(:trading)
-    assert result.failure?
-  end
-
   # Hyperliquid
   def test_hyperliquid_validate_trading_success
     client = Honeymaker::Clients::Hyperliquid.new(api_key: "0xabc", api_secret: "s")

data/test/honeymaker/honeymaker_test.rb

@@ -22,6 +22,6 @@ class HoneymakerTest < Minitest::Test
   end
 
   def test_all_exchanges_registered
-    assert_equal 14, Honeymaker::EXCHANGES.size
+    assert_equal 13, Honeymaker::EXCHANGES.size
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.9.12
+  version: 0.11.0
 platform: ruby
 authors:
 - Deltabadger
@@ -98,7 +98,6 @@ files:
 - lib/honeymaker/clients/binance_us.rb
 - lib/honeymaker/clients/bingx.rb
 - lib/honeymaker/clients/bitget.rb
-- lib/honeymaker/clients/bitmart.rb
 - lib/honeymaker/clients/bitrue.rb
 - lib/honeymaker/clients/bitvavo.rb
 - lib/honeymaker/clients/bybit.rb
@@ -114,7 +113,6 @@ files:
 - lib/honeymaker/exchanges/binance_us.rb
 - lib/honeymaker/exchanges/bingx.rb
 - lib/honeymaker/exchanges/bitget.rb
-- lib/honeymaker/exchanges/bitmart.rb
 - lib/honeymaker/exchanges/bitrue.rb
 - lib/honeymaker/exchanges/bitvavo.rb
 - lib/honeymaker/exchanges/bybit.rb
@@ -160,7 +158,6 @@ files:
 - test/honeymaker/clients/binance_us_client_test.rb
 - test/honeymaker/clients/bingx_client_test.rb
 - test/honeymaker/clients/bitget_client_test.rb
-- test/honeymaker/clients/bitmart_client_test.rb
 - test/honeymaker/clients/bitrue_client_test.rb
 - test/honeymaker/clients/bitvavo_client_test.rb
 - test/honeymaker/clients/bybit_client_test.rb
@@ -178,7 +175,6 @@ files:
 - test/honeymaker/exchanges/binance_us_test.rb
 - test/honeymaker/exchanges/bingx_test.rb
 - test/honeymaker/exchanges/bitget_test.rb
-- test/honeymaker/exchanges/bitmart_test.rb
 - test/honeymaker/exchanges/bitrue_test.rb
 - test/honeymaker/exchanges/bitvavo_test.rb
 - test/honeymaker/exchanges/bybit_test.rb

data/lib/honeymaker/clients/bitmart.rb

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-module Honeymaker
-  module Clients
-    class BitMart < Client
-      URL = "https://api-cloud.bitmart.com"
-      RATE_LIMITS = { default: 100, orders: 200 }.freeze
-
-      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_currencies
-        get_public("/account/v1/currencies")
-      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 get_balances
-        result = get_wallet
-        return result if result.failure?
-
-        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
-
-        balances = {}
-        (result.data.dig("data", "wallet") || []).each do |wallet|
-          symbol = wallet["id"]
-          free = BigDecimal((wallet["available"] || "0").to_s)
-          locked = BigDecimal((wallet["frozen"] || "0").to_s)
-          next if free.zero? && locked.zero?
-          balances[symbol] = { free: free, locked: locked }
-        end
-
-        Result::Success.new(balances)
-      end
-
-      def submit_order(symbol:, side:, type:, size: nil, notional: nil, price: nil, client_order_id: nil)
-        result = post_signed("/spot/v2/submit_order", {
-          symbol: symbol, side: side, type: type,
-          size: size, notional: notional, price: price,
-          client_order_id: client_order_id
-        })
-        return result if result.failure?
-        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
-
-        order_id = result.data.dig("data", "order_id")
-        Result::Success.new({ order_id: order_id.to_s, raw: result.data })
-      end
-
-      def get_order(order_id:)
-        result = post_signed("/spot/v2/order_detail", { orderId: order_id })
-        return result if result.failure?
-        return Result::Failure.new("BitMart API error") unless result.data["code"] == 1000
-
-        raw = result.data["data"]
-        return Result::Failure.new("Order not found") unless raw
-
-        Result::Success.new(normalize_order(order_id.to_s, raw))
-      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 get_withdraw_addresses
-        get_signed("/account/v1/withdraw/address/list")
-      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
-
-      # --- Margin ---
-
-      def margin_borrow_records(symbol: nil, borrow_id: nil, start_time: nil, end_time: nil, n: nil)
-        get_signed("/spot/v1/margin/isolated/borrow_record", {
-          symbol: symbol, borrow_id: borrow_id, start_time: start_time, end_time: end_time, N: n
-        })
-      end
-
-      def margin_repay_records(symbol: nil, repay_id: nil, currency: nil, start_time: nil, end_time: nil, n: nil)
-        get_signed("/spot/v1/margin/isolated/repay_record", {
-          symbol: symbol, repay_id: repay_id, currency: currency, start_time: start_time, end_time: end_time, N: n
-        })
-      end
-
-      # --- Futures ---
-
-      def futures_transaction_history(start_time: nil, end_time: nil, page_num: nil, page_size: nil, flow_type: nil)
-        get_signed("/contract/private/transaction-history", {
-          start_time: start_time, end_time: end_time,
-          page_num: page_num, page_size: page_size, flow_type: flow_type
-        })
-      end
-
-      def futures_trades(symbol:, start_time: nil, end_time: nil, page_num: nil, page_size: nil)
-        get_signed("/contract/private/trades", {
-          symbol: symbol, start_time: start_time, end_time: end_time,
-          page_num: page_num, page_size: page_size
-        })
-      end
-
-      private
-
-      def normalize_order(order_id, raw)
-        order_type = parse_order_type(raw["type"])
-        side = raw["side"]&.downcase&.to_sym
-        status = parse_order_status(raw["status"])
-
-        amount = BigDecimal((raw["size"] || "0").to_s)
-        amount = nil if amount.zero?
-        quote_amount = raw["notional"] ? BigDecimal(raw["notional"].to_s) : nil
-        quote_amount = nil if quote_amount&.zero?
-
-        amount_exec = BigDecimal((raw["filled_size"] || "0").to_s)
-        quote_amount_exec = BigDecimal((raw["filled_notional"] || "0").to_s)
-        quote_amount_exec = nil if quote_amount_exec.negative?
-
-        price = BigDecimal((raw["price"] || "0").to_s)
-        if price.zero? && quote_amount_exec&.positive? && amount_exec.positive?
-          price = quote_amount_exec / amount_exec
-        end
-        price = nil if price.zero?
-
-        {
-          order_id: order_id, status: status, side: side, order_type: order_type,
-          price: price, amount: amount, quote_amount: quote_amount,
-          amount_exec: amount_exec, quote_amount_exec: quote_amount_exec, raw: raw
-        }
-      end
-
-      def parse_order_type(type)
-        case type
-        when "market" then :market
-        when "limit" then :limit
-        else :unknown
-        end
-      end
-
-      def parse_order_status(status)
-        case status
-        when "new", "partially_filled" then :open
-        when "filled" then :closed
-        when "canceled", "expired", "partially_canceled" then :cancelled
-        when "rejected", "failed" then :failed
-        else :unknown
-        end
-      end
-
-      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/exchanges/bitmart.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Honeymaker
-  module Exchanges
-    class BitMart < Exchange
-      BASE_URL = "https://api-cloud.bitmart.com"
-
-      def get_tickers_info
-        with_rescue do
-          response = connection.get("/spot/v1/symbols/details")
-
-          response.body["data"]["symbols"].filter_map do |product|
-            {
-              ticker: product["symbol"],
-              base: product["base_currency"],
-              quote: product["quote_currency"],
-              minimum_base_size: product["base_min_size"],
-              minimum_quote_size: product["min_buy_amount"],
-              maximum_base_size: nil,
-              maximum_quote_size: nil,
-              base_decimals: Utils.decimals(product["base_min_size"]),
-              quote_decimals: Utils.decimals(product["quote_increment"]),
-              price_decimals: product["price_max_precision"].to_i,
-              available: true,
-              trading_enabled: product["trade_status"] == "trading"
-            }
-          end
-        end
-      end
-
-      def get_bid_ask(symbol)
-        with_rescue do
-          response = connection.get("/spot/quotation/v3/ticker") do |req|
-            req.params = { symbol: symbol }
-          end
-
-          data = response.body["data"]
-          {
-            bid: BigDecimal(data["best_bid"]),
-            ask: BigDecimal(data["best_ask"])
-          }
-        end
-      end
-
-      private
-
-      def connection
-        @connection ||= build_connection(BASE_URL)
-      end
-    end
-  end
-end

data/test/honeymaker/clients/bitmart_client_test.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class Honeymaker::Clients::BitMartTest < Minitest::Test
-  def setup
-    @client = Honeymaker::Clients::BitMart.new(
-      api_key: "test_key", api_secret: "test_secret", memo: "test_memo"
-    )
-  end
-
-  def test_url
-    assert_equal "https://api-cloud.bitmart.com", Honeymaker::Clients::BitMart::URL
-  end
-
-  def test_accepts_memo
-    assert_equal "test_memo", @client.memo
-  end
-
-  def test_get_symbols_details
-    stub_connection(:get, { "data" => { "symbols" => [{ "symbol" => "BTC_USDT" }] } })
-    result = @client.get_symbols_details
-    assert result.success?
-  end
-
-  def test_get_ticker
-    stub_connection(:get, { "data" => [{ "symbol" => "BTC_USDT" }] })
-    result = @client.get_ticker(symbol: "BTC_USDT")
-    assert result.success?
-  end
-
-  def test_get_wallet
-    stub_connection(:get, { "data" => { "wallet" => [{ "id" => "BTC" }] } })
-    result = @client.get_wallet
-    assert result.success?
-  end
-
-  def test_submit_order
-    stub_connection(:post, { "code" => 1000, "data" => { "order_id" => 123 } })
-    result = @client.submit_order(symbol: "BTC_USDT", side: "buy", type: "market", notional: "100")
-    assert result.success?
-    assert_equal "123", result.data[:order_id]
-  end
-
-  def test_get_order
-    stub_connection(:post, { "code" => 1000, "data" => {
-      "symbol" => "BTC_USDT", "type" => "market", "side" => "buy", "status" => "filled",
-      "size" => "0.001", "filled_size" => "0.001", "filled_notional" => "50", "price" => "50000"
-    } })
-    result = @client.get_order(order_id: "123")
-    assert result.success?
-    assert_equal :closed, result.data[:status]
-  end
-
-  def test_cancel_order
-    stub_connection(:post, { "data" => true })
-    result = @client.cancel_order(symbol: "BTC_USDT", order_id: "123")
-    assert result.success?
-  end
-
-  def test_withdraw
-    stub_connection(:post, { "data" => { "withdraw_id" => "w1" } })
-    result = @client.withdraw(currency: "BTC", amount: "0.1", address: "addr")
-    assert result.success?
-  end
-
-  def test_get_trades
-    stub_connection(:get, { "data" => [{ "tradeId" => "t1" }] })
-    result = @client.get_trades(symbol: "BTC_USDT")
-    assert result.success?
-  end
-
-  def test_deposit_list
-    stub_connection(:get, { "data" => { "records" => [{ "currency" => "BTC" }] } })
-    result = @client.deposit_list
-    assert result.success?
-  end
-
-  def test_withdraw_list
-    stub_connection(:get, { "data" => { "records" => [{ "currency" => "ETH" }] } })
-    result = @client.withdraw_list
-    assert result.success?
-  end
-
-  def test_signed_headers_include_memo_in_signature
-    ts = "1234567890"
-    pre_sign = "#{ts}#test_memo#body"
-    headers = @client.send(:signed_headers, ts, pre_sign)
-    assert_equal "test_key", headers[:"X-BM-KEY"]
-    assert headers.key?(:"X-BM-SIGN")
-  end
-
-  private
-
-  def stub_connection(method, body)
-    response = stub(body: body)
-    connection = stub
-    connection.stubs(method).returns(response)
-    @client.instance_variable_set(:@connection, connection)
-  end
-end

data/test/honeymaker/exchanges/bitmart_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class Honeymaker::Exchanges::BitMartTest < Minitest::Test
-  include FixtureHelper
-
-  def setup
-    @exchange = Honeymaker::Exchanges::BitMart.new
-  end
-
-  def test_get_tickers_info_parses_response
-    body = load_fixture("bitmart_symbols.json")
-    stub_connection(body)
-
-    result = @exchange.get_tickers_info
-
-    assert result.success?
-    assert_equal 2, result.data.size
-
-    ticker = result.data.first
-    assert_equal "BTC_USDT", ticker[:ticker]
-    assert_equal "BTC", ticker[:base]
-    assert_equal "USDT", ticker[:quote]
-    assert_equal "0.00001", ticker[:minimum_base_size]
-    assert_equal "5", ticker[:minimum_quote_size]
-    assert_nil ticker[:maximum_base_size]
-    assert_equal 5, ticker[:base_decimals]
-    assert_equal 2, ticker[:quote_decimals]
-    assert_equal 2, ticker[:price_decimals]
-    assert ticker[:available]
-    assert ticker[:trading_enabled]
-  end
-
-  def test_pre_trade_listed_but_not_trading_enabled
-    body = load_fixture("bitmart_symbols.json")
-    stub_connection(body)
-
-    result = @exchange.get_tickers_info
-
-    eth = result.data.find { |t| t[:ticker] == "ETH_USDT" }
-    assert eth[:available]          # still listed
-    refute eth[:trading_enabled]    # but not trading
-  end
-
-  def test_get_bid_ask_parses_response
-    body = load_fixture("bitmart_ticker.json")
-    stub_connection(body)
-
-    result = @exchange.get_bid_ask("BTC_USDT")
-
-    assert result.success?
-    assert_equal BigDecimal("67123.45"), result.data[:bid]
-    assert_equal BigDecimal("67125.67"), result.data[:ask]
-  end
-
-  private
-
-  def stub_connection(body)
-    response = stub(body: body)
-    connection = stub
-    connection.stubs(:get).returns(response)
-    @exchange.instance_variable_set(:@connection, connection)
-  end
-end