honeymaker 0.12.3 → 0.12.5

data/ext/honeymaker_native/src/ruby_decimal.rs

@@ -0,0 +1,90 @@
+use honeymaker_core::num::Num;
+use magnus::{Ruby, Value, prelude::*, value::BoxValue};
+
+/// Ruby's BigDecimal behind the core's Num trait. BoxValue registers the object with the GC,
+/// so it is safe inside the Vecs and structs the normalizers return. Calls retain the GVL.
+pub struct RubyDecimal(BoxValue<Value>);
+
+impl RubyDecimal {
+    pub fn value(&self) -> Value {
+        *self.0
+    }
+
+    fn wrap(v: Value) -> Self {
+        RubyDecimal(BoxValue::new(v))
+    }
+
+    fn ruby() -> Ruby {
+        Ruby::get().expect("called on a Ruby thread")
+    }
+}
+
+impl Num for RubyDecimal {
+    type Error = magnus::Error;
+
+    fn parse(text: &str) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(
+            Self::ruby()
+                .module_kernel()
+                .funcall("BigDecimal", (text,))?,
+        ))
+    }
+
+    fn parse_to_s(v: &serde_json::Value) -> Result<Self, magnus::Error> {
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        let text = BoxValue::new(obj.funcall::<_, _, Value>("to_s", ())?);
+        Ok(Self::wrap(
+            ruby.module_kernel().funcall("BigDecimal", (*text,))?,
+        ))
+    }
+
+    fn parse_json(v: &serde_json::Value) -> Result<Self, magnus::Error> {
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        Ok(Self::wrap(
+            ruby.module_kernel().funcall("BigDecimal", (*obj,))?,
+        ))
+    }
+
+    fn string_op(
+        v: &serde_json::Value,
+        op: honeymaker_core::semantics::StringOp<'_>,
+    ) -> Result<serde_json::Value, magnus::Error> {
+        use honeymaker_core::semantics::StringOp;
+        let ruby = Self::ruby();
+        let obj = BoxValue::new(crate::convert::from_json(&ruby, v)?);
+        let result: Value = match op {
+            StringOp::Index(key) => obj.funcall("[]", (key,))?,
+            StringOp::Split(sep) => obj.funcall("split", (sep,))?,
+            StringOp::First => obj.funcall("[]", (0,))?,
+            StringOp::DowncaseSymbol | StringOp::Symbol => {
+                let text = BoxValue::new(if matches!(op, StringOp::DowncaseSymbol) {
+                    obj.funcall("downcase", ())?
+                } else {
+                    *obj
+                });
+                // Validate now, in legacy's evaluation order, before parsing decimals.
+                text.funcall::<_, _, Value>("to_sym", ())?;
+                *text
+            }
+        };
+        crate::convert::to_json(&ruby, result)
+    }
+
+    fn add(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("+", (o.value(),))?))
+    }
+
+    fn sub(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("-", (o.value(),))?))
+    }
+
+    fn div(&self, o: &Self) -> Result<Self, magnus::Error> {
+        Ok(Self::wrap(self.value().funcall("/", (o.value(),))?))
+    }
+
+    fn is_zero(&self) -> Result<bool, magnus::Error> {
+        self.value().funcall("zero?", ())
+    }
+}

data/lib/honeymaker/clients/bingx.rb

@@ -18,10 +18,11 @@ module Honeymaker
         get_public("/openApi/spot/v1/market/depth", { symbol: symbol, limit: limit })
       end
 
-      def get_klines(symbol:, interval:, start_time: nil, end_time: nil, limit: nil)
+      # time_zone: 0 aligns candles to UTC; BingX's default is 8 (UTC+8).
+      def get_klines(symbol:, interval:, start_time: nil, end_time: nil, limit: nil, time_zone: nil)
         get_public("/openApi/spot/v1/market/kline", {
           symbol: symbol, interval: interval,
-          startTime: start_time, endTime: end_time, limit: limit
+          startTime: start_time, endTime: end_time, limit: limit, timeZone: time_zone
         })
       end
 
@@ -87,22 +88,25 @@ module Honeymaker
         get_signed("/openApi/wallets/v1/capital/config/getall")
       end
 
-      def get_trade_fills(symbol: nil, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: nil)
-        get_signed("/openApi/spot/v1/trade/fills", {
+      # Query transaction details. symbol is required; only the past 7 days; limit ≤ 1000.
+      def get_trade_fills(symbol:, order_id: nil, start_time: nil, end_time: nil, from_id: nil, limit: nil)
+        get_signed("/openApi/spot/v1/trade/myTrades", {
           symbol: symbol, orderId: order_id,
           startTime: start_time, endTime: end_time, fromId: from_id, limit: limit
         })
       end
 
+      # Deposit records: a bare array, offset + limit ≤ 1000.
       def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil)
-        get_signed("/openApi/wallets/v1/capital/deposit/hisrec", {
+        get_signed("/openApi/api/v3/capital/deposit/hisrec", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time, offset: offset, limit: limit
         })
       end
 
+      # Withdraw records: a bare array, offset + limit ≤ 1000.
       def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: nil, id: nil)
-        get_signed("/openApi/wallets/v1/capital/withdraw/history", {
+        get_signed("/openApi/api/v3/capital/withdraw/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time, offset: offset, limit: limit, id: id
         })

data/lib/honeymaker/clients/bitrue.rb

@@ -14,14 +14,22 @@ module Honeymaker
         get_public("/api/v1/ticker/price", { symbol: symbol })
       end
 
+      # Without a symbol, /ticker/price answers nothing usable; /ticker/24hr lists every pair
+      # (weight 40) with lastPrice.
+      def ticker_24hr(symbol: nil)
+        get_public("/api/v1/ticker/24hr", { 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)
+      # Documented: symbol, scale, fromIdx, limit (max 1440). startTime/endTime are not documented and
+      # are ignored; fromIdx (ms) caps the newest candle, so a walk goes back with fromIdx = oldest - 1.
+      def candlestick_data(symbol:, interval:, start_time: nil, end_time: nil, limit: 500, from_idx: nil)
         get_public("/api/v1/market/kline", {
           symbol: symbol, scale: interval, startTime: start_time,
-          endTime: end_time, limit: limit
+          endTime: end_time, limit: limit, fromIdx: from_idx
         })
       end
 
@@ -77,34 +85,56 @@ module Honeymaker
         })
       end
 
-      def get_all_coins_information(recv_window: 5000)
-        get_signed("/api/v1/capital/config/getall", { recvWindow: recv_window })
+      # /api/v1/capital/config/getall redirects to the website. The documented source of withdrawal
+      # networks and fees is the public exchangeInfo `coins[].chainDetail[]`; it is answered here in the
+      # Binance shape the method always promised: [{ "coin", "networkList" => [{ "network",
+      # "withdrawFee", "withdrawMin", "withdrawMax", "withdrawEnable", "depositEnable", "isDefault" }] }].
+      # Bitrue marks no default chain; a chain closed for withdrawal is left out.
+      def get_all_coins_information
+        result = exchange_information
+        return result if result.failure?
+
+        coins = Array(result.data["coins"]).map do |coin|
+          networks = Array(coin["chainDetail"]).select { |c| c["enableWithdraw"] }.map do |c|
+            { "network" => c["chain"], "withdrawFee" => c["withdrawFee"], "withdrawMin" => c["minWithdraw"],
+              "withdrawMax" => c["maxWithdraw"], "withdrawEnable" => true,
+              "depositEnable" => c["enableDeposit"], "isDefault" => false }
+          end
+          { "coin" => coin["coin"].to_s.upcase, "networkList" => networks }
+        end
+        Result::Success.new(coins)
       end
 
-      def withdraw(coin:, address:, amount:, network: nil, address_tag: nil, recv_window: 5000)
-        post_signed("/api/v1/capital/withdraw/apply", {
-          coin: coin, address: address, amount: amount,
-          network: network, addressTag: address_tag, recvWindow: recv_window
+      # POST /api/v1/withdraw/commit: coin without chain name, chainName, addressTo; needs the
+      # withdraw privilege, an IP-limited key and a whitelisted address.
+      def withdraw(coin:, address:, amount:, network:, address_tag: nil, recv_window: 5000)
+        post_signed("/api/v1/withdraw/commit", {
+          coin: coin, amount: amount, addressTo: address,
+          chainName: network, tag: address_tag, recvWindow: recv_window
         })
       end
 
+      # GET /api/v2/myTrades (v1 is undocumented): limit ≤ 1000, a startTime..endTime span ≤ 3 months.
       def account_trade_list(symbol:, start_time: nil, end_time: nil, from_id: nil, limit: 500, recv_window: 5000)
-        get_signed("/api/v1/myTrades", {
+        get_signed("/api/v2/myTrades", {
           symbol: symbol, startTime: start_time, endTime: end_time,
           fromId: from_id, limit: limit, recvWindow: recv_window
         })
       end
 
-      def deposit_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
-        get_signed("/api/v1/capital/deposit/hisrec", {
+      # GET /api/v1/deposit/history and /api/v1/withdraw/history (the /capital/ paths redirect to the
+      # website): coin is required and has no chain suffix; status defaults to 0 (init) — finished is
+      # 1 for a deposit, 5 for a withdrawal; offset + limit ≤ 1000; answers { "code" => 200, "data" => [...] }.
+      def deposit_history(coin:, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v1/deposit/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time,
           offset: offset, limit: limit, recvWindow: recv_window
         })
       end
 
-      def withdraw_history(coin: nil, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
-        get_signed("/api/v1/capital/withdraw/history", {
+      def withdraw_history(coin:, status: nil, start_time: nil, end_time: nil, offset: nil, limit: 1000, recv_window: 5000)
+        get_signed("/api/v1/withdraw/history", {
           coin: coin, status: status,
           startTime: start_time, endTime: end_time,
           offset: offset, limit: limit, recvWindow: recv_window

data/lib/honeymaker/clients/bitvavo.rb

@@ -90,12 +90,14 @@ module Honeymaker
         })
       end
 
+      # GET /v2/deposit is the deposit ADDRESS, and GET /v2/withdrawal answers 405. The histories are
+      # /v2/depositHistory and /v2/withdrawalHistory: limit ≤ 1000 (default 500), latest first.
       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 })
+        get_signed("/v2/depositHistory", { 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 })
+        get_signed("/v2/withdrawalHistory", { symbol: symbol, limit: limit, start: start_time, end: end_time })
       end
 
       def withdraw(symbol:, amount:, address:, payment_id: nil)
@@ -106,8 +108,11 @@ module Honeymaker
 
       # --- History ---
 
-      def get_transactions(limit: nil, start_time: nil, end_time: nil)
-        get_signed("/v2/transactions", { limit: limit, start: start_time, end: end_time })
+      # /v2/transactions is a 404. The transaction history is /v2/account/history: every type (buy,
+      # sell, deposit, withdrawal, staking, ...), fromDate/toDate in ms, page from 1, maxItems ≤ 100;
+      # answers { "items" => [...], "currentPage", "totalPages", "maxItems" }.
+      def get_transactions(limit: nil, start_time: nil, end_time: nil, page: nil, type: nil)
+        get_signed("/v2/account/history", { fromDate: start_time, toDate: end_time, page: page, maxItems: limit, type: type })
       end
 
       private

data/lib/honeymaker/clients/bybit.rb

@@ -96,6 +96,15 @@ module Honeymaker
         })
       end
 
+      # Closed orders that /v5/order/realtime no longer returns.
+      def order_history(category:, symbol: nil, order_id: nil, order_link_id: nil, order_status: nil,
+                        start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/order/history", {
+          category: category, symbol: symbol, orderId: order_id, orderLinkId: order_link_id,
+          orderStatus: order_status, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
       def transaction_log(account_type: nil, category: nil, currency: nil, type: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
         get_authenticated("/v5/account/transaction-log", {
           accountType: account_type, category: category, currency: currency, type: type,
@@ -116,6 +125,13 @@ module Honeymaker
         })
       end
 
+      # Off-chain deposits from another Bybit user; query-record does not include them.
+      def internal_deposit_records(tx_id: nil, coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil)
+        get_authenticated("/v5/asset/deposit/query-internal-record", {
+          txID: tx_id, coin: coin, startTime: start_time, endTime: end_time, limit: limit, cursor: cursor
+        })
+      end
+
       def withdraw_records(coin: nil, start_time: nil, end_time: nil, limit: nil, cursor: nil, withdraw_type: nil)
         get_authenticated("/v5/asset/withdraw/query-record", {
           coin: coin, startTime: start_time, endTime: end_time,
@@ -207,9 +223,10 @@ module Honeymaker
       def parse_order_status(status)
         case status
         when "Created", "Untriggered" then :unknown
-        when "New", "PartiallyFilled", "PartiallyFilledCanceled" then :open
+        when "New", "PartiallyFilled" then :open
         when "Filled" then :closed
-        when "Cancelled", "Expired", "Deactivated" then :cancelled
+        # PartiallyFilledCanceled is final: a spot order cancelled after a partial fill.
+        when "Cancelled", "PartiallyFilledCanceled", "Expired", "Deactivated" then :cancelled
         when "Rejected" then :failed
         else :unknown
         end

data/lib/honeymaker/clients/coinbase.rb

@@ -105,8 +105,9 @@ module Honeymaker
         get("/api/v3/brokerage/key_permissions")
       end
 
-      def list_accounts
-        get("/api/v3/brokerage/accounts")
+      # One page of accounts; pass the response's `cursor` back while `has_next` is true.
+      def list_accounts(limit: nil, cursor: nil)
+        get("/api/v3/brokerage/accounts", { limit: limit, cursor: cursor })
       end
 
       def list_portfolios

data/lib/honeymaker/clients/gemini.rb

@@ -84,6 +84,16 @@ module Honeymaker
         post_signed("/v1/transfers", { timestamp: timestamp, limit_transfers: limit_transfers })
       end
 
+      # POST /v2/transfers, which replaces the retiring /v1/transfers: limit_transfers ≤ 50 (default 10),
+      # timestamp in ms, rows carry feeAmount/feeCurrency/txHash; 1 request per 5 s per account.
+      def get_transfers_v2(timestamp: nil, limit_transfers: nil, currency: nil, network: nil, account: nil,
+                           show_completed_deposit_advances: nil)
+        post_signed("/v2/transfers", {
+          timestamp: timestamp, limit_transfers: limit_transfers, currency: currency, network: network,
+          account: account, show_completed_deposit_advances: show_completed_deposit_advances
+        })
+      end
+
       def withdraw(currency:, address:, amount:)
         post_signed("/v1/withdraw/#{currency}", { address: address, amount: amount })
       end

data/lib/honeymaker/clients/hyperliquid.rb

@@ -5,6 +5,20 @@ module Honeymaker
     class Hyperliquid < Client
       URL = "https://api.hyperliquid.xyz"
       RATE_LIMITS = { default: 200, orders: 200 }.freeze
+      # A cap on the userFillsByTime walk for one order's cost: the venue keeps only the 10000 most
+      # recent fills, at most 2000 (500 by the general note) per answer, so 25 pages reach them all.
+      FILLS_PAGES = 25
+
+      NONCE_LOCK = Mutex.new
+      @last_nonce = 0
+
+      # Hyperliquid keeps the 100 highest nonces per signer and refuses a reused one. hyperliquid-rb
+      # signs with the wall clock in ms, so two orders signed in the same ms by one agent collide —
+      # and the app builds a client per call, so the counter lives on the class: strictly
+      # increasing for the whole process, never behind the clock (the venue's own advice).
+      def self.next_nonce
+        NONCE_LOCK.synchronize { @last_nonce = [(Time.now.to_f * 1000).to_i, @last_nonce + 1].max }
+      end
 
       def initialize(api_key: nil, api_secret: nil, proxy: nil, logger: nil)
         super
@@ -87,13 +101,13 @@ module Honeymaker
         quote_amount_exec = BigDecimal("0")
         price = limit_price
         if amount_exec.positive?
-          fills_result = order["timestamp"] ? user_fills_by_time(user: user, start_time: order["timestamp"]) : nil
+          fills_result = order["timestamp"] ? order_fills(user: user, oid: oid, start_time: order["timestamp"], size: amount_exec) : nil
           # A FAILED exact-cost lookup (timeout / rate-limit) is PROPAGATED so the consumer's typed-error
           # retry runs — never record an executed order with an estimated cost just because userFills
           # blipped (that would silently corrupt accounting and skip the retry).
           return fills_result if fills_result&.failure?
 
-          matched = Array(fills_result&.data).select { |f| f["oid"].to_s == oid.to_s }
+          matched = Array(fills_result&.data)
           matched_quote = matched.sum(BigDecimal("0")) { |f| BigDecimal(f["px"].to_s) * BigDecimal(f["sz"].to_s) }
           # userFills SUCCEEDED but has no matching fill (aged out of the window) → estimate from the
           # limit price so a filled order never reports quote_amount_exec 0. Only on success, never failure.
@@ -127,6 +141,11 @@ module Honeymaker
         post_info(body)
       end
 
+      # "missing", "user", "agent" (with the master under data.user), "vault" or "subAccount".
+      def user_role(user:)
+        post_info({ type: "userRole", user: user })
+      end
+
       # --- Trading (requires hyperliquid-rb gem) ---
 
       def order(coin:, is_buy:, size:, limit_px:, order_type: { limit: { tif: "Gtc" } })
@@ -157,6 +176,28 @@ module Honeymaker
 
       private
 
+      # This order's fills, from its timestamp on. One answer is capped, so the walk goes on from the
+      # newest time it saw (inclusive, so fills are deduped by tid) until the order's executed size
+      # is covered or a page brings nothing new.
+      def order_fills(user:, oid:, start_time:, size:)
+        seen = {}
+        matched = []
+        FILLS_PAGES.times do
+          page = user_fills_by_time(user: user, start_time: start_time)
+          return page if page.failure?
+
+          fresh = Array(page.data).reject { |f| seen[f["tid"] || f.hash] }
+          break if fresh.empty?
+
+          fresh.each { |f| seen[f["tid"] || f.hash] = true }
+          matched.concat(fresh.select { |f| f["oid"].to_s == oid.to_s })
+          break if matched.sum(BigDecimal("0")) { |f| BigDecimal(f["sz"].to_s) } >= size
+
+          start_time = fresh.map { |f| f["time"].to_i }.max
+        end
+        Result::Success.new(matched)
+      end
+
       # Trading does not go over this client's Faraday connection: it goes through hyperliquid-rb,
       # which raises its own error for every non-2xx instead of answering. Client#with_rescue can
       # only see an unlabelled StandardError there, so it flags it `client_error` — "no clean
@@ -211,12 +252,30 @@ module Honeymaker
         raise Error, "Trading requires api_secret (agent key)" unless @api_secret && !@api_secret.empty?
         @exchange ||= begin
           require "hyperliquid"
-          ::Hyperliquid::Exchange.new(private_key: @api_secret)
+          build_exchange
         rescue LoadError
           raise Error, "Add 'hyperliquid-rb' to your Gemfile to use Hyperliquid trading"
         end
       end
 
+      # hyperliquid-rb's defaults do not fit a client built per call:
+      # - its Info opens a websocket and a ping thread unless skip_ws, and nothing here ever stops
+      #   them — one leaked socket per trading client. Nothing here subscribes, so never open it;
+      # - its two Transports build their own Faraday without our proxy, so placement and the asset
+      #   lookup went out direct. hyperliquid-rb 0.1.1 has no proxy option; set it on both;
+      # - its nonce is the wall-clock ms (see .next_nonce).
+      def build_exchange
+        exchange = ::Hyperliquid::Exchange.new(private_key: @api_secret, skip_ws: true)
+        if @proxy
+          [exchange.instance_variable_get(:@transport), exchange.info.transport].each do |transport|
+            transport.instance_variable_get(:@connection).proxy = @proxy
+          end
+        end
+        exchange.singleton_class.send(:define_method, :timestamp_ms) { Honeymaker::Clients::Hyperliquid.next_nonce }
+        exchange.singleton_class.send(:private, :timestamp_ms)
+        exchange
+      end
+
       def post_info(body)
         with_rescue do
           response = connection.post do |req|

data/lib/honeymaker/clients/kraken.rb

@@ -148,6 +148,7 @@ module Honeymaker
         return Result::Success.new({}) if wanted.empty?
 
         by_order = Hash.new { |h, k| h[k] = [] }
+        seen = {}
         offset = 0
         pages = 0
         loop do
@@ -161,7 +162,11 @@ module Honeymaker
           trades = result.data.dig("result", "trades") || {}
           break if trades.empty?
 
-          trades.each_value do |t|
+          trades.each_pair do |trade_id, t|
+            # Offset paging over a list that grows at the top can serve a trade twice: count it once.
+            next if seen.key?(trade_id)
+
+            seen[trade_id] = true
             otxid = t["ordertxid"]
             by_order[otxid] << t if wanted.include?(otxid)
           end

data/lib/honeymaker/clients/mexc.rb

@@ -6,8 +6,9 @@ module Honeymaker
       URL = "https://api.mexc.com"
       RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
-      def get_all_coins_information
-        get_public("/api/v3/capital/config/getall")
+      # Signed (permission SPOT_WITHDRAW_READ): unsigned, MEXC answers 400 "api key required".
+      def get_all_coins_information(recv_window: 5000)
+        get_signed("/api/v3/capital/config/getall", { recvWindow: recv_window })
       end
 
       def exchange_information
@@ -108,6 +109,19 @@ module Honeymaker
         get_signed("/api/v3/capital/withdraw/address", { recvWindow: recv_window })
       end
 
+      # POST /api/v3/capital/withdraw, the endpoint MEXC replaces /withdraw/apply with ("previous,
+      # offline soon"). It takes netWork — networkList[].netWork from get_all_coins_information, a
+      # different value from the old `network` — and answers a single { "id" } object, not an array.
+      def capital_withdraw(coin:, address:, amount:, net_work: nil, memo: nil, withdraw_order_id: nil,
+                           contract_address: nil, remark: nil, recv_window: 5000)
+        post_signed("/api/v3/capital/withdraw", {
+          coin: coin, address: address, amount: amount, netWork: net_work, memo: memo,
+          withdrawOrderId: withdraw_order_id, contractAddress: contract_address, remark: remark,
+          recvWindow: recv_window
+        })
+      end
+
+      # The previous endpoint, which MEXC marks "offline soon"; see #capital_withdraw.
       def withdraw(coin:, address:, amount:, network: nil, memo: nil, recv_window: 5000)
         post_signed("/api/v3/capital/withdraw/apply", {
           coin: coin, address: address, amount: amount,

data/lib/honeymaker/exchanges/coinbase.rb

@@ -6,7 +6,7 @@ module Honeymaker
       BASE_URL = "https://api.coinbase.com"
 
       ASSET_BLACKLIST = [
-        "RENDER",    # has the same external_id as RNDR
+        "RNDR",      # delisted; has the same external_id as RENDER
         "ZETACHAIN", # has the same external_id as ZETA
         "WAXL"       # has the same external_id as AXL
       ].freeze
@@ -51,10 +51,11 @@ module Honeymaker
 
       private
 
-      # Coinbase only signals problems explicitly: a `trading_disabled` flag or a non-"online"
-      # `status`. Absent either signal, treat the pair as enabled.
+      # Coinbase only signals problems explicitly: a `trading_disabled`, `is_disabled`, `limit_only`
+      # or `cancel_only` flag, or a non-"online" `status`. Absent any signal, treat the pair as
+      # enabled. limit_only is reported as not tradable, like Kraken's limit_only status.
       def trading_enabled?(product)
-        return false if product["trading_disabled"] == true
+        return false if %w[trading_disabled is_disabled limit_only cancel_only].any? { |flag| product[flag] == true }
         return false if product.key?("status") && product["status"] != "online"
 
         true

data/lib/honeymaker/exchanges/mexc.rb

@@ -16,10 +16,15 @@ module Honeymaker
               ticker: product["symbol"],
               base: product["baseAsset"],
               quote: product["quoteAsset"],
-              minimum_base_size: f[:lot_size]&.[]("minQty"),
-              minimum_quote_size: f[:notional]&.[]("minNotional"),
+              # MEXC sends no LOT_SIZE or NOTIONAL filter (only PERCENT_PRICE_BY_SIDE). Its minimums are
+              # baseSizePrecision ("min order quantity") and quoteAmountPrecision ("min order amount";
+              # quoteAmountPrecisionMarket for a market order, so the larger of the two), and
+              # maxQuoteAmount caps the order value. A filter still wins if MEXC ever sends one.
+              minimum_base_size: f[:lot_size]&.[]("minQty") || product["baseSizePrecision"],
+              minimum_quote_size: f[:notional]&.[]("minNotional") ||
+                product.values_at("quoteAmountPrecision", "quoteAmountPrecisionMarket").compact.max_by { |v| BigDecimal(v.to_s) },
               maximum_base_size: f[:lot_size]&.[]("maxQty"),
-              maximum_quote_size: f[:notional]&.[]("maxNotional"),
+              maximum_quote_size: f[:notional]&.[]("maxNotional") || product["maxQuoteAmount"],
               base_decimals: f[:lot_size] ? Utils.decimals(f[:lot_size]["stepSize"]) : product["baseAssetPrecision"],
               quote_decimals: product["quoteAssetPrecision"],
               price_decimals: f[:price] ? Utils.decimals(f[:price]["tickSize"]) : product["quotePrecision"],