@dcasegr/amm-client 0.38.2 → 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,6 +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=&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?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.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).
@@ -73,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 } : {}),
     };
@@ -92,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`. */
@@ -131,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));
 }
@@ -139,48 +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 (P1 or P2) as an event stream (D16, D22): `GET <url>` with `Accept:
- * text/event-stream` (the browser's EventSource sends it), the event `pools` carrying the answer,
- * first the current one, then again each time it changes; `onAnswer` gets each. 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;
-        };
-    }
     const es = new ES(url);
-    es.addEventListener("pools", (e) => {
+    es.addEventListener("pool", (e) => {
         if (stopped)
             return;
+        let m = null;
         try {
-            onAnswer(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);
     });
-    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") : [] };
 }
@@ -195,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) {
@@ -232,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),
@@ -300,3 +322,210 @@ export async function readDiscoveryList(discovery, fetchFn) {
 export async function readDiscoveryDeploy(discovery, tokenId, fetchFn) {
     return getBytes(`${trim(discovery)}/${encodeURIComponent(tokenId)}/deploy`, fetchFn);
 }
+const intOrNull = (x) => (typeof x === "number" && Number.isFinite(x) ? x : null);
+const int = (x) => intOrNull(x) ?? 0;
+function toPrice(x) {
+    const p = x;
+    if (!p || typeof p !== "object" || p.sats === undefined || p.tokens === undefined)
+        return null;
+    return { sats: wireBig(p.sats), tokens: wireBig(p.tokens) };
+}
+/** A trade row, or null when it is not one. */
+export function toTrade(x) {
+    const r = x;
+    if (!r || typeof r !== "object" || typeof r.txid !== "string" || typeof r.lpPubKey !== "string" || (r.side !== "buy" && r.side !== "sell"))
+        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),
+        feeLp: wireBig(r.feeLp),
+        feeValidator: wireBig(r.feeValidator),
+        feeCommission: wireBig(r.feeCommission),
+        bsvReserve: wireBig(r.bsvReserve),
+        tokenReserve: wireBig(r.tokenReserve),
+        at: int(r.at),
+        height: intOrNull(r.height),
+    };
+}
+function toCandle(x) {
+    const r = x;
+    if (!r || typeof r !== "object")
+        return null;
+    const [o, h, l, c] = [toPrice(r.o), toPrice(r.h), toPrice(r.l), toPrice(r.c)];
+    if (!o || !h || !l || !c || typeof r.t !== "number")
+        return null;
+    return { t: r.t, o, h, l, c, volumeSats: wireBig(r.volumeSats), volumeTokens: wireBig(r.volumeTokens), n: int(r.n) };
+}
+/** A stats record (H3), or null when it is not one. */
+export function toStats(x) {
+    const r = x;
+    if (!r || typeof r !== "object" || typeof r.tokenId !== "string")
+        return null;
+    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),
+        volume24hTokens: wireBig(r.volume24hTokens),
+        buys24h: int(r.buys24h),
+        sells24h: int(r.sells24h),
+        lastTradeAt: intOrNull(r.lastTradeAt),
+        tvlSats: wireBig(r.tvlSats),
+        tvlTokens: wireBig(r.tvlTokens),
+        pools: int(r.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=&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, 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,
+    };
+}
+/** H1 with `txid`: one Swap's trade row; null when the transaction has none (404). */
+export async function readTrade(base, txid, fetchFn) {
+    const url = `${trim(base)}/trades?txid=${encodeURIComponent(txid)}`;
+    const res = await (fetchFn ?? plain)(url, { headers: { accept: "application/json" } });
+    if (res.status === 404)
+        return null;
+    if (!res.ok)
+        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=&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, series: o.series })}`, fetchFn);
+    return (Array.isArray(a) ? a : []).map(toCandle).filter((c) => c !== null);
+}
+/** H3: `GET <base>/stats`. */
+export async function readStats(base, fetchFn) {
+    const url = `${trim(base)}/stats`;
+    const s = toStats(await getJson(url, fetchFn));
+    if (!s)
+        throw new Error(`GET ${url}: not a stats record`);
+    return s;
+}
+/** H4: `GET <swap base>/stats` (`ids`: those enabled tokens only, in that order) → every enabled token's stats. */
+export async function readAllStats(swapBase, ids, fetchFn) {
+    const a = await getJson(`${trim(swapBase)}/stats${ids ? `?ids=${list(ids)}` : ""}`, fetchFn);
+    return (Array.isArray(a) ? a : []).map(toStats).filter((s) => s !== null);
+}
+/** H6: `GET <token base>/color/<token>/holders?limit=&skip=` → the count and the rows, largest first. */
+export async function readHolders(base, tokenId, o = {}, fetchFn) {
+    const a = (await getJson(`${trim(base)}/color/${encodeURIComponent(tokenId)}/holders${query({ limit: o.limit, skip: o.skip })}`, fetchFn));
+    return {
+        count: int(a?.count),
+        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?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?pool=${list(poolIds)}`, fetchFn);
+    return (Array.isArray(a) ? a : [])
+        .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) => ({
+        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 };