honeymaker 0.9.11 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50e3e2d9451d404977937fddc4d265c25da9ca8ed848ba6d6c008f24e8e129c9
-  data.tar.gz: a949bcc4a042ce6076986ae76c19fdb4a4bea583f0934fd6e1a5548e492d8898
+  metadata.gz: bbfab70631b45882e86a1f4af9ea69b9c32c98840a383183b69ebae133b2f3bf
+  data.tar.gz: 3d65a28ae18b85f5de60959aac90e327471ff617488956538442b6841ddc4bd9
 SHA512:
-  metadata.gz: 9489aa1616d24f9d17b37c603b468426b0354d87aa27a16970165919859565a35195aef1a665348e6e1d24e3ca636eb23901d34c002a2a85f932a99d6a7335b1
-  data.tar.gz: 70f1ebd03b468460c76c28bd5fcc69b975d64562790cef14075e13236e647d2132294a13e2bf3267b822526c6ae7d9905e7c5d18bfe28a0ea4e5548a169e4daa
+  metadata.gz: 00f3d5d33b5c1d231be4f1bafb5815083bc26cafae31a8cfe2c4403be217ece9120f7195bc6f5fa15d14286950c9f8817762767a4824f0c29396a6b679ca483e
+  data.tar.gz: 3209e5756f1aab9c2af0537c533b3b2dbadf468c635c5f882d4f85362679597495d78f9ec77a2f7ca1b10a8c1c534687d19b95be73989ce88fe23fbf5f03120a

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/exchanges/hyperliquid.rb

@@ -5,6 +5,11 @@ module Honeymaker
     class Hyperliquid < Exchange
       BASE_URL = "https://api.hyperliquid.xyz"
 
+      # Hyperliquid enforces a hard 10-USDC minimum order value on every spot pair (spotMeta exposes
+      # no per-token base floor). Surfaced as minimum_quote_size so consumers skip/reject sub-10
+      # orders up front instead of having the exchange reject them.
+      MINIMUM_QUOTE_SIZE = 10
+
       def get_tickers_info
         with_rescue do
           response = connection.post("/info") do |req|
@@ -25,7 +30,7 @@ module Honeymaker
               base: base_token["name"],
               quote: quote_token["name"],
               minimum_base_size: nil,
-              minimum_quote_size: nil,
+              minimum_quote_size: MINIMUM_QUOTE_SIZE,
               maximum_base_size: nil,
               maximum_quote_size: nil,
               base_decimals: base_token["szDecimals"] || 0,

data/lib/honeymaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Honeymaker
-  VERSION = "0.9.11"
+  VERSION = "0.10.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/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/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/exchanges/hyperliquid_test.rb

@@ -22,8 +22,8 @@ class Honeymaker::Exchanges::HyperliquidTest < Minitest::Test
     assert_equal "PURR/USDC", ticker[:ticker]
     assert_equal "PURR", ticker[:base]
     assert_equal "USDC", ticker[:quote]
-    assert_nil ticker[:minimum_base_size]
-    assert_nil ticker[:minimum_quote_size]
+    assert_nil ticker[:minimum_base_size] # no per-token base floor in spotMeta
+    assert_equal 10, ticker[:minimum_quote_size] # Hyperliquid's hard 10-USDC spot order floor
     assert_equal 2, ticker[:base_decimals]
     assert_equal 2, ticker[:quote_decimals]
     assert_equal 5, ticker[:price_decimals]

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.11
+  version: 0.10.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