@dcasegr/amm-client 0.42.3 → 0.44.1

package/README.md

@@ -103,7 +103,7 @@ last-leg change keys), `swapInstructions` / `swapSatsInstructions` (their custom
 change row's with `order`), `LP_KEY_PROTOCOL` (BRC-29) + `LP_KEY_MARK` +
 `lpKeyDescription` / `lpKeyIdOfDescription` (the deploy's pool output description naming the LP
 keyID), `POOL_TAG` / `POOL_OP` / `isPoolRow` / `poolCustomInstructions` (an `amm-pools` row),
-`POOL_DEPLOY_LABEL` (`amm-pool-deploy`), `SWAP_TTL_MS` (15 s), `transferPlanLabels` (the `p color
+`POOL_DEPLOY_LABEL` (`amm-pool-deploy`), `LEG_PATIENCE_MS` (15 s: how long a swap leg waits for the host's answer before closing the request; 0.44.0, was the swap's expiry), `transferPlanLabels` (the `p color
 plan` labels), the receipt helpers `newReceivingKey` / `receiptOutput`, and `xTopics` (the BRC-22
 `x-topics` header: a JSON array).
 

package/dist/client.d.ts

@@ -20,9 +20,10 @@
  *   market's minimum (the host's filter), each validator's minimum leg, the market's commission key
  *   hash; a quote is the matching engine's plan over that list (no request); a swap (`executeSwap`)
  *   stages what the swap basket lacks by ONE wallet action, then per leg the pools route read fresh,
- *   ONE `GET /@<token>/amm/pools/beef?pool=` and the leg's relay request (`amm.swap.submit`, held by
- *   the host until the relay rests; 15 s expiry); no answer → the host's `GET /amm/spends`, once
- *   more, a race. The pool events (`watchPoolEvents`, 0.41.0: the host's feeds) are signals for
+ *   ONE `GET /@<token>/amm/pools/beef?pool=` and the leg's ONE plain `POST /@<token>/amm/swap`
+ *   (0.44.0: the host is the relay, answering the validator's reply; the page's patience,
+ *   `LEG_PATIENCE_MS`, is the only timer); no answer → the host's `GET /amm/spends`, once more, a
+ *   race. The pool events (`watchPoolEvents`, 0.41.0: the host's feeds) are signals for
  *   display: a page reads the route again on one.
  * - **Liquidity** (D9, D23; 0.40.0: by pool id): the wallet's pool rows and deploy history, then
  *   ONE `GET /@<token>/amm/positions?pool=` per token; a deploy the history has but the basket

package/dist/client.js

@@ -20,9 +20,10 @@
  *   market's minimum (the host's filter), each validator's minimum leg, the market's commission key
  *   hash; a quote is the matching engine's plan over that list (no request); a swap (`executeSwap`)
  *   stages what the swap basket lacks by ONE wallet action, then per leg the pools route read fresh,
- *   ONE `GET /@<token>/amm/pools/beef?pool=` and the leg's relay request (`amm.swap.submit`, held by
- *   the host until the relay rests; 15 s expiry); no answer → the host's `GET /amm/spends`, once
- *   more, a race. The pool events (`watchPoolEvents`, 0.41.0: the host's feeds) are signals for
+ *   ONE `GET /@<token>/amm/pools/beef?pool=` and the leg's ONE plain `POST /@<token>/amm/swap`
+ *   (0.44.0: the host is the relay, answering the validator's reply; the page's patience,
+ *   `LEG_PATIENCE_MS`, is the only timer); no answer → the host's `GET /amm/spends`, once more, a
+ *   race. The pool events (`watchPoolEvents`, 0.41.0: the host's feeds) are signals for
  *   display: a page reads the route again on one.
  * - **Liquidity** (D9, D23; 0.40.0: by pool id): the wallet's pool rows and deploy history, then
  *   ONE `GET /@<token>/amm/positions?pool=` per token; a deploy the history has but the basket
@@ -633,7 +634,8 @@ function makeClient(opts, s) {
      *      (`relaying`):
      *      - accepted → taken in (ONE internalizeAction) before the next leg;
      *      - refused `pool_spent` (`repricing`) → the list read again: the relaying host took the
-     *        validator's state in before it answered (0.41.0);
+     *        validator's state in before it answered (0.41.0); the list still showing the pool at the
+     *        outpoint the leg spent → that pool excluded for the rest of this swap (0.43.0);
      *      - refused otherwise (`below_minimum` included) → that outpoint excluded;
      *      - no answer → (a) the overlay: a staged input spent → the leg landed (taken in by the
      *        pass), the pool spent by another's swap → continue with the same rows; (b) else the
@@ -672,19 +674,20 @@ function makeClient(opts, s) {
         return result;
     }
     async function runSwap(quote, progress, signal) {
-        const { wallet, signedFor } = needWallet();
+        const { wallet } = needWallet();
         const p = planned.get(quote);
         if (!p)
             throw new Error("Quote again: this quote was not planned here");
         const tokenId = quote.request.tokenId;
         const base = tokenBase(tokenId, swapBase);
-        const af = signedFor(base);
         const buy = quote.request.side === "buy";
         const direction = buy ? "bsvToToken" : "tokenToBsv";
         const minerFee = legMinerFeeSats(feeRate);
         const meta = { sym: p.sym, dec: p.dec };
         // 0.41.0: the server's list, read fresh before each leg; the outpoints excluded (a pool that refused other than pool_spent, or did not answer).
         const excluded = new Set();
+        /** 0.43.0 (D4): the outpoint a leg was just refused `pool_spent` on: still listed there at the next read → excluded. */
+        let spentAt;
         /** 0.40.2: the legs the order may still fill (the request's maxSources less the legs filled). */
         let budget = quote.request.maxSources;
         const legs = [];
@@ -727,6 +730,11 @@ function makeClient(opts, s) {
             }
             const remaining = quote.request.amountIn - filledIn;
             const answer = await tokenPools(tokenId);
+            // 0.43.0 (D4): refused pool_spent, yet the server's fresh list still shows the pool at the outpoint the leg spent:
+            // the pool is not asked again in this swap.
+            if (spentAt !== undefined && answer.pools.some((r) => r.outpoint === spentAt))
+                excluded.add(spentAt);
+            spentAt = undefined;
             const pools = poolsWithMinimums(answer).filter((r) => !excluded.has(r.outpoint));
             const minOut = quote.minAmountOut > filledOut ? quote.minAmountOut - filledOut : 0n;
             const next = nextLeg({ pools, direction, remaining, fixedCost: { minerFeeSats: minerFee }, minOut, maxSources: budget });
@@ -760,8 +768,8 @@ function makeClient(opts, s) {
             const prepared = await prepareSwap({ ...common, inputs, ...(order ? { order } : {}), last: leg.amountIn === remaining, holdingBeef: await swapHoldingBeef(wallet) });
             const at = { leg: outpointText(leg.outpoint), amountIn: leg.amountIn, amountOut: leg.amountOut };
             progress({ phase: "relaying", ...at, filled: [...legs] });
-            let outcome = await relayLeg(wallet, af, base, prepared, peerId);
-            if (outcome.status === "unknown" || outcome.status === "timeout") {
+            let outcome = await relayLeg(wallet, base, prepared, peerId);
+            if (outcome.status === "unknown") {
                 // (a) The overlay: what the leg spends.
                 const spent = await readSpendsAll(swapBase, [outpointText(leg.outpoint), ...inputs.sats.map((r) => r.outpoint), ...inputs.tokens.map((r) => r.outpoint)], freshFetch).catch(() => []);
                 const ours = spent.find((x) => x.spentBy && x.outpoint !== outpointText(leg.outpoint));
@@ -773,8 +781,8 @@ function makeClient(opts, s) {
                 if (spent.some((x) => x.spentBy && x.outpoint === outpointText(leg.outpoint)))
                     continue;
                 // (b) Once more to the same validator.
-                outcome = await relayLeg(wallet, af, base, prepared, peerId);
-                if (outcome.status === "unknown" || outcome.status === "timeout") {
+                outcome = await relayLeg(wallet, base, prepared, peerId);
+                if (outcome.status === "unknown") {
                     // (c) Race: the next leg to another pool with the same rows.
                     pending.push({ prepared, leg, poolId: row.poolId });
                     excluded.add(row.outpoint);
@@ -797,6 +805,7 @@ function makeClient(opts, s) {
             if (outcome.status === "refused" && outcome.reason.startsWith("pool_spent")) {
                 // The relaying host took the validator's state in before it answered: the next read lists it.
                 progress({ phase: "repricing", ...at, filled: [...legs] });
+                spentAt = row.outpoint;
             }
             else {
                 excluded.add(row.outpoint);
@@ -820,9 +829,9 @@ function makeClient(opts, s) {
         }
         return out;
     }
-    /** One relay of a prepared leg (0.34.0: no browser note); a thrown error is no answer. */
-    function relayLeg(wallet, af, base, prepared, peerId) {
-        return relaySwap({ wallet, authFetch: af, base }, prepared, peerId).catch((e) => ({ status: "unknown", id: swapIdOf(prepared), reason: errText(e) }));
+    /** One leg to the host's swap route (0.44.0: a plain POST, the page's patience its only timer); a thrown error is no answer. */
+    function relayLeg(wallet, base, prepared, peerId) {
+        return relaySwap({ wallet, fetch: f, base }, prepared, peerId).catch((e) => ({ status: "unknown", id: swapIdOf(prepared), reason: errText(e) }));
     }
     /** A plain GET past the browser's short cache (`state` class: max-age 5): what a swap is about to spend must be read now. */
     const freshFetch = (url, init) => f(url, { ...init, cache: "no-cache" });

package/dist/errors.js

@@ -14,7 +14,8 @@
  *   pool_spent      the pool was spent since the quote (the quote's freshness read; the validator's
  *                   `pool_spent` refusal)
  *   user_rejected   the user declined in the wallet (the wallet's `ERR_PERMISSION_DENIED`, "denied")
- *   no_answer       the relay gave no settled answer yet ("no answer yet"; a timed-out swap record)
+ *   no_answer       no answer to a leg yet ("no answer yet": the host could not reach the validator,
+ *                   the request failed, or the page's patience ran out)
  *   below_minimum   (0.40.0) under a validator's minimum leg (its `below_minimum` refusal; a quote no
  *                   pool takes for its size)
  *   refused         the validator, the relay or the host refused it (a refusal other than pool_spent
@@ -69,7 +70,6 @@ export function kindOfOutcome(o) {
             return undefined;
         case "refused":
             return o.reason.startsWith("pool_spent") ? "pool_spent" : o.reason.startsWith("below_minimum") ? "below_minimum" : "refused";
-        case "timeout":
         case "unknown":
             return "no_answer";
         case "failed":

package/dist/index.d.ts

@@ -51,8 +51,8 @@ export { isPoolRow } from "./lp/poolDeploy.js";
 export { poolCustomInstructions } from "./lp/poolDeploy.js";
 /** The label of a pool deploy's action (`amm-pool-deploy`): the positions reader's history. */
 export { POOL_DEPLOY_LABEL } from "./lp/positions.js";
-/** How long the relay may take a swap leg (the swap's `expires`), ms. */
-export { SWAP_TTL_MS } from "./market/swapAction.js";
+/** How long the page waits for one swap leg's answer before it closes the request (0.44.0: the host's relay stops with it), ms. */
+export { LEG_PATIENCE_MS } from "./market/swapFlow.js";
 /** The `p color plan` labels of a transfer of one asset (BRC-207 plan version 1): every token action's. */
 export { transferPlanLabels } from "./wallet/color.js";
 /** A module receiving key for one output of an asset from a sender: its receipt, key and hash160. */

package/dist/index.js

@@ -53,8 +53,8 @@ export { isPoolRow } from "./lp/poolDeploy.js";
 export { poolCustomInstructions } from "./lp/poolDeploy.js";
 /** The label of a pool deploy's action (`amm-pool-deploy`): the positions reader's history. */
 export { POOL_DEPLOY_LABEL } from "./lp/positions.js";
-/** How long the relay may take a swap leg (the swap's `expires`), ms. */
-export { SWAP_TTL_MS } from "./market/swapAction.js";
+/** How long the page waits for one swap leg's answer before it closes the request (0.44.0: the host's relay stops with it), ms. */
+export { LEG_PATIENCE_MS } from "./market/swapFlow.js";
 /** The `p color plan` labels of a transfer of one asset (BRC-207 plan version 1): every token action's. */
 export { transferPlanLabels } from "./wallet/color.js";
 /** A module receiving key for one output of an asset from a sender: its receipt, key and hash160. */

package/dist/lib/overlay.d.ts

@@ -178,8 +178,6 @@ export interface Spend {
 export declare function readSpends(base: string, outpoints: string[], fetchFn?: FetchFn): Promise<Spend[]>;
 /** P9: `GET <base>/tx?id=<txid>`: the transaction's BEEF (every input's source with it); null when the instance does not hold it. */
 export declare function readTx(base: string, txid: string, fetchFn?: FetchFn): Promise<number[] | null>;
-/** P10: `GET <base>/swaps?id=<id>`: the relay record (dag-json, as `amm.swap.status` answers it); null when unknown. */
-export declare function readSwap(base: string, id: string, fetchFn?: FetchFn): Promise<unknown | null>;
 /** A token on discovery (P13, P14): its metadata; `iconUrl` absolute (P13 gives it relative to the list). */
 export interface DiscoveryRow {
     tokenId: string;

package/dist/lib/overlay.js

@@ -17,7 +17,7 @@
  * | 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 |
+ * | (P10) | gone in 0.44.0: the host relays a leg (`POST /@<token>/amm/swap`, src/market/relay.ts), nothing is recorded |
  * | P11 | `GET /@<token>/amm/token` | the token's record |
  * | P12 | `GET <origin>/amm/tokens` | the exchange's token list (src/lib/skein.ts `readTokens`) |
  * | P13 | `GET /@discovery/1color/tokens?ids=a,b` (or paged `?limit=&skip=`) | `[{tokenId, topic, sym, dec, iconUrl?, txid, vout}]`; an id not on discovery `{tokenId, listed: false}` |
@@ -270,15 +270,6 @@ export async function readSpends(base, outpoints, fetchFn) {
 export async function readTx(base, txid, fetchFn) {
     return getBytes(`${trim(base)}/tx?id=${encodeURIComponent(txid)}`, fetchFn);
 }
-/** P10: `GET <base>/swaps?id=<id>`: the relay record (dag-json, as `amm.swap.status` answers it); null when unknown. */
-export async function readSwap(base, id, fetchFn) {
-    const res = await (fetchFn ?? plain)(`${trim(base)}/swaps?id=${encodeURIComponent(id)}`, { headers: { accept: "application/json" } });
-    if (res.status === 404)
-        return null;
-    if (!res.ok)
-        throw new Error(`GET ${trim(base)}/swaps: ${res.status} ${(await res.text()).slice(0, 200)}`);
-    return res.json();
-}
 function discoveryRow(x, listUrl) {
     const listed = x.listed !== false;
     const dec = typeof x.dec === "number" ? x.dec : typeof x.dec === "string" && /^\d+$/.test(x.dec) ? Number(x.dec) : undefined;

package/dist/market/relay.d.ts

@@ -1,6 +1,4 @@
 import type { PoolState } from "@dcasegr/amm-engine";
-export declare const SWAP_SUBMIT_FN = "amm.swap.submit";
-export declare const SWAP_STATUS_FN = "amm.swap.status";
 export declare const SWAP_TERMS_FN = "amm.swap.terms";
 /** The relay's terms: where it takes the commission (hash160 hex), or null when it names none; this market's minimum commission (bps, 0 when unset). */
 export interface SwapTerms {
@@ -15,7 +13,8 @@ export interface AuthFetchLike {
         body?: string;
     }): Promise<Pick<Response, "status" | "text">>;
 }
-export interface SwapSubmit {
+/** A leg as the host's swap route takes it. */
+export interface SwapRequest {
     /** The funding transaction as AtomicBEEF (the swap's unproven parent, with its ancestry). */
     funding: number[];
     /** Raw swap transaction, the validator's slot empty. */
@@ -24,32 +23,32 @@ export interface SwapSubmit {
     pool: string;
     /** The pool's validator identity key (hex; sent as 33 bytes). */
     validator: string;
-    /** The validator's libp2p peer ID (text), as the liveness read gave it: what the relay dials. */
+    /** The validator's libp2p peer ID (text), as the pools route gave it: what the host dials. */
     peerId: string;
-    /** Unix ms after which the relay gives up. */
-    expires: number;
 }
-export type SwapRecord = {
-    id: string;
-    status: "pending";
-} | {
-    id: string;
-    status: "accepted";
+/** The host's answer to a leg: the validator's reply, or the host's own refusal / break (`unreachable`). */
+export type SwapReply = {
+    ok: true;
     tx: number[];
     txid: string;
 } | {
-    id: string;
-    status: "refused";
+    ok: false;
     reason: string;
     pool?: PoolState;
-} | {
-    id: string;
-    status: "timeout";
-} | {
-    id: string;
-    status: "failed";
+}
+/** Any break in the call (dial refused, protocol not served, write failed, stream closed without an answer): no answer, the swap may or may not stand. */
+ | {
+    ok: false;
+    unreachable: true;
     reason: string;
 };
+/** What the swap route needs of `fetch` (and what the tests fake): a plain fetch that honours `signal`. */
+export type FetchLike = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+    signal?: AbortSignal;
+}) => Promise<Pick<Response, "status" | "text">>;
 export declare class RelayError extends Error {
     readonly code: string;
     readonly httpStatus: number;
@@ -63,10 +62,10 @@ export declare function dagBytes(bytes: number[]): {
 /** DAG-JSON bytes, hex, or a byte array → bytes; null otherwise. */
 export declare function readBytes(x: unknown): number[] | null;
 export declare function callUrl(base: string): string;
-export declare function submitBody(s: SwapSubmit): {
-    fn: string;
-    args: Record<string, unknown>;
-};
+export declare const SWAP_ROUTE = "/swap";
+/** The host's swap route of a token instance's AMM base (`<origin>/@<tokenId>/amm`). */
+export declare function swapUrl(base: string): string;
+export declare function swapBody(s: SwapRequest): Record<string, unknown>;
 /** One `{fn, args}` call on the app's `/call` route. Throws `RelayError` on an error answer. */
 export declare function callApp(af: AuthFetchLike, base: string, fn: string, args: unknown): Promise<unknown>;
 /**
@@ -76,9 +75,14 @@ export declare function callApp(af: AuthFetchLike, base: string, fn: string, arg
  * missing a field, is undefined: nothing left to re-price.
  */
 export declare function toPoolState(raw: unknown): PoolState | undefined;
-export declare function parseSwapRecord(x: unknown): SwapRecord;
+/** The host's answer (200, JSON) to a leg, as a `SwapReply`; throws when it is no reply. */
+export declare function parseSwapReply(x: unknown): SwapReply;
 /** `amm.swap.terms`'s answer: `commissionPkh` as DAG-JSON bytes (or hex, or a byte array) of 20 bytes, or null / absent; `minCommissionBps` an integer 0 to 10 000, absent 0 (0.16.0). */
 export declare function parseSwapTerms(x: unknown): SwapTerms;
 export declare function swapTerms(af: AuthFetchLike, base: string): Promise<SwapTerms>;
-export declare function submitSwap(af: AuthFetchLike, base: string, s: SwapSubmit): Promise<SwapRecord>;
-export declare function swapStatus(af: AuthFetchLike, base: string, id: string): Promise<SwapRecord>;
+/**
+ * One leg to the host's swap route (a plain POST; `signal` closes the request — the page's patience,
+ * the host's only timer). Throws `RelayError` on an answer that is not 200 (the host relayed nothing)
+ * and the fetch's own error on a network failure or an abort (no answer: the swap may stand).
+ */
+export declare function postSwap(fetchFn: FetchLike, base: string, s: SwapRequest, signal?: AbortSignal): Promise<SwapReply>;

package/dist/market/relay.js

@@ -1,61 +1,41 @@
 /**
- * The marketplace relay (docs/notes.md, "Marketplace relay"): the user's own
- * skein instance takes the funding and swap transactions and carries them to
- * the pool's validator, so the browser needs no libp2p. Two functions on the
- * AMM app's box, hosted by programs/amm-p2p:
+ * The swap relay and the app's `/call` functions, as the pages reach them.
  *
- *   amm.swap.terms   (reads)   {} → {commissionPkh: bytes(20) | null, minCommissionBps}
- *   amm.swap.submit  (writes)  {funding, swap, pool, validator, peerId, expires} → the record
- *                              (0.34.0, D15: the host holds the request until the relay thread
- *                              rests, so the answer is the settled record; past the host's bound,
- *                              503: no answer yet)
- *   amm.swap.status  (reads)   {id} → the record (0.34.0: the pages read it plain, `GET
- *                              <base>/swaps?id=`, src/lib/overlay.ts `readSwap`, behind "Check again")
+ * 0.44.0 (David Case 2026-11-06, "the instance logs facts, never attempts"): the HOST is the relay.
+ * A leg is one plain POST to the open-exchange host's route
  *
- *   commissionPkh  the address the relay takes the pool's commission at
- *              (Swap's `commissionPkh`; 0.16.0: hash160 of the instance's
- *              own derived key, no config); null when the instance names
- *              none, in which case a pool with a nonzero CommissionBps pays
- *              the commission to the taker's own key
- *              (src/market/swapAction.ts, "the commission")
- *   minCommissionBps  this market's minimum commission (0.16.0: the record
- *              root sets, `amm/market`; absent or unset, 0): a listing
- *              preference, the pools the Swap page lists, not a rule
+ *   POST <origin>/@<tokenId>/amm/swap      (`swapUrl(base)`; no BRC-104 session, as /submit is plain)
+ *   body    {funding, swap, pool, validator, peerId}   JSON, bytes as DAG-JSON bytes
+ *   answer  the validator's reply as it is:  {ok: true, tx, txid, beef?}
+ *                                            {ok: false, reason, detail?, pool?, beef?}
+ *           or the host's own:               {ok: false, reason: "unreachable", detail}   any break in the call
+ *                                            {ok: false, reason: "commission_missing", detail}   the one rule it checks
  *
- *   funding    bytes: the funding transaction as the wallet's AtomicBEEF (its
- *              ancestry with it: the validator's overlay verifies the unproven
- *              funding against parents in the BEEF); 0.29.0: the transaction
- *              of the leg's `amm-swap` sats output, the swap's input 1
+ *   funding    bytes: the funding transaction as the wallet's AtomicBEEF (0.40.1 `fundingBeef`: every
+ *              staged input's source with its ancestry)
  *   swap       bytes: the raw swap, the validator's slot `OP_0`
- *   pool       text `<txid>_<vout>`; validator bytes(33); expires unix ms
- *   peerId     text: the validator's libp2p peer ID, from the pools route's row
- *              (`validatorPeerId`, 0.34.0: the host joined it from the beat): the
- *              relay dials it (or, when it is the relay's own node, hands the
- *              swap to its own validator program); it looks at no liveness
+ *   pool       text `<txid>_<vout>`; validator bytes(33)
+ *   peerId     text: the validator's libp2p peer ID, from the pools route's row (`validatorPeerId`)
+ *
+ * The host checks that the swap's commission pays this exchange's key (amm-p2p README "The
+ * commission rule") and nothing else, signs the validator's package with the token instance's key,
+ * carries it on one libp2p stream (or to a validator on its own node as an inbound frame), submits a
+ * `beef` the reply carries to the token instance's overlay and then answers. Nothing is recorded:
+ * no swap id to ask about, no status, no expiry. THE PAGE'S CONNECTION IS THE ONLY TIMER: closing
+ * it (`LEG_PATIENCE_MS`, src/market/swapFlow.ts) stops the host — a dial in progress cancelled, a
+ * request not yet written never written. Once written, the validator answers on that stream; a
+ * signed swap lands on the overlay and the swap loop's settle pass finds it.
  *
- * record (programs/amm-p2p relay.zig `Record.answer`; id = sha256 of the swap, hex):
- *   {id, status: "pending" | "accepted" | "refused" | "timeout" | "failed", pool, expires, …,
- *    tx?, txid?            accepted: the validator's signed swap
- *    reason?, detail?,     refused / timeout / failed
- *    poolState?}           refused: the pool's current state (the validator's)
- * "failed" is the relay's transport failure (retryable by submitting again):
- * the validator may or may not have the swap, so the page treats it as no
- * answer, not as a refusal.
+ * The app's `/call` route (skein docs/APPS.md §4) stays for `amm.swap.terms`, `amm.pool.terms`
+ * and `amm.pool.affirm`: `POST <base>/call`, JSON body `{fn, args}`, answer `{fn, result}` (200) or
+ * `{fn, error: {code, message}}`; BRC-104 authenticated (the wallet-backed AuthFetch).
  *
- * Transport: the app's `/call` route (skein docs/APPS.md §4): `POST
- * <VITE_AMM_OVERLAY>/call`, JSON body `{fn, args}`, answer `{fn, result}`
- * (200) or `{fn, error: {code, message}}` (400 bad-request / bad-args, 403
- * not-admitted, 404 unknown-fn, 409 read-only, 500 failed). The route is
- * BRC-104 authenticated: the caller must be admitted to the app's box, so
- * both calls go through the wallet-backed AuthFetch (src/wallet/authFetch.ts).
+ *   amm.swap.terms   (reads)   {} → {commissionPkh: bytes(20) | null, minCommissionBps}
  *
- * Bytes in `args` are DAG-JSON bytes (`{"/": {"bytes": "<base64, unpadded>"}}`),
- * how skein reads JSON bodies (docs/MESSAGES.md "The messagebox"); answers are
+ * Bytes in bodies are DAG-JSON bytes (`{"/": {"bytes": "<base64, unpadded>"}}`); answers are
  * read as DAG-JSON bytes, hex or a byte array.
  */
 import { Utils } from "@bsv/sdk";
-export const SWAP_SUBMIT_FN = "amm.swap.submit";
-export const SWAP_STATUS_FN = "amm.swap.status";
 export const SWAP_TERMS_FN = "amm.swap.terms";
 export class RelayError extends Error {
     code;
@@ -86,11 +66,13 @@ export function readBytes(x) {
 export function callUrl(base) {
     return `${base.replace(/\/+$/, "")}/call`;
 }
-export function submitBody(s) {
-    return {
-        fn: SWAP_SUBMIT_FN,
-        args: { funding: dagBytes(s.funding), swap: dagBytes(s.swap), pool: s.pool, validator: dagBytes(Utils.toArray(s.validator, "hex")), peerId: s.peerId, expires: s.expires },
-    };
+export const SWAP_ROUTE = "/swap";
+/** The host's swap route of a token instance's AMM base (`<origin>/@<tokenId>/amm`). */
+export function swapUrl(base) {
+    return `${base.replace(/\/+$/, "")}${SWAP_ROUTE}`;
+}
+export function swapBody(s) {
+    return { funding: dagBytes(s.funding), swap: dagBytes(s.swap), pool: s.pool, validator: dagBytes(Utils.toArray(s.validator, "hex")), peerId: s.peerId };
 }
 /** One `{fn, args}` call on the app's `/call` route. Throws `RelayError` on an error answer. */
 export async function callApp(af, base, fn, args) {
@@ -147,32 +129,22 @@ export function toPoolState(raw) {
         validatorIdentityKey: identity,
     };
 }
-export function parseSwapRecord(x) {
+/** The host's answer (200, JSON) to a leg, as a `SwapReply`; throws when it is no reply. */
+export function parseSwapReply(x) {
     const r = x;
-    const id = r?.id ?? r?.swapId;
-    const status = r?.status ?? r?.state;
-    if (!r || typeof id !== "string")
-        throw new Error(`relay: not a swap record: ${JSON.stringify(x)?.slice(0, 200)}`);
-    switch (status) {
-        case "pending":
-        case "timeout":
-            return { id, status };
-        case "failed":
-            return { id, status, reason: (typeof r.reason === "string" ? r.reason : "failed") + (typeof r.detail === "string" && r.detail ? `: ${r.detail}` : "") };
-        case "accepted": {
-            const tx = readBytes(r.tx);
-            if (!tx || typeof r.txid !== "string")
-                throw new Error("relay: accepted without tx / txid");
-            return { id, status, tx, txid: r.txid };
-        }
-        case "refused": {
-            const pool = toPoolState(r.poolState ?? (typeof r.pool === "object" ? r.pool : undefined));
-            const reason = (typeof r.reason === "string" ? r.reason : "refused") + (typeof r.detail === "string" && r.detail ? `: ${r.detail}` : "");
-            return pool ? { id, status, reason, pool } : { id, status, reason };
-        }
-        default:
-            throw new Error(`relay: unknown swap status ${JSON.stringify(status)}`);
+    if (!r || typeof r !== "object" || typeof r.ok !== "boolean")
+        throw new Error(`relay: not a swap reply: ${JSON.stringify(x)?.slice(0, 200)}`);
+    if (r.ok) {
+        const tx = readBytes(r.tx);
+        if (!tx || typeof r.txid !== "string")
+            throw new Error("relay: accepted without tx / txid");
+        return { ok: true, tx, txid: r.txid };
     }
+    const reason = (typeof r.reason === "string" ? r.reason : "refused") + (typeof r.detail === "string" && r.detail ? `: ${r.detail}` : "");
+    if (r.reason === "unreachable")
+        return { ok: false, unreachable: true, reason };
+    const pool = toPoolState(typeof r.pool === "object" ? r.pool : undefined);
+    return pool ? { ok: false, reason, pool } : { ok: false, reason };
 }
 /** `amm.swap.terms`'s answer: `commissionPkh` as DAG-JSON bytes (or hex, or a byte array) of 20 bytes, or null / absent; `minCommissionBps` an integer 0 to 10 000, absent 0 (0.16.0). */
 export function parseSwapTerms(x) {
@@ -192,10 +164,28 @@ export function parseSwapTerms(x) {
 export async function swapTerms(af, base) {
     return parseSwapTerms(await callApp(af, base, SWAP_TERMS_FN, {}));
 }
-export async function submitSwap(af, base, s) {
-    const { fn, args } = submitBody(s);
-    return parseSwapRecord(await callApp(af, base, fn, args));
-}
-export async function swapStatus(af, base, id) {
-    return parseSwapRecord(await callApp(af, base, SWAP_STATUS_FN, { id }));
+/**
+ * One leg to the host's swap route (a plain POST; `signal` closes the request — the page's patience,
+ * the host's only timer). Throws `RelayError` on an answer that is not 200 (the host relayed nothing)
+ * and the fetch's own error on a network failure or an abort (no answer: the swap may stand).
+ */
+export async function postSwap(fetchFn, base, s, signal) {
+    const res = await fetchFn(swapUrl(base), {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify(swapBody(s)),
+        ...(signal ? { signal } : {}),
+    });
+    const text = await res.text();
+    let answer = null;
+    try {
+        answer = JSON.parse(text);
+    }
+    catch {
+        /* not JSON */
+    }
+    if (res.status === 200 && answer && typeof answer === "object" && "ok" in answer)
+        return parseSwapReply(answer);
+    const e = answer;
+    throw new RelayError(typeof e?.code === "string" ? e.code : `HTTP ${res.status}`, typeof e?.description === "string" ? e.description : text.slice(0, 200), res.status);
 }

package/dist/market/swapAction.d.ts

@@ -20,7 +20,7 @@
  *      into `amm-swap` with the order's key input in its customInstructions; the LAST leg (it takes
  *      all that remains) → the WALLET: sats to a BRC-29 key of the user's, tokens to a module
  *      receiving key for self, both `legDerivation(order, "change")`.
- *   4. The relay (src/market/relay.ts) carries it to the validator with the first sats input's
+ *   4. The host's relay (src/market/relay.ts, `POST /@<tokenId>/amm/swap`, 0.44.0) carries it to the validator with the first sats input's
  *      transaction as the swap's funding transaction: ONE BEEF of every staged input's source,
  *      its subject that transaction (0.40.1, `fundingBeef`).
  *   5. Accepted: `completeSwap` takes in, in ONE `internalizeAction`, the payout, the commission
@@ -35,11 +35,6 @@ import { type PaymentRemittance } from "../wallet/brc29.js";
 import { type ColorReceipt } from "../wallet/color.js";
 /** A P2PKH unlocking script's upper bound: push(DER ≤ 72 + sighash byte) + push(33-byte key). */
 export declare const P2PKH_UNLOCK_LENGTH = 108;
-/**
- * How long the relay may take (the swap's `expires`): 15 s (0.34.0, D15, David Case 2026-11-04;
- * was 120 s, a 10-05 builder number): the held submit returns inside it.
- */
-export declare const SWAP_TTL_MS = 15000;
 export declare class LegShapeError extends Error {
     constructor(message: string);
 }
@@ -199,8 +194,6 @@ export interface PrepareSwapInput extends PlanLegInput {
     last: boolean;
     /** The swap basket's source transactions: the rows' (default: `amm-swap`'s, from the wallet). */
     holdingBeef?: Beef;
-    now?: number;
-    ttlMs?: number;
 }
 export type SwapPayout = {
     kind: "color";
@@ -228,7 +221,6 @@ export interface PreparedSwap {
     pool: string;
     validator: string;
     bsvIn: boolean;
-    expires: number;
     plan: CallPlan;
     /** The order's key input (`<txid>.<vout>`): what the payout keys are derived from. */
     order: string;

package/dist/market/swapAction.js

@@ -20,7 +20,7 @@
  *      into `amm-swap` with the order's key input in its customInstructions; the LAST leg (it takes
  *      all that remains) → the WALLET: sats to a BRC-29 key of the user's, tokens to a module
  *      receiving key for self, both `legDerivation(order, "change")`.
- *   4. The relay (src/market/relay.ts) carries it to the validator with the first sats input's
+ *   4. The host's relay (src/market/relay.ts, `POST /@<tokenId>/amm/swap`, 0.44.0) carries it to the validator with the first sats input's
  *      transaction as the swap's funding transaction: ONE BEEF of every staged input's source,
  *      its subject that transaction (0.40.1, `fundingBeef`).
  *   5. Accepted: `completeSwap` takes in, in ONE `internalizeAction`, the payout, the commission
@@ -36,11 +36,6 @@ import { WALLET_PAYMENT, identityKeyOf, newBrc29Payout, p2pkhHexOf } from "../wa
 import { SWAP_BASKET, SWAP_PROTOCOL, newReceivingKey, receiptOutput, swapInstructions, swapSatsInstructions } from "../wallet/color.js";
 /** A P2PKH unlocking script's upper bound: push(DER ≤ 72 + sighash byte) + push(33-byte key). */
 export const P2PKH_UNLOCK_LENGTH = 108;
-/**
- * How long the relay may take (the swap's `expires`): 15 s (0.34.0, D15, David Case 2026-11-04;
- * was 120 s, a 10-05 builder number): the held submit returns inside it.
- */
-export const SWAP_TTL_MS = 15_000;
 const toHex = (b) => Utils.toHex(b);
 export class LegShapeError extends Error {
     constructor(message) {
@@ -462,7 +457,6 @@ export async function prepareSwap(i) {
         pool: i.leg.outpoint,
         validator: i.pool.validatorIdentityKey,
         bsvIn,
-        expires: (i.now ?? Date.now()) + (i.ttlMs ?? SWAP_TTL_MS),
         plan,
         order,
         last: i.last,

package/dist/market/swapFlow.d.ts

@@ -1,24 +1,27 @@
 /**
- * A prepared swap through the relay to its end (pure over the wallet and
- * AuthFetch, tested with fakes). 0.34.0 (D15, David Case 2026-11-04): the submit's answer is
- * the settled record — the host holds the `/call` request until the relay thread rests (the
- * validator's answer; a dial failure settles `failed` at once) — so nothing polls:
+ * A prepared swap through the host's relay to its end (pure over the wallet and fetch, tested with
+ * fakes). 0.44.0 (David Case 2026-11-06): the host is the relay — one plain POST per leg to
+ * `<origin>/@<tokenId>/amm/swap`, answered with the validator's reply (src/market/relay.ts); no
+ * record, no status, no expiry:
  *
- *   submit (amm.swap.submit) →
- *     accepted: completeSwap (internalizeAction; 0.29.0: no relinquishOutput)
- *     refused / timeout / an error answer to submit (nothing recorded):
+ *   POST /swap →
+ *     {ok: true, tx, txid}: completeSwap (internalizeAction; 0.29.0: no relinquishOutput) → accepted
+ *     {ok: false, reason, pool?} (the validator's refusal, or the host's commission rule): refused —
  *       nothing to undo: the leg's `amm-swap` outputs stay there
- *     no answer (a network failure, the host's 503 past its bound, a `pending` record, the
- *       relay's transport `failed`): "no answer yet", left alone — the relay may still carry it
- *       (0.40.0: the swap's loop resolves it from the overlay, sends it once more, or races it;
- *       src/client.ts `executeSwap`).
+ *     {ok: false, reason: "unreachable"} (any break in the host's call), a network failure, or no
+ *       answer within LEG_PATIENCE_MS (the request is closed: the host stops): unknown, "no answer
+ *       yet" — the swap may stand (0.40.0: the swap's loop resolves it from the overlay, asks once
+ *       more, or races it; src/client.ts `executeSwap`)
+ *     an answer that is not 200 (a bad request, an unknown token): failed — the host relayed nothing
  *
- * The swap's id is the relay's (amm-p2p relay.zig `idOf`): sha256 of the swap as submitted (the
- * validator's slot empty), hex — known to the page, so a lost answer can be checked again.
+ * The page's patience is the only timer: the AbortController's signal closes the request, and with
+ * it the host's attempt (a plain fetch honours `signal`; AuthFetch does not, which is why the leg is
+ * a plain fetch). The swap's id is sha256 of the swap as sent (the validator's slot empty), hex: the
+ * page's own name for a leg.
  */
 import { type WalletInterface } from "@bsv/sdk";
 import type { PoolState } from "@dcasegr/amm-engine";
-import { type AuthFetchLike } from "./relay.js";
+import { type FetchLike } from "./relay.js";
 import { type CompletedSwap, type PreparedSwap } from "./swapAction.js";
 export type SwapOutcome = {
     status: "accepted";
@@ -30,9 +33,6 @@ export type SwapOutcome = {
     id: string;
     reason: string;
     pool?: PoolState;
-} | {
-    status: "timeout";
-    id: string;
 } | {
     status: "failed";
     reason: string;
@@ -41,15 +41,20 @@ export type SwapOutcome = {
     id: string;
     reason: string;
 };
+/** How long the page waits for one leg's answer before it closes the request (the host then stops), ms. */
+export declare const LEG_PATIENCE_MS = 15000;
 export interface RelayContext {
     wallet: WalletInterface;
-    authFetch: AuthFetchLike;
-    /** The token instance's AMM base. */
+    /** A plain fetch (it must honour `signal`). Default: the global fetch. */
+    fetch?: FetchLike;
+    /** The token instance's AMM base, `<origin>/@<tokenId>/amm`. */
     base: string;
+    /** The page's patience for this leg (default LEG_PATIENCE_MS). */
+    patienceMs?: number;
 }
-/** The relay's id of a prepared swap: sha256 of the swap's bytes as submitted, hex. */
+/** A prepared swap's id: sha256 of the swap's bytes as sent, hex. */
 export declare function swapIdOf(p: PreparedSwap): string;
-/** "no answer yet": what a held request that came back without the settled record means. */
+/** "no answer yet": what a leg that came back without the validator's reply means. */
 export declare const NO_ANSWER_YET = "no answer yet";
-/** `peerId`: the chosen validator's libp2p peer ID, from the pools route's row (the relay dials it). */
+/** `peerId`: the chosen validator's libp2p peer ID, from the pools route's row (the host dials it). */
 export declare function relaySwap(c: RelayContext, p: PreparedSwap, peerId: string): Promise<SwapOutcome>;

package/dist/market/swapFlow.js

@@ -1,68 +1,65 @@
 /**
- * A prepared swap through the relay to its end (pure over the wallet and
- * AuthFetch, tested with fakes). 0.34.0 (D15, David Case 2026-11-04): the submit's answer is
- * the settled record — the host holds the `/call` request until the relay thread rests (the
- * validator's answer; a dial failure settles `failed` at once) — so nothing polls:
+ * A prepared swap through the host's relay to its end (pure over the wallet and fetch, tested with
+ * fakes). 0.44.0 (David Case 2026-11-06): the host is the relay — one plain POST per leg to
+ * `<origin>/@<tokenId>/amm/swap`, answered with the validator's reply (src/market/relay.ts); no
+ * record, no status, no expiry:
  *
- *   submit (amm.swap.submit) →
- *     accepted: completeSwap (internalizeAction; 0.29.0: no relinquishOutput)
- *     refused / timeout / an error answer to submit (nothing recorded):
+ *   POST /swap →
+ *     {ok: true, tx, txid}: completeSwap (internalizeAction; 0.29.0: no relinquishOutput) → accepted
+ *     {ok: false, reason, pool?} (the validator's refusal, or the host's commission rule): refused —
  *       nothing to undo: the leg's `amm-swap` outputs stay there
- *     no answer (a network failure, the host's 503 past its bound, a `pending` record, the
- *       relay's transport `failed`): "no answer yet", left alone — the relay may still carry it
- *       (0.40.0: the swap's loop resolves it from the overlay, sends it once more, or races it;
- *       src/client.ts `executeSwap`).
+ *     {ok: false, reason: "unreachable"} (any break in the host's call), a network failure, or no
+ *       answer within LEG_PATIENCE_MS (the request is closed: the host stops): unknown, "no answer
+ *       yet" — the swap may stand (0.40.0: the swap's loop resolves it from the overlay, asks once
+ *       more, or races it; src/client.ts `executeSwap`)
+ *     an answer that is not 200 (a bad request, an unknown token): failed — the host relayed nothing
  *
- * The swap's id is the relay's (amm-p2p relay.zig `idOf`): sha256 of the swap as submitted (the
- * validator's slot empty), hex — known to the page, so a lost answer can be checked again.
+ * The page's patience is the only timer: the AbortController's signal closes the request, and with
+ * it the host's attempt (a plain fetch honours `signal`; AuthFetch does not, which is why the leg is
+ * a plain fetch). The swap's id is sha256 of the swap as sent (the validator's slot empty), hex: the
+ * page's own name for a leg.
  */
 import { Hash, Utils } from "@bsv/sdk";
-import { RelayError, submitSwap } from "./relay.js";
+import { RelayError, postSwap } from "./relay.js";
 import { completeSwap } from "./swapAction.js";
+/** How long the page waits for one leg's answer before it closes the request (the host then stops), ms. */
+export const LEG_PATIENCE_MS = 15_000;
 const errText = (e) => (e instanceof Error ? e.message : String(e));
-/** The relay's id of a prepared swap: sha256 of the swap's bytes as submitted, hex. */
+/** A prepared swap's id: sha256 of the swap's bytes as sent, hex. */
 export function swapIdOf(p) {
     return Utils.toHex(Hash.sha256(p.swap.toBinary()));
 }
-/** "no answer yet": what a held request that came back without the settled record means. */
+/** "no answer yet": what a leg that came back without the validator's reply means. */
 export const NO_ANSWER_YET = "no answer yet";
-/** `peerId`: the chosen validator's libp2p peer ID, from the pools route's row (the relay dials it). */
+/** `peerId`: the chosen validator's libp2p peer ID, from the pools route's row (the host dials it). */
 export async function relaySwap(c, p, peerId) {
     const id = swapIdOf(p);
-    let record;
+    const patience = c.patienceMs ?? LEG_PATIENCE_MS;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new Error(`no answer within ${patience} ms`)), patience);
+    let reply;
     try {
-        record = await submitSwap(c.authFetch, c.base, {
+        reply = await postSwap(c.fetch ?? globalThis.fetch, c.base, {
             funding: p.funding.atomicBeef,
             swap: p.swap.toBinary(),
             pool: p.pool,
             validator: p.validator,
             peerId,
-            expires: p.expires,
-        });
+        }, ac.signal);
     }
     catch (err) {
-        // The host's bound passed with the relay still out: no answer yet (the swap stands).
-        if (err instanceof RelayError && err.httpStatus === 503)
-            return { status: "unknown", id, reason: NO_ANSWER_YET };
-        // The relay answered with an error: it recorded nothing and sent nothing on.
+        // An answer that is not 200: the host relayed nothing.
         if (err instanceof RelayError)
-            return { status: "failed", reason: `amm.swap.submit: ${err.message}` };
-        return { status: "unknown", id, reason: `${NO_ANSWER_YET}: amm.swap.submit: ${errText(err)}` };
+            return { status: "failed", reason: `swap: ${err.message}` };
+        // A network failure, or the page's patience ran out (the request closed: the host stopped).
+        return { status: "unknown", id, reason: `${NO_ANSWER_YET}: ${ac.signal.aborted ? errText(ac.signal.reason) : errText(err)}` };
     }
-    return act(c, p, record);
-}
-/** A record's outcome, acted on (accepted: the wallet takes the payout in). */
-async function act(c, p, r) {
-    switch (r.status) {
-        case "pending":
-            return { status: "unknown", id: r.id, reason: NO_ANSWER_YET };
-        case "accepted":
-            return { status: "accepted", id: r.id, txid: r.txid, completed: await completeSwap(c.wallet, p, r.tx, r.txid) };
-        case "refused":
-            return r.pool ? { status: "refused", id: r.id, reason: r.reason, pool: r.pool } : { status: "refused", id: r.id, reason: r.reason };
-        case "timeout":
-            return { status: "timeout", id: r.id };
-        case "failed":
-            return { status: "unknown", id: r.id, reason: `the relay could not reach the validator (${r.reason})` };
+    finally {
+        clearTimeout(timer);
     }
+    if (reply.ok)
+        return { status: "accepted", id, txid: reply.txid, completed: await completeSwap(c.wallet, p, reply.tx, reply.txid) };
+    if ("unreachable" in reply)
+        return { status: "unknown", id, reason: `${NO_ANSWER_YET}: the host could not reach the validator (${reply.reason})` };
+    return reply.pool ? { status: "refused", id, reason: reply.reason, pool: reply.pool } : { status: "refused", id, reason: reply.reason };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcasegr/amm-client",
-  "version": "0.42.3",
+  "version": "0.44.1",
   "type": "module",
   "description": "The Open Exchange client (skein-amm): reads, swap, pool deploy / close / rebalance, move back and positions over a BRC-100 wallet, bound to one exchange by createClient. No React, no styles, no wallet provider.",
   "repository": {
@@ -30,7 +30,7 @@
   },
   "dependencies": {
     "@1sat/actions": "0.1.3",
-    "@dcasegr/amm-engine": "0.42.3",
+    "@dcasegr/amm-engine": "0.44.1",
     "cbor2": "^2.3.0"
   },
   "peerDependencies": {