@dcasegr/amm-client 0.38.2 → 0.41.1

package/dist/pool/template.d.ts

@@ -89,6 +89,13 @@ export interface SwapParams extends CallCommon {
      * only when the commission (ceil(amountIn·CommissionBps/10000)) is nonzero.
      */
     commissionPkh: string;
+    /**
+     * 0.40.0: the taker's token change (Swap's `tokenChange`, ≥ 0): one more 1Color output of this
+     * many tokens to `tokenChangePkh` (1 sat) after the commission, only when nonzero. Default 0.
+     */
+    tokenChange?: bigint;
+    /** Hash160 (hex) of the token change's key (Swap's `tokenChangePkh`): always pushed. Default 20 zero bytes. */
+    tokenChangePkh?: string;
     /** What the caller priced the leg against; any mismatch is refused (see PoolBuildError). */
     expect?: SwapExpectation;
 }
@@ -214,13 +221,14 @@ export declare class PoolTemplate {
     /**
      * Swap (method 0). Outputs: 0 pool, 1 the taker's payout, then the LP fee,
      * the validator fee and the commission (each only when nonzero, each in
-     * the input asset), then change. Token payouts and token fees are 1-sat
+     * the input asset), then (0.40.0) the token change when nonzero, then change. Token payouts and token fees are 1-sat
      * 1Color outputs; BSV ones are P2PKH. The validator's slot is left empty.
      */
     static swap(p: SwapParams): Promise<PoolCall>;
     /**
      * The Swap call without its funding: the outputs the contract requires (in
-     * order: pool, payout, LP fee, validator fee, commission; no change) and
+     * order: pool, payout, LP fee, validator fee, commission, 0.40.0 the token change; no sats
+     * change) and
      * the method arguments, with the validator's slot empty. For a builder that
      * does not pick the funding itself (a BRC-100 wallet's `createAction` picks
      * inputs and change): hand these outputs over, then fill input 0 with

package/dist/pool/template.js

@@ -64,6 +64,7 @@ const toHex = (b) => Utils.toHex(Array.from(b));
 const fromHex = (h) => Utils.toArray(h, "hex");
 const scriptHex = (s) => (typeof s === "string" ? s.toLowerCase() : s.toHex());
 const p2pkhHex = (pkh) => `76a914${pkh}88ac`;
+const ZERO_PKH = "00".repeat(20);
 const pkhOf = (pubKeyHex) => toHex(Hash.hash160(fromHex(pubKeyHex)));
 function tokenPrefixHex(assetId, amount) {
     return toHex(oneColorValuePrefix(fromHex(assetId), amount));
@@ -256,14 +257,14 @@ export class PoolTemplate {
     /**
      * Swap (method 0). Outputs: 0 pool, 1 the taker's payout, then the LP fee,
      * the validator fee and the commission (each only when nonzero, each in
-     * the input asset), then change. Token payouts and token fees are 1-sat
+     * the input asset), then (0.40.0) the token change when nonzero, then change. Token payouts and token fees are 1-sat
      * 1Color outputs; BSV ones are P2PKH. The validator's slot is left empty.
      */
     static async swap(p) {
         const plan = PoolTemplate.planSwap(p);
-        // Tokens in: the token inputs must carry exactly amountIn (no token change
-        // output exists). BSV in: no token of this asset may be spent (it would burn).
-        checkTokenInputs(p.inputs, plan.pool.args.assetId, p.bsvIn ? 0n : p.amountIn);
+        // Tokens in: the token inputs must carry exactly amountIn plus the token change (0.40.0). BSV
+        // in: no token of this asset may be spent beyond the token change (it would burn).
+        checkTokenInputs(p.inputs, plan.pool.args.assetId, (p.bsvIn ? 0n : p.amountIn) + (p.tokenChange ?? 0n));
         const call = await buildCall({
             common: p,
             pool: plan.pool,
@@ -279,7 +280,8 @@ export class PoolTemplate {
     }
     /**
      * The Swap call without its funding: the outputs the contract requires (in
-     * order: pool, payout, LP fee, validator fee, commission; no change) and
+     * order: pool, payout, LP fee, validator fee, commission, 0.40.0 the token change; no sats
+     * change) and
      * the method arguments, with the validator's slot empty. For a builder that
      * does not pick the funding itself (a BRC-100 wallet's `createAction` picks
      * inputs and change): hand these outputs over, then fill input 0 with
@@ -310,6 +312,12 @@ export class PoolTemplate {
             throw new PoolBuildError("invalid", "commissionPkh must be 20 bytes of hex");
         if (!isHex(p.userPkh, 20))
             throw new PoolBuildError("invalid", "userPkh must be 20 bytes of hex");
+        const tokenChange = p.tokenChange ?? 0n;
+        const tokenChangePkh = p.tokenChangePkh ?? ZERO_PKH;
+        if (tokenChange < 0n)
+            throw new PoolBuildError("invalid", "tokenChange must be ≥ 0");
+        if (!isHex(tokenChangePkh, 20))
+            throw new PoolBuildError("invalid", "tokenChangePkh must be 20 bytes of hex");
         // Pool.runar.go Swap, line for line.
         const amountIn = p.amountIn;
         if (amountIn <= 0n)
@@ -364,12 +372,14 @@ export class PoolTemplate {
             outputs.push(payout(validatorFee, validatorPkh, p.bsvIn));
         if (commission > 0n)
             outputs.push(payout(commission, p.commissionPkh, p.bsvIn));
+        if (tokenChange > 0n)
+            outputs.push({ satoshis: 1n, script: tokenP2pkhHex(args.assetId, tokenChange, tokenChangePkh) });
         return {
             pool,
             poolUtxo: p.pool,
             method: "swap",
             outputs,
-            args: [EMPTY_SIG, nextValidatorPubKey, amountIn, p.bsvIn, p.userPkh, p.commissionPkh],
+            args: [EMPTY_SIG, nextValidatorPubKey, amountIn, p.bsvIn, p.userPkh, p.commissionPkh, tokenChangePkh, tokenChange],
             sigSlots: { validator: 0 },
             next: { pool: { ...pool, state: nextState, contractScript: pool.code + "6a" + stateHex(pool.version, nextState) }, satoshis: Number(newBsv), script: continuation },
             swap: { amountOut: out, lpFee, validatorFee, commission },

package/dist/wallet/color.d.ts

@@ -25,9 +25,9 @@
  *
  * The exchange's own baskets (not `p color`; the module would refuse them):
  * `amm-pools` (the LP's position rows) and `amm-swap` (the active swap
- * basket: tokens sent out of the module for swap legs and, 0.29.0, each leg's
- * sats, under the exchange's protocol `[2, "amm swap"]`, counterparty self, a
- * fresh keyID per output).
+ * basket: what a swap stages for its legs and their change between legs,
+ * 0.40.0, under the exchange's protocol `[2, "amm swap"]`, counterparty self:
+ * a staged row's keyID random, a change row's derived from what the leg spent).
  */
 import { type ColorReceipt } from "@1sat/actions";
 import { ASSETS_SELECTOR, assetBasket, assetTag, colorProtocolID, type ColorRemittance } from "@bsv/color-permission-module";
@@ -41,25 +41,29 @@ export declare const SWAP_BASKET = "amm-swap";
 export declare const SWAP_PROTOCOL: WalletProtocol;
 /** BRC-100's largest `limit`. */
 export declare const LIST_LIMIT = 10000;
-/** customInstructions of an `amm-swap` output: the asset, the amount and the key that spends it. */
+/**
+ * customInstructions of an `amm-swap` token row: the asset, the amount and the key that spends it;
+ * 0.40.0, a leg's token change also `order` (the order's key input, `<txid>.<vout>`).
+ */
 export declare function swapInstructions(o: {
     assetId: string;
     amount: bigint;
     protocolID: WalletProtocol;
     keyID: string;
     counterparty: string;
+    order?: string;
 }): string;
 /**
- * customInstructions of an `amm-swap` SATS output (0.29.0): a swap leg's sats (the miner fee; sats
- * in, also the amount in and the token payout's sat), staged in the swap basket by the same send as
- * the tokens; `sats: true` tells it from a token row; `assetId` (0.29.1) names the token whose swap
- * staged it (Move back sweeps it with that token's rows). The key that spends it, as for a token row.
+ * customInstructions of an `amm-swap` SATS row (0.29.0; 0.40.0, agent-env
+ * plans/swap-balance-build-2026-11-05.md: no token tag — the sats rows are the exchange's, not a
+ * token's): `sats: true` tells it from a token row; the key that spends it; a leg's sats change
+ * also `order` (the order's key input).
  */
 export declare function swapSatsInstructions(o: {
-    assetId: string;
     protocolID: WalletProtocol;
     keyID: string;
     counterparty: string;
+    order?: string;
 }): string;
 /** `p color balance <assetTag>`: the selector of one asset's value balance. */
 export declare function balanceSelector(assetId: string): string;

package/dist/wallet/color.js

@@ -25,9 +25,9 @@
  *
  * The exchange's own baskets (not `p color`; the module would refuse them):
  * `amm-pools` (the LP's position rows) and `amm-swap` (the active swap
- * basket: tokens sent out of the module for swap legs and, 0.29.0, each leg's
- * sats, under the exchange's protocol `[2, "amm swap"]`, counterparty self, a
- * fresh keyID per output).
+ * basket: what a swap stages for its legs and their change between legs,
+ * 0.40.0, under the exchange's protocol `[2, "amm swap"]`, counterparty self:
+ * a staged row's keyID random, a change row's derived from what the leg spent).
  */
 import { colorReceiptInstructions } from "@1sat/actions";
 import { ASSETS_SELECTOR, COLOR_KEY_ID, ColorPlan, assetBasket, assetTag, colorProtocolID } from "@bsv/color-permission-module";
@@ -42,18 +42,21 @@ export const SWAP_BASKET = "amm-swap";
 export const SWAP_PROTOCOL = [2, "amm swap"];
 /** BRC-100's largest `limit`. */
 export const LIST_LIMIT = 10000;
-/** customInstructions of an `amm-swap` output: the asset, the amount and the key that spends it. */
+/**
+ * customInstructions of an `amm-swap` token row: the asset, the amount and the key that spends it;
+ * 0.40.0, a leg's token change also `order` (the order's key input, `<txid>.<vout>`).
+ */
 export function swapInstructions(o) {
-    return JSON.stringify({ assetId: o.assetId, amount: String(o.amount), protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty });
+    return JSON.stringify({ assetId: o.assetId, amount: String(o.amount), protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty, ...(o.order ? { order: o.order } : {}) });
 }
 /**
- * customInstructions of an `amm-swap` SATS output (0.29.0): a swap leg's sats (the miner fee; sats
- * in, also the amount in and the token payout's sat), staged in the swap basket by the same send as
- * the tokens; `sats: true` tells it from a token row; `assetId` (0.29.1) names the token whose swap
- * staged it (Move back sweeps it with that token's rows). The key that spends it, as for a token row.
+ * customInstructions of an `amm-swap` SATS row (0.29.0; 0.40.0, agent-env
+ * plans/swap-balance-build-2026-11-05.md: no token tag — the sats rows are the exchange's, not a
+ * token's): `sats: true` tells it from a token row; the key that spends it; a leg's sats change
+ * also `order` (the order's key input).
  */
 export function swapSatsInstructions(o) {
-    return JSON.stringify({ sats: true, assetId: o.assetId, protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty });
+    return JSON.stringify({ sats: true, protocolID: o.protocolID, keyID: o.keyID, counterparty: o.counterparty, ...(o.order ? { order: o.order } : {}) });
 }
 /** `p color balance <assetTag>`: the selector of one asset's value balance. */
 export function balanceSelector(assetId) {

package/dist/wallet/swapPayouts.d.ts

@@ -1,35 +1,52 @@
 /**
- * Swap legs left in the wallet, settled silently (skein-amm 0.34.0; D18, D24, David Case
- * 2026-11-04). No browser store: the leg's staged rows in the `amm-swap` basket ARE the note — each
- * row's keyID names the pool outpoint the leg was quoted on (`amm-swap-<txid>.<vout>` /
- * `…:sats`, src/market/activeSwap.ts `swapKeyID`). On Your tokens load (`settleStagedSwaps`),
- * reads only, no resend, nothing shown:
+ * Resolve from the overlay (skein-amm 0.40.0, agent-env plans/swap-balance-build-2026-11-05.md
+ * Builder 2 item 5): the overlay is the truth about an `amm-swap` row, not the wallet's own flag.
+ * On load, before a swap starts, and after any refused or rejected leg (`resolveFromOverlay`):
  *
- *   1. the rows grouped by token and pool outpoint;
- *   2. per token, ONE `GET /@<token>/amm/spends?outpoint=a,b` (P8): each pool's spender;
- *   3. a spender: its transaction, `GET /@<token>/amm/tx?id=` (P9: the BEEF as admitted, every
- *      input's source with it); an output paying this wallet's leg key (`swapPayoutOf`, re-derived
- *      from the transaction's own inputs) → the wallet takes it in (`internalizeAction`, which also
- *      marks the staged rows it spends spent); no such output (another's swap) → nothing, the rows
- *      stay the user's;
- *   4. a pool not spent → nothing (the validator checks no expiry: the leg may still land).
+ *   1. every `amm-swap` row (src/market/activeSwap.ts) asked in ONE read of the host's
+ *      `GET <origin>/amm/spends?outpoint=a,b` (each enabled token's `/spends`, the first naming a
+ *      spender);
+ *   2. a spender: its transaction, `GET /@<token>/amm/tx?id=` (the BEEF as admitted, every input's
+ *      source with it); the payout key tried with the spent row's `order` (when it has one) and with
+ *      the transaction's own key input (`legDerivation`; its first token input on a sell, its first
+ *      sats input on a buy);
+ *   3. a match → the leg's take-in (`legTakeInOf`: the payout, the taker's own commission, the
+ *      change — kept in `amm-swap` with the order, or the last leg's to the wallet), ONE
+ *      `internalizeAction` (taking in a transaction the wallet already holds is harmless and
+ *      re-marks its inputs spent); no match → nothing;
+ *   4. again, until no row has a spender the wallet lacks (a take-in's change rows may be spent by
+ *      a later leg whose page was lost).
  *
- * Any failed read or take-in: nothing, the next load tries again.
+ * Any failed read or take-in: nothing, the next pass tries again. 0.34.0's pool-outpoint grouping
+ * of staged rows is gone.
  */
-import { Transaction, type InternalizeOutput, type WalletInterface, type WalletOutput } from "@bsv/sdk";
+import { Transaction, type InternalizeOutput, type WalletInterface } from "@bsv/sdk";
+import type { SpendAll } from "../lib/overlay.js";
+/** The swap's own key input (`legDerivation`'s): its first token input on a sell, its first sats input on a buy; null without one. */
+export declare function ownKeyInputOf(tx: Transaction): string | null;
 /**
- * Whether output `vout` of `tx` (a swap: the pool at input 0 and output 0) pays this wallet's leg
- * key, re-derived from the transaction's own inputs (`legDerivation`): the take-in for it, or null.
- * A 1Color output is a receipt (sender the pool's validator), a P2PKH one a BRC-29 payment.
+ * The take-in of a swap leg (a pool at input 0 and output 0) under the order `order`: output 1 must
+ * pay the order's payout key (else null: another's swap); then each other output that pays one of
+ * the order's keys — the taker's own commission, the change kept in `amm-swap` (the keyID of the
+ * leg's first input of that kind, the customInstructions with `order`), or the last leg's change to
+ * the wallet (`legDerivation(order, "change")`). A 1Color output is a receipt for self (sender the
+ * user), a P2PKH one a BRC-29 payment or a basket insertion.
  */
-export declare function swapPayoutOf(wallet: WalletInterface, tx: Transaction, vout: number, tokenId: string): Promise<InternalizeOutput | null>;
-/** The pool outpoint (`<txid>.<vout>`) an `amm-swap` row was staged for, from its keyID; null for another row. */
-export declare function stagedPoolOf(row: Pick<WalletOutput, "customInstructions">): string | null;
-/** The token an `amm-swap` row is staged for: its 1Color script's, else (a sats row) its customInstructions' `assetId`. */
-export declare function stagedTokenOf(row: Pick<WalletOutput, "lockingScript" | "customInstructions">): string | null;
-/** The staged legs: token → the pool outpoints its rows were staged for. */
-export declare function stagedLegs(rows: Pick<WalletOutput, "lockingScript" | "customInstructions">[]): Map<string, Set<string>>;
-type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
-/** The silent pass (see the module comment): → the txids taken in. Never throws. */
-export declare function settleStagedSwaps(wallet: WalletInterface, baseOf: (tokenId: string) => string, fetchFn?: FetchFn): Promise<string[]>;
+export declare function legTakeInOf(wallet: WalletInterface, tx: Transaction, tokenId: string, order: string): Promise<InternalizeOutput[] | null>;
+type FetchTx = (tokenId: string, txid: string) => Promise<number[] | null>;
+/** A leg the pass took in: its transaction, its token, the outpoints it spends (`<txid>.<vout>`, the pool's first) and its payout output. */
+export interface ResolvedLeg {
+    txid: string;
+    tokenId: string;
+    inputs: string[];
+    payout: {
+        satoshis: number;
+        tokens?: bigint;
+    };
+}
+/** The pass (see the module comment): → the legs taken in. Never throws. */
+export declare function resolveFromOverlay(wallet: WalletInterface, reads: {
+    spendsAll: (outpoints: string[]) => Promise<SpendAll[]>;
+    tx: FetchTx;
+}): Promise<ResolvedLeg[]>;
 export {};

package/dist/wallet/swapPayouts.js

@@ -1,146 +1,158 @@
 /**
- * Swap legs left in the wallet, settled silently (skein-amm 0.34.0; D18, D24, David Case
- * 2026-11-04). No browser store: the leg's staged rows in the `amm-swap` basket ARE the note — each
- * row's keyID names the pool outpoint the leg was quoted on (`amm-swap-<txid>.<vout>` /
- * `…:sats`, src/market/activeSwap.ts `swapKeyID`). On Your tokens load (`settleStagedSwaps`),
- * reads only, no resend, nothing shown:
+ * Resolve from the overlay (skein-amm 0.40.0, agent-env plans/swap-balance-build-2026-11-05.md
+ * Builder 2 item 5): the overlay is the truth about an `amm-swap` row, not the wallet's own flag.
+ * On load, before a swap starts, and after any refused or rejected leg (`resolveFromOverlay`):
  *
- *   1. the rows grouped by token and pool outpoint;
- *   2. per token, ONE `GET /@<token>/amm/spends?outpoint=a,b` (P8): each pool's spender;
- *   3. a spender: its transaction, `GET /@<token>/amm/tx?id=` (P9: the BEEF as admitted, every
- *      input's source with it); an output paying this wallet's leg key (`swapPayoutOf`, re-derived
- *      from the transaction's own inputs) → the wallet takes it in (`internalizeAction`, which also
- *      marks the staged rows it spends spent); no such output (another's swap) → nothing, the rows
- *      stay the user's;
- *   4. a pool not spent → nothing (the validator checks no expiry: the leg may still land).
+ *   1. every `amm-swap` row (src/market/activeSwap.ts) asked in ONE read of the host's
+ *      `GET <origin>/amm/spends?outpoint=a,b` (each enabled token's `/spends`, the first naming a
+ *      spender);
+ *   2. a spender: its transaction, `GET /@<token>/amm/tx?id=` (the BEEF as admitted, every input's
+ *      source with it); the payout key tried with the spent row's `order` (when it has one) and with
+ *      the transaction's own key input (`legDerivation`; its first token input on a sell, its first
+ *      sats input on a buy);
+ *   3. a match → the leg's take-in (`legTakeInOf`: the payout, the taker's own commission, the
+ *      change — kept in `amm-swap` with the order, or the last leg's to the wallet), ONE
+ *      `internalizeAction` (taking in a transaction the wallet already holds is harmless and
+ *      re-marks its inputs spent); no match → nothing;
+ *   4. again, until no row has a spender the wallet lacks (a take-in's change rows may be spent by
+ *      a later leg whose page was lost).
  *
- * Any failed read or take-in: nothing, the next load tries again.
+ * Any failed read or take-in: nothing, the next pass tries again. 0.34.0's pool-outpoint grouping
+ * of staged rows is gone.
  */
-import { PublicKey, Transaction, Utils } from "@bsv/sdk";
+import { Transaction } from "@bsv/sdk";
 import { WALLET_PAYMENT, brc29PublicKey, identityKeyOf, p2pkhHexOf } from "./brc29.js";
-import { SWAP_BASKET, newReceivingKey, receiptOutput } from "./color.js";
+import { SWAP_BASKET, SWAP_PROTOCOL, newReceivingKey, receiptOutput, swapInstructions, swapSatsInstructions } from "./color.js";
 import { PoolTemplate, decodeOneColor } from "../pool/index.js";
-import { parseTokenId, sdkTokenId, tokenIdOfWire, tokenIdText } from "../lib/tokenId.js";
-import { legDerivation, legKeyInputOf } from "../market/swapAction.js";
+import { parseOutpoint, sdkTokenId } from "../lib/tokenId.js";
+import { changeKeyID, legDerivation, legInputsOf } from "../market/swapAction.js";
 import { tokenP2pkhScript } from "../lp/poolDeploy.js";
 import { basketRows } from "../lp/wallet.js";
-import { readSpends, readTx } from "../lib/overlay.js";
-/**
- * Whether output `vout` of `tx` (a swap: the pool at input 0 and output 0) pays this wallet's leg
- * key, re-derived from the transaction's own inputs (`legDerivation`): the take-in for it, or null.
- * A 1Color output is a receipt (sender the pool's validator), a P2PKH one a BRC-29 payment.
- */
-export async function swapPayoutOf(wallet, tx, vout, tokenId) {
-    const pool = tx.outputs[0] ? PoolTemplate.decode(tx.outputs[0].lockingScript) : null;
-    const out = tx.outputs[vout];
-    const first = tx.outputs[1];
-    if (!pool || !out || !first || vout < 1 || tx.inputs.length < 2)
-        return null;
-    const bsvIn = decodeOneColor(first.lockingScript.toBinary()) !== null;
-    let keyInput;
+/** A row's `order` (its customInstructions'), or undefined. */
+function orderOf(row) {
     try {
-        keyInput = legKeyInputOf(tx, bsvIn);
+        const ci = JSON.parse(row.customInstructions ?? "{}");
+        return typeof ci.order === "string" ? ci.order : undefined;
     }
     catch {
-        return null;
-    }
-    const d = legDerivation(keyInput, vout === 1 ? "payout" : "commission");
-    const script = out.lockingScript.toHex();
-    const token = decodeOneColor(out.lockingScript.toBinary());
-    if (token) {
-        const sdkId = sdkTokenId(tokenId);
-        const k = await newReceivingKey(wallet, sdkId, pool.state.validatorIdentity, d);
-        return tokenP2pkhScript(sdkId, token.amount, k.publicKey) === script ? receiptOutput(vout, k.receipt) : null;
+        return undefined;
     }
-    const identity = await identityKeyOf(wallet);
-    const pub = await brc29PublicKey(wallet, d);
-    if (p2pkhHexOf(PublicKey.fromString(pub).toString()) !== script)
-        return null;
-    return { outputIndex: vout, protocol: WALLET_PAYMENT, paymentRemittance: { ...d, senderIdentityKey: identity } };
 }
-/** The pool outpoint (`<txid>.<vout>`) an `amm-swap` row was staged for, from its keyID; null for another row. */
-export function stagedPoolOf(row) {
-    let ci = {};
-    try {
-        ci = JSON.parse(row.customInstructions ?? "{}");
-    }
-    catch {
+/** The swap's own key input (`legDerivation`'s): its first token input on a sell, its first sats input on a buy; null without one. */
+export function ownKeyInputOf(tx) {
+    const first = tx.outputs[1];
+    if (!first)
         return null;
-    }
-    const m = typeof ci.keyID === "string" ? /^amm-swap-([0-9a-f]{64})\.(\d+)(:sats)?$/.exec(ci.keyID) : null;
-    return m ? `${m[1]}.${m[2]}` : null;
+    const bsvIn = decodeOneColor(first.lockingScript.toBinary()) !== null;
+    const ins = legInputsOf(tx);
+    return (bsvIn ? ins.sats[0] : ins.tokens[0]) ?? null;
 }
-/** The token an `amm-swap` row is staged for: its 1Color script's, else (a sats row) its customInstructions' `assetId`. */
-export function stagedTokenOf(row) {
-    if (row.lockingScript) {
-        const t = decodeOneColor(Utils.toArray(row.lockingScript, "hex"));
-        if (t && t.role === "value" && t.idBytes)
-            return tokenIdOfWire(t.idBytes);
-    }
-    try {
-        const ci = JSON.parse(row.customInstructions ?? "{}");
-        const ref = typeof ci.assetId === "string" ? parseTokenId(ci.assetId) : null;
-        return ref ? tokenIdText(ref) : null;
-    }
-    catch {
+/**
+ * The take-in of a swap leg (a pool at input 0 and output 0) under the order `order`: output 1 must
+ * pay the order's payout key (else null: another's swap); then each other output that pays one of
+ * the order's keys — the taker's own commission, the change kept in `amm-swap` (the keyID of the
+ * leg's first input of that kind, the customInstructions with `order`), or the last leg's change to
+ * the wallet (`legDerivation(order, "change")`). A 1Color output is a receipt for self (sender the
+ * user), a P2PKH one a BRC-29 payment or a basket insertion.
+ */
+export async function legTakeInOf(wallet, tx, tokenId, order) {
+    const pool = tx.outputs[0] ? PoolTemplate.decode(tx.outputs[0].lockingScript) : null;
+    if (!pool || tx.outputs.length < 2 || tx.inputs.length < 2)
         return null;
-    }
-}
-/** The staged legs: token → the pool outpoints its rows were staged for. */
-export function stagedLegs(rows) {
-    const out = new Map();
-    for (const r of rows) {
-        const pool = stagedPoolOf(r);
-        const token = pool ? stagedTokenOf(r) : null;
-        if (!pool || !token)
+    const identity = await identityKeyOf(wallet);
+    const sdkId = sdkTokenId(tokenId);
+    const ins = legInputsOf(tx);
+    const keyed = async (vout, which) => {
+        const out = tx.outputs[vout];
+        const d = legDerivation(order, which);
+        const token = decodeOneColor(out.lockingScript.toBinary());
+        if (token) {
+            const k = await newReceivingKey(wallet, sdkId, identity, d);
+            return tokenP2pkhScript(sdkId, token.amount, k.publicKey) === out.lockingScript.toHex() ? receiptOutput(vout, k.receipt) : null;
+        }
+        const pub = await brc29PublicKey(wallet, d);
+        return p2pkhHexOf(pub) === out.lockingScript.toHex() ? { outputIndex: vout, protocol: WALLET_PAYMENT, paymentRemittance: { ...d, senderIdentityKey: identity } } : null;
+    };
+    const payout = await keyed(1, "payout");
+    if (!payout)
+        return null;
+    const outs = [payout];
+    const swapKey = async (keyID) => (await wallet.getPublicKey({ protocolID: SWAP_PROTOCOL, keyID, counterparty: "self", forSelf: true })).publicKey;
+    const satsChange = ins.sats[0] ? { keyID: changeKeyID(ins.sats[0]), pub: await swapKey(changeKeyID(ins.sats[0])) } : null;
+    const tokenChange = ins.tokens[0] ? { keyID: changeKeyID(ins.tokens[0]), pub: await swapKey(changeKeyID(ins.tokens[0])) } : null;
+    for (let vout = 2; vout < tx.outputs.length; vout++) {
+        const out = tx.outputs[vout];
+        const script = out.lockingScript.toHex();
+        const token = decodeOneColor(out.lockingScript.toBinary());
+        if (token && tokenChange && tokenP2pkhScript(sdkId, token.amount, tokenChange.pub) === script) {
+            outs.push({ outputIndex: vout, protocol: "basket insertion", insertionRemittance: { basket: SWAP_BASKET, customInstructions: swapInstructions({ assetId: sdkId, amount: token.amount, protocolID: SWAP_PROTOCOL, keyID: tokenChange.keyID, counterparty: "self", order }) } });
             continue;
-        const s = out.get(token) ?? new Set();
-        s.add(pool);
-        out.set(token, s);
+        }
+        if (!token && satsChange && p2pkhHexOf(satsChange.pub) === script) {
+            outs.push({ outputIndex: vout, protocol: "basket insertion", insertionRemittance: { basket: SWAP_BASKET, customInstructions: swapSatsInstructions({ protocolID: SWAP_PROTOCOL, keyID: satsChange.keyID, counterparty: "self", order }) } });
+            continue;
+        }
+        const mine = (await keyed(vout, "commission")) ?? (await keyed(vout, "change"));
+        if (mine)
+            outs.push(mine);
     }
-    return out;
+    return outs;
 }
-/** The silent pass (see the module comment): → the txids taken in. Never throws. */
-export async function settleStagedSwaps(wallet, baseOf, fetchFn) {
+/** The pass (see the module comment): → the legs taken in. Never throws. */
+export async function resolveFromOverlay(wallet, reads) {
     const taken = [];
-    let rows;
-    try {
-        rows = await basketRows(wallet, SWAP_BASKET);
-    }
-    catch {
-        return taken;
-    }
-    for (const [tokenId, pools] of stagedLegs(rows)) {
+    const tried = new Set();
+    for (let round = 0; round < 64; round++) {
+        let rows;
+        let spends;
         try {
-            const base = baseOf(tokenId);
-            const spends = await readSpends(base, [...pools], fetchFn);
-            const spenders = [...new Set(spends.map((s) => s.spentBy).filter((t) => typeof t === "string"))];
-            for (const txid of spenders) {
-                try {
-                    const beef = await readTx(base, txid, fetchFn);
-                    if (!beef)
-                        continue;
-                    const tx = Transaction.fromAtomicBEEF(beef);
-                    const outputs = [];
-                    for (let vout = 1; vout < tx.outputs.length; vout++) {
-                        const o = await swapPayoutOf(wallet, tx, vout, tokenId);
-                        if (o)
-                            outputs.push(o);
-                    }
-                    if (outputs.length === 0)
+            rows = await basketRows(wallet, SWAP_BASKET);
+            if (rows.length === 0)
+                return taken;
+            spends = await reads.spendsAll(rows.map((r) => r.outpoint.replace("_", ".")));
+        }
+        catch {
+            return taken;
+        }
+        const byOutpoint = new Map(rows.map((r) => [r.outpoint.replace("_", "."), r]));
+        let took = false;
+        for (const s of spends) {
+            if (!s.spentBy || !s.tokenId || tried.has(s.spentBy))
+                continue;
+            tried.add(s.spentBy);
+            try {
+                const beef = await reads.tx(s.tokenId, s.spentBy);
+                if (!beef)
+                    continue;
+                const tx = Transaction.fromAtomicBEEF(beef);
+                const op = parseOutpoint(s.outpoint);
+                const row = op ? byOutpoint.get(`${op.txid}.${op.vout}`) : undefined;
+                const orders = [...new Set([row ? orderOf(row) : undefined, ownKeyInputOf(tx) ?? undefined].filter((x) => typeof x === "string"))];
+                for (const order of orders) {
+                    const outputs = await legTakeInOf(wallet, tx, s.tokenId, order);
+                    if (!outputs)
                         continue;
                     const r = await wallet.internalizeAction({ tx: beef, outputs, description: "AMM swap payout", labels: ["amm-swap"] });
-                    if (r.accepted)
-                        taken.push(txid);
-                }
-                catch {
-                    /* the next load */
+                    if (r.accepted) {
+                        const out1 = tx.outputs[1];
+                        const t = decodeOneColor(out1.lockingScript.toBinary());
+                        taken.push({
+                            txid: s.spentBy,
+                            tokenId: s.tokenId,
+                            inputs: tx.inputs.map((i) => `${i.sourceTXID ?? i.sourceTransaction?.id("hex")}.${i.sourceOutputIndex}`),
+                            payout: { satoshis: out1.satoshis ?? 0, ...(t ? { tokens: t.amount } : {}) },
+                        });
+                        took = true;
+                    }
+                    break;
                 }
             }
+            catch {
+                /* the next pass */
+            }
         }
-        catch {
-            /* the next load */
-        }
+        if (!took)
+            return taken;
     }
     return taken;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcasegr/amm-client",
-  "version": "0.38.2",
+  "version": "0.41.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.38.2",
+    "@dcasegr/amm-engine": "0.41.1",
     "cbor2": "^2.3.0"
   },
   "peerDependencies": {