@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/venues/scorch/index.d.ts

@@ -0,0 +1,42 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, VenueAccount } from "../types.js";
+declare const SLUG = "scorch";
+/** CORE — pool state owner + pricing engine. This is `SVM_VENUE_PROGRAM_IDS.scorch`. */
+export declare const SCORCH_CORE_PROGRAM_ID: Address<"ojh19ojaKduoJZuaJADhcVGp4xt1TcdAvZmpVsCorch">;
+/** ROUTER — the real custodian; the swap CPI's actual CALL target. */
+export declare const SCORCH_ROUTER_PROGRAM_ID: Address<"SCoRcH8c2dpjvcJD6FiPbCSQyQgu3PcUAWj2Xxx3mqn">;
+/**
+ * Conservative haircut on the raw vault-reserve-ratio price (parts per
+ * million of the naive constant-product output) — see this file's top
+ * docblock for the measured justification. 300,000 = keep 70% of the naive
+ * CP output.
+ */
+export declare const SCORCH_HAIRCUT_PPM = 300000n;
+export interface ScorchPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'AtoB' (default, mintA in / mintB out) | 'BtoA'. */
+    direction: "AtoB" | "BtoA";
+    mintA: Address;
+    vaultA: Address;
+    assetConfigA: Address;
+    mintB: Address;
+    vaultB: Address;
+    assetConfigB: Address;
+}
+export declare const scorch: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"ojh19ojaKduoJZuaJADhcVGp4xt1TcdAvZmpVsCorch">;
+    /**
+     * Reads the PairConfig account directly (mints + vaults; both mints' known
+     * AssetConfig addresses resolved via the vendored directory). Throws a
+     * clear, named error — never silently mis-decodes — on wrong size/tag, a
+     * missing AssetConfig entry (a not-yet-snapshotted asset), or a
+     * non-classic (likely token-2022) vault; any of those drops just this ONE
+     * pool from discovery, per the venue-robustness convention.
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<ScorchPoolConfig>;
+    quoteAccounts(base: PoolConfig): VenueAccount[];
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/scorch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/scorch/index.ts"],"names":[],"mappings":"AA6EA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3E,QAAA,MAAM,IAAI,WAAW,CAAC;AAEtB,wFAAwF;AACxF,eAAO,MAAM,sBAAsB,wDAAyD,CAAC;AAC7F,sEAAsE;AACtE,eAAO,MAAM,wBAAwB,wDAAyD,CAAC;AAY/F;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,UAAW,CAAC;AAC3C,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,uDAAuD;IACvD,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;CACvB;AAgCD,eAAO,MAAM,MAAM;;;;IAKjB;;;;;;;OAOG;0BACyB,aAAa,QAAQ,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC;wBAmFhE,UAAU,GAAG,YAAY,EAAE;CAOhD,CAAC"}

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

@@ -0,0 +1,222 @@
+/**
+ * Scorch (SvmRoute venue, closed-source-binary reverse-engineering — no on-chain IDL; the same
+ * RE method used for the WITHDRAWN BisonFi integration attempt, see docs/bisonfi-evidence.md —
+ * this file does not import from it, the shared lineage is methodology only).
+ *
+ * PROGRAM SHAPE (ground-truthed against mainnet, 2026-07-31 — no source, no
+ * IDL, no public docs; recovered via `solana program dump` + ELF strings +
+ * real historical transaction decode, see the ledger below):
+ *
+ *   - CORE (`ojh19ojaKduoJZuaJADhcVGp4xt1TcdAvZmpVsCorch`, Jupiter's own
+ *     label-map program id for "Scorch") is a PURE PRICING/ACCOUNTING
+ *     program: it owns the pool state (PairConfig/AssetConfig/a single
+ *     global oracle account) and computes a quote + updates internal
+ *     accounting, but never itself calls the token program — every real
+ *     transaction shows zero nested CPIs under its own invoke frame.
+ *   - ROUTER (`SCoRcH8c2dpjvcJD6FiPbCSQyQgu3PcUAWj2Xxx3mqn`) is the actual
+ *     custodian: it holds the pair's inventory in two vault token accounts
+ *     under a single GLOBAL vault-authority PDA
+ *     (`EHcege7dok1iYs7SxL2XzDPvhg6XzMVcx2V5SkMUurJP`, confirmed identical
+ *     across two unrelated pairs — a program-wide singleton, not per-pair),
+ *     pulls the input from the caller, CPIs into CORE for the quote, and
+ *     pushes the output based on CORE's returned u64. THIS is the program
+ *     our swap CPI targets — CORE alone would price a trade but move no
+ *     funds.
+ *
+ * Both programs, plus the global oracle account, were dumped/read directly
+ * off mainnet-beta and are what `test/svm/fixtures/scorch/` replays; six
+ * live-mainnet historical transactions (both directions) and six FRESH
+ * `simulateTransaction` probes against real, live pool state (three sizes
+ * per direction: 1, 500 and 20,000 whole tokens) all executed cleanly with
+ * the exact account list + instruction encoding this file emits — see
+ * `docs/svm-venues.md`'s Scorch section for the full transcript.
+ *
+ * INSTRUCTION FORMAT (ROUTER's own swap ix, NOT a Jupiter-specific shim —
+ * two independent unrelated pairs were observed calling the SAME program
+ * with the SAME account shape): `[u8 disc=0x02][u8 subtag][16-byte
+ * commitment][u64 LE amountIn][u64 LE minOut]`. Two subtag/commitment modes
+ * were observed in the wild: `0xa0` + a large, hash-like 16-byte value (an
+ * apparent price-commitment digest — the exact preimage was not recovered),
+ * and `0x80` + an all-zero 16-byte value (no commitment). `0x80`+zero is
+ * PROVEN LIVE-WORKING via the fresh simulate probes above (both directions,
+ * three sizes each, on real current mainnet state) and is what this adapter
+ * emits — the simpler, ground-truthed encoding, not a guess.
+ *
+ * PRICING MODEL (why the off-chain estimate is deliberately conservative):
+ * CORE's true price comes from the oracle account (4130 bytes, layout NOT
+ * recovered within this pass — a full oracle decode is future work). The
+ * pool's OWN vault-reserve ratio is measurably NOT the trade price: for the
+ * live JupSOL/pump pair on 2026-07-31, raw vault ratio was ~0.780 (jupSOL
+ * per pump) while the REAL simulated swap rate was ~0.622 — a ~20% gap,
+ * confirming this is an oracle-priced PMM, not a plain constant-product
+ * pool. Rather than assert a specific mid-price we cannot back with a
+ * decoded oracle read, `referenceQuote`/`emitQuoteCall` model a
+ * constant-product curve over the LIVE vault reserves with a fixed 30%
+ * conservative haircut (`SCORCH_HAIRCUT_PPM`) on top of the raw
+ * reserve-ratio price — chosen so the modeled price stays BELOW the one
+ * observed real rate by a comfortable margin (0.7 * 0.780 = 0.546 vs the
+ * real 0.622) rather than tuned to match it exactly. This is intentionally
+ * one-sided: a venue that looks WORSE than reality costs a missed
+ * optimization (the merge under-uses it); a venue that looks BETTER than
+ * reality wins elections it cannot honor (the documented "favourable error"
+ * hazard) — so the haircut only ever pushes the wrong way when it is safe
+ * to. `depthReserves` (liveness/relative-depth filtering) reads the REAL,
+ * un-haircut vault balances — that gate cares about "is there any inventory
+ * here", not price. Real execution always calls the real CPI, so a
+ * mispriced off-chain estimate affects split QUALITY, never fund safety
+ * (the recipe's minOut/priceLimit floor is unaffected by this file).
+ * TODO: decode the oracle account layout and replace the haircut with a
+ * real price read (would tighten the estimate; never required for safety).
+ *
+ * AssetConfig resolution: the router's account list needs both pair mints'
+ * AssetConfig addresses, which are neither embedded in PairConfig nor
+ * derivable via any PDA seed scheme this pass could recover (see
+ * ./scorch-asset-configs.ts's header for what was tried) — resolved via a
+ * vendored, recapturable directory instead.
+ */
+import { address } from "@solana/kit";
+import { SCORCH_ASSET_CONFIGS } from "./asset-configs.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "scorch";
+/** CORE — pool state owner + pricing engine. This is `SVM_VENUE_PROGRAM_IDS.scorch`. */
+export const SCORCH_CORE_PROGRAM_ID = address("ojh19ojaKduoJZuaJADhcVGp4xt1TcdAvZmpVsCorch");
+/** ROUTER — the real custodian; the swap CPI's actual CALL target. */
+export const SCORCH_ROUTER_PROGRAM_ID = address("SCoRcH8c2dpjvcJD6FiPbCSQyQgu3PcUAWj2Xxx3mqn");
+// PairConfig (658 bytes, owned by CORE): tag(1)=0x02, flag(1), reserved(12)=0xff*12,
+// idxA(u16 LE)@14, mintA(32)@16, vaultA(32)@48, idxB(u16 LE)@80, mintB(32)@82,
+// vaultB(32)@114, an 8-byte tail @146 of unrecovered semantics, zero-padded to 658.
+// Validated against 5 real mainnet PairConfig accounts spanning 2 distinct pairs.
+const PAIR_CONFIG_SIZE = 658;
+const PAIR_TAG = 0x02;
+const OFF_MINT_A = 16;
+const OFF_VAULT_A = 48;
+const OFF_MINT_B = 82;
+const OFF_VAULT_B = 114;
+/**
+ * Conservative haircut on the raw vault-reserve-ratio price (parts per
+ * million of the naive constant-product output) — see this file's top
+ * docblock for the measured justification. 300,000 = keep 70% of the naive
+ * CP output.
+ */
+export const SCORCH_HAIRCUT_PPM = 300000n;
+function b58Address(bytes, offset) {
+    // The 32-byte pubkey slice, re-encoded through `address()` so callers get a
+    // real branded Address — no direct base58 dependency needed here.
+    return address(b58encode(bytes.subarray(offset, offset + 32)));
+}
+const B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function b58encode(bytes) {
+    let n = 0n;
+    for (const b of bytes)
+        n = (n << 8n) | BigInt(b);
+    let s = "";
+    while (n > 0n) {
+        const r = Number(n % 58n);
+        n /= 58n;
+        s = B58_ALPHABET[r] + s;
+    }
+    let pad = 0;
+    for (const b of bytes) {
+        if (b === 0)
+            pad++;
+        else
+            break;
+    }
+    return B58_ALPHABET[0].repeat(pad) + s;
+}
+function scorchConfig(cfg) {
+    if (cfg.venue !== SLUG)
+        throw new Error(`${SLUG} ladder adapter got a '${cfg.venue}' pool config`);
+    return cfg;
+}
+export const scorch = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: SCORCH_CORE_PROGRAM_ID,
+    /**
+     * Reads the PairConfig account directly (mints + vaults; both mints' known
+     * AssetConfig addresses resolved via the vendored directory). Throws a
+     * clear, named error — never silently mis-decodes — on wrong size/tag, a
+     * missing AssetConfig entry (a not-yet-snapshotted asset), or a
+     * non-classic (likely token-2022) vault; any of those drops just this ONE
+     * pool from discovery, per the venue-robustness convention.
+     */
+    async fetchPoolConfig(load, pool) {
+        const data = await load(pool);
+        if (data === null)
+            throw new Error(`scorch pool ${pool} does not exist`);
+        if (data.length !== PAIR_CONFIG_SIZE) {
+            throw new Error(`scorch pool ${pool} has unexpected size ${data.length} (want ${PAIR_CONFIG_SIZE})`);
+        }
+        if (data[0] !== PAIR_TAG)
+            throw new Error(`scorch pool ${pool} has unexpected tag ${data[0]} (want ${PAIR_TAG})`);
+        const mintA = b58Address(data, OFF_MINT_A);
+        const vaultA = b58Address(data, OFF_VAULT_A);
+        const mintB = b58Address(data, OFF_MINT_B);
+        const vaultB = b58Address(data, OFF_VAULT_B);
+        // The ROUTER's swap CPI moves both sides through the classic Tokenkeg
+        // program, so a Token-2022 mint (or one carrying an un-routable extension)
+        // must SELF-DROP. Detect the real token program per mint via the shared
+        // data-shape resolver (replacing the old vault-size T22 proxy); the thrown
+        // error IS the graceful drop (this ONE pool leaves discovery, per the
+        // venue-robustness convention). LEGACY path unchanged: a classic 82-byte
+        // mint classifies Tokenkeg, parses no extensions, config built as before. An
+        // unreadable mint falls back to the legacy assumption.
+        const mints = [mintA, mintB];
+        const mintDatas = await Promise.all(mints.map((mint) => load(mint)));
+        for (let mi = 0; mi < mints.length; mi++) {
+            const mint = mints[mi];
+            const mintData = mintDatas[mi];
+            if (mintData === null)
+                continue;
+            if (classifyMintProgram(mint, mintData) === TOKEN_2022_PROGRAM_ID) {
+                throw new Error(`scorch: dropping pool ${pool} — mint ${mint} is Token-2022 (this venue's swap is legacy-SPL only)`);
+            }
+            const { blocking } = parseMintExtensions(mintData);
+            if (blocking.length > 0) {
+                throw new Error(`scorch: dropping pool ${pool} — mint ${mint} is un-routable: ${blocking.join("; ")}`);
+            }
+        }
+        const assetConfigAStr = SCORCH_ASSET_CONFIGS[mintA];
+        const assetConfigBStr = SCORCH_ASSET_CONFIGS[mintB];
+        if (assetConfigAStr === undefined) {
+            throw new Error(`scorch pool ${pool}: no known AssetConfig for mint ${mintA} — refresh the consuming app scorch-asset-configs venue module`);
+        }
+        if (assetConfigBStr === undefined) {
+            throw new Error(`scorch pool ${pool}: no known AssetConfig for mint ${mintB} — refresh the consuming app scorch-asset-configs venue module`);
+        }
+        // Vault structural existence check (the T22-vault size proxy that used to
+        // live here is superseded by the per-mint Token-2022 detection above).
+        const vaultEntries = [
+            ["A", vaultA],
+            ["B", vaultB],
+        ];
+        const vaultBytesList = await Promise.all(vaultEntries.map(([, vault]) => load(vault)));
+        for (let vi = 0; vi < vaultEntries.length; vi++) {
+            const [role, vault] = vaultEntries[vi];
+            const vaultBytes = vaultBytesList[vi];
+            if (vaultBytes === null)
+                throw new Error(`scorch pool ${pool}: vault${role} ${vault} does not exist`);
+        }
+        return {
+            venue: SLUG,
+            pool,
+            direction: "AtoB",
+            mintA,
+            vaultA,
+            assetConfigA: address(assetConfigAStr),
+            mintB,
+            vaultB,
+            assetConfigB: address(assetConfigBStr),
+        };
+    },
+    quoteAccounts(base) {
+        const cfg = scorchConfig(base);
+        return [
+            { ref: `${cfg.pool}:vaultA`, address: cfg.vaultA },
+            { ref: `${cfg.pool}:vaultB`, address: cfg.vaultB },
+        ];
+    },
+};
+//# sourceMappingURL=index.js.map

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

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

package/sdk/dist/svm/venues/solayer/index.d.ts

@@ -0,0 +1,33 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "solayer";
+export declare const SOLAYER_PROGRAM_ID: Address<"endoLNCKTqDn8gSVnN2hDdpgACUPWHZTwoYnnMybpAT">;
+export declare const SOLAYER_SSOL_MINT: Address<"sSo14endRuUbvQaJS3dq36Q829a3A6BEfoeeRGJywEh">;
+export declare const ENDO_AVS_ACCOUNT_SIZE = 443;
+/** sha256('account:EndoAVS')[0..8] — verified identical across all 20 live pool accounts. */
+export declare const ENDO_AVS_DISCRIMINATOR: number[];
+/** sha256('global:delegate_no_init')[0..8] — verified against a real mainnet instruction's leading bytes. */
+export declare const DELEGATE_NO_INIT_DISCRIMINATOR: number[];
+/** sha256('global:undelegate_no_init')[0..8] — verified against a real mainnet instruction's leading bytes. */
+export declare const UNDELEGATE_NO_INIT_DISCRIMINATOR: number[];
+export type SolayerDirection = "delegate" | "undelegate";
+export interface SolayerPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    direction: SolayerDirection;
+    authority: Address;
+    receiptMint: Address;
+    lstMint: Address;
+    vault: Address;
+    name: string;
+}
+/** Off-chain, once per pool: decode the EndoAVS account and gate its two mints. Read-only against the loader. */
+export declare function fetchSolayerPoolConfig(load: AccountLoader, pool: Address): Promise<SolayerPoolConfig>;
+/** Family facade for the recipe orchestrator. */
+export declare const solayer: {
+    slug: string;
+    programId: Address<"endoLNCKTqDn8gSVnN2hDdpgACUPWHZTwoYnnMybpAT">;
+    tokenProgram: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+    fetchPoolConfig: typeof fetchSolayerPoolConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/solayer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/solayer/index.ts"],"names":[],"mappings":"AAyIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,YAAY,CAAC;AACvB,eAAO,MAAM,kBAAkB,wDAAyD,CAAC;AACzF,eAAO,MAAM,iBAAiB,wDAAyD,CAAC;AAGxF,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,6FAA6F;AAC7F,eAAO,MAAM,sBAAsB,UAAmD,CAAC;AACvF,6GAA6G;AAC7G,eAAO,MAAM,8BAA8B,UAAmD,CAAC;AAC/F,+GAA+G;AAC/G,eAAO,MAAM,gCAAgC,UAAmD,CAAC;AASjG,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,YAAY,CAAC;AAEzD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,iHAAiH;AACjH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,iBAAiB,CAAC,CAkE5B;AAED,iDAAiD;AACjD,eAAO,MAAM,OAAO;;;;;CAKnB,CAAC"}

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

@@ -0,0 +1,224 @@
+/**
+ * Solayer EndoAVS delegation venue adapter — program
+ * `endoLNCKTqDn8gSVnN2hDdpgACUPWHZTwoYnnMybpAT` (Jupiter's own
+ * `program-id-to-label` capture, `benchmark/adapters/fixtures/
+ * jupiter-program-id-to-label.json`, calls this program "Solayer").
+ *
+ * WHAT THIS PROGRAM ACTUALLY IS (there is no public on-chain IDL for it —
+ * everything below is reverse-engineered from live mainnet state plus one
+ * corroborating source, see "GROUND TRUTH" below): it is NOT the sSOL
+ * mint/redeem stake pool itself (that is a *different* program,
+ * `sSo1iU21jBrU9VaJ8PJib1MtorefUV4fzC9GURa2KNn`, wrapping the SPL stake
+ * pool at `po1osKDWYF9oiVEGmzKA4eTs8eMveFRMox3bUKazGN2` — see
+ * `solayer-labs/solayer-cli`'s `restaking/` folder — which needs a
+ * withdraw-stake + deactivate QUEUE to redeem, exactly the queued path this
+ * family avoids). `endoLNCK...` is Solayer's **EndoAVS delegation**
+ * program: it lets an sSOL holder "delegate" sSOL 1:1 into a per-AVS
+ * "delegated" receipt token (e.g. `sonickAJFi...` for the "Sonic" AVS,
+ * `hash4eTHs...` for "Hashkey Cloud AVS", 20 such AVS pools live at
+ * integration time — `getProgramAccounts` on this program id returns
+ * EXACTLY 20 accounts, all 443 bytes, no other account type exists under
+ * this program) and "undelegate" back. Both directions are FULLY ATOMIC —
+ * no queue, no cooldown, no separate ticket account (verified against 3
+ * real mainnet transactions at 3 different sizes/pools/directions, see
+ * "VALIDATION" below) — so unlike the plan's default caution ("wire the
+ * atomic direction first"), there is no non-atomic direction to drop here;
+ * this family wires BOTH.
+ *
+ * GROUND TRUTH: `solayer-labs/solayer-cli`'s `endoavs/utils/constants.ts`
+ * (`PROGRAM_ID = endoLNCKTqDn8gSVnN2hDdpgACUPWHZTwoYnnMybpAT`,
+ * `DELEGATED_TOKEN_MINT_ID = sSo14endRuUbvQaJS3dq36Q829a3A6BEfoeeRGJywEh`)
+ * and `endoavs/utils/type.ts`'s hand-written `EndoAvs` TS type
+ * (`{ bump, authority, avsTokenMint, delegatedTokenMint,
+ * delegatedTokenVault, name, url }`) — this is a CLI author's own partial
+ * reconstruction, not a published Anchor IDL (its `instructions` list is
+ * missing the `_no_init` variants this adapter actually uses), but its
+ * field ORDER matches this adapter's independently-decoded byte layout
+ * exactly, and the account discriminator computed from its type name
+ * (`sha256("account:EndoAVS")[0..8]` = `42a829b1bb0bad7b`) is
+ * BYTE-IDENTICAL to all 20 real pool accounts' leading 8 bytes — strong
+ * independent corroboration that this is genuinely the account's Anchor
+ * name, not a coincidence.
+ *
+ * ACCOUNT LAYOUT (`EndoAVS`, 443 bytes, Anchor-standard 8-byte
+ * discriminator then declared-field order, Borsh-packed) — decoded from
+ * all 20 live pool accounts, cross-checked against real instruction
+ * account lists (below):
+ *   [0..8)    discriminator = sha256("account:EndoAVS")[0..8]
+ *   [8..40)   authority     Pubkey (the AVS's admin; several pools share one)
+ *   [40..41)  bump          u8
+ *   [41..73)  avsTokenMint  Pubkey — THIS adapter's `receiptMint` (per-pool, varies)
+ *   [73..105) lstMint       Pubkey — always `sSo14endRuUbvQaJS3dq36Q829a3A6BEfoeeRGJywEh` (sSOL) on all 20 live pools
+ *   [105..137) vault        Pubkey — the SPL token account (owned by this program's PDA) holding delegated sSOL
+ *   [137..)   name          Borsh String (u32 LE length + UTF-8 bytes)
+ *   [..)      url           Borsh String (u32 LE length + UTF-8 bytes) — often unset (zero length)
+ *   [..443)   reserved padding (observed all-zero on every live pool; may carry
+ *             future fields the CLI's partial IDL does not yet name — never read here)
+ *
+ * INSTRUCTIONS — two ANCHOR-standard discriminators
+ * (`sha256("global:<snake_case name>")[0..8]`), recovered from real
+ * transaction `Program log: Instruction: <Name>` lines and independently
+ * confirmed by recomputing the sha256 of the candidate snake_case name and
+ * matching it byte-for-byte against the real instruction data's leading 8
+ * bytes (both matched exactly — see VALIDATION):
+ *   delegate_no_init   fe 00 de 28 91 76 6e 14   (mints receiptMint 1:1 for sSOL)
+ *   undelegate_no_init d5 11 d7 51 05 72 7c 4e   (burns receiptMint 1:1 for sSOL)
+ * Both take a SINGLE u64 LE amount argument immediately after the
+ * discriminator (no trailing min-out/slippage word — this program has no
+ * partial-fill or slippage concept of its own; the recipe's own terminal
+ * outAta-delta check is what enforces `minOut`, exactly like every other
+ * venue here). The `_no_init` suffix (vs. the base `delegate`/`undelegate`
+ * the CLI's stale partial IDL names) means neither instruction creates the
+ * destination ATA — this recipe's ATAs are always pre-resolved, so `_no_init`
+ * is the correct (cheaper) variant, same reasoning as every other venue's
+ * ATA handling in this recipe.
+ *
+ * Both instructions share ONE account order for BOTH directions (only
+ * which physical account plays "in" vs "out" changes; the ORDER doesn't):
+ *   0 user            signer
+ *   1 pool (EndoAVS)   PDA, read-only (its bump/authority fields sign
+ *                      internally via invoke_signed; the caller never signs for it)
+ *   2 receiptMint      writable (its supply changes: minted on delegate, burned on undelegate)
+ *   3 vault            writable (its sSOL balance changes)
+ *   4 lstMint          read-only (sSOL mint, mint-checked by `transfer_checked`)
+ *   5 user's sSOL ATA      writable (source on delegate, destination on undelegate)
+ *   6 user's receiptMint ATA writable (destination on delegate, source on undelegate)
+ *   7 token program
+ * (delegate: burn/transfer inner ixs observed as `transfer_checked(sSOL: user->vault)` then
+ * `mint_to(receiptMint: ->user)`, both for the SAME amount; undelegate: `burn(receiptMint: user)`
+ * then `transfer_checked(sSOL: vault->user)`, again the SAME amount both sides.)
+ *
+ * QUOTE MATH: EXACT 1:1, NO FEE. There is no fee/exchange-rate field
+ * anywhere in the 443-byte account (every byte past `url` is zero on
+ * every one of the 20 live pools), and all 3 real transactions below
+ * transferred/minted/burned the IDENTICAL raw amount on both legs. The
+ * only real constraint is CAPACITY, and it is DIRECTIONAL and HARD (a
+ * step function, not a diminishing curve):
+ *   - delegate (sSOL -> receiptMint): bounded only by the receiptMint's
+ *     remaining u64 mint headroom (`2^64-1 - supply`) — astronomically
+ *     large in practice (observed live supplies are ~10^12-10^13 raw,
+ *     ~13 orders of magnitude under the u64 ceiling) but modeled exactly
+ *     rather than assumed infinite, so a pathological near-max-supply pool
+ *     is still never over-quoted.
+ *   - undelegate (receiptMint -> sSOL): bounded by the vault's LIVE sSOL
+ *     balance (an `accountUint` read at execution time) — the real,
+ *     binding constraint (a live-observed pool has vault balance *above*
+ *     its receipt supply by a materially nonzero amount — some
+ *     out-of-band sSOL entered the vault outside delegate/undelegate,
+ *     e.g. reward accrual or a direct top-up; capacity is read from the
+ *     vault directly, never assumed equal to supply, so this is harmless).
+ * Both are exactly `min(x, cap)` — monotone non-decreasing and concave
+ * (the min of an affine function and a constant), satisfying the merge's
+ * ladder-curve requirement with no curvature to model at all.
+ *
+ * VALIDATION (three real mainnet transactions, three sizes, both
+ * directions, two different AVS pools — decoded via `getTransaction`
+ * `jsonParsed` + inner-instruction `parsed.info`, not guessed):
+ *   delegate,   Sonic pool    (via a Jupiter RouteV2 leg): 208_072_380 sSOL in
+ *               -> 208_072_380 sonicK minted.  tx H7JUL9QEcrnnsSXDGzW2mYap1t4n9jAmk9xvmtwNmP5m8Jn4sED8h582Tph96epsz7yoAW2LY1yBqHQtZxyHHby
+ *   undelegate, Sonic pool    (direct top-level call):     3_010_000_000 sonicK burned
+ *               -> 3_010_000_000 sSOL out. tx 5jRGKMb7simyMyYp3bbviMhc1pndgGEnSv2oRWsQd6fjkEEH1rM8g64fAcUoGmHf25WXLYQuSQv7FnxAjh9yMfcX
+ *   undelegate, Hashkey Cloud AVS pool (via a Jupiter SharedAccountsRouteV2 leg): 12_450_000 hash4eT burned
+ *               -> 12_450_000 sSOL out. tx 4bnVs3683krULUFbQc6sC7Yx5pJNaDbnxBu12uW2ikMrZq3qgSX3ZLgcPdRwsNr4KuwffwnbMNAqyZCKjXjGGNzf
+ * `the consuming app solayer e2e test` replays real fixture dumps of
+ * the Sonic and Hashkey Cloud AVS pools (`test/svm/fixtures/solayer{,-dir1}`,
+ * captured at integration time) through `referenceQuote` AND through the
+ * real committed engine, and separately drives the REAL dumped
+ * `solayer.so` program binary (SAUCE_VENUE_PROGRAMS-gated real-CPI cell)
+ * to prove this adapter's exact instruction/account encoding is accepted
+ * by the live program, not merely self-consistent.
+ *
+ * Both mints are classic Tokenkeg (82-byte SPL mint accounts) on every one
+ * of the 20 live pools plus the shared sSOL mint — confirmed via
+ * `getMultipleAccounts`, no Token-2022 extension mint observed anywhere in
+ * this family, so this adapter gates on that (Tokenkeg-only, like most of
+ * this recipe's other venues) rather than modeling transfer-fee extensions.
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { readUintLE } from "../math.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "solayer";
+export const SOLAYER_PROGRAM_ID = address("endoLNCKTqDn8gSVnN2hDdpgACUPWHZTwoYnnMybpAT");
+export const SOLAYER_SSOL_MINT = address("sSo14endRuUbvQaJS3dq36Q829a3A6BEfoeeRGJywEh");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+export const ENDO_AVS_ACCOUNT_SIZE = 443;
+/** sha256('account:EndoAVS')[0..8] — verified identical across all 20 live pool accounts. */
+export const ENDO_AVS_DISCRIMINATOR = [0x42, 0xa8, 0x29, 0xb1, 0xbb, 0x0b, 0xad, 0x7b];
+/** sha256('global:delegate_no_init')[0..8] — verified against a real mainnet instruction's leading bytes. */
+export const DELEGATE_NO_INIT_DISCRIMINATOR = [0xfe, 0x00, 0xde, 0x28, 0x91, 0x76, 0x6e, 0x14];
+/** sha256('global:undelegate_no_init')[0..8] — verified against a real mainnet instruction's leading bytes. */
+export const UNDELEGATE_NO_INIT_DISCRIMINATOR = [0xd5, 0x11, 0xd7, 0x51, 0x05, 0x72, 0x7c, 0x4e];
+const OFF_AUTHORITY = 8;
+const OFF_RECEIPT_MINT = 41;
+const OFF_LST_MINT = 73;
+const OFF_VAULT = 105;
+const OFF_NAME_LEN = 137;
+const OFF_NAME = 141;
+const SPL_TOKEN_ACCOUNT_SIZE = 165;
+function hasDiscriminator(data, discriminator) {
+    return discriminator.every((byte, i) => data[i] === byte);
+}
+/** Off-chain, once per pool: decode the EndoAVS account and gate its two mints. Read-only against the loader. */
+export async function fetchSolayerPoolConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG} pool account ${pool} not found`);
+    if (data.length !== ENDO_AVS_ACCOUNT_SIZE) {
+        throw new Error(`${SLUG} pool ${pool} data must be ${ENDO_AVS_ACCOUNT_SIZE} bytes (EndoAVS), got ${data.length}`);
+    }
+    if (!hasDiscriminator(data, ENDO_AVS_DISCRIMINATOR)) {
+        throw new Error(`${SLUG} pool ${pool} has a foreign discriminator (not an EndoAVS account)`);
+    }
+    const codec = getAddressCodec();
+    const authority = codec.decode(data.subarray(OFF_AUTHORITY, OFF_AUTHORITY + 32));
+    const receiptMint = codec.decode(data.subarray(OFF_RECEIPT_MINT, OFF_RECEIPT_MINT + 32));
+    const lstMint = codec.decode(data.subarray(OFF_LST_MINT, OFF_LST_MINT + 32));
+    const vault = codec.decode(data.subarray(OFF_VAULT, OFF_VAULT + 32));
+    const nameLen = Number(readUintLE(data, OFF_NAME_LEN, 4));
+    if (OFF_NAME + nameLen > data.length) {
+        throw new Error(`${SLUG} pool ${pool} has a corrupt name length (${nameLen})`);
+    }
+    const name = new TextDecoder().decode(data.subarray(OFF_NAME, OFF_NAME + nameLen));
+    // Both directions transfer/mint/burn via the classic Tokenkeg program, so a
+    // Token-2022 mint (or one carrying an un-routable extension) must SELF-DROP.
+    // Detect the real token program per mint via the shared data-shape resolver;
+    // the thrown error IS the graceful drop (SvmRoute catches a fetchPoolConfig
+    // throw and drops the venue). LEGACY path byte-identical: a classic 82-byte
+    // mint classifies Tokenkeg, parses no extensions, config built unchanged. An
+    // unreadable mint falls back to the legacy assumption (keeps existing tests green).
+    const [receiptMintData, lstMintData] = await Promise.all([load(receiptMint), load(lstMint)]);
+    for (const [mint, mintData] of [
+        [receiptMint, receiptMintData],
+        [lstMint, lstMintData],
+    ]) {
+        if (mintData === null)
+            continue;
+        if (classifyMintProgram(mint, mintData) === TOKEN_2022_PROGRAM_ID) {
+            throw new Error(`${SLUG}: dropping pool ${pool} — mint ${mint} 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 ${mint} is un-routable: ${blocking.join("; ")}`);
+        }
+    }
+    const vaultData = await load(vault);
+    if (vaultData === null)
+        throw new Error(`${SLUG} pool ${pool} vault ${vault} not found`);
+    if (vaultData.length !== SPL_TOKEN_ACCOUNT_SIZE) {
+        throw new Error(`${SLUG} pool ${pool} vault ${vault} must be a ${SPL_TOKEN_ACCOUNT_SIZE}-byte SPL token account, got ${vaultData.length} bytes`);
+    }
+    const vaultMint = codec.decode(vaultData.subarray(0, 32));
+    if (vaultMint !== lstMint) {
+        throw new Error(`${SLUG} pool ${pool} vault ${vault} mint ${vaultMint} does not match the pool's lst mint ${lstMint}`);
+    }
+    return { venue: SLUG, pool, direction: "delegate", authority, receiptMint, lstMint, vault, name };
+}
+/** Family facade for the recipe orchestrator. */
+export const solayer = {
+    slug: SLUG,
+    programId: SOLAYER_PROGRAM_ID,
+    tokenProgram: TOKEN_PROGRAM,
+    fetchPoolConfig: fetchSolayerPoolConfig,
+};
+//# sourceMappingURL=index.js.map

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

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

package/sdk/dist/svm/venues/solfi-v1/index.d.ts

@@ -0,0 +1,54 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "solfi-v1";
+export declare const SOLFI_V1_PROGRAM_ID: Address<"SoLFiHG9TfgtdUXUjWAxi3LtvYuFyDLVhBWxdMZxyCe">;
+export declare const POOL_ACCOUNT_SIZE = 2800;
+export declare const OFF_MINT_A = 2664;
+export declare const OFF_MINT_B = 2696;
+export declare const OFF_VAULT_A = 2736;
+export declare const OFF_VAULT_B = 2768;
+/**
+ * The verified conservative floor rate for a pool + direction: real realized
+ * output is >= (num/den)·amountIn at every sampled size (see the module doc
+ * and docs/solfi-v1-evidence.md for the raw LiteSVM sweep this was derived
+ * from — NOT a claim about the venue's real fee/impact schedule, a safety
+ * floor sized so the model never over-promises).
+ */
+export interface SolfiV1FloorRate {
+    num: bigint;
+    den: bigint;
+}
+/**
+ * Per-pool, per-direction verified floor rates. A pool absent here THROWS at
+ * `fetchPoolConfig` (see `fetchSolfiV1Config`) — never borrowed from another
+ * pool, mirroring solfi-v2's `POOL_K`. direction 0 = mintA -> mintB, 1 =
+ * mintB -> mintA (matches the on-chain instruction's direction byte).
+ *
+ * '65ZHSArs...'-style single-pool coverage today: the only pool this
+ * integration's LiteSVM sweep verified (docs/solfi-v1-evidence.md). Extend
+ * by running the same sweep against another pool's real bytes.
+ */
+export declare const SOLFI_V1_POOL_RATES: Record<string, {
+    0: SolfiV1FloorRate;
+    1: SolfiV1FloorRate;
+}>;
+export interface SolfiV1PoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 0 = mintA -> mintB, 1 = mintB -> mintA. */
+    direction: 0 | 1;
+    mintA: Address;
+    mintB: Address;
+    vaultA: Address;
+    vaultB: Address;
+    rate0: SolfiV1FloorRate;
+    rate1: SolfiV1FloorRate;
+}
+/**
+ * Off-chain gate + decode: pool size, mint/vault pubkeys (plaintext, fixed
+ * offsets — verified across all 40 discovered pools), and the per-pool
+ * verified floor rate (REQUIRED — see `SOLFI_V1_POOL_RATES`; a pool not yet
+ * independently verified throws rather than guessing).
+ */
+export declare function fetchSolfiV1Config(load: AccountLoader, pool: Address, direction?: 0 | 1): Promise<SolfiV1PoolConfig>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/solfi-v1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/solfi-v1/index.ts"],"names":[],"mappings":"AAgGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,QAAA,MAAM,IAAI,aAAa,CAAC;AAExB,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC,6CAA6C,CAEtF,CAAC;AAEF,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAGtC,eAAO,MAAM,UAAU,OAAO,CAAC;AAC/B,eAAO,MAAM,UAAU,OAAO,CAAC;AAC/B,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,CAAC,EAAE,gBAAgB,CAAC;IAAC,CAAC,EAAE,gBAAgB,CAAA;CAAE,CAS5F,CAAC;AAEF,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,8CAA8C;IAC9C,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAID;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,EACb,SAAS,GAAE,CAAC,GAAG,CAAK,GACnB,OAAO,CAAC,iBAAiB,CAAC,CA4B5B"}