@eco-incorp/sauce 0.99.0

package/sdk/dist/token/svm.js

@@ -0,0 +1,188 @@
+/**
+ * The SPL Token arm — statement/expression builders for the universal token interface's SVM
+ * lowering. Reuses the shipped SPL knowledge in `sdk/src/svm/venues/scale-common.ts`.
+ *
+ * ACCOUNT MODEL. Every account a program touches is a `main` PARAMETER, declared in the order the
+ * caller must attach them; the compiler reports that order back as the account manifest, and a slot
+ * carries the role its annotation asserts (`Account<Writable>`, `Account<Signer>`). So a ref name
+ * here becomes an identifier in the emitted source rather than a string, an account read is
+ * `svm.sload(ref, off, len).toLe()`, and a CPI is `svm.call(program, [accounts], data)` where the
+ * program is itself one of those params.
+ *
+ * That collapses three things the string-ref form needed:
+ *   - the `accountData(ref, 0, 0)` zero-length read whose only job was to force the CPI target into
+ *     an account slot — a param already is one;
+ *   - the split between the CPI target as a baked VALUE and as a separate account ref, and with it
+ *     the "two independent bindings a caller must keep in sync" hazard: there is now one binding;
+ *   - the `le8` byteswap helper and the `abi.encode(...).slice(...)` dance, replaced by
+ *     `.toBytesLe(width)` (and `abi.encode` is not available on the svm target anyway).
+ *
+ * Because `svm.call` invokes whatever account occupies the program slot, each concrete token program
+ * is pinned with `require(<ref> == <pubkey>)`. The baked-value form got that check for free (the
+ * engine resolved the CPI by scanning the attached accounts for the baked pubkey); this restores it
+ * explicitly.
+ */
+import { getAddressEncoder } from "@solana/kit";
+import { TOKEN_2022_PROGRAM, TOKEN_PROGRAM } from "../svm/venues/scale-common.js";
+import { formatBigint } from "../deposit/format.js";
+import { MINT_DECIMALS_OFFSET, SPL_AMOUNT_OFFSET, SPL_APPROVE_CHECKED, SPL_TRANSFER_CHECKED, } from "./types.js";
+import { ownerRef, toAmountBigint, tokenProgramRef } from "./params.js";
+const ADDRESS_ENCODER = getAddressEncoder();
+/** A ref becomes a `main` parameter name, so it has to be spellable as one. */
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function addressToBigint(addr) {
+    const bytes = new Uint8Array(ADDRESS_ENCODER.encode(addr));
+    let v = 0n;
+    for (const b of bytes)
+        v = (v << 8n) | BigInt(b);
+    return v;
+}
+/** Well-known SPL program ids, converted once to the bigint literal the identity check wants. */
+export const TOKEN_PROGRAM_BIGINT = addressToBigint(TOKEN_PROGRAM);
+export const TOKEN_2022_PROGRAM_BIGINT = addressToBigint(TOKEN_2022_PROGRAM);
+/** The SauceScript expression for a `SvmTokenProgramInput` CPI-target VALUE. Defaults to `"spl"`. */
+export function tokenProgramValueExpr(input) {
+    if (input === undefined || input === "spl")
+        return formatBigint(TOKEN_PROGRAM_BIGINT);
+    if (input === "token-2022")
+        return formatBigint(TOKEN_2022_PROGRAM_BIGINT);
+    return formatBigint(input);
+}
+export function assertRefIsIdentifier(ref, label) {
+    if (!IDENTIFIER_RE.test(ref)) {
+        throw new Error(`${label}: svm ref '${ref}' must be a valid identifier — it becomes a main() account parameter`);
+    }
+}
+export function newSvmEmitState() {
+    return { pinnedTokenPrograms: new Map() };
+}
+/** `Account`, `Account<Writable>`, `Account<Signer>` or `Account<Writable, Signer>`. */
+export function accountParamType({ writable, signer }) {
+    const args = [...(writable ? ["Writable"] : []), ...(signer ? ["Signer"] : [])];
+    return args.length > 0 ? `Account<${args.join(", ")}>` : "Account";
+}
+/** The refs one spec needs, in attach order, each with the role that spec demands of it. */
+function specParams(spec) {
+    if (spec.op === "balanceOf") {
+        return [{ ref: spec.svm.source, writable: false, signer: false }];
+    }
+    const refs = spec.svm;
+    const counterparty = spec.op === "transfer"
+        ? { ref: refs.dest, writable: true, signer: false }
+        : { ref: refs.delegate, writable: false, signer: false };
+    return [
+        { ref: tokenProgramRef(refs), writable: false, signer: false },
+        { ref: refs.mint, writable: false, signer: false },
+        { ref: refs.source, writable: true, signer: false },
+        counterparty,
+        { ref: ownerRef(refs), writable: false, signer: true },
+    ];
+}
+/**
+ * Every account the program's specs touch, in FIRST-USE order — the order a caller attaches them
+ * and the order the manifest reports. A ref shared across ops (`owner`/`tokenProgram` by design)
+ * appears once, holding the strongest role any op demanded of it.
+ */
+export function svmAccountParams(specs) {
+    const byRef = new Map();
+    for (const spec of specs) {
+        for (const param of specParams(spec)) {
+            assertRefIsIdentifier(param.ref, "tokenSource");
+            const seen = byRef.get(param.ref);
+            if (seen === undefined) {
+                byRef.set(param.ref, { ...param });
+                continue;
+            }
+            seen.writable = seen.writable || param.writable;
+            seen.signer = seen.signer || param.signer;
+        }
+    }
+    return [...byRef.values()];
+}
+/** The `main(...)` parameter list for `specs`, annotated with each slot's required role. */
+export function svmAccountParamList(specs) {
+    return svmAccountParams(specs)
+        .map((param) => `${param.ref}: ${accountParamType(param)}`)
+        .join(", ");
+}
+// ── statements ──
+function amountExpr(amount, sourceRef, label) {
+    if (amount === "balance")
+        return `svm.sload(${sourceRef}, ${SPL_AMOUNT_OFFSET}, 8).toLe()`;
+    // formatBigint takes a bigint, so a `number` amount CANNOT be stringified into the emitted
+    // source without going through toAmountBigint first.
+    return formatBigint(toAmountBigint(amount, label));
+}
+/**
+ * `require(<ref> == <pubkey>)`, emitted once per (ref, program) pair. A ref names ONE attached
+ * account, so two ops pinning the same ref to different programs cannot both be satisfied -- the
+ * second would silently execute against the first's program. Distinct programs need distinct refs.
+ */
+function tokenProgramPin(ref, tokenProgram, state) {
+    const value = tokenProgramValueExpr(tokenProgram);
+    const pinned = state.pinnedTokenPrograms.get(ref);
+    if (pinned === value)
+        return undefined;
+    if (pinned !== undefined) {
+        throw new Error(`svm token: ref '${ref}' is pinned to ${pinned} and cannot also be ${value} -- one ref is one ` +
+            `attached account. Give the ops distinct svm.tokenProgram refs.`);
+    }
+    state.pinnedTokenPrograms.set(ref, value);
+    return `require(${ref} == ${value});`;
+}
+/**
+ * `svm.call(...)` block for a `TransferChecked`/`ApproveChecked` CPI. `index` disambiguates the
+ * bound-local names (`dec0`, `amtv0`, ...) across a multi-op program; a method call on a literal is
+ * outside the compiler's supported subset, so each operand is bound to a const first.
+ */
+function checkedCallLines(opts) {
+    const { index, discriminant, refs, amount, tokenProgram, counterpartyRef, label, state } = opts;
+    const mintRef = refs.mint;
+    const sourceRef = refs.source;
+    const ownerName = ownerRef(refs);
+    const tpRef = tokenProgramRef(refs);
+    const lines = [];
+    const pin = tokenProgramPin(tpRef, tokenProgram, state);
+    if (pin !== undefined)
+        lines.push(pin);
+    lines.push(`const disc${index} = hex\`${discriminant.toString(16).padStart(2, "0")}\`;`, `const amtv${index} = ${amountExpr(amount, sourceRef, label)};`, `const dec${index} = svm.sload(${mintRef}, ${MINT_DECIMALS_OFFSET}, 1).toLe();`, `const data${index} = disc${index}.concat(amtv${index}.toBytesLe(8)).concat(dec${index}.toBytesLe(1));`, `svm.call(${tpRef}, [${sourceRef}, ${mintRef}, ${counterpartyRef}, ${ownerName}], data${index});`);
+    return lines;
+}
+export function svmTransferLines(spec, index, state) {
+    const refs = spec.svm;
+    return checkedCallLines({
+        index,
+        discriminant: SPL_TRANSFER_CHECKED,
+        refs,
+        amount: spec.amount,
+        tokenProgram: spec.tokenProgram,
+        counterpartyRef: refs.dest,
+        label: "Token.transfer amount",
+        state,
+    });
+}
+export function svmApproveLines(spec, index, state) {
+    const refs = spec.svm;
+    return checkedCallLines({
+        index,
+        discriminant: SPL_APPROVE_CHECKED,
+        refs,
+        amount: spec.amount,
+        tokenProgram: spec.tokenProgram,
+        counterpartyRef: refs.delegate,
+        label: "Token.approve amount",
+        state,
+    });
+}
+export function svmBalanceExpression(spec) {
+    const refs = spec.svm;
+    return `svm.sload(${refs.source}, ${SPL_AMOUNT_OFFSET}, 8).toLe()`;
+}
+/** The account manifest refs, in attach order, for `transfer`/`approve` with the given refs. */
+export function accountRefsForTransfer(refs) {
+    return [tokenProgramRef(refs), refs.mint, refs.source, refs.dest, ownerRef(refs)];
+}
+export function accountRefsForApprove(refs) {
+    return [tokenProgramRef(refs), refs.mint, refs.source, refs.delegate, ownerRef(refs)];
+}
+//# sourceMappingURL=svm.js.map

package/sdk/dist/token/svm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"svm.js","sourceRoot":"","sources":["../../src/token/svm.ts"],"names":[],"mappings":"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"}

package/sdk/dist/token/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The universal token interface — types + registry constants. Sibling module to `swap/` and
+ * `deposit/`: compiler-free, SauceScript SOURCE emission only. See `sdk/src/token/index.ts` for the
+ * module-level overview and `sdk/src/token/source.ts` for the per-target emission seam.
+ */
+/** A 20-byte EVM address, as an ordinary `0x`-prefixed hex string. */
+export type Address = `0x${string}`;
+/** Anything the token normalizers accept for an address-shaped field. */
+export type AddressInput = Address | bigint;
+/**
+ * `"evm"` is a target-agnostic alias for the ERC20 arm — the emitted SauceScript text is byte-
+ * identical for `"evm"`/`"v1"`/`"v12"` (only `compile()`'s own `target` option, not this module,
+ * decides which Huff runtime the text lowers against). `"svm"` selects the SPL Token arm.
+ */
+export type TokenTarget = "evm" | "v1" | "v12" | "svm";
+export type TokenOp = "transfer" | "approve" | "balanceOf";
+/** SPL Token TransferChecked instruction discriminant. */
+export declare const SPL_TRANSFER_CHECKED = 12;
+/** SPL Token ApproveChecked instruction discriminant. */
+export declare const SPL_APPROVE_CHECKED = 13;
+/** Offset of the SPL token account's u64 `amount` field (identical in classic SPL + Token-2022). */
+export declare const SPL_AMOUNT_OFFSET = 64;
+/** Offset of the mint's `decimals` byte (identical in the first 82 bytes of both programs' mints). */
+export declare const MINT_DECIMALS_OFFSET = 44;
+/**
+ * SVM account refs a token op needs, as caller-named strings resolved at EXECUTION time (the same
+ * contract `svmSettleRefs` establishes) — never resolved addresses baked into the source. Defaults
+ * cover the common single-op case; a multi-op program must pass distinct names per op.
+ */
+export interface SvmTokenRefs {
+    /** The SPL token account being debited (transfer/approve) or read (balanceOf). */
+    source: string;
+    /** The mint, read on-chain for decimals by `*Checked`. Required for transfer/approve. */
+    mint?: string;
+    /** The recipient's token account. Required for `transfer`. */
+    dest?: string;
+    /** The delegate's identity (not an account read — see `svm.ts`). Required for `approve`. */
+    delegate?: string;
+    /** The signing authority. Defaults to `"owner"`. */
+    owner?: string;
+    /** The CPI-target account ref (must be attached so the engine can resolve the CPI). Defaults to
+     *  `"tokenProgram"`. */
+    tokenProgram?: string;
+}
+/**
+ * The SVM CPI target VALUE — a well-known program id by name, or a raw pubkey as a bigint. Always a
+ * LITERAL: every account identity a program touches is an attach slot, so a caller-supplied identity
+ * belongs in `SvmTokenRefs.tokenProgram` (the ref this value is pinned against), never in the value.
+ */
+export type SvmTokenProgramInput = "spl" | "token-2022" | bigint;
+export interface TokenTransferSpec {
+    /** EVM: the ERC20 contract. Required on an EVM target. */
+    token?: AddressInput;
+    /** EVM: the recipient. Required on an EVM target. */
+    to?: AddressInput;
+    /**
+     * `"balance"` reads the live balance instead. A `number` must be a SAFE integer: past 2^53-1 the
+     * double has already been rounded, so pass a bigint.
+     */
+    amount: bigint | number | "balance";
+    /** SVM: the account refs this op touches. Required on `target: "svm"`. */
+    svm?: SvmTokenRefs;
+    /** SVM: the CPI target value. Defaults to `"spl"`. */
+    tokenProgram?: SvmTokenProgramInput;
+}
+export interface TokenApproveSpec {
+    token?: AddressInput;
+    /** EVM: the approved spender. Required on an EVM target. */
+    spender?: AddressInput;
+    /**
+     * `"balance"` reads the live balance instead. A `number` must be a SAFE integer: past 2^53-1 the
+     * double has already been rounded, so pass a bigint.
+     */
+    amount: bigint | number | "balance";
+    svm?: SvmTokenRefs;
+    tokenProgram?: SvmTokenProgramInput;
+}
+export interface TokenBalanceSpec {
+    token?: AddressInput;
+    /** EVM: the address whose balance is read, or `"self"`. Required on an EVM target. */
+    owner?: AddressInput | "self";
+    svm?: Pick<SvmTokenRefs, "source">;
+}
+export type TokenSpec = ({
+    op: "transfer";
+} & TokenTransferSpec) | ({
+    op: "approve";
+} & TokenApproveSpec) | ({
+    op: "balanceOf";
+} & TokenBalanceSpec);
+//# sourceMappingURL=types.d.ts.map

package/sdk/dist/token/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/token/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sEAAsE;AACtE,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAEpC,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvD,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;AAE3D,0DAA0D;AAC1D,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,oGAAoG;AACpG,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,sGAAsG;AACtG,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;4BACwB;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,YAAY,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,qDAAqD;IACrD,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB;;;OAGG;IACH,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACpC,0EAA0E;IAC1E,GAAG,CAAC,EAAE,YAAY,CAAC;IACnB,sDAAsD;IACtD,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;OAGG;IACH,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACpC,GAAG,CAAC,EAAE,YAAY,CAAC;IACnB,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,sFAAsF;IACtF,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IAC9B,GAAG,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;CACpC;AAED,MAAM,MAAM,SAAS,GACjB,CAAC;IAAE,EAAE,EAAE,UAAU,CAAA;CAAE,GAAG,iBAAiB,CAAC,GACxC,CAAC;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG,gBAAgB,CAAC,GACtC,CAAC;IAAE,EAAE,EAAE,WAAW,CAAA;CAAE,GAAG,gBAAgB,CAAC,CAAC"}

package/sdk/dist/token/types.js

@@ -0,0 +1,14 @@
+/**
+ * The universal token interface — types + registry constants. Sibling module to `swap/` and
+ * `deposit/`: compiler-free, SauceScript SOURCE emission only. See `sdk/src/token/index.ts` for the
+ * module-level overview and `sdk/src/token/source.ts` for the per-target emission seam.
+ */
+/** SPL Token TransferChecked instruction discriminant. */
+export const SPL_TRANSFER_CHECKED = 12;
+/** SPL Token ApproveChecked instruction discriminant. */
+export const SPL_APPROVE_CHECKED = 13;
+/** Offset of the SPL token account's u64 `amount` field (identical in classic SPL + Token-2022). */
+export const SPL_AMOUNT_OFFSET = 64;
+/** Offset of the mint's `decimals` byte (identical in the first 82 bytes of both programs' mints). */
+export const MINT_DECIMALS_OFFSET = 44;
+//# sourceMappingURL=types.js.map

package/sdk/dist/token/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/token/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiBH,0DAA0D;AAC1D,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AACvC,yDAAyD;AACzD,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,oGAAoG;AACpG,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AACpC,sGAAsG;AACtG,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC"}

package/sdk/dist/verify/decode.d.ts

@@ -0,0 +1,216 @@
+/**
+ * SAUCE SETTLE PAYLOAD WIRE FORMAT — `recipes/settle.sauce.ts` on engine target v12, compiled by
+ * the published Rust compiler.
+ *
+ * `payload := PROGRAM || ARGS`. Byte 0 is the first program byte — there is no header, magic,
+ * version byte or length prefix. The two regions are DISJOINT: the program is a compile-time
+ * constant, the arguments are per-execution bytes the engine reads back through CALLDATA.
+ *
+ * ```
+ * payload     := program , args
+ * program     := 362 bytes                        ; SETTLE_WIRE.PROGRAM_BYTES — invariant
+ * args        := head , token_array
+ * head        := tokens_ptr , minout , recipient  ; three 32-byte big-endian words
+ * tokens_ptr  := word, value = 96                 ; byte offset WITHIN args of token_array
+ * minout      := word, uint256, value = minOut    ; 0 = floor disabled
+ * recipient   := word, uint160 in the LOW 20 bytes, upper 12 zero, MUST be nonzero
+ * token_array := count , token{count}             ; at args + 96
+ * count       := word, uint256, value = tokens.length, MUST be >= 1
+ * token       := word, uint160 in the LOW 20 bytes, upper 12 zero
+ * ```
+ *
+ * So `args` is exactly `128 + 32 * tokens.length` bytes, and `tokens[i]` — in SOURCE order, index 0
+ * is the floor token — sits at `PROGRAM_BYTES + 128 + 32*i`. This is the compiler's appended-args
+ * ABI: a scalar entry argument occupies one word at `PROGRAM_BYTES + slot*32`, and a dynamic array
+ * spends its word on a pointer to `[count][element…]`, ABI-style, rooted at the start of `args`.
+ *
+ * §4 CANONICALITY — WHY THIS IS STRICTER THAN THE ENGINE. Measured on a real v12 runtime, the engine
+ * ACCEPTS five payloads this decoder rejects — `SETTLE_REJECTIONS.filter(r => r.engineAccepts)` is the
+ * list, and the suite pins it, so this prose is a description and not the source of truth. They are: a
+ * `tokens_ptr` other than 96 (it follows any offset), trailing bytes past the token array, a token
+ * word whose upper 12 bytes are dirty (the call target is masked to 160 bits, so it sweeps the same
+ * token), a dirty RECIPIENT word, and a ZERO recipient. The first three move the same tokens against
+ * any ERC20. The last two both follow from one fact: the engine passes the recipient word through
+ * UNMASKED and never inspects it, so what refuses them is the callee's own `address` / zero check —
+ * against a token that omits those (Vyper, older solc, a forwarding proxy) they deliver too, the zero
+ * case to address(0).
+ * Each is a DIFFERENT byte string producing IDENTICAL behavior. Accepting them would make the decode
+ * non-injective and put `encodeSettleProgram`'s re-encode-and-compare (§5) at odds with a
+ * decode-and-compare, so ALL of them are refused — the recipient cases included, precisely because
+ * whether they are caught depends on the callee rather than on the payload. An accepted payload is the UNIQUE
+ * byte encoding of the values it decodes to.
+ *
+ * DO NOT PORT A POSITIONAL DECODER ONTO THIS WIRE. Values here are fixed 32-byte words and the
+ * tokens head word is a POINTER, not a value (see the layout at the top of this file) — so a reader
+ * that walks the tail by position,
+ * as a decoder for a PUSH-prologue encoding must, lands on the offset and returns a plausible
+ * wrong answer instead of failing. That is the one mistake this format invites, and §4 is what
+ * closes it.
+ *
+ * WHAT THIS PROVES. `decodeSettleProgram` is STRUCTURAL: it pins the program's LENGTH and reads the
+ * tail, so it tells you which `(tokens, minOut, recipient)` a payload carries and nothing about
+ * what the 362 program bytes do. `validateSettleProgram` adds the authenticity half — one
+ * `keccak256` over the WHOLE program against `SETTLE_WIRE.PROGRAM_HASH` — and that is now a
+ * complete answer rather than a partial one: because the arguments left the program, a matching
+ * hash means the payload runs the audited `settle.sauce.ts` and nothing else — a statement about
+ * the bytes alone, needing nothing the caller has to compile and compare for themselves.
+ *
+ * Dependency closure is `viem` only (`keccak256`) — no compiler, no `node:*`, no artifact
+ * resolution — so this surface stays safe to import in a browser or an edge runtime. That closure
+ * is the reason `/verify` decodes rather than recompiling-and-comparing: a recompile would put a
+ * 1.96 MB wasm compiler in every consumer's dependency graph to answer a question `viem` answers
+ * with one hash.
+ */
+import { type Hex } from "viem";
+/** An accepted program: its `keccak256` AND the byte length the payload splits at. Both are needed —
+ *  the split happens before any hash is computed, so a historical pin whose program was a different
+ *  length cannot be matched by hash alone. */
+export interface ProgramPin {
+    hash: Hex;
+    bytes: number;
+}
+/** Stable failure codes — safe to `switch` on. Every one is a REAL rejection this decoder makes.
+ *
+ *  BREAKING vs the v1 grammar: eight codes are GONE, because the defects they named cannot occur on a
+ *  fixed-width wire. `NON_MINIMAL_PUSH`, `TRUNCATED_PUSH`, `TRUNCATED_MINOUT`, `TRUNCATED_RECIPIENT`
+ *  and `OVERSIZE_ADDRESS` all described a variable-length PUSH prologue that no longer exists;
+ *  `ARITY_MISMATCH` and `NOT_SETTLE_SHAPED` described shape inference the whole-program hash now
+ *  settles outright; `BODY_LENGTH` described a body slice that is no longer a separate region. Their
+ *  uniqueness role is taken by §4's canonicality rules and `PROGRAM_HASH`. Only `EMPTY` and
+ *  `ZERO_RECIPIENT` carry over. A consumer with an exhaustive `switch` on the old union will compile
+ *  and silently stop matching, which is why this ships as a breaking change. */
+export type SettleFailureCode = "EMPTY" | "PROGRAM_TRUNCATED" | "ARGS_TRUNCATED" | "ARGS_OVERLONG" | "TOKENS_OFFSET" | "TOKENS_EMPTY" | "DIRTY_ADDRESS_WORD" | "ZERO_RECIPIENT" | "PROGRAM_HASH";
+export declare class SettleDecodeError extends Error {
+    readonly code: SettleFailureCode;
+    constructor(code: SettleFailureCode, message: string);
+}
+export interface DecodedSettleProgram {
+    /** The swept token list, in SOURCE order (index 0 is the FLOOR token — the wire does not reverse). */
+    tokens: Address20[];
+    minOut: bigint;
+    recipient: Address20;
+    /** `tokens[0]` — the floor token, named for readability at call sites. */
+    floorToken: Address20;
+    /** The leading bytes the payload was split at — `SETTLE_WIRE.PROGRAM_BYTES` by default, or the
+     *  matched `ProgramPin.bytes` when validating against a historical pin. Argument-independent. */
+    program: Hex;
+    /** `keccak256(program)`. Compare against `SETTLE_WIRE.PROGRAM_HASH`, or let
+     *  `validateSettleProgram` do it. */
+    programHash: Hex;
+    /** The argument tail — everything after the program. */
+    args: Hex;
+    argsSize: number;
+    payloadSize: number;
+}
+/** A 20-byte address rendered as lowercase 0x-hex — deliberately NOT `viem`'s `Address` branded
+ *  type: callers that want an EIP-55 checksum should `getAddress()` it themselves. */
+export type Address20 = `0x${string}`;
+/** Internal parse result — used by both the throwing `decodeSettleProgram` and the non-throwing
+ *  `bestEffortDecode`, which keeps partial state past a failure. */
+export interface SettleParse {
+    bytes: Uint8Array;
+    program: Uint8Array | null;
+    programHash: Hex | null;
+    args: Uint8Array | null;
+    /** The `tokens` head word as it appears on the wire — `SETTLE_WIRE.HEAD_BYTES` on a canonical
+     *  payload. Recorded even when wrong, so a report can say what it was. */
+    tokensOffset: bigint | null;
+    minOut: bigint | null;
+    recipient: bigint | null;
+    /** The recipient word BEFORE masking — what the engine actually passes to the token, since it does
+     *  not mask that word. Differs from `recipient` exactly when the upper 12 bytes are dirty. */
+    recipientWord: bigint | null;
+    recipientNonZero: boolean;
+    /** The declared element count, READ AT THE CANONICAL OFFSET 96. Values past what the payload can
+     *  hold are recorded here and reported as `ARGS_TRUNCATED`.
+     *
+     *  When `fatal.code` is `TOKENS_OFFSET` this is NOT what the engine reads: the engine follows the
+     *  payload's own pointer, this reads at 96, and the two name different arrays. Use
+     *  `bestEffortDecode`, which declines that case, rather than reporting off raw parse state. */
+    tokenCount: bigint | null;
+    /** Element words as they appear on the wire, unmasked, so a dirty word is visible to a report. Read
+     *  at the canonical offset — same `TOKENS_OFFSET` caveat as `tokenCount`. */
+    tokenWords: bigint[];
+    /** The first fatal failure, in scan order — null iff the payload is canonical. */
+    fatal: {
+        code: SettleFailureCode;
+        message: string;
+    } | null;
+}
+/** Best-effort single left-to-right pass — never throws. This is the shared engine both
+ *  `decodeSettleProgram` (throws on `parse.fatal`) and `bestEffortDecode` (keeps whatever DID
+ *  parse even when a later stage failed) run on top of. */
+export declare function parseSettleProgram(payload: Hex, programBytes?: number): SettleParse;
+/** Decode whenever the shape is well-formed enough to name a full `(tokens, minOut, recipient)` —
+ *  even when a check that does not block reading (a trailing-slack tail, a dirty address word, a
+ *  zero recipient) would make `decodeSettleProgram` throw — so a rejected payload's decoded intent is
+ *  still visible to a caller debugging the rejection.
+ *
+ *  DECLINES wherever the report would not match execution — the whole point being that on a hostile
+ *  payload, reporting nothing beats reporting a wrong answer confidently. Two cases:
+ *
+ *  - a non-canonical tokens pointer: the engine follows it, this reads at the canonical offset, so the
+ *    two name different TOKENS.
+ *  - a dirty RECIPIENT word: `recipient` is masked here, but the engine does not mask that word (§4),
+ *    so execution addresses a different 256-bit key than the masked answer would suggest.
+ *
+ *  A dirty TOKEN word is NOT declined: the engine masks a call target to 160 bits, so there the masked
+ *  answer is exactly what executes, and reporting it is what shows the payload's true meaning. */
+export declare function bestEffortDecode(parse: SettleParse): DecodedSettleProgram | null;
+/**
+ * Decode a settle payload back into `(tokens, minOut, recipient)`. STRICT: rejects a non-canonical
+ * tokens pointer, a tail longer or shorter than the token count implies, an address word with
+ * dirty upper bytes, and a zero recipient — see §4 for why. Throws `SettleDecodeError` (carrying a
+ * stable `.code`) on any of the failures in `SettleFailureCode`.
+ *
+ * This is a STRUCTURAL decode: it proves the payload is `362 bytes || a canonical argument tail`.
+ * It does NOT prove those 362 bytes are the settle program you audited — any 362-byte prefix
+ * passes. Use `validateSettleProgram` when that matters, which is nearly always.
+ */
+export declare function decodeSettleProgram(payload: Hex, programBytes?: number): DecodedSettleProgram;
+/**
+ * `decodeSettleProgram` plus the authenticity pin: the payload's 362 program bytes must hash to
+ * `SETTLE_WIRE.PROGRAM_HASH`. Because the arguments no longer live inside the program, a match
+ * means the payload runs the audited `recipes/settle.sauce.ts` and nothing else — the whole
+ * question, not the structural half.
+ *
+ * Throws `SettleDecodeError` with code `PROGRAM_HASH` when the program is a different 362 bytes,
+ * and whatever `decodeSettleProgram` would throw otherwise.
+ *
+ * `accepted` overrides the pin. The dependency is a caret range and `SETTLE_WIRE` documents that a
+ * codegen change is answered by RE-PINNING — at which point every intent already on chain carries the
+ * OLD program, and a single hard-coded pin makes all of them unverifiable. Pass the pins you accept
+ * (the current one plus any historical ones) to keep those payloads readable across a re-pin.
+ *
+ * A PIN IS A HASH *AND* A LENGTH, which is why a bare hash is not enough. The payload is split into
+ * program and argument tail at a byte offset, before any hash is computed — so if a re-pin changes the
+ * program's length (the likely outcome of a codegen change), splitting a historical payload at the NEW
+ * length yields a wrong program and a truncated tail, and it dies as `ARGS_TRUNCATED` without any hash
+ * ever being compared. Each entry may be `{ hash, bytes }`; a bare `Hex` means the CURRENT
+ * `SETTLE_WIRE.PROGRAM_BYTES` and is only safe for a same-length re-pin. Candidates are tried in order
+ * and the first whose program hash matches wins. Defaults to the current pin.
+ */
+export declare function validateSettleProgram(payload: Hex, accepted?: readonly (Hex | ProgramPin)[]): DecodedSettleProgram;
+/**
+ * §5 of the wire spec — the cheaper, EQUIVALENT alternative to scan-and-check: when the caller
+ * already knows the intended `(tokens, minOut, recipient)` (the normal case — they asked for the
+ * swap), encode them directly and `memcmp`/hash-compare the whole payload rather than decoding.
+ * Given §4 this produces the UNIQUE canonical encoding, so `encodeSettleProgram(...)` equals
+ * `payload` exactly when `validateSettleProgram(payload)` succeeds with those values — in one
+ * comparison, with no parser exposed to a hostile input at all. This is the recommended
+ * non-TypeScript (Solidity/Go/Python) implementation, where a payload is bytes and the comparison is
+ * a plain `memcmp`.
+ *
+ * THE EQUIVALENCE IS OVER BYTES, NOT OVER HEX SPELLINGS. `validateSettleProgram` accepts any spelling
+ * of the same bytes — uppercase, a `0X` prefix, no prefix at all — while this returns canonical
+ * lowercase `0x`. So `validateSettleProgram(p.toUpperCase())` succeeds where
+ * `encodeSettleProgram(...) === p.toUpperCase()` is `false`. A string `===` is only equivalent once
+ * both sides are in canonical spelling; normalize first, or compare decoded bytes.
+ *
+ * `programHex` is supplied by the caller — pass the program you compiled yourself. There is
+ * deliberately no default: the bytes you compare against should be ones you derived, not ones
+ * shipped alongside the claim they support. `SETTLE_WIRE.PROGRAM_HASH` is what to check them
+ * against once you have them.
+ */
+export declare function encodeSettleProgram(tokens: readonly (bigint | `0x${string}`)[], minOut: bigint, recipient: bigint | `0x${string}`, programHex: Hex): Hex;
+//# sourceMappingURL=decode.d.ts.map

package/sdk/dist/verify/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/verify/decode.ts"],"names":[],"mappings":"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"}