honeymaker 0.4.0 → 0.5.0

data/lib/honeymaker/clients/kraken_futures.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Honeymaker
+  module Clients
+    class KrakenFutures < Client
+      URL = "https://futures.kraken.com"
+
+      RATE_LIMITS = { default: 500, orders: 500 }.freeze
+
+      def get_accounts
+        get_private("/derivatives/api/v3/accounts")
+      end
+
+      def get_fills(last_fill_time: nil)
+        get_private("/derivatives/api/v3/fills", { lastFillTime: last_fill_time })
+      end
+
+      def get_open_positions
+        get_private("/derivatives/api/v3/openpositions")
+      end
+
+      def historical_funding_rates(symbol:)
+        get_public("/derivatives/api/v3/historicalfundingrates", { symbol: symbol })
+      end
+
+      private
+
+      def validate_trading_credentials
+        result = get_accounts
+        return Result::Failure.new("Invalid trading credentials") if result.failure?
+        Result::Success.new(true)
+      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_private(path, params = {})
+        with_rescue do
+          params = params.compact
+          query_string = params.empty? ? "" : Faraday::Utils.build_query(params)
+          nonce = timestamp_ms.to_s
+
+          post_data = query_string
+          hash_input = "#{post_data}#{nonce}#{path}"
+          sha256_hash = Digest::SHA256.digest(hash_input)
+          decoded_secret = Base64.decode64(@api_secret)
+          hmac = OpenSSL::HMAC.digest("sha512", decoded_secret, sha256_hash)
+          authent = Base64.strict_encode64(hmac)
+
+          response = connection.get do |req|
+            req.url path
+            req.headers = {
+              "APIKey": @api_key,
+              "Authent": authent,
+              "Nonce": nonce,
+              Accept: "application/json"
+            }
+            req.params = params
+          end
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/honeymaker/clients/kucoin.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Kucoin < Client
       URL = "https://api.kucoin.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       attr_reader :passphrase
 
@@ -34,17 +35,47 @@ module Honeymaker
         get_signed("/api/v1/accounts", { currency: currency, type: type })
       end
 
+      def get_balances(type: "trade")
+        result = get_accounts(type: type)
+        return result if result.failure?
+
+        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+
+        balances = {}
+        (result.data["data"] || []).each do |account|
+          symbol = account["currency"]
+          free = BigDecimal((account["available"] || "0").to_s)
+          locked = BigDecimal((account["holds"] || "0").to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def place_order(client_oid:, side:, symbol:, type:, size: nil, funds: nil, price: nil,
                       time_in_force: nil, stp: nil)
-        post_signed("/api/v1/orders", {
+        result = post_signed("/api/v1/orders", {
           clientOid: client_oid, side: side, symbol: symbol, type: type,
           size: size, funds: funds, price: price,
           timeInForce: time_in_force, stp: stp
         })
+        return result if result.failure?
+        return Result::Failure.new("KuCoin API error") unless result.data["code"] == "200000"
+
+        order_id = result.data.dig("data", "orderId")
+        Result::Success.new({ order_id: order_id, raw: result.data })
       end
 
       def get_order(order_id:)
-        get_signed("/api/v1/orders/#{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"
+
+        raw = result.data["data"]
+        return Result::Failure.new("Order not found") unless raw
+
+        Result::Success.new(normalize_order(order_id, raw))
       end
 
       def cancel_order(order_id:)
@@ -97,8 +128,91 @@ module Honeymaker
         })
       end
 
+      # --- Margin ---
+
+      def margin_borrow_history(currency: nil, is_isolated: nil, symbol: nil, order_no: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/borrow", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol, orderNo: order_no,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def margin_repay_history(currency: nil, is_isolated: nil, symbol: nil, order_no: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/repay", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol, orderNo: order_no,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      def margin_interest_history(currency: nil, is_isolated: nil, symbol: nil, start_time: nil, end_time: nil, current_page: nil, page_size: nil)
+        get_signed("/api/v3/margin/interest", {
+          currency: currency, isIsolated: is_isolated, symbol: symbol,
+          startTime: start_time, endTime: end_time, currentPage: current_page, pageSize: page_size
+        })
+      end
+
+      # --- Futures ---
+
+      def futures_funding_history(symbol:, start_at: nil, end_at: nil, reverse: nil, offset: nil, forward: nil, max_count: nil)
+        with_rescue do
+          params = {
+            symbol: symbol, startAt: start_at, endAt: end_at,
+            reverse: reverse, offset: offset, forward: forward, maxCount: max_count
+          }.compact
+          query_string = params.empty? ? "" : "?#{Faraday::Utils.build_query(params)}"
+          path = "/api/v1/funding-history"
+          ts = timestamp_ms.to_s
+          pre_sign = "#{ts}GET#{path}#{query_string}"
+
+          response = futures_connection.get do |req|
+            req.url path
+            req.headers = signed_headers(ts, pre_sign)
+            req.params = params
+          end
+          response.body
+        end
+      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)
+
+        deal_funds = BigDecimal((raw["dealFunds"] || "0").to_s)
+        deal_size = BigDecimal((raw["dealSize"] || "0").to_s)
+        price = deal_funds.positive? && deal_size.positive? ? deal_funds / deal_size : BigDecimal((raw["price"] || "0").to_s)
+        price = nil if price.zero?
+
+        amount = raw["size"] ? BigDecimal(raw["size"].to_s) : nil
+        quote_amount = raw["funds"] ? BigDecimal(raw["funds"].to_s) : nil
+
+        {
+          order_id: order_id, status: status, side: side, order_type: order_type,
+          price: price, amount: amount, quote_amount: quote_amount,
+          amount_exec: deal_size, quote_amount_exec: deal_funds, raw: raw
+        }
+      end
+
+      def parse_order_type(type)
+        case type&.downcase
+        when "market" then :market
+        when "limit" then :limit
+        else :unknown
+        end
+      end
+
+      def parse_order_status(raw)
+        if raw["cancelExist"]
+          :cancelled
+        elsif raw["isActive"]
+          :open
+        else
+          BigDecimal((raw["dealSize"] || "0").to_s).positive? ? :closed : :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = get_accounts(type: "trade")
         return Result::Failure.new("Invalid trading credentials") if result.failure?
@@ -183,6 +297,10 @@ module Honeymaker
           "Content-Type": "application/json"
         }
       end
+
+      def futures_connection
+        @futures_connection ||= build_client_connection("https://api-futures.kucoin.com")
+      end
     end
   end
 end

data/lib/honeymaker/clients/mexc.rb

@@ -4,6 +4,7 @@ module Honeymaker
   module Clients
     class Mexc < Client
       URL = "https://api.mexc.com"
+      RATE_LIMITS = { default: 100, orders: 200 }.freeze
 
       def get_all_coins_information
         get_public("/api/v3/capital/config/getall")
@@ -32,21 +33,45 @@ module Honeymaker
         get_signed("/api/v3/account", { recvWindow: recv_window })
       end
 
+      def get_balances
+        result = account_information
+        return result if result.failure?
+
+        balances = {}
+        Array(result.data["balances"]).each do |balance|
+          symbol = balance["asset"]
+          free = BigDecimal(balance["free"].to_s)
+          locked = BigDecimal(balance["locked"].to_s)
+          next if free.zero? && locked.zero?
+          balances[symbol] = { free: free, locked: locked }
+        end
+
+        Result::Success.new(balances)
+      end
+
       def query_order(symbol:, order_id: nil, orig_client_order_id: nil, recv_window: 5000)
-        get_signed("/api/v3/order", {
+        result = get_signed("/api/v3/order", {
           symbol: symbol, orderId: order_id,
           origClientOrderId: orig_client_order_id, recvWindow: recv_window
         })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new(normalize_order("#{symbol}-#{raw['orderId']}", raw))
       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/v3/order", {
+        result = post_signed("/api/v3/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
         })
+        return result if result.failure?
+
+        raw = result.data
+        Result::Success.new({ order_id: "#{symbol}-#{raw['orderId']}", raw: raw })
       end
 
       def cancel_order(symbol:, order_id: nil, orig_client_order_id: nil,
@@ -90,8 +115,66 @@ module Honeymaker
         })
       end
 
+      # --- Other ---
+
+      def dust_conversion_history(recv_window: 5000)
+        get_signed("/api/v3/capital/convert", { recvWindow: recv_window })
+      end
+
+      def universal_transfer_history(type:, start_time: nil, end_time: nil, page: nil, size: nil, recv_window: 5000)
+        get_signed("/api/v3/capital/transfer", {
+          type: type, startTime: start_time, endTime: end_time,
+          page: page, size: size, recvWindow: recv_window
+        })
+      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["origQty"].to_s)
+        amount = nil if amount.zero?
+        quote_amount = raw["origQuoteOrderQty"] ? BigDecimal(raw["origQuoteOrderQty"].to_s) : nil
+        quote_amount = nil if quote_amount&.zero?
+
+        amount_exec = BigDecimal(raw["executedQty"].to_s)
+        quote_amount_exec = BigDecimal(raw["cummulativeQuoteQty"].to_s)
+        quote_amount_exec = nil if quote_amount_exec.negative?
+
+        price = BigDecimal(raw["price"].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" then :cancelled
+        when "REJECTED" then :failed
+        else :unknown
+        end
+      end
+
       def validate_trading_credentials
         result = account_information
         result.success? ? Result::Success.new(true) : Result::Failure.new("Invalid trading credentials")

data/lib/honeymaker/version.rb

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

data/lib/honeymaker.rb

@@ -23,6 +23,7 @@ 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"
 require_relative "honeymaker/exchanges/binance_us"
 require_relative "honeymaker/exchanges/kraken"
@@ -72,7 +73,8 @@ module Honeymaker
     "bingx" => Clients::BingX,
     "bitrue" => Clients::Bitrue,
     "bitmart" => Clients::BitMart,
-    "hyperliquid" => Clients::Hyperliquid
+    "hyperliquid" => Clients::Hyperliquid,
+    "kraken_futures" => Clients::KrakenFutures
   }.freeze
 
   def self.exchange(name)

data/test/honeymaker/clients/binance_client_test.rb

@@ -22,13 +22,20 @@ class Honeymaker::Clients::BinanceTest < Minitest::Test
     stub_connection(:post, { "orderId" => 123, "status" => "FILLED" })
     result = @client.new_order(symbol: "BTCUSDT", side: "BUY", type: "MARKET", quantity: "0.001")
     assert result.success?
-    assert_equal 123, result.data["orderId"]
+    assert_equal "BTCUSDT-123", result.data[:order_id]
+    assert_equal 123, result.data[:raw]["orderId"]
   end
 
   def test_query_order
-    stub_connection(:get, { "orderId" => 123, "status" => "FILLED" })
+    stub_connection(:get, {
+      "orderId" => 123, "symbol" => "BTCUSDT", "status" => "FILLED", "type" => "MARKET",
+      "side" => "BUY", "origQty" => "0.001", "origQuoteOrderQty" => "0",
+      "executedQty" => "0.001", "cummulativeQuoteQty" => "50", "price" => "50000"
+    })
     result = @client.query_order(symbol: "BTCUSDT", order_id: 123)
     assert result.success?
+    assert_equal :closed, result.data[:status]
+    assert_equal :buy, result.data[:side]
   end
 
   def test_account_information

data/test/honeymaker/clients/bitget_client_test.rb

@@ -36,21 +36,27 @@ class Honeymaker::Clients::BitgetTest < Minitest::Test
   end
 
   def test_place_order
-    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    stub_connection(:post, { "code" => "00000", "data" => { "orderId" => "123" } })
     result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", size: "0.001")
     assert result.success?
+    assert_equal "123", result.data[:order_id]
   end
 
   def test_place_order_with_quote_size
-    stub_connection(:post, { "data" => { "orderId" => "456" } })
+    stub_connection(:post, { "code" => "00000", "data" => { "orderId" => "456" } })
     result = @client.place_order(symbol: "BTCUSDT", side: "buy", order_type: "market", quote_size: "100")
     assert result.success?
+    assert_equal "456", result.data[:order_id]
   end
 
   def test_get_order
-    stub_connection(:get, { "data" => [{ "orderId" => "123" }] })
+    stub_connection(:get, { "code" => "00000", "data" => [{
+      "orderId" => "123", "orderType" => "market", "side" => "buy", "status" => "full_fill",
+      "priceAvg" => "50000", "size" => "0.001", "baseVolume" => "0.001", "quoteVolume" => "50"
+    }] })
     result = @client.get_order(order_id: "123")
     assert result.success?
+    assert_equal :closed, result.data[:status]
   end
 
   def test_cancel_order

data/test/honeymaker/clients/bitmart_client_test.rb

@@ -36,15 +36,20 @@ class Honeymaker::Clients::BitMartTest < Minitest::Test
   end
 
   def test_submit_order
-    stub_connection(:post, { "data" => { "order_id" => 123 } })
+    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, { "data" => { "order_id" => 123 } })
+    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

data/test/honeymaker/clients/bitvavo_client_test.rb

@@ -23,9 +23,9 @@ class Honeymaker::Clients::BitvavoTest < Minitest::Test
     assert result.success?
   end
 
-  def test_get_balance
+  def test_get_raw_balance
     stub_connection(:get, [{ "symbol" => "BTC", "available" => "0.5" }])
-    result = @client.get_balance
+    result = @client.get_raw_balance
     assert result.success?
   end
 

data/test/honeymaker/clients/bybit_client_test.rb

@@ -30,16 +30,20 @@ class Honeymaker::Clients::BybitTest < Minitest::Test
   end
 
   def test_create_order
-    stub_connection(:post, { "result" => { "orderId" => "123" } })
+    stub_connection(:post, { "retCode" => 0, "retMsg" => "OK", "result" => { "orderId" => "123" } })
     result = @client.create_order(category: "spot", symbol: "BTCUSDT", side: "Buy", order_type: "Market", qty: "0.001")
     assert result.success?
-    assert_equal "123", result.data["result"]["orderId"]
+    assert_equal "123", result.data[:order_id]
   end
 
   def test_get_order
-    stub_connection(:get, { "result" => { "list" => [{ "orderId" => "123" }] } })
+    stub_connection(:get, { "retCode" => 0, "retMsg" => "OK", "result" => { "list" => [{
+      "orderId" => "123", "orderType" => "Market", "side" => "Buy", "orderStatus" => "Filled",
+      "avgPrice" => "50000", "qty" => "0.001", "cumExecQty" => "0.001", "cumExecValue" => "50"
+    }] } })
     result = @client.get_order(category: "spot", order_id: "123")
     assert result.success?
+    assert_equal :closed, result.data[:status]
   end
 
   def test_cancel_order

data/test/honeymaker/clients/coinbase_client_test.rb

@@ -17,19 +17,26 @@ class Honeymaker::Clients::CoinbaseTest < Minitest::Test
   end
 
   def test_get_order
-    stub_connection(:get, { "order" => { "order_id" => "abc", "status" => "FILLED" } })
+    stub_connection(:get, { "order" => {
+      "order_id" => "abc", "status" => "FILLED", "order_type" => "MARKET", "side" => "BUY",
+      "average_filled_price" => "50000", "filled_size" => "0.001",
+      "total_value_after_fees" => "50", "outstanding_hold_amount" => "0",
+      "order_configuration" => { "market_market_ioc" => { "quote_size" => "50" } }
+    } })
     result = @client.get_order(order_id: "abc")
     assert result.success?
-    assert_equal "abc", result.data["order"]["order_id"]
+    assert_equal "abc", result.data[:order_id]
+    assert_equal :closed, result.data[:status]
   end
 
   def test_create_order
-    stub_connection(:post, { "success" => true, "order_id" => "xyz" })
+    stub_connection(:post, { "success" => true, "success_response" => { "order_id" => "xyz" } })
     result = @client.create_order(
       client_order_id: "c1", product_id: "BTC-USD",
       side: "BUY", order_configuration: { market_market_ioc: { quote_size: "100" } }
     )
     assert result.success?
+    assert_equal "xyz", result.data[:order_id]
   end
 
   def test_cancel_orders

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 14, Honeymaker::CLIENTS.size
+    assert_equal 15, Honeymaker::CLIENTS.size
   end
 
   def test_client_passes_credentials

data/test/honeymaker/clients/kraken_client_test.rb

@@ -31,7 +31,8 @@ class Honeymaker::Clients::KrakenTest < Minitest::Test
     stub_connection(:post, { "error" => [], "result" => { "txid" => ["ORDER-123"] } })
     result = @client.add_order(ordertype: "market", type: "buy", volume: "0.001", pair: "XBTUSDT")
     assert result.success?
-    assert_equal ["ORDER-123"], result.data["result"]["txid"]
+    assert_equal "ORDER-123", result.data[:order_id]
+    assert_equal ["ORDER-123"], result.data[:raw]["result"]["txid"]
   end
 
   def test_cancel_order

data/test/honeymaker/clients/kraken_futures_client_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class Honeymaker::Clients::KrakenFuturesTest < Minitest::Test
+  def setup
+    @client = Honeymaker::Clients::KrakenFutures.new(
+      api_key: "test_key",
+      api_secret: Base64.strict_encode64("test_secret_key_1234567890123456")
+    )
+  end
+
+  def test_url
+    assert_equal "https://futures.kraken.com", Honeymaker::Clients::KrakenFutures::URL
+  end
+
+  def test_get_accounts
+    stub_connection(:get, { "result" => "success", "accounts" => {} })
+    result = @client.get_accounts
+    assert result.success?
+  end
+
+  def test_get_fills
+    stub_connection(:get, { "result" => "success", "fills" => [] })
+    result = @client.get_fills
+    assert result.success?
+  end
+
+  def test_get_open_positions
+    stub_connection(:get, { "result" => "success", "openPositions" => [] })
+    result = @client.get_open_positions
+    assert result.success?
+  end
+
+  def test_historical_funding_rates
+    stub_connection(:get, { "result" => "success", "rates" => [] })
+    result = @client.historical_funding_rates(symbol: "PF_XBTUSD")
+    assert result.success?
+  end
+
+  def test_client_registered
+    client = Honeymaker.client("kraken_futures", api_key: "k", api_secret: Base64.strict_encode64("s" * 32))
+    assert_instance_of Honeymaker::Clients::KrakenFutures, client
+  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/clients/kucoin_client_test.rb

@@ -36,15 +36,21 @@ class Honeymaker::Clients::KucoinTest < Minitest::Test
   end
 
   def test_place_order
-    stub_connection(:post, { "data" => { "orderId" => "123" } })
+    stub_connection(:post, { "code" => "200000", "data" => { "orderId" => "123" } })
     result = @client.place_order(client_oid: "c1", side: "buy", symbol: "BTC-USDT", type: "market", funds: "100")
     assert result.success?
+    assert_equal "123", result.data[:order_id]
   end
 
   def test_get_order
-    stub_connection(:get, { "data" => { "id" => "123", "isActive" => false } })
+    stub_connection(:get, { "code" => "200000", "data" => {
+      "id" => "123", "symbol" => "BTC-USDT", "type" => "market", "side" => "buy",
+      "isActive" => false, "cancelExist" => false, "dealSize" => "0.001",
+      "dealFunds" => "50", "size" => "0.001", "price" => "50000"
+    } })
     result = @client.get_order(order_id: "123")
     assert result.success?
+    assert_equal :closed, result.data[:status]
   end
 
   def test_cancel_order

data/test/honeymaker/clients/mexc_client_test.rb

@@ -36,9 +36,14 @@ class Honeymaker::Clients::MexcTest < Minitest::Test
   end
 
   def test_query_order
-    stub_connection(:get, { "orderId" => "123", "status" => "FILLED" })
+    stub_connection(:get, {
+      "orderId" => "123", "symbol" => "BTCUSDT", "status" => "FILLED", "type" => "MARKET",
+      "side" => "BUY", "origQty" => "0.001", "executedQty" => "0.001",
+      "cummulativeQuoteQty" => "50", "price" => "50000"
+    })
     result = @client.query_order(symbol: "BTCUSDT", order_id: "123")
     assert result.success?
+    assert_equal :closed, result.data[:status]
   end
 
   def test_cancel_order