@dcasegr/amm-client 0.39.0 → 0.41.1

package/dist/lib/overlay.js

@@ -8,13 +8,13 @@
  *
  * | # | route | answer |
  * |---|---|---|
- * | P1 | `GET <origin>/amm/pools` (and as an event stream) | `[{tokenId, …P2 row}]`, every enabled token's live pools (the host's) |
- * | P2 | `GET <origin>/@<token>/amm/pools` (and as an event stream) | `{market: {commissionPkh, minCommissionBps}, validators: [{identity, peerId}] (0.34.1: beating now), pools: [{lpPubKey, outpoint, bsvReserve, tokenReserve, liquidityFeeBps, validationFeeBps, commissionBps, validatorIdentityKey, validatorPeerId}]}`: only pools whose validator beats now and whose commission is at or above the market's minimum (the host's) |
- * | P3 | `GET /@<token>/amm/pools/beef?lp=k1,k2` | `{pools: [P2 row without validatorPeerId], beef: <base64 BEEF of their transactions>}` |
- * | P4 | `GET /@<token>/amm/positions?lp=k1,k2` | `[{lpPubKey, status: live|rescinded|closed, outpoint?, current?, sats, tokens, swaps}]` |
+ * | P1 | `GET <origin>/amm/pools` | `[{tokenId, …P2 row}]`, every enabled token's live pools (the host's) |
+ * | P2 | `GET <origin>/@<token>/amm/pools` (0.41.0: a plain read only) | `{market: {commissionPkh, minCommissionBps}, validators: [{identity, peerId, minLegSats?}] (0.34.1: beating now; 0.40.0: the minimum leg its terms announce), pools: [{poolId, lpPubKey, outpoint, bsvReserve, tokenReserve, liquidityFeeBps, validationFeeBps, commissionBps, validatorIdentityKey, validatorPeerId, swaps}]}`: only pools whose validator beats now and whose commission is at or above the market's minimum (the host's) |
+ * | P3 | `GET /@<token>/amm/pools/beef?pool=id1,id2` (0.40.0: by pool id) | `{pools: [P2 row without validatorPeerId], beef: <base64 BEEF of their transactions>}` |
+ * | P4 | `GET /@<token>/amm/positions?pool=id1,id2` (0.40.0) | `[{poolId, lpPubKey, status: live|rescinded|closed, outpoint?, current?, sats, tokens, swaps}]` |
  * | P5 | `GET /@<token>/amm/fees/validator?id=k1,k2` | `[{validatorIdentityKey, sats, tokens, swaps, pools}]` |
  * | P6 | `GET /@<token>/amm/fees/commission?pkh=h1,h2` | `[{commissionPkh, sats, tokens, swaps}]` |
- * | P7 | `GET /@<token>/amm/terms` | `{validator: {identity, peerId, lpFeeBps, validatorFeeBps, commissionBps} | null, market: {commissionPkh, minCommissionBps}}` |
+ * | P7 | `GET /@<token>/amm/terms` | `{validator: {identity, peerId, lpFeeBps, validatorFeeBps, commissionBps, minLegSats} | null, market: {commissionPkh, minCommissionBps}}` |
  * | P8 | `GET /@<token>/amm/spends?outpoint=a,b` | `[{outpoint, spentBy?, current?, hops, closed}]` (one outpoint: the object) |
  * | P9 | `GET /@<token>/amm/tx?id=<txid>` | the transaction's BEEF (bytes) |
  * | P10 | `GET /@<token>/amm/swaps?id=<id>` | the relay record, as `amm.swap.status` answers it |
@@ -25,16 +25,24 @@
  * | P15 | `GET /@discovery/1color/<token>/icon` | the icon's bytes |
  * | P16 | `GET /@discovery/1color/<token>/deploy` | the deploy's BEEF (bytes) |
  * | P17 | `GET <origin>/.well-known/skein`, `/skeins?key=`, `/amm/admin`, `/amm/defaults`, `/amm/discovery` | as before |
- * | H1 | `GET /@<token>/amm/trades?from=&to=&limit=&before=&lp=` (or `?txid=`) | `{trades: [Trade], next}` newest first (one txid: the row) |
- * | H2 | `GET /@<token>/amm/candles?tf=&from=&to=` | `[{t, o, h, l, c, volumeSats, volumeTokens, n}]`, one per non-empty bucket |
- * | H3 | `GET /@<token>/amm/stats` | `{tokenId, price, change1h, change24h, volume24hSats, volume24hTokens, buys24h, sells24h, lastTradeAt, tvlSats, tvlTokens, pools}` |
+ * | H1 | `GET /@<token>/amm/trades?from=&to=&limit=&before=&pool=` (or `?txid=`) | `{trades: [Trade], next}` newest first (one txid: the row) |
+ * | H2 | `GET /@<token>/amm/candles?tf=&from=&to=&series=fill|market` | `[{t, o, h, l, c, volumeSats, volumeTokens, n}]`, one per non-empty bucket (0.40.0: `market`, the host's: the price after each pool event) |
+ * | H3 | `GET /@<token>/amm/stats` | `{tokenId, price, buyPrice, sellPrice, lastTradePrice, change1h, change24h, volume24hSats, volume24hTokens, buys24h, sells24h, lastTradeAt, tvlSats, tvlTokens, pools}` |
  * | H4 | `GET <origin>/amm/stats?ids=` | `[H3]`, every enabled token's (the host's) |
- * | H5 | `GET <origin>/amm/positions?lp=` | `[{tokenId, …P4 row}]`, every enabled token's (the host's) |
+ * | H5 | `GET <origin>/amm/positions?pool=` | `[{tokenId, …P4 row}]`, every enabled token's (the host's) |
+ * | H7 | `GET /@<token>/amm/pools/at?t=<ms>` (0.40.0) | `[{poolId, outpoint, bsvReserve, tokenReserve, lpPubKey, …the three bps, validatorIdentityKey, at, swaps}]`: every pool listed at `t` |
+ * | H8 | `GET /@<token>/amm/pools/history?from=&to=&pool=&limit=&after=` (0.40.0) | `{events: [PoolEvent], next}` oldest first; `next` → `after` |
+ * | H9 | `GET <origin>/amm/spends?outpoint=a,b` (0.40.0, the host's) | `[{outpoint, tokenId?, spentBy?}]`: each enabled token's `/spends`, the first that names a spender |
  * | H6 | `GET /@<token>/amm/color/<token>/holders?limit=&skip=` | `{count, rows: [{address, balance}]}` largest first |
+ * | E1 | `GET /@<token>/amm/events`, `GET <origin>/amm/events` (0.41.0, the host's) | Server-Sent Events, each `event: pool`, `data: {tokenId, …row}`: the AMM lookup's pool event (a deploy, swap, close or rescind: the H8 row; a `revert`), one token's or every enabled token's; nothing on connect, nothing replayed |
  *
- * 0.39.0 (agent-env plans/history-api-2026-11-05.md D7): P2's stream sends the whole answer once
- * (`pools`), then ONE `change` per pool change (`{kind, outpoint, pool?, trade?}`); the host-wide
- * stream is gone (P1, H4 and H5 are plain reads).
+ * 0.41.0 (agent-env plans/swap-balance-build-2026-11-05.md §5): P2's event-stream form is gone
+ * (0.39.0's `pools` / `change` events); the pool events are the lookup's, passed through by the
+ * host's feeds (E1): signals for display, the pools route the truth.
+ *
+ * 0.40.0 (agent-env plans/swap-balance-build-2026-11-05.md §0 3): a pool's id is its deploy outpoint
+ * `<txid>_<vout>` (`poolId`, copied forward along its swaps); every read by LP key is by pool id
+ * now (`?pool=`), the LP key a field. A clean break: no `?lp=` here.
  *
  * Writes stay what they were: `POST <origin>/submit` (BRC-22, plain), `/call` and `/sendMessage`
  * (signed, the wallet's BRC-104 client).
@@ -83,7 +91,9 @@ export function toPoolRow(raw) {
         return null;
     return {
         ...toPoolState(raw),
+        poolId: typeof raw.poolId === "string" ? raw.poolId.toLowerCase() : "",
         lpPubKey: typeof raw.lpPubKey === "string" ? raw.lpPubKey.toLowerCase() : "",
+        swaps: Number(raw.swaps ?? 0),
         ...(typeof raw.validatorPeerId === "string" && raw.validatorPeerId ? { validatorPeerId: raw.validatorPeerId } : {}),
         ...(typeof raw.tokenId === "string" ? { tokenId: raw.tokenId } : {}),
     };
@@ -102,7 +112,10 @@ export function parsePools(x) {
     const a = x;
     const validators = (Array.isArray(a?.validators) ? a.validators : [])
         .filter((v) => v && typeof v.identity === "string")
-        .map((v) => ({ identity: String(v.identity).toLowerCase(), peerId: typeof v.peerId === "string" ? v.peerId : "" }));
+        .map((v) => {
+        const min = typeof v.minLegSats === "number" || typeof v.minLegSats === "string" ? BigInt(v.minLegSats) : 0n;
+        return { identity: String(v.identity).toLowerCase(), peerId: typeof v.peerId === "string" ? v.peerId : "", ...(min > 0n ? { minLegSats: min } : {}) };
+    });
     return { market: toMarket(a?.market), pools: poolRows(a?.pools), validators };
 }
 /** P1's JSON: every enabled token's rows, each naming its `tokenId`. */
@@ -141,7 +154,7 @@ const list = (xs) => xs.map(encodeURIComponent).join(",");
 export function poolsUrl(base) {
     return `${trim(base)}/pools`;
 }
-/** P2 once (a one-shot reader; the Swap page holds the stream, `watchPools`). */
+/** P2: the token's pools as the host lists them now (0.41.0: a plain read only). */
 export async function readPools(base, fetchFn) {
     return parsePools(await getJson(poolsUrl(base), fetchFn));
 }
@@ -149,89 +162,43 @@ function eventSourceCtor() {
     const g = globalThis;
     return typeof g.EventSource === "function" ? g.EventSource : null;
 }
+/** E1's URL: `<base>/events` (a token instance's app base: that token's; the swap app's: every token's). */
+export function eventsUrl(base) {
+    return `${trim(base)}/events`;
+}
 /**
- * Holds a pools route as an event stream (D16; 0.39.0, D7): `GET <url>` with `Accept:
- * text/event-stream` (the browser's EventSource sends it). The event `pools` carries the whole
- * answer (first the current one; again when the host cannot say what changed): it replaces the held
- * answer. With `change` (P2), the event `change` carries one pool change: `change(held, x)` applies
- * it to the held answer (null: it cannot); one it cannot apply (no answer held yet, an unknown
- * kind, a row it names not held) → the route is read again ONCE (a plain GET) and that answer is
- * held (changes arriving while it is read are dropped: the answer read is the newer state). Each
- * new held answer goes to `onAnswer`. Without an EventSource (an old browser, a test): ONE plain
- * GET, no poll. → the unsubscribe.
+ * Listens to a host's pool event feed (E1, 0.41.0): each `pool` message parsed
+ * (`parsePoolEventMessage`) to `onEvent`; one it cannot parse is passed over. Reconnecting is the
+ * browser's EventSource's. Without an EventSource: nothing. → the unsubscribe.
  */
-export function watchPools(url, parse, onAnswer, o = {}) {
+export function watchPoolEvents(url, onEvent, o = {}) {
     const ES = o.EventSource === undefined ? eventSourceCtor() : o.EventSource;
+    if (!ES)
+        return () => { };
     let stopped = false;
-    if (!ES) {
-        getJson(url, o.fetch).then((x) => {
-            if (!stopped)
-                onAnswer(parse(x));
-        }, (e) => {
-            if (!stopped)
-                o.onError?.(e);
-        });
-        return () => {
-            stopped = true;
-        };
-    }
-    let held = null;
-    let rereading = false;
-    const hold = (a) => {
-        held = a;
-        onAnswer(a);
-    };
-    const reread = () => {
-        rereading = true;
-        getJson(url, o.fetch).then((x) => {
-            rereading = false;
-            if (!stopped)
-                hold(parse(x));
-        }, (e) => {
-            rereading = false;
-            if (!stopped)
-                o.onError?.(e);
-        });
-    };
     const es = new ES(url);
-    es.addEventListener("pools", (e) => {
+    es.addEventListener("pool", (e) => {
         if (stopped)
             return;
+        let m = null;
         try {
-            hold(parse(JSON.parse(String(e.data))));
+            m = parsePoolEventMessage(JSON.parse(String(e.data)));
         }
-        catch (err) {
-            o.onError?.(err);
+        catch {
+            m = null;
         }
+        if (m)
+            onEvent(m);
     });
-    const apply = o.change;
-    if (apply) {
-        es.addEventListener("change", (e) => {
-            if (stopped || rereading)
-                return;
-            let next = null;
-            try {
-                next = held === null ? null : apply(held, JSON.parse(String(e.data)));
-            }
-            catch {
-                next = null;
-            }
-            if (next === null)
-                reread();
-            else
-                hold(next);
-        });
-    }
-    es.onopen = () => o.onOpen?.();
     es.onerror = (e) => o.onError?.(e);
     return () => {
         stopped = true;
         es.close();
     };
 }
-/** P3: `GET <base>/pools/beef?lp=k1,k2` (no `lpKeys`: every live pool). */
-export async function readPoolsBeef(base, lpKeys, fetchFn) {
-    const url = `${trim(base)}/pools/beef${lpKeys ? `?lp=${list(lpKeys)}` : ""}`;
+/** P3: `GET <base>/pools/beef?pool=id1,id2` (0.40.0: by pool id; no `poolIds`: every live pool). */
+export async function readPoolsBeef(base, poolIds, fetchFn) {
+    const url = `${trim(base)}/pools/beef${poolIds ? `?pool=${list(poolIds)}` : ""}`;
     const a = (await getJson(url, fetchFn));
     return { pools: poolRows(a?.pools), beef: typeof a?.beef === "string" && a.beef ? Utils.toArray(a.beef, "base64") : [] };
 }
@@ -246,24 +213,27 @@ export function poolOutputOf(pb, outpoint) {
     return { beef: beef.toBinaryAtomic(m[1].toLowerCase()), outputIndex: Number(m[2]) };
 }
 const wireBig = (x) => (typeof x === "number" || typeof x === "string" || typeof x === "bigint" ? BigInt(x) : 0n);
-/** P4: `GET <base>/positions?lp=k1,k2` → one record per key in the same order. */
-export async function readPositions(base, lpPubKeys, fetchFn) {
-    const url = `${trim(base)}/positions?lp=${list(lpPubKeys)}`;
+/** One P4 / H5 record. */
+function lpPoolOf(r, poolId) {
+    const status = r.status === "live" || r.status === "rescinded" ? r.status : "closed";
+    return {
+        poolId: typeof r.poolId === "string" ? r.poolId.toLowerCase() : poolId,
+        lpPubKey: typeof r.lpPubKey === "string" ? r.lpPubKey.toLowerCase() : null,
+        status,
+        outpoint: typeof r.outpoint === "string" ? r.outpoint : null,
+        current: isWirePool(r.current) ? toPoolState(r.current) : null,
+        sats: wireBig(r.sats),
+        tokens: wireBig(r.tokens),
+        swaps: Number(r.swaps ?? 0),
+    };
+}
+/** P4: `GET <base>/positions?pool=id1,id2` (0.40.0) → one record per pool id in the same order. */
+export async function readPositions(base, poolIds, fetchFn) {
+    const url = `${trim(base)}/positions?pool=${list(poolIds)}`;
     const a = await getJson(url, fetchFn);
-    if (!Array.isArray(a) || a.length !== lpPubKeys.length)
-        throw new Error(`GET ${url}: not one record per key`);
-    return a.map((r, i) => {
-        const status = r.status === "live" || r.status === "rescinded" ? r.status : "closed";
-        return {
-            lpPubKey: typeof r.lpPubKey === "string" ? r.lpPubKey : lpPubKeys[i],
-            status,
-            outpoint: typeof r.outpoint === "string" ? r.outpoint : null,
-            current: isWirePool(r.current) ? toPoolState(r.current) : null,
-            sats: wireBig(r.sats),
-            tokens: wireBig(r.tokens),
-            swaps: Number(r.swaps ?? 0),
-        };
-    });
+    if (!Array.isArray(a) || a.length !== poolIds.length)
+        throw new Error(`GET ${url}: not one record per pool`);
+    return a.map((r, i) => lpPoolOf(r, poolIds[i]));
 }
 /** P7: `GET <base>/terms`, unsigned. */
 export async function readTerms(base, fetchFn) {
@@ -283,6 +253,7 @@ export async function readTerms(base, fetchFn) {
                 lpFeeBps: int(v.lpFeeBps, "lpFeeBps"),
                 validatorFeeBps: int(v.validatorFeeBps, "validatorFeeBps"),
                 commissionBps: int(v.commissionBps, "commissionBps"),
+                minLegSats: typeof v.minLegSats === "number" && Number.isInteger(v.minLegSats) ? v.minLegSats : 0,
             }
             : null,
         market: toMarket(a?.market),
@@ -366,7 +337,9 @@ export function toTrade(x) {
         return null;
     return {
         txid: r.txid.toLowerCase(),
+        poolId: typeof r.poolId === "string" ? r.poolId.toLowerCase() : "",
         lpPubKey: r.lpPubKey.toLowerCase(),
+        payoutPkh: typeof r.payoutPkh === "string" ? r.payoutPkh.toLowerCase() : "",
         side: r.side,
         amountIn: wireBig(r.amountIn),
         amountOut: wireBig(r.amountOut),
@@ -396,6 +369,9 @@ export function toStats(x) {
     return {
         tokenId: r.tokenId,
         price: toPrice(r.price),
+        buyPrice: toPrice(r.buyPrice),
+        sellPrice: toPrice(r.sellPrice),
+        lastTradePrice: toPrice(r.lastTradePrice),
         change1h: intOrNull(r.change1h),
         change24h: intOrNull(r.change24h),
         volume24hSats: wireBig(r.volume24hSats),
@@ -408,59 +384,13 @@ export function toStats(x) {
         pools: int(r.pools),
     };
 }
-/** A `change` event's data, or null when it is not one this client knows. */
-export function parseChange(x) {
-    const r = x;
-    if (!r || typeof r !== "object" || typeof r.outpoint !== "string")
-        return null;
-    if (r.kind !== "deploy" && r.kind !== "swap" && r.kind !== "close" && r.kind !== "rescind")
-        return null;
-    const pool = r.pool === undefined ? null : toPoolRow(r.pool);
-    const trade = r.trade === undefined ? null : toTrade(r.trade);
-    return { kind: r.kind, outpoint: r.outpoint, ...(pool ? { pool } : {}), ...(trade ? { trade } : {}) };
-}
-const sameOutpoint = (a, b) => a.toLowerCase().replace(".", "_") === b.toLowerCase().replace(".", "_");
-/**
- * One `change` applied to a held P2 answer (D7) → the new answer, or null when it cannot be applied
- * (the caller reads the route again): `swap` — the row of `trade.lpPubKey` replaced by `pool` (its
- * outpoint moved); `deploy` — `pool` added; `close` / `rescind` — the row at `outpoint` removed.
- * The market and the validators are kept (a change of either comes as a whole `pools` answer).
- */
-export function applyPoolChange(held, x) {
-    const ch = parseChange(x);
-    if (!ch)
-        return null;
-    switch (ch.kind) {
-        case "swap": {
-            if (!ch.pool || !ch.trade)
-                return null;
-            const i = held.pools.findIndex((p) => p.lpPubKey === ch.trade.lpPubKey);
-            if (i < 0)
-                return null;
-            const pools = held.pools.slice();
-            pools[i] = ch.pool;
-            return { ...held, pools };
-        }
-        case "deploy":
-            if (!ch.pool)
-                return null;
-            return { ...held, pools: [...held.pools, ch.pool] };
-        case "close":
-        case "rescind": {
-            const pools = held.pools.filter((p) => !sameOutpoint(p.outpoint, ch.outpoint));
-            if (pools.length === held.pools.length)
-                return null;
-            return { ...held, pools };
-        }
-    }
-}
 const query = (q) => {
     const kv = Object.entries(q).filter(([, x]) => x !== undefined).map(([k, x]) => `${k}=${encodeURIComponent(String(x))}`);
     return kv.length ? `?${kv.join("&")}` : "";
 };
-/** H1: `GET <base>/trades?from=&to=&limit=&before=&lp=` → the page, newest first. */
+/** H1: `GET <base>/trades?from=&to=&limit=&before=&pool=` (0.40.0: `pool` one pool's) → the page, newest first. */
 export async function readTrades(base, o = {}, fetchFn) {
-    const a = (await getJson(`${trim(base)}/trades${query({ from: o.from, to: o.to, limit: o.limit, before: o.before, lp: o.lp })}`, fetchFn));
+    const a = (await getJson(`${trim(base)}/trades${query({ from: o.from, to: o.to, limit: o.limit, before: o.before, pool: o.pool })}`, fetchFn));
     return {
         trades: (Array.isArray(a?.trades) ? a.trades : []).map(toTrade).filter((t) => t !== null),
         next: typeof a?.next === "string" ? a.next : null,
@@ -476,9 +406,9 @@ export async function readTrade(base, txid, fetchFn) {
         throw new Error(`GET ${url}: ${res.status} ${(await res.text()).slice(0, 200)}`);
     return toTrade(await res.json());
 }
-/** H2: `GET <base>/candles?tf=&from=&to=` → one candle per non-empty bucket, oldest first. */
+/** H2: `GET <base>/candles?tf=&from=&to=&series=` → one candle per non-empty bucket, oldest first. */
 export async function readCandles(base, o, fetchFn) {
-    const a = await getJson(`${trim(base)}/candles${query({ tf: o.tf, from: o.from, to: o.to })}`, fetchFn);
+    const a = await getJson(`${trim(base)}/candles${query({ tf: o.tf, from: o.from, to: o.to, series: o.series })}`, fetchFn);
     return (Array.isArray(a) ? a : []).map(toCandle).filter((c) => c !== null);
 }
 /** H3: `GET <base>/stats`. */
@@ -502,21 +432,100 @@ export async function readHolders(base, tokenId, o = {}, fetchFn) {
         rows: (Array.isArray(a?.rows) ? a.rows : []).filter((r) => r && typeof r.address === "string").map((r) => ({ address: String(r.address), balance: wireBig(r.balance) })),
     };
 }
-/** H5: `GET <swap base>/positions?lp=k1,k2` → every enabled token's rows for the keys, each with its token. */
-export async function readAllPositions(swapBase, lpPubKeys, fetchFn) {
-    if (lpPubKeys.length === 0)
+/** H5: `GET <swap base>/positions?pool=id1,id2` (0.40.0) → every enabled token's rows for the pools, each with its token. */
+export async function readAllPositions(swapBase, poolIds, fetchFn) {
+    if (poolIds.length === 0)
         return [];
-    const a = await getJson(`${trim(swapBase)}/positions?lp=${list(lpPubKeys)}`, fetchFn);
+    const a = await getJson(`${trim(swapBase)}/positions?pool=${list(poolIds)}`, fetchFn);
     return (Array.isArray(a) ? a : [])
-        .filter((r) => r && typeof r.tokenId === "string" && typeof r.lpPubKey === "string")
+        .filter((r) => r && typeof r.tokenId === "string" && typeof r.poolId === "string")
+        .map((r) => ({ tokenId: String(r.tokenId), ...lpPoolOf(r, String(r.poolId)) }));
+}
+/** H7: `GET <base>/pools/at?t=<ms>` → every pool listed at `t`. */
+export async function readPoolsAt(base, t, fetchFn) {
+    const a = await getJson(`${trim(base)}/pools/at${query({ t })}`, fetchFn);
+    return (Array.isArray(a) ? a : []).flatMap((r) => {
+        const row = toPoolRow(r);
+        return row ? [{ ...row, at: int(r.at) }] : [];
+    });
+}
+function toPoolEvent(x) {
+    const r = x;
+    if (!r || typeof r !== "object" || typeof r.txid !== "string" || typeof r.poolId !== "string")
+        return null;
+    if (r.kind !== "deploy" && r.kind !== "swap" && r.kind !== "close" && r.kind !== "rescind")
+        return null;
+    const big = (k) => (r[k] === undefined || r[k] === null ? {} : { [k]: wireBig(r[k]) });
+    const text = (k) => (typeof r[k] === "string" ? { [k]: String(r[k]).toLowerCase() } : {});
+    return {
+        kind: r.kind,
+        txid: r.txid.toLowerCase(),
+        poolId: r.poolId.toLowerCase(),
+        ...(typeof r.outpoint === "string" ? { outpoint: r.outpoint } : {}),
+        ...big("bsvReserve"),
+        ...big("tokenReserve"),
+        lpPubKey: typeof r.lpPubKey === "string" ? r.lpPubKey.toLowerCase() : "",
+        liquidityFeeBps: wireBig(r.liquidityFeeBps),
+        validationFeeBps: wireBig(r.validationFeeBps),
+        commissionBps: wireBig(r.commissionBps),
+        validatorIdentityKey: typeof r.validatorIdentityKey === "string" ? r.validatorIdentityKey.toLowerCase() : "",
+        at: int(r.at),
+        swaps: int(r.swaps),
+        ...(r.side === "buy" || r.side === "sell" ? { side: r.side } : {}),
+        ...big("amountIn"),
+        ...big("amountOut"),
+        ...big("feeLp"),
+        ...big("feeValidator"),
+        ...big("feeCommission"),
+        ...text("commissionPkh"),
+        ...text("payoutPkh"),
+    };
+}
+function toPoolRevert(r) {
+    if (r.kind !== "revert" || typeof r.txid !== "string" || typeof r.poolId !== "string")
+        return null;
+    const base = { kind: "revert", txid: r.txid.toLowerCase(), poolId: r.poolId.toLowerCase(), at: int(r.at) };
+    if (typeof r.outpoint !== "string")
+        return base;
+    return {
+        ...base,
+        outpoint: r.outpoint,
+        bsvReserve: wireBig(r.bsvReserve),
+        tokenReserve: wireBig(r.tokenReserve),
+        lpPubKey: typeof r.lpPubKey === "string" ? r.lpPubKey.toLowerCase() : "",
+        liquidityFeeBps: wireBig(r.liquidityFeeBps),
+        validationFeeBps: wireBig(r.validationFeeBps),
+        commissionBps: wireBig(r.commissionBps),
+        validatorIdentityKey: typeof r.validatorIdentityKey === "string" ? r.validatorIdentityKey.toLowerCase() : "",
+        swaps: int(r.swaps),
+    };
+}
+/** A pool event feed message's data, or null when it is not one. */
+export function parsePoolEventMessage(x) {
+    const r = x;
+    if (!r || typeof r !== "object" || typeof r.tokenId !== "string")
+        return null;
+    const row = r.kind === "revert" ? toPoolRevert(r) : toPoolEvent(r);
+    return row ? { tokenId: r.tokenId, ...row } : null;
+}
+/** H8: `GET <base>/pools/history?from=&to=&pool=&limit=&after=` → the page, oldest first. */
+export async function readPoolHistory(base, o = {}, fetchFn) {
+    const a = (await getJson(`${trim(base)}/pools/history${query({ from: o.from, to: o.to, pool: o.pool, limit: o.limit, after: o.after })}`, fetchFn));
+    return {
+        events: (Array.isArray(a?.events) ? a.events : []).map(toPoolEvent).filter((e) => e !== null),
+        next: typeof a?.next === "string" ? a.next : null,
+    };
+}
+/** H9: `GET <swap base>/spends?outpoint=a,b` (the host's: every enabled token's `/spends`, the first naming a spender) → one record per outpoint. */
+export async function readSpendsAll(swapBase, outpoints, fetchFn) {
+    if (outpoints.length === 0)
+        return [];
+    const a = await getJson(`${trim(swapBase)}/spends?outpoint=${list(outpoints)}`, fetchFn);
+    return (Array.isArray(a) ? a : [a])
+        .filter((r) => r && typeof r.outpoint === "string")
         .map((r) => ({
-        tokenId: String(r.tokenId),
-        lpPubKey: String(r.lpPubKey),
-        status: r.status === "live" || r.status === "rescinded" ? r.status : "closed",
-        outpoint: typeof r.outpoint === "string" ? r.outpoint : null,
-        current: isWirePool(r.current) ? toPoolState(r.current) : null,
-        sats: wireBig(r.sats),
-        tokens: wireBig(r.tokens),
-        swaps: Number(r.swaps ?? 0),
+        outpoint: String(r.outpoint),
+        ...(typeof r.tokenId === "string" ? { tokenId: r.tokenId } : {}),
+        ...(typeof r.spentBy === "string" ? { spentBy: r.spentBy.toLowerCase() } : {}),
     }));
 }

package/dist/lib/skein.d.ts

@@ -63,10 +63,12 @@ export interface EnabledToken {
 export declare function readTokens(base: string, fetchFn?: typeof fetch): Promise<EnabledToken[]>;
 /** The defaults a new token instance is created with (0.17.0, `GET <config>/defaults`): each absent when unset. */
 export interface Defaults {
+    /** 0.40.0: `minLegSats` present when the defaults set one. */
     terms?: {
         lpFeeBps: number;
         validatorFeeBps: number;
         commissionBps: number;
+        minLegSats?: number;
     };
     market?: {
         minCommissionBps: number;

package/dist/lib/skein.js

@@ -134,7 +134,7 @@ export async function readDefaults(base, fetchFn = fetch) {
     const out = {};
     const t = a?.terms;
     if (t && typeof t.lpFeeBps === "number" && typeof t.validatorFeeBps === "number" && typeof t.commissionBps === "number")
-        out.terms = { lpFeeBps: t.lpFeeBps, validatorFeeBps: t.validatorFeeBps, commissionBps: t.commissionBps };
+        out.terms = { lpFeeBps: t.lpFeeBps, validatorFeeBps: t.validatorFeeBps, commissionBps: t.commissionBps, ...(typeof t.minLegSats === "number" && t.minLegSats > 0 ? { minLegSats: t.minLegSats } : {}) };
     const m = a?.market;
     if (m && typeof m.minCommissionBps === "number")
         out.market = { minCommissionBps: m.minCommissionBps };