@logswap/sdk 0.5.57 → 0.5.58

package/dist/fees.d.ts

@@ -30,7 +30,17 @@ export interface SwapFeeWindow {
     swapFees: bigint;
     swaps: number;
 }
-/** The first block with timestamp ≥ `t`, by bisection over `[lo, hi]`; `hi` when none is earlier. */
+/**
+ * The first block with timestamp ≥ `t` in `[lo, hi]`; `hi` when none is earlier.
+ *
+ * A PARALLEL search: each round reads {@link PROBES} evenly spaced blocks at once and keeps the
+ * sixteenth of the bracket that holds the answer, so 64k blocks take 4 round trips. Bisection read
+ * one block per round trip — ~16 sequential `getBlock`s, seconds apiece against a distant node,
+ * before a fee figure could render. Interpolating on timestamps was tried and did no better: a
+ * devnet mines on demand plus a heartbeat, so its blocks are far from evenly spaced in time.
+ * Exact for monotonic timestamps; a chain restored from a snapshot can carry a genesis stamped
+ * after its later blocks, so callers bound `lo` by the block they care about (a pool's own).
+ */
 export declare function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi: bigint): Promise<bigint>;
 /**
  * Sum the swap fees of market `m` over a window: from `since` (unix seconds) or `fromBlock`, to

package/dist/fees.js

@@ -17,16 +17,42 @@ const YEAR_SECONDS = 31_536_000;
 export function swapFeeOf(e, phi) {
     return e.baseIn ? (e.amountOut * phi) / (WAD - phi) : (e.amountIn * phi) / (WAD + phi);
 }
-/** The first block with timestamp ≥ `t`, by bisection over `[lo, hi]`; `hi` when none is earlier. */
+/** Probes per round of {@link blockAtOrAfter}: 15 splits the bracket 16 ways. */
+const PROBES = 15n;
+/**
+ * The first block with timestamp ≥ `t` in `[lo, hi]`; `hi` when none is earlier.
+ *
+ * A PARALLEL search: each round reads {@link PROBES} evenly spaced blocks at once and keeps the
+ * sixteenth of the bracket that holds the answer, so 64k blocks take 4 round trips. Bisection read
+ * one block per round trip — ~16 sequential `getBlock`s, seconds apiece against a distant node,
+ * before a fee figure could render. Interpolating on timestamps was tried and did no better: a
+ * devnet mines on demand plus a heartbeat, so its blocks are far from evenly spaced in time.
+ * Exact for monotonic timestamps; a chain restored from a snapshot can carry a genesis stamped
+ * after its later blocks, so callers bound `lo` by the block they care about (a pool's own).
+ */
 export async function blockAtOrAfter(c, t, lo, hi) {
-    while (lo < hi) {
-        const mid = (lo + hi) / 2n;
-        if ((await c.public.getBlock({ blockNumber: mid })).timestamp < t)
-            lo = mid + 1n;
-        else
-            hi = mid;
+    if (lo >= hi)
+        return hi;
+    const stamp = async (n) => (await c.public.getBlock({ blockNumber: n })).timestamp;
+    if ((await stamp(lo)) >= t)
+        return lo;
+    // invariant from here: ts(lo) < t, and the answer is in (lo, hi]
+    while (hi - lo > 1n) {
+        const width = hi - lo;
+        const probes = [...new Set(Array.from({ length: Number(PROBES) }, (_, i) => lo + (width * BigInt(i + 1)) / (PROBES + 1n)))].filter((n) => n > lo && n < hi);
+        if (probes.length === 0)
+            probes.push(lo + width / 2n);
+        const stamps = await Promise.all(probes.map(stamp));
+        const first = stamps.findIndex((ts) => ts >= t);
+        if (first === -1)
+            lo = probes[probes.length - 1];
+        else {
+            hi = probes[first];
+            if (first > 0)
+                lo = probes[first - 1];
+        }
     }
-    return lo;
+    return hi;
 }
 /**
  * Sum the swap fees of market `m` over a window: from `since` (unix seconds) or `fromBlock`, to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.57",
+  "version": "0.5.58",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/fees.ts

@@ -36,14 +36,40 @@ export interface SwapFeeWindow {
   swaps: number;
 }
 
-/** The first block with timestamp ≥ `t`, by bisection over `[lo, hi]`; `hi` when none is earlier. */
+/** Probes per round of {@link blockAtOrAfter}: 15 splits the bracket 16 ways. */
+const PROBES = 15n;
+
+/**
+ * The first block with timestamp ≥ `t` in `[lo, hi]`; `hi` when none is earlier.
+ *
+ * A PARALLEL search: each round reads {@link PROBES} evenly spaced blocks at once and keeps the
+ * sixteenth of the bracket that holds the answer, so 64k blocks take 4 round trips. Bisection read
+ * one block per round trip — ~16 sequential `getBlock`s, seconds apiece against a distant node,
+ * before a fee figure could render. Interpolating on timestamps was tried and did no better: a
+ * devnet mines on demand plus a heartbeat, so its blocks are far from evenly spaced in time.
+ * Exact for monotonic timestamps; a chain restored from a snapshot can carry a genesis stamped
+ * after its later blocks, so callers bound `lo` by the block they care about (a pool's own).
+ */
 export async function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi: bigint): Promise<bigint> {
-  while (lo < hi) {
-    const mid = (lo + hi) / 2n;
-    if ((await c.public.getBlock({ blockNumber: mid })).timestamp < t) lo = mid + 1n;
-    else hi = mid;
+  if (lo >= hi) return hi;
+  const stamp = async (n: bigint) => (await c.public.getBlock({ blockNumber: n })).timestamp;
+  if ((await stamp(lo)) >= t) return lo;
+  // invariant from here: ts(lo) < t, and the answer is in (lo, hi]
+  while (hi - lo > 1n) {
+    const width = hi - lo;
+    const probes = [...new Set(Array.from({ length: Number(PROBES) }, (_, i) => lo + (width * BigInt(i + 1)) / (PROBES + 1n)))].filter(
+      (n) => n > lo && n < hi,
+    );
+    if (probes.length === 0) probes.push(lo + width / 2n);
+    const stamps = await Promise.all(probes.map(stamp));
+    const first = stamps.findIndex((ts) => ts >= t);
+    if (first === -1) lo = probes[probes.length - 1]!;
+    else {
+      hi = probes[first]!;
+      if (first > 0) lo = probes[first - 1]!;
+    }
   }
-  return lo;
+  return hi;
 }
 
 /**