@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/venues/zerofi/index.js

@@ -0,0 +1,364 @@
+/**
+ * ZeroFi venue adapter (program ZERor4xhbUycZ6gb9ntrhqscUcZmAbQDjEAtCf4hbZY) —
+ * a closed-source, oracle-priced PMM ("prop AMM", tier P-A). No IDL, no docs:
+ * every field below was recovered by dumping the deployed program (ProgramData
+ * ELF, 425,485 bytes; disassembled with capstone's BPF backend), sampling real
+ * mainnet `swap_v4` transactions (getTransaction, `preTokenBalances`/
+ * `postTokenBalances` for the vault deltas), and cross-referencing the
+ * decoded pool bytes against those deltas.
+ *
+ * QUOTE MODEL (measured, not assumed): the realized swap price tracks a
+ * SEPARATE oracle account's live mid almost exactly, with NO detectable
+ * curvature across a ~1000x input range —
+ *
+ *   - JUP/USDC (oracle CsyasUrpePHQAJeQHMytaTbyxEag8FCuCBiQKQvBc3GV): 7 real
+ *     landed swaps, amountIn 245,414..262,787,635 (raw USDC, 6dp) all priced
+ *     within 5.2156..5.2160 JUP/USDC (0.08% band, consistent with ordinary
+ *     price drift across the ~15 minutes the sample spans, not size).
+ *   - BONK/USDC (oracle BhDYyPxERMSyhNtVNNGN4eSqzMcBmT2ySi3FhrLXFSVs): a
+ *     6-BONK dust fill cross-checked the SAME oracle-mid convention.
+ *   - Fresh `simulateTransaction` re-quotes (sigVerify:false, impersonating
+ *     the aggregator's own registered authority — see AUTHORITY below) at
+ *     3 sizes EACH spanning ~600x (JUP/USDC: 500,000 / 25,000,000 /
+ *     300,000,000 raw USDC) and ~5000x (BONK/USDC: 10,000,000 /
+ *     1,000,000,000 / 50,000,000,000 raw BONK) against LIVE mainnet state
+ *     reproduce a FLAT realized-price ratio to the oracle mid: 0.99872,
+ *     0.99872, 0.99924 (JUP/USDC) and 0.99558, 0.99562, 0.99564 (BONK/USDC) —
+ *     i.e. a per-pool, per-direction fee/spread the ladder charges as
+ *     `feePpm`, ROUNDED UP from the measured value so predicted <= realized
+ *     (one-sided safe for minOut, the obric-v2/solfi-v2 convention).
+ *
+ * The oracle (owner W1LDCARDa67SPBG7TFpQivHnEZXRtxCFP13ysEd1bWR, "Wildcard")
+ * stores price as a plain IEEE-754 f64 LE at PRICE_OFFSET — verified by
+ * decoding that word on two independent live feeds and matching both the
+ * JUP/USDC and BONK/USDC measured ratios above to within ordinary drift.
+ * ladder.ts decodes it ON-CHAIN with pure integer ops (no float unit assumed
+ * in the VM): extract the exponent/mantissa by shift+mask, gate the slot to
+ * 0 if the live exponent has drifted off the PREPARE-TIME baked value (the
+ * fast path degenerates to a coarse staleness/sanity check — an overflow-
+ * class repricing self-drops the slot rather than misquoting it), then scale
+ * the 53-bit mantissa by a prepare-time-reduced (num, den) rational that
+ * folds the 2^exponent term and the mintA/mintB decimals difference.
+ *
+ * POOL ACCOUNT LAYOUT (the `pool` fetchPoolConfig takes — 38,176 bytes,
+ * owner == PROGRAM_ID; ground-truthed IDENTICALLY on both sampled pools):
+ *   +72   mintA (32B)         +104  mintB (32B)
+ *   +136  vaultA (32B, SPL)   +168  companionA (32B, ZeroFi-owned, 1072B)
+ *   +200  vaultB (32B, SPL)   +232  companionB (32B, ZeroFi-owned, 1072B)
+ *   +2184 oracle (32B, Wildcard-owned, 128B)
+ * mintA/mintB/oracle are FIXED regardless of swap direction; the
+ * (companion, vault) PAIR at {168,136} vs {232,200} swaps roles with
+ * direction (mintA-in uses vaultA as the deposit vault; mintB-in uses
+ * vaultB) — confirmed on the BONK/USDC pool in both directions.
+ * `companionA`/`companionB` are ZeroFi-owned 1072-byte accounts whose fields
+ * are NOT decoded by this adapter (undecoded, but real, live-owned
+ * accounts — required by the CPI, not read for the quote).
+ *
+ * SWAP INSTRUCTION ("swap_v4", disc byte 0x10 — a single-byte opcode, not an
+ * 8-byte Anchor sighash): `[0x10] ++ amountIn u64 LE ++ minOut u64 LE` (17
+ * bytes). 14 accounts, order fixed regardless of direction except the
+ * (companion, vault) swap noted above:
+ *   0 pool  1 oracle  2 companionIn  3 vaultIn  4 companionOut  5 vaultOut
+ *   6 authorityAtaB  7 authorityAtaA  8 AUTHORITY (signer)  9 tokenProgramA
+ *   10 mintA  11 tokenProgramB  12 mintB  13 Sysvar Instructions
+ *
+ * ACCOUNTS 6/7 ("authorityAtaB"/"authorityAtaA"): decoded directly off a
+ * real landed transaction AND confirmed by a controlled standalone
+ * `simulateTransaction` (this adapter's ONLY instruction, no aggregator
+ * wrapper, at 25,000,000 raw USDC in): both are ordinary SPL token
+ * accounts (165 bytes) whose `owner` field (bytes 32..64) equals the
+ * pubkey riding slot 8 exactly. THE REAL FUND FLOW, measured directly:
+ * authorityAtaB (USDC) DEBITS exactly amountIn, vaultA/vaultB-side
+ * CREDITS it (the pool-vault "vaultIn" in the module's earlier framing);
+ * the pool's vaultOut DEBITS the realized output, authorityAtaA (JUP)
+ * CREDITS exactly that amount — the authority's JUP balance in this probe
+ * started at ZERO and still received the fill correctly, so slots 6/7 are
+ * NOT a pre-funded capital reserve the authority must carry; they are a
+ * REQUIRED, registered SIGNING/SETTLEMENT relay the swap moves value
+ * through (existence + registration required, not standing inventory).
+ * There is no slot anywhere in the 14 for an arbitrary, unregistered
+ * caller's own token account — this is NOT a normal permissionless
+ * flash-swap shape, it settles ONLY through a registered authority's own
+ * accounts. One larger sampled BONK/USDC transaction moved a DIFFERENT
+ * pair of accounts at these same two slots (a distinct registered
+ * authority) alongside its own pool vaults, consistent with this reading:
+ * whichever authority signs owns whichever pair rides slots 6/7.
+ *
+ * ACCOUNT 8 ("AUTHORITY", signer, not writable): validated live by flipping
+ * signer-ness account-by-account against a `simulateTransaction`
+ * (sigVerify:false) replay of a real historical swap — see ladder.ts's
+ * module doc for the exact probe. Result: idx 8 must be a SPECIFIC
+ * account (the routing aggregator's own PDA in every sampled transaction,
+ * owner T1TANpTeScyeqVzzgNViGDNrkQ6qHz9KrSBS4aNXvGT in the JUP/USDC sample);
+ * substituting an unrelated signer FAILS DETERMINISTICALLY (custom program
+ * error 4, reproduced 3/3), while the real aggregator PDA succeeds
+ * DETERMINISTICALLY (5/5). Combined with the slots-6/7-are-its-own-ATAs
+ * finding above, this reads as a per-integrator registration (a real
+ * market-maker/authority relationship ZeroFi's program checks), not a bare
+ * "any signer" guard — an access-control + inventory gap, not a math gap.
+ * `fetchPoolConfig` REFUSES (throws) a pool without a registered authority
+ * rather than wiring an address guaranteed to fail on-chain — the
+ * deployment must populate ZEROFI_POOL_AUTHORITY once registered with
+ * ZeroFi, exactly the shape of the Quantum aggregator-whitelist gap this
+ * venue set already builds past.
+ *
+ * FEE CATALOG: keyed by POOL (not guessed, not interpolated) — see
+ * ZEROFI_POOL_FEE_PPM. A pool absent from the catalog THROWS at
+ * fetchPoolConfig (refuse, don't guess — the solfi-v2 POOL_K precedent).
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { readUintLE } from "../math.js";
+import { INSTRUCTIONS_SYSVAR } from "../../cpi-probe.js";
+import { ieee754ScaleParams } from "./ieee754.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "zerofi";
+export const ZEROFI_PROGRAM_ID = address("ZERor4xhbUycZ6gb9ntrhqscUcZmAbQDjEAtCf4hbZY");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+export const POOL_ACCOUNT_SIZE = 38_176;
+export const ORACLE_ACCOUNT_SIZE = 128;
+// Pool account layout (see module doc — ground-truthed on 2 live pools).
+export const OFF_MINT_A = 72;
+export const OFF_MINT_B = 104;
+export const OFF_VAULT_A = 136;
+export const OFF_COMPANION_A = 168;
+export const OFF_VAULT_B = 200;
+export const OFF_COMPANION_B = 232;
+export const OFF_ORACLE = 2184;
+/** IEEE-754 f64 LE price word inside the oracle account (mintB per whole mintA). */
+export const PRICE_OFFSET = 0x30;
+/** `swap_v4`'s single-byte discriminator (NOT an 8-byte Anchor sighash). */
+export const ZEROFI_SWAP_DISCRIMINATOR = 0x10;
+const codec = getAddressCodec();
+const pubkeyAt = (data, offset) => codec.decode(data.subarray(offset, offset + 32));
+/**
+ * Per-pool, per-direction fee/spread the ladder charges against the raw
+ * oracle mid, in parts-per-million, ROUNDED UP from the measured realized
+ * ratio (see module doc) so a predicted quote never exceeds the real fill —
+ * REFUSE (fetchPoolConfig throws), don't guess, for any pool not listed
+ * here. Keyed by pool account address (the 38,176-byte account), matching
+ * solfi-v2's POOL_K precedent: a pool is never assumed to share its
+ * neighbor's fee.
+ */
+export const ZEROFI_POOL_FEE_PPM = {
+    // JUP/USDC — measured realized/oracle-mid ratio 0.998723 (worst of 3 fresh
+    // simulateTransaction sizes: 500,000 / 25,000,000 / 300,000,000 raw USDC,
+    // 2026-07-31). 1 - 0.998723 = 1277ppm; rounded up to 1300ppm for margin.
+    Et6HnPjetV8AzmxNAfzKJ6ax5VM82ZB7phY465Ns5iZW: 1300n,
+    // BONK/USDC — measured realized/oracle-mid ratio 0.995581..0.995641 across
+    // 3 fresh sizes (10,000,000 / 1,000,000,000 / 50,000,000,000 raw BONK,
+    // 2026-07-31). Worst (smallest) ratio 0.995581 -> 4419ppm; rounded up to
+    // 4500ppm for margin.
+    "5Dp922oSaj9rdLHTxZzq1B7QV7KmwY7U7K1JNCRhc45J": 4500n,
+};
+/**
+ * The registered authority + its own token-account pair, per pool — see the
+ * module doc's "ACCOUNT 8" note. UNCONFIGURED BY DEFAULT: there is no
+ * synthesizable value (a bare PDA does not satisfy the live program's
+ * check, see the module doc), so `fetchPoolConfig` throws for any pool
+ * without an entry here rather than wiring an address guaranteed to fail
+ * on-chain. Populate this once ZeroFi (or whatever registry backs the
+ * check) recognizes this deployment's own authority.
+ */
+export const ZEROFI_POOL_AUTHORITY = {};
+/**
+ * Conservative quotable-capacity divisor: the ladder never quotes more than
+ * `liveReserveOut / CAP_DIVISOR` output (see ladder.ts). 20 == 5% of the
+ * live output vault. This is NOT a measured venue depth limit (the true
+ * capacity model is unresolved — see the module doc's "ACCOUNTS 6/7" note);
+ * it is a deliberately-conservative ceiling picked so that every measured
+ * real fill in this integration's sample (largest: 262,787,635 raw USDC
+ * against a >29B raw USDC vault, ~0.9% of reserve) sat comfortably inside
+ * it, while still being far short of "unbounded" — an unbounded linear
+ * quote is unsafe on its own (a more-favourable-than-real quote wins merge
+ * elections it cannot actually fill).
+ */
+export const CAP_DIVISOR = 20n;
+function zerofiConfig(cfg) {
+    if (cfg.venue !== SLUG)
+        throw new Error(`${SLUG} adapter got a config for venue '${cfg.venue}'`);
+    const c = cfg;
+    if (c.direction !== 0 && c.direction !== 1) {
+        throw new Error(`${SLUG} direction must be 0 or 1, got '${String(c.direction)}'`);
+    }
+    return c;
+}
+/** SPL Mint `decimals` byte offset. */
+const MINT_DECIMALS_OFFSET = 44;
+export const zerofi = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: ZEROFI_PROGRAM_ID,
+    /**
+     * Off-chain gate + decode. `pool` is the 38,176-byte account (see module
+     * doc). Rejects: wrong size, missing account, a pool absent from the
+     * verified fee catalog, a pool without a registered authority (REFUSE,
+     * don't guess, for both — see ZEROFI_POOL_FEE_PPM / ZEROFI_POOL_AUTHORITY),
+     * and missing mint/oracle accounts. Tokenkeg-only (both sampled pools use
+     * plain Tokenkeg for both legs, confirmed from real swap_v4 account
+     * lists — slots 9/11 are always TokenkegQfeZy...; a Token-2022 pool
+     * changes wire semantics this adapter has not verified against, the
+     * same scope restriction obric-v2 documents for itself).
+     */
+    async fetchPoolConfig(load, pool, direction = 0) {
+        const data = await load(pool);
+        if (data === null)
+            throw new Error(`${SLUG} pool ${pool} account not found`);
+        if (data.length !== POOL_ACCOUNT_SIZE) {
+            throw new Error(`${SLUG} pool ${pool} account is ${data.length} bytes, expected ${POOL_ACCOUNT_SIZE}`);
+        }
+        const feePpm = ZEROFI_POOL_FEE_PPM[pool];
+        if (feePpm === undefined) {
+            throw new Error(`${SLUG} pool ${pool} has no independently-verified fee (resolved per POOL, never guessed — see ZEROFI_POOL_FEE_PPM)`);
+        }
+        const authorityCfg = ZEROFI_POOL_AUTHORITY[pool];
+        if (authorityCfg === undefined) {
+            throw new Error(`${SLUG} pool ${pool} has no registered authority configured (ZEROFI_POOL_AUTHORITY) — the live program ` +
+                `rejects an unregistered signer at slot 8 (see this file's module doc); register the deployment's ` +
+                `authority with ZeroFi and populate ZEROFI_POOL_AUTHORITY before this pool can serve a real cook`);
+        }
+        const mintA = pubkeyAt(data, OFF_MINT_A);
+        const mintB = pubkeyAt(data, OFF_MINT_B);
+        const vaultA = pubkeyAt(data, OFF_VAULT_A);
+        const vaultB = pubkeyAt(data, OFF_VAULT_B);
+        const companionA = pubkeyAt(data, OFF_COMPANION_A);
+        const companionB = pubkeyAt(data, OFF_COMPANION_B);
+        const oracle = pubkeyAt(data, OFF_ORACLE);
+        const oracleData = await load(oracle);
+        if (oracleData === null)
+            throw new Error(`${SLUG} pool ${pool} oracle ${oracle} account not found`);
+        if (oracleData.length !== ORACLE_ACCOUNT_SIZE) {
+            throw new Error(`${SLUG} pool ${pool} oracle ${oracle} is ${oracleData.length} bytes, expected ${ORACLE_ACCOUNT_SIZE}`);
+        }
+        const [mintAData, mintBData] = await Promise.all([load(mintA), load(mintB)]);
+        if (mintAData === null || mintBData === null) {
+            throw new Error(`${SLUG} pool ${pool} mint account(s) not found`);
+        }
+        if (mintAData.length < MINT_DECIMALS_OFFSET + 1 ||
+            mintBData.length < MINT_DECIMALS_OFFSET + 1) {
+            throw new Error(`${SLUG} pool ${pool} mint account(s) too short to be an SPL mint`);
+        }
+        // `swap_v4` is Tokenkeg-only (slots 9/11 are always the classic Token
+        // program). Detect a Token-2022 (or otherwise un-routable) mint per side
+        // and GRACEFULLY SELF-DROP the pool (the SvmRoute orchestrator catches a
+        // fetchPoolConfig throw and drops the venue). Reuses the mint bytes already
+        // loaded above; the LEGACY path is byte-identical (a classic 82-byte mint
+        // classifies Tokenkeg, parses no extensions).
+        for (const [m, mintData] of [
+            [mintA, mintAData],
+            [mintB, mintBData],
+        ]) {
+            if (classifyMintProgram(m, mintData) === TOKEN_2022_PROGRAM_ID) {
+                throw new Error(`${SLUG}: dropping pool ${pool} — mint ${m} is Token-2022 (this venue's swap is legacy-SPL only)`);
+            }
+            const { blocking } = parseMintExtensions(mintData);
+            if (blocking.length > 0) {
+                throw new Error(`${SLUG}: dropping pool ${pool} — mint ${m} is un-routable: ${blocking.join("; ")}`);
+            }
+        }
+        const decimalsA = mintAData[MINT_DECIMALS_OFFSET];
+        const decimalsB = mintBData[MINT_DECIMALS_OFFSET];
+        if (oracleData.length < PRICE_OFFSET + 8) {
+            throw new Error(`${SLUG} pool ${pool} oracle ${oracle} is too short to hold the price word at offset ${PRICE_OFFSET}`);
+        }
+        const rawPriceBits = readUintLE(oracleData, PRICE_OFFSET, 8);
+        const scale = ieee754ScaleParams(rawPriceBits, decimalsA, decimalsB);
+        const U64_MAX = (1n << 64n) - 1n;
+        if (scale.num > U64_MAX || scale.den > U64_MAX) {
+            throw new Error(`${SLUG} pool ${pool} price scale (num=${scale.num}, den=${scale.den}) exceeds u64 after reduction — refusing rather than emitting an overflow-prone fragment`);
+        }
+        return {
+            venue: SLUG,
+            pool,
+            direction,
+            mintA,
+            mintB,
+            vaultA,
+            vaultB,
+            companionA,
+            companionB,
+            oracle,
+            tokenProgramA: TOKEN_PROGRAM,
+            tokenProgramB: TOKEN_PROGRAM,
+            decimalsA,
+            decimalsB,
+            authority: authorityCfg.authority,
+            authorityAtaA: authorityCfg.authorityAtaA,
+            authorityAtaB: authorityCfg.authorityAtaB,
+            feePpm,
+            scaleBakedTop: scale.bakedTop,
+            scaleShiftPre: scale.shiftPre,
+            scaleNum: scale.num,
+            scaleDen: scale.den,
+        };
+    },
+    quoteAccounts(cfg) {
+        const c = zerofiConfig(cfg);
+        const vaultOut = c.direction === 0 ? c.vaultB : c.vaultA;
+        return [
+            { ref: c.pool, address: c.pool, writable: true },
+            { ref: c.oracle, address: c.oracle },
+            { ref: vaultOut, address: vaultOut },
+        ];
+    },
+    /**
+     * v1 swap CPI (amount baked). disc(1) || amountIn u64 LE || minOut u64
+     * LE=1. NOTE (see module doc): this CPI settles through the registered
+     * `c.authority`'s own ATAs, not `user`'s — `user` is accepted for
+     * interface parity with every other adapter but is UNUSED here (there is
+     * no slot for an arbitrary caller-owned token account in this venue's
+     * instruction — see zerofiSwapAccounts).
+     */
+    buildSwap(cfg, user, amountIn) {
+        const c = zerofiConfig(cfg);
+        void user;
+        const U64_MAX = (1n << 64n) - 1n;
+        if (amountIn <= 0n || amountIn > U64_MAX) {
+            throw new Error(`${SLUG} buildSwap amountIn must be a positive u64, got ${amountIn}`);
+        }
+        const data = new Uint8Array(17);
+        data[0] = ZEROFI_SWAP_DISCRIMINATOR;
+        for (let b = 0; b < 8; b++)
+            data[1 + b] = Number((amountIn >> BigInt(8 * b)) & 0xffn);
+        data[9] = 1; // minOut = 1 (the recipe's terminal delta owns the real bound)
+        return {
+            programId: ZEROFI_PROGRAM_ID,
+            data,
+            accounts: zerofiSwapAccounts(c, (ref, addr, w) => fixed(ref, addr, w)),
+        };
+    },
+};
+const fixed = (ref, addr, writable) => writable ? { ref, address: addr, writable: true } : { ref, address: addr };
+/**
+ * The 14-account order for ZeroFi's `swap_v4` (disc 0x10) — see module doc
+ * for the full derivation and the measured fund-flow proof. The pool's own
+ * vaultA/vaultB (slots 3/5, direction-selected) and the registered
+ * authority's own ATA pair (slots 6/7) are the ONLY accounts that carry
+ * value; slot 8 is the authority's signature. There is deliberately no
+ * `user`-token-account parameter — see `zerofi.buildSwap`'s doc.
+ */
+export function zerofiSwapAccounts(c, make, refFor) {
+    const r = refFor ?? ((role) => role);
+    const aIn = c.direction === 0;
+    const vaultIn = aIn ? c.vaultA : c.vaultB;
+    const vaultOut = aIn ? c.vaultB : c.vaultA;
+    const companionIn = aIn ? c.companionA : c.companionB;
+    const companionOut = aIn ? c.companionB : c.companionA;
+    return [
+        make(r("pool"), c.pool, true),
+        make(r("oracle"), c.oracle, true),
+        make(r("cin"), companionIn, true),
+        make(r("vin"), vaultIn, true),
+        make(r("cout"), companionOut, true),
+        make(r("vout"), vaultOut, true),
+        make(r("aatab"), c.authorityAtaB, true),
+        make(r("aataa"), c.authorityAtaA, true),
+        { ref: c.authority, signer: true },
+        make(r("tpa"), c.tokenProgramA),
+        make(r("ma"), c.mintA),
+        make(r("tpb"), c.tokenProgramB),
+        make(r("mb"), c.mintB),
+        { ref: INSTRUCTIONS_SYSVAR },
+    ];
+}
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/zerofi/index.js.map

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

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

@@ -0,0 +1,212 @@
+import type { Address } from "@solana/kit";
+export { decodePortalCalldataWithAccounts, encodePortalCalldataWithAccounts, extractSvmSettleFromCalls, extractSvmSettleFromIntent, type PortalAccountMeta, type PortalCalldataWithAccounts, type PortalCalldataWithAccountsInput, type BytesInput, type UniversalAddressInput, type SvmIntentCallLike, type SvmIntentLike, type ExtractSvmSettleOptions, type ExtractedSvmSettle, type SvmSettleTarget, } from "./intent.js";
+/**
+ * The values a settle program was compiled with. Both are folded into the bytecode, so they are what
+ * a recompile pins: naming them is how a caller says "prove the program enforces THIS floor and THIS
+ * split", rather than reading them back out of an execution and trusting them.
+ */
+export interface SvmSettleExpectation {
+    /** The floor applied to escrow 0 (0 disables the floor). */
+    minOut: bigint;
+    /** Escrows i < splCount sweep via tokenProgram0, the rest via tokenProgram1. */
+    splCount: bigint;
+}
+/** Just enough of an account manifest to count and name its slots. */
+export interface SettleManifestLike {
+    accounts: readonly {
+        kind: string;
+        name?: string;
+    }[];
+}
+export interface SvmSettleVerification {
+    /** True iff the bytecode byte-matches svmSettleSource(escrowCount) AND the plan's refs match svmSettleRefs. */
+    genuine: boolean;
+    /** The inferred escrow count, or null when the account plan does not fit any settle shape. */
+    escrowCount: number | null;
+    /** The canonical ref order for `escrowCount` (svmSettleRefs) — empty when escrowCount is null. */
+    refs: string[];
+    /** Present iff not genuine: what failed (unrecognized shape / bytecode mismatch / ref mismatch). */
+    mismatch?: string;
+}
+/**
+ * Verifies a compiled SVM settle program is genuine AND enforces `expected` — the SVM analogue of the
+ * EVM check, done by recompile. It:
+ *   1. takes the escrow count N (or infers it from the manifest's `3N + 3` slots),
+ *   2. recompiles `svmSettleSource(N)` with `expected` as defines, and
+ *   3. byte-compares the result, and asserts the manifest's slot names equal `svmSettleRefs(N)`.
+ *
+ * A genuine result means the bytecode IS the reusable settle logic for N escrows, compiled for
+ * exactly this floor and this split — all three are the same bytes, so one comparison pins them all.
+ * The resolved account identities (from the executed instruction) remain the caller's own check.
+ * Never throws for a non-genuine program; returns `{ genuine: false, mismatch }`.
+ */
+export declare function verifySvmSettleProgram(bytecode: Uint8Array, manifest: SettleManifestLike, expected: SvmSettleExpectation): SvmSettleVerification;
+/** An account entry as either the base58 address itself or an object carrying it (the recipes split
+ *  response uses `{ pubkey, isSigner, isWritable, ref }`; a resolved instruction meta uses `{ address }`). */
+export type SvmSettleAccountLike = string | {
+    address?: string;
+    pubkey?: string;
+    ref?: string;
+};
+export interface SvmSettleExecutionInput {
+    /**
+     * The instruction data. On the released engine that is the 8-byte discriminator and nothing else:
+     * `executeFromAccount` reads account 0's data verbatim, and a settle's params are defines folded
+     * into the bytecode. From the recipes split response this is
+     * base64-decode(`execution.instructionData`); from an executed instruction it is the raw ix data.
+     */
+    instructionData: Uint8Array;
+    /**
+     * The instruction's account list — EITHER the user tail alone (`3N+3`, the recipes
+     * `execution.accounts[]`) OR the full list with the leading buffer (`3N+4`, a raw instruction). The
+     * leading buffer is detected by length and stripped; each entry is a base58 address or an object
+     * with `.address`/`.pubkey`.
+     */
+    accounts: readonly SvmSettleAccountLike[];
+}
+export interface DecodedSvmSettleExecution {
+    /**
+     * Which engine instruction the calldata is.
+     *
+     * `execute_and_close` is gone with the pre-release engine, and so are the `pin` and `slice` this
+     * used to report: the released engine carries no payload here, so there is nothing on this wire
+     * committing to the staged bytecode. **A caller that wants that commitment must read the
+     * KITCHEN's `cook_from_account`**, whose `pin` refuses unless the staged bytes hash to it — see
+     * `kitchen.ts`. Reporting a pin from here would now always be `undefined`, which reads as "no pin
+     * was given" rather than "this wire cannot carry one".
+     */
+    instruction: "execute" | "execute_from_account";
+    /** The escrow count inferred from the account-list length. */
+    escrowCount: number;
+    /** The canonical ref order for `escrowCount` — `svmSettleRefs(escrowCount)`. */
+    refs: string[];
+    /** Each settle account ref → the pubkey attached at that slot, positionally against `refs`. */
+    accounts: Record<string, Address>;
+    /** True iff a leading bytecode-buffer account was detected in `accounts` and skipped. */
+    hadBufferAccount: boolean;
+    /** Whether the provided account labels matched the canonical refs, or null if entries carried no
+     *  `ref` (a bare address list). Identities are resolved positionally regardless — this only reports
+     *  whether a caller-supplied label agreed with the slot it landed in. */
+    labeledRefsConsistent: boolean | null;
+}
+/**
+ * Decodes a full settle execution — the calldata AND the account list — into its staged-execute header
+ * and resolved account identities in one call. It parses the execute payload grammar off
+ * `instructionData`, infers the escrow count from the account-list length, and resolves each
+ * `svmSettleRefs(N)` slot to the attached pubkey. Consumes the sauce-recipes `split=1` settle sauce
+ * (`execution.instructionData` + `execution.accounts[]`) directly, and equally an executed engine
+ * instruction (full data + `[buffer, …user]` account list).
+ *
+ * `minOut`/`splCount` are NOT among the results, and cannot be: they are defines folded into the
+ * bytecode, so no amount of reading the calldata recovers them. `verifySvmSettleExecution` establishes
+ * them the only way available — by recompiling with the values a caller expects and byte-comparing.
+ *
+ * What IS here is not trusted either: the header comes from the raw calldata (not from a receipt), and
+ * the account identities are resolved positionally against the canonical refs, never from
+ * caller-supplied labels — `labeledRefsConsistent` only reports whether a label the caller happened to
+ * attach agreed with the slot it landed in.
+ *
+ * IMPORTANT — this is a STRUCTURAL decode, NOT a genuineness proof. A staged settle's calldata
+ * carries no structural signature: any staged Sauce execute with a `3N+3`/`3N+4` account count has
+ * this exact shape. So a non-settle execution (or an adversarial decoy) decodes here without error
+ * into any staged program at all. To prove the execution actually runs the genuine settle program,
+ * use `verifySvmSettleExecution` (or `extractSvmSettleFromIntent`), which ties the calldata to the
+ * SDK's own recompiled canonical settle bytecode.
+ *
+ * The EVM half splits the same two questions the same way — `decodeSettleProgram` is structural and
+ * accepts any 362-byte program, `validateSettleProgram` is the genuineness proof — but reaches the
+ * second one WITHOUT a compiler: an EVM settle's params ride the payload after the program, so the
+ * program is a constant and one `keccak256` settles it. Here they are `defines` folded into the
+ * bytecode, which is why this side recompiles.
+ */
+export declare function decodeSvmSettleExecution(input: SvmSettleExecutionInput): DecodedSvmSettleExecution;
+export interface SvmSettleExecutionVerifyInput extends SvmSettleExecutionInput, SvmSettleExpectation {
+    /**
+     * OPTIONAL. The compiled settle bytecode this execution runs (from the recipes split response this is
+     * base64-decode(`sauces[settleIdx].program.bytecode`); from an eco-solver intent it is
+     * base64-decode(`fulfillmentMetadata.svm.sauceStage.buffers[settleIdx].bytecode`)). When supplied, the
+     * actual staged bytes are byte-compared to the canonical settle and tied to the pin.
+     *
+     * A partner usually does NOT have this (only the on-chain `route.calls`), and does not need it: the SDK
+     * recompiles the canonical settle itself and proves genuineness via the calldata pin (see below).
+     */
+    bytecode?: Uint8Array;
+    /**
+     * OPTIONAL. The 32-byte content pin committing to the staged bytes.
+     *
+     * **Supplied by the caller, not read off this instruction.** It used to be decoded from the
+     * engine's own calldata; the released engine's `executeFromAccount` carries no payload, so the
+     * commitment lives one layer up — in the KITCHEN's `cook_from_account`, whose `pin` refuses unless
+     * the staged bytes hash to it. Read it from that instruction and pass it here.
+     *
+     * Without it, supplying `bytecode` proves only that YOUR copy is canonical: nothing ties those
+     * bytes to the code account this execution actually runs, and the verdict says so rather than
+     * calling the execution genuine.
+     */
+    pin?: Uint8Array;
+}
+/**
+ * How genuineness was established. The verdicts differ in what they actually prove, and the gap
+ * between the strongest and the weakest is the whole reason this type is not a boolean.
+ *
+ * `inline-bytecode` — an `execute`: the program is IN the calldata, and it byte-matches the
+ * canonical settle. The bytes verified are the bytes that run, with nothing in between. A pin means
+ * nothing on this path (the engine never reads one) and cannot make an inline execution genuine.
+ *
+ * `bytecode` — an `execute_from_account` where the caller supplied the staged bytes: they match the
+ * canonical settle AND the caller's pin ties to them. A pinless calldata commits to nothing, so it
+ * is never genuine here however good the bytes are.
+ *
+ * `caller-asserted-pin` — an `execute_from_account` with no bytecode, whose pin equals
+ * `sha256(canonical settle)`. **This is not an on-chain guarantee.** The released engine's
+ * `execute_from_account` has no payload, so nothing enforces this pin at execute time; it means
+ * "the caller asserts these staged bytes hash to this", and it is only as good as the caller's
+ * evidence — a kitchen `cook_from_account` they witnessed. It was named `pin` while documented as
+ * engine-enforced, which is precisely the belief that made it dangerous.
+ *
+ * `none` — no pin and no bytecode. Genuineness cannot be established from structure alone.
+ *
+ * The instruction's CALLEE is outside every verdict here: an arbitrary program accepting the same
+ * discriminator can do whatever it likes — see `ExtractedSvmSettle.target`, whose `program` state a
+ * caller must compare against the engine program id it trusts.
+ */
+export type SvmSettleVerifiedBy = "inline-bytecode" | "bytecode" | "caller-asserted-pin" | "none";
+export interface SvmSettleExecutionVerification extends DecodedSvmSettleExecution {
+    /** True iff the execution provably runs the genuine `svmSettleSource(escrowCount)` program. */
+    genuine: boolean;
+    /** How `genuine` was established (or why it could not be). */
+    verifiedBy: SvmSettleVerifiedBy;
+    /** `sha256(canonical recompiled settle)` === the calldata pin. null iff the calldata carried no pin. */
+    pinMatchesCanonical: boolean | null;
+    /** Only when `bytecode` was supplied: `sha256(bytecode)` === the calldata pin. null otherwise. */
+    pinMatchesBytecode: boolean | null;
+    /** Only when `bytecode` was supplied: the bytes byte-match the canonical settle. null otherwise. */
+    bytecodeMatchesCanonical: boolean | null;
+    /** Present iff not genuine: what failed. */
+    mismatch?: string;
+}
+/**
+ * The genuineness check for a settle execution — the crucial companion to `decodeSvmSettleExecution`,
+ * whose structural decode alone CANNOT tell a settle from any other staged Sauce execute (an account
+ * count is not a signature). This ties the calldata to the SDK's own recompiled canonical settle
+ * bytecode, in one of two ways, no partner bytecode required for either verdict:
+ *
+ *   - `bytecode` supplied → byte-compare it to `compileCanonicalSettle(escrowCount)` AND require the pin
+ *     to tie to it (`sha256(bytecode) === pin`). Proves the exact staged bytes ARE the settle and WILL run.
+ *     Both halves are load-bearing: calldata with no pin commits to no program at all, so bytes alone —
+ *     however genuine — prove nothing about what runs, and the verdict is not genuine.
+ *   - no bytecode, but a pin was supplied → check `pin === sha256(canonical settle)`. NOTHING ENFORCES
+ *     THIS ON CHAIN: the released engine's `execute_from_account` has no payload, so this is the
+ *     caller asserting the staged bytes hash to that value, and it is worth exactly what their
+ *     evidence is worth — hence `verifiedBy: 'caller-asserted-pin'`.
+ *   - neither → `genuine: false`, `verifiedBy: 'none'` (structure alone is not proof).
+ *
+ * An `execute` is handled separately and BEFORE any of the above: its program is inline in the
+ * calldata, so it is compared directly and a pin cannot make it genuine.
+ *
+ * Because `minOut`/`splCount` are folded into the bytecode, a `genuine` result also proves the program
+ * enforces the `minOut`/`splCount` passed in — leaving only the resolved account identities for the
+ * caller to check. Never throws beyond the shared structural decode; reports failures in `mismatch`.
+ */
+export declare function verifySvmSettleExecution(input: SvmSettleExecutionVerifyInput): SvmSettleExecutionVerification;
+//# sourceMappingURL=verify.d.ts.map

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

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