honeymaker 0.9.7 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 632a9bc63075c21713722ff28baece102104084e83a6b20675c7a0604c0a49e6
-  data.tar.gz: 4d2d63654b5fedd397945f72dd21eca95ca2762b1f658f73cf80b02cb1a7285b
+  metadata.gz: ed9b0709acd948d270d3d3a56c6ebc829f85e89d22705bf7df6701f73cdff8c5
+  data.tar.gz: be9a09290fec662246e8e8577290d360cd79fd508ade8714f3b907f5fb0ee034
 SHA512:
-  metadata.gz: 3a5f15c7d5163ef0013998fa7cccb81aa661018ff65561d7d55e606c7e70969e4172fca70ec3cfdc1529ad03c4637c69b6bff2eefaa9586627710aefe15710a1
-  data.tar.gz: 15b53a301be6c936a90d3ac96c505ebe9946448783d07fbfb4832d5e294e6ca2cd44bd726e86f7fa34eda0074b1febf24142c2206f0e743d3edda9609e091f26
+  metadata.gz: 307536ee43e2d581eb48fcc265d2c30907a55531d272a526469f16e22486ad2d10955c5aa61b9c9c81c4c1b7134fcad0b44a4ba60a04456fd4522cff77e699da
+  data.tar.gz: e39fe73a3b4ca2a418428efa29053a9e552345c331c0ab476db5cfc92ebbe91ee02d624403c74e9ae7ae6f497b48ab2ac5d32d2a411adfb564a2800b9bd38421

data/lib/honeymaker/clients/kraken.rb

@@ -121,6 +121,47 @@ module Honeymaker
         })
       end
 
+      # Reconcile orders that QueryOrders has already dropped (Kraken removes terminal
+      # orders within hours) against TradesHistory, which is authoritative for executions
+      # and effectively unbounded in retention. Returns ONLY orders that actually executed,
+      # keyed by ordertxid, each as a per-order executed aggregate. Orders with no trades
+      # (never filled / truly gone) are simply absent from the result.
+      #
+      # `start` should be a unix timestamp bounding the lookback (e.g. the order's creation
+      # time) so we don't page the user's entire trade history.
+      def closed_orders_from_trades(order_ids:, start: nil, max_pages: 20)
+        wanted = Array(order_ids)
+        return Result::Success.new({}) if wanted.empty?
+
+        by_order = Hash.new { |h, k| h[k] = [] }
+        offset = 0
+        pages = 0
+        loop do
+          result = get_trades_history(start: start, ofs: offset)
+          return result if result.failure?
+
+          errors = result.data["error"]
+          return Result::Failure.new(*errors) if errors.is_a?(Array) && errors.any?
+
+          trades = result.data.dig("result", "trades") || {}
+          break if trades.empty?
+
+          trades.each_value do |t|
+            otxid = t["ordertxid"]
+            by_order[otxid] << t if wanted.include?(otxid)
+          end
+
+          # Do NOT early-exit when each id has been *seen* — a partial fill can have trades on
+          # later pages. Page the whole [start, now] window (bounded by `start` + max_pages).
+          pages += 1
+          offset += trades.size
+          count = result.data.dig("result", "count").to_i
+          break if offset >= count || pages >= max_pages
+        end
+
+        Result::Success.new(by_order.transform_values { |trades| aggregate_trades(trades) })
+      end
+
       def get_withdraw_addresses(asset: nil, method: nil)
         post_private("/0/private/WithdrawAddresses", { nonce: nonce, asset: asset, method: method })
       end
@@ -145,6 +186,29 @@ module Honeymaker
 
       private
 
+      def aggregate_trades(trades)
+        first = trades.first
+        vol  = trades.sum { |t| BigDecimal(t["vol"].to_s) }
+        cost = trades.sum { |t| BigDecimal(t["cost"].to_s) }
+        fee  = trades.sum { |t| BigDecimal(t["fee"].to_s) }
+        {
+          order_id: first["ordertxid"],
+          status: :closed,                       # only executed orders reach here
+          side: first["type"]&.to_sym,           # buy / sell
+          order_type: parse_order_type(first["ordertype"]),
+          price: vol.zero? ? nil : cost / vol,   # VWAP across (partial) fills
+          amount: nil,                           # original order size unknown from trades
+          quote_amount: nil,
+          amount_exec: vol,
+          quote_amount_exec: cost,
+          fee: fee,
+          pair: first["pair"],
+          trade_count: trades.size,
+          last_trade_at: trades.map { |t| t["time"].to_f }.max,
+          raw: { "trades" => trades }
+        }
+      end
+
       def normalize_order(order_id, raw)
         descr = raw["descr"] || {}
         order_type = parse_order_type(descr["ordertype"])

data/lib/honeymaker/version.rb

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

data/test/honeymaker/clients/kraken_client_test.rb

@@ -126,6 +126,53 @@ class Honeymaker::Clients::KrakenTest < Minitest::Test
     assert_equal first_key_first_nonce, second_key_first_nonce
   end
 
+  def test_closed_orders_from_trades_aggregates_partial_fills
+    page = { "error" => [], "result" => { "count" => 2, "trades" => {
+      "TID-1" => { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy",
+                   "ordertype" => "limit", "price" => "60000.0", "cost" => "6.0",
+                   "vol" => "0.0001", "fee" => "0.01", "time" => 1_700_000_000.0 },
+      "TID-2" => { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy",
+                   "ordertype" => "limit", "price" => "61000.0", "cost" => "4.0",
+                   "vol" => "0.00006557", "fee" => "0.006", "time" => 1_700_000_100.0 } } } }
+    stub_connection(:post, page)
+    result = @client.closed_orders_from_trades(order_ids: ["OABC"], start: 1_699_999_000)
+    assert result.success?
+    agg = result.data["OABC"]
+    assert_equal :closed, agg[:status]
+    assert_equal :buy, agg[:side]
+    assert_equal :limit, agg[:order_type]
+    assert_equal BigDecimal("10.0"), agg[:quote_amount_exec]          # 6 + 4
+    assert_equal BigDecimal("0.00016557"), agg[:amount_exec]          # summed vol
+    assert_equal BigDecimal("0.016"), agg[:fee]                       # 0.01 + 0.006
+    assert_equal BigDecimal("10.0") / BigDecimal("0.00016557"), agg[:price] # VWAP = cost/vol
+    assert_equal "XXBTZUSD", agg[:pair]
+  end
+
+  def test_closed_orders_from_trades_ignores_unrelated_orders
+    stub_connection(:post, { "error" => [], "result" => { "count" => 1, "trades" => {
+      "TID-9" => { "ordertxid" => "OOTHER", "pair" => "XXBTZUSD", "type" => "buy",
+                   "ordertype" => "limit", "price" => "1", "cost" => "1", "vol" => "1",
+                   "fee" => "0", "time" => 1_700_000_000.0 } } } })
+    result = @client.closed_orders_from_trades(order_ids: ["OABC"], start: 1)
+    assert result.success?
+    assert_empty result.data
+  end
+
+  def test_closed_orders_from_trades_aggregates_partial_fills_across_pages
+    page1 = Honeymaker::Result::Success.new({ "error" => [], "result" => { "count" => 2, "trades" => {
+      "TID-1" => { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy", "ordertype" => "limit",
+                   "price" => "60000.0", "cost" => "6.0", "vol" => "0.0001", "fee" => "0.01", "time" => 1.0 } } } })
+    page2 = Honeymaker::Result::Success.new({ "error" => [], "result" => { "count" => 2, "trades" => {
+      "TID-2" => { "ordertxid" => "OABC", "pair" => "XXBTZUSD", "type" => "buy", "ordertype" => "limit",
+                   "price" => "61000.0", "cost" => "4.0", "vol" => "0.00006557", "fee" => "0.006", "time" => 2.0 } } } })
+    @client.stubs(:get_trades_history).returns(page1, page2)  # Mocha returns successive values per call
+    result = @client.closed_orders_from_trades(order_ids: ["OABC"], start: 1, max_pages: 5)
+    assert result.success?
+    agg = result.data["OABC"]
+    assert_equal BigDecimal("10.0"), agg[:quote_amount_exec]        # 6 + 4 across both pages
+    assert_equal BigDecimal("0.00016557"), agg[:amount_exec]
+  end
+
   private
 
   def assert_strictly_increasing(values)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.9
 platform: ruby
 authors:
 - Deltabadger