@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,300 @@
+/**
+ * Voltr (SvmRoute ladder fragment) — a permissionless vault-infrastructure
+ * protocol (`voltrxyz`): depositors mint LP shares against a vault's live
+ * NAV (`deposit_vault`) and can redeem them atomically for the underlying
+ * asset out of the vault's un-invested ("idle") float (`instant_withdraw_vault`).
+ * `request_withdraw_vault`/`withdraw_vault` are the QUEUED path (burns LP now,
+ * creates a `RequestWithdrawVaultReceipt`, delivers nothing atomically — the
+ * asset lands only after `withdrawal_waiting_period` via a SEPARATE later
+ * transaction) and are therefore NOT modeled here, the same "cannot be a
+ * Sauce venue leg" reasoning `xorca.ts`'s file header applies to its own
+ * queued Unstake/Withdraw path.
+ *
+ * ── Ground truth: the program's OWN on-chain-published Anchor IDL ──
+ *
+ * Voltr publishes its IDL on-chain at the canonical Anchor IDL PDA
+ * (`createAddressWithSeed(findProgramAddress([], programId), "anchor:idl",
+ * programId)` — fetched 2026-07-31, decompresses to exactly 73,416 bytes of
+ * JSON from a 10,770-byte account, `voltr_vault` v0.2.0). Every offset,
+ * discriminator, instruction-account order, and struct field below is taken
+ * DIRECTLY from that IDL (`accounts`/`types`/`instructions`), not
+ * reverse-engineered from bytes. The `Vault` account is `bytemuckunsafe`
+ * zero-copy `repr(C)` — Anchor zero-copy buffers are only guaranteed
+ * 8-byte alignment (the 8-byte discriminator precedes the struct), so this
+ * struct's `u128` field (`HighWaterMark.highest_asset_per_lp_decimal_bits`)
+ * is laid out at 8-byte, NOT the natural Rust 16-byte, alignment —
+ * confirmed empirically: computing offsets with align-16 for u128 predicts
+ * an 8-byte gap before `high_water_mark` and a total size of 936 bytes
+ * (disc-inclusive), but every one of 196 real mainnet `Vault` accounts
+ * sampled (`getProgramAccounts` with a discriminator memcmp, 2026-07-31) is
+ * exactly 928 bytes; re-deriving with align-8 for u128 removes that gap and
+ * predicts 928 bytes EXACTLY, and every field decoded at the resulting
+ * offsets (asset/lp mints, fee bps, timestamps, manager/admin pubkeys) reads
+ * as a plausible, self-consistent real value across all 196 samples — the
+ * strongest available confirmation short of the Rust source itself. (Two of
+ * the 196 are 952 bytes — a newer/rarer on-disk variant; `fetchPoolConfig`
+ * accepts any length >= `VAULT_MIN_LEN` since every field this adapter reads
+ * sits well inside the first 928 bytes either way, but `SVM_FAMILY_FILTERS`'s
+ * gPA `dataSize` filter only matches the 194 at exactly 928 — self-dropping
+ * the 952-byte pair from DISCOVERY, not from direct resolution.)
+ *
+ * ── Quote math — a byte-exact port of the protocol's OWN published SDK ──
+ *
+ * `@voltr/vault-sdk`'s `VoltrClient.calculateLpForDeposit` /
+ * `calculateAssetsForWithdrawHelper` (both in `src/client.ts`, MIT, published
+ * by the protocol team as the canonical off-chain preview of the on-chain
+ * accounting) give the exact closed form ported below — NOT an approximation:
+ *
+ *   unharvestedFeesLp = accumulated_lp_{manager,admin,protocol}_fees (summed)
+ *   lpSupplyInclAccumulatedFees = lp_mint.supply + unharvestedFeesLp + dead_weight
+ *   mgmtFeeBps = manager_management_fee + admin_management_fee + protocol_management_fee
+ *   unrealisedLpFees = 0 if lastMgmtFeeUpdateTs==0 || totalValue==0 || mgmtFeeBps==0
+ *     else (elapsed = max(0, now - lastMgmtFeeUpdateTs); 0 if elapsed==0; else
+ *     feeInAsset = totalValue*elapsed*mgmtFeeBps/10000/31536000 (a per-second
+ *     linear accrual over a 365-day year, BPS-scaled);
+ *     ceil(feeInAsset * lpSupplyInclAccumulatedFees / (totalValue - feeInAsset)))
+ *   lpSupplyInclFees = lpSupplyInclAccumulatedFees + unrealisedLpFees
+ *
+ *   DEPOSIT (lpSupplyInclFees == 0, i.e. a never-deposited-into vault):
+ *     mint = assetIn * 10^lpDecimals / 10^assetDecimals  (decimals-aware 1:1)
+ *   DEPOSIT (else):
+ *     mint = floor(assetIn * lpSupplyInclFees * (10000-issuanceFeeBps)
+ *                  / (totalValue*10000 + assetIn*issuanceFeeBps))
+ *     — algebraically (totalValue+assetIn)*10000 - assetIn*(10000-issuanceFeeBps)
+ *       reduces to totalValue*10000 + assetIn*issuanceFeeBps, so assetIn appears
+ *       in the denominator ONLY via issuanceFeeBps: issuanceFeeBps==0 (the
+ *       common case, confirmed on multiple live vaults) makes this EXACTLY
+ *       linear; issuanceFeeBps>0 makes it a mild, still monotone-concave,
+ *       saturating (CP-like) curve — never non-monotone.
+ *
+ *   WITHDRAW: lockedProfit = 0 if locked_profit_degradation_duration==0, else
+ *     (duration = max(0, now - last_report); 0 if duration > degradationDuration
+ *     else last_updated_locked_profit * (degradationDuration-duration) / degradationDuration)
+ *     totalUnlockedValue = totalValue - lockedProfit
+ *     assetOut = floor(lpIn * totalUnlockedValue * (10000-redemptionFeeBps)
+ *                       / (lpSupplyInclFees * 10000))
+ *     — EXACTLY linear in lpIn (no lpIn term in the denominator).
+ *
+ * `last_updated_locked_profit` genuinely holds a PROFIT AMOUNT (not a
+ * timestamp, despite the SDK's `calculateLockedProfit` naming its own first
+ * arg `lastUpdatedLockedProfit` and using it in a `now - lastUpdatedLockedProfit`
+ * subtraction) — confirmed by live values: every sampled vault's field reads
+ * as an asset-scale magnitude (9, 38126, ..., 10680089518998677 for a
+ * near-empty/dead vault) while `last_report` always reads as a plausible
+ * 2026 Unix timestamp (~1.78-1.79 billion). Ported EXACTLY as the SDK computes
+ * it regardless (a real elapsed-time-vs-profit-amount subtraction is
+ * dimensionally strange, but at every magnitude actually observed on mainnet
+ * it drives `duration` far past any real `locked_profit_degradation_duration`
+ * — itself always a short window, 0 or up to a few days in every sample — so
+ * the guard `duration > degradationDuration` fires and locked profit reads 0;
+ * porting the SDK's literal arithmetic rather than a "corrected" reading is
+ * the safe choice either way since it can only make `totalUnlockedValue`
+ * SMALLER, never larger, than a version using `last_report` for the
+ * subtraction would — i.e. it never over-promises a withdrawal).
+ *
+ * `ctx.timestamp()` (the compiler's Clock-sysvar-backed global, the SAME
+ * intrinsic `meteora-damm-v1-stable`'s own locked-profit-decay quote already
+ * uses on-chain) drives the time-dependent terms; `Vault`'s own bytes drive
+ * everything else — nothing here is baked at prepare time except
+ * `assetDecimals`/`lpDecimals` (fixed per vault forever) and the vault's own
+ * address-derived accounts.
+ *
+ * ── Two SELF-DROP-worthy hard caps, both handled as a SATURATING clamp
+ *    (never a revert) so a program built against a stale/racy plan degrades
+ *    to a smaller fill instead of aborting the whole cook (SVM execution-time
+ *    CPI failure is unrecoverable — see the consuming app SVM README) ──
+ *
+ * 1. DEPOSIT vs `vault_configuration.max_cap`: a deposit that would push
+ *    `total_value` past `max_cap` is documented ("The maximum total amount
+ *    allowed in the vault") to be rejected by the program. This adapter
+ *    clamps the EFFECTIVE input to `max(0, max_cap - total_value)` before
+ *    quoting, so the reported mint amount flattens at the cap instead of
+ *    quoting a number the real CPI would then revert on. (Not independently
+ *    revert-tested against a live over-cap deposit — the clamp is
+ *    conservative regardless: it can only quote LESS than the uncapped
+ *    formula would, never more.)
+ * 2. WITHDRAW vs the live idle-ATA SPL balance: `instant_withdraw_vault`
+ *    pays out of `vault_asset_idle_ata` ONLY (never touches strategy-invested
+ *    capital) — CONFIRMED via a real `simulateTransaction` against a live
+ *    vault (2026-07-31): a withdrawal sized above the idle ATA's real balance
+ *    fails with the SPL Token program's own "insufficient funds" (custom
+ *    error `0x1`), not a Voltr-level revert. This adapter clamps the quoted
+ *    payout to the live idle-ATA balance, read on-chain in the SAME setup
+ *    block.
+ *
+ * ── Validated against the REAL deployed program on REAL mainnet state,
+ *    at 4+ sizes each direction, via `simulateTransaction` (sigVerify:false,
+ *    replaceRecentBlockhash:true — no real signature needed, any funded
+ *    wallet can serve as fee payer while an arbitrary real token holder is
+ *    impersonated as the depositor/withdrawer; nothing was ever submitted) —
+ *
+ * DEPOSIT (vault `Gj8kURFs8fK3GhiX5Yc6H1HQKSpEvLHeDRZsP6Y2D1je`, HUB-denominated,
+ * issuanceFee=0 so exactly linear): a real HUB holder's canonical ATA
+ * depositing 1 / 10 / 100 / 500 HUB (1e9/1e10/1e11/5e11 raw, 9 decimals)
+ * against the SAME-SLOT post-deposit vault/mint state minted EXACTLY
+ * 998,312,468 / 9,983,124,685 / 99,831,246,854 / 499,156,234,274 raw LP
+ * — the formula above, evaluated on that same-slot state, predicts the
+ * IDENTICAL integer at all 4 sizes (bit-for-bit, verified programmatically).
+ * The deposit CPI itself (including its 2 nested SPL Transfer/MintTo CPIs)
+ * measured 33,527 / 33,643 / 33,644 / 33,643 CU.
+ *
+ * WITHDRAW (same vault, redemptionFee=15bps): a real LP holder's canonical
+ * ATA withdrawing 0.5 / 2 / 5 LP (5e8/2e9/5e9 raw) against GENUINE PRE-state
+ * (fetched via `getMultipleAccounts` immediately before simulating — the
+ * withdraw formula's fee-retention means feeding it POST-state, unlike
+ * deposit's self-consistent floor identity, does NOT reproduce the same
+ * answer) paid out EXACTLY 500,093,222 / 2,000,372,890 / 5,000,932,225 raw
+ * asset — the formula predicts the IDENTICAL integer at all 3 sizes,
+ * bit-for-bit. A 4th size (20 LP, exceeding the vault's live ~9.6 HUB idle
+ * balance) failed with the SPL "insufficient funds" error described above,
+ * confirming the idle-liquidity cliff empirically. The withdraw CPI measured
+ * 35,517 / 35,517 / 35,633 CU on the three successful sizes.
+ *
+ * ── CU (`the consuming app SVM CU-budget module`'s `CU_FAMILIES.voltr`) ──
+ *
+ * Per the standing "existing pins omit the venue CPI" gap, this pin takes
+ * raydium-cp-swap's 183,187 as a same-complexity NON-CPI baseline (2 vault
+ * reads + a fee-adjusted CP formula) and adds a margin over OUR OWN measured
+ * CPI (max 35,633 across both directions, +15% -> ~40,978) PLUS extra
+ * headroom for this family's heavier setup (this adapter reads ~10 distinct
+ * Vault fields plus the LP mint's supply, vs raydium-cp-swap's 2 balances),
+ * landing at 225,000 (deliberately rounded UP past the arithmetic sum, never
+ * down — this can only over-estimate CU, never under). `rung` reuses
+ * raydium-cp-swap's 65,054 verbatim: a rung here is one more helper-function
+ * call over already-read setup locals (a handful of multiplies/divides/
+ * comparisons), at most as expensive as raydium-cp-swap's own per-rung
+ * fee-adjusted CP formula.
+ *
+ * ── Token-2022 assets: not distinguished (documented simplification, not a
+ *    permission gate) ──
+ *
+ * `AccountLoader` returns raw bytes only (no owning-program field), so
+ * `fetchPoolConfig` cannot see whether `vault_asset_mint` is Token or
+ * Token-2022 owned. Every one of the sampled vaults' assets (HUB, USDC, wSOL,
+ * USDS, and others) is a classic SPL Token mint, so `assetTokenProgram` is
+ * pinned to the classic Token program. A future Token-2022-asset vault would
+ * fail its OWN CPI cleanly (a program-ownership mismatch on the passed
+ * token-program account) rather than corrupt anything — a self-drop for that
+ * one vault, not a systemic risk. `lpTokenProgram` needs no such handling:
+ * the IDL fixes it to the classic Token program unconditionally (LP shares
+ * are never Token-2022).
+ */
+import { address, getAddressDecoder, getAddressEncoder, getProgramDerivedAddress, } from "@solana/kit";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { memoizedFindAssociatedTokenPda, memoizedGetProgramDerivedAddress } from "../pda-memo.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "voltr";
+export const VOLTR_PROGRAM_ID = address("vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8");
+export const SPL_TOKEN_PROGRAM_ID = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+// ── Anchor IDL constants (voltr_vault v0.2.0, decoded from the on-chain IDL account) ──
+const VAULT_DISCRIMINATOR = [211, 8, 232, 43, 2, 152, 117, 119];
+/** Minimum real length (the 928-byte layout); a 952-byte variant also decodes fine. */
+const VAULT_MIN_LEN = 928;
+const OFF_ASSET_MINT = 104;
+const OFF_LP_MINT = 272;
+/** SPL `Mint.decimals`, u8 (4-byte COption tag + 32-byte pubkey + 8-byte supply precede it). */
+const MINT_DECIMALS_OFFSET = 44;
+// Bound at module scope (not per-call) — getAddressDecoder() builds a fresh
+// codec instance each call, cheap but pointless to redo per field.
+const ADDRESS_DECODER = getAddressDecoder();
+function readAddress(data, offset) {
+    return ADDRESS_DECODER.decode(data.subarray(offset, offset + 32));
+}
+let cachedProtocolPda;
+function protocolPda() {
+    if (cachedProtocolPda === undefined) {
+        cachedProtocolPda = getProgramDerivedAddress({
+            programAddress: VOLTR_PROGRAM_ID,
+            seeds: [new TextEncoder().encode("protocol")],
+        }).then(([pda]) => pda);
+    }
+    return cachedProtocolPda;
+}
+/**
+ * Off-chain, once per pool: derive every PDA the CPI needs, verify the
+ * stored LP mint address matches its own seed derivation (a cheap
+ * self-consistency check — a mismatch means a wrong/spoofed account), and
+ * read the two mints' decimals (needed only for the empty-vault bootstrap
+ * case, fixed forever per vault so safe to bake at prepare time).
+ */
+export async function fetchVoltrConfig(load, pool) {
+    const raw = await load(pool);
+    if (raw === null)
+        throw new Error(`${SLUG}: vault account ${pool} not found`);
+    if (raw.length < VAULT_MIN_LEN) {
+        throw new Error(`${SLUG}: vault account ${pool} is ${raw.length} bytes, want >= ${VAULT_MIN_LEN}`);
+    }
+    for (let i = 0; i < VAULT_DISCRIMINATOR.length; i++) {
+        if (raw[i] !== VAULT_DISCRIMINATOR[i]) {
+            throw new Error(`${SLUG}: vault account ${pool} has the wrong account discriminator`);
+        }
+    }
+    const assetMint = readAddress(raw, OFF_ASSET_MINT);
+    const lpMint = readAddress(raw, OFF_LP_MINT);
+    const enc = getAddressEncoder();
+    const poolBytes = enc.encode(pool);
+    const [protocol, vaultAssetIdleAuth, vaultLpMintAuth, derivedLpMint] = await Promise.all([
+        protocolPda(),
+        memoizedGetProgramDerivedAddress(VOLTR_PROGRAM_ID, [
+            new TextEncoder().encode("vault_asset_idle_auth"),
+            poolBytes,
+        ]),
+        memoizedGetProgramDerivedAddress(VOLTR_PROGRAM_ID, [
+            new TextEncoder().encode("vault_lp_mint_auth"),
+            poolBytes,
+        ]),
+        memoizedGetProgramDerivedAddress(VOLTR_PROGRAM_ID, [
+            new TextEncoder().encode("vault_lp_mint"),
+            poolBytes,
+        ]),
+    ]);
+    if (derivedLpMint !== lpMint) {
+        throw new Error(`${SLUG}: vault ${pool} lp mint ${lpMint} does not match its own PDA derivation ${derivedLpMint}`);
+    }
+    const vaultAssetIdleAta = await memoizedFindAssociatedTokenPda({
+        owner: vaultAssetIdleAuth,
+        mint: assetMint,
+        tokenProgram: SPL_TOKEN_PROGRAM_ID,
+    });
+    const [assetMintRaw, lpMintRaw] = await Promise.all([load(assetMint), load(lpMint)]);
+    if (assetMintRaw === null)
+        throw new Error(`${SLUG}: asset mint ${assetMint} not found`);
+    if (lpMintRaw === null)
+        throw new Error(`${SLUG}: lp mint ${lpMint} not found`);
+    const assetDecimals = assetMintRaw[MINT_DECIMALS_OFFSET];
+    const lpDecimals = lpMintRaw[MINT_DECIMALS_OFFSET];
+    // `deposit_vault`/`instant_withdraw_vault` pass the classic Token program for
+    // the asset side; a Token-2022 asset changes wire semantics this adapter has
+    // not verified against. Detect a Token-2022 (or otherwise un-routable) mint
+    // and GRACEFULLY SELF-DROP the pool (the SvmRoute orchestrator catches a
+    // fetchPoolConfig throw and drops the venue) instead of relying on the CPI to
+    // fail on-chain. Reuses the mint bytes already loaded above; the LEGACY path
+    // is byte-identical (a classic 82-byte mint classifies Tokenkeg, parses no
+    // extensions). LP shares are always classic per the IDL, checked defensively.
+    for (const [m, mintData] of [
+        [assetMint, assetMintRaw],
+        [lpMint, lpMintRaw],
+    ]) {
+        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("; ")}`);
+        }
+    }
+    return {
+        venue: SLUG,
+        pool,
+        direction: "assetToLp",
+        assetMint,
+        lpMint,
+        protocol,
+        vaultAssetIdleAuth,
+        vaultAssetIdleAta,
+        vaultLpMintAuth,
+        assetDecimals,
+        lpDecimals,
+    };
+}
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,36 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, VenueAccount } from "../types.js";
+declare const SLUG = "whalestreet";
+export declare const WHALESTREET_PROGRAM_ID: Address<"FW6zUqn4iKRaeopwwhwsquTY6ABWLLgjxtrC3VPnaWBf">;
+export declare const WHALESTREET_OFF_MINT_A = 22;
+export declare const WHALESTREET_OFF_VAULT_A = 54;
+export declare const WHALESTREET_OFF_MINT_B = 137;
+export declare const WHALESTREET_OFF_VAULT_B = 169;
+/**
+ * The REAL, validated 9-byte instruction-data prefix — opcode 0x01 plus an
+ * 8-byte tag observed identical across all 5 real captured samples (3
+ * sizes + a repeat + the reverse direction) on the ONE pool this
+ * integration validated against. See the module doc's "INSTRUCTION DATA".
+ */
+export declare const WHALESTREET_IX_PREFIX: Uint8Array<ArrayBuffer>;
+export interface WhalestreetPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 0 = mintA in / mintB out, 1 = mintB in / mintA out. */
+    direction: 0 | 1;
+    mintA: Address;
+    mintB: Address;
+    vaultA: Address;
+    vaultB: Address;
+}
+export declare function fetchWhalestreetPoolConfig(load: AccountLoader, pool: Address): Promise<WhalestreetPoolConfig>;
+declare function quoteAccounts(base: PoolConfig): VenueAccount[];
+/** Partial v1-shaped helper (fetchPoolConfig/quoteAccounts only) — this venue is ladder-only (v2); see whalestreetLadder below for the full adapter surface. */
+export declare const whalestreet: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"FW6zUqn4iKRaeopwwhwsquTY6ABWLLgjxtrC3VPnaWBf">;
+    fetchPoolConfig: typeof fetchWhalestreetPoolConfig;
+    quoteAccounts: typeof quoteAccounts;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/whalestreet/index.ts"],"names":[],"mappings":"AAiJA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3E,QAAA,MAAM,IAAI,gBAAgB,CAAC;AAC3B,eAAO,MAAM,sBAAsB,yDAA0D,CAAC;AAG9F,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,yBAEhC,CAAC;AAMH,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,0DAA0D;IAC1D,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;CACjB;AAQD,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,qBAAqB,CAAC,CA0ChC;AAED,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,EAAE,CAMvD;AAED,gKAAgK;AAChK,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC"}

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

@@ -0,0 +1,225 @@
+/**
+ * WhaleStreet — a closed-source Solana AMM (program
+ * `FW6zUqn4iKRaeopwwhwsquTY6ABWLLgjxtrC3VPnaWBf`, Jupiter label `"WhaleStreet"`
+ * per `benchmark/adapters/fixtures/jupiter-program-id-to-label.json`),
+ * 5.7M/7d, 0.8M/24h real volume per the integration brief this venue was
+ * scoped from. No on-chain IDL ships for this program — everything below is
+ * recovered by live account/transaction archaeology, the same method used
+ * for obric-v2/solfi-v2/scorch.
+ *
+ * ── DISCOVERY (a live `getProgramAccounts`, owner=program, no filters) ──
+ * Found exactly 4 live pools at the time of this integration, ALL a fixed
+ * 605-byte "pool" account: `2EeB1sfELZykmHvms37B9G2mKmrAZ6S7NcsamiyjaJW6`,
+ * `8K1JEwrRYwBcvsFNtkFo41fnA2nhfeQ8twrQwvqvt1Xp`,
+ * `FMcPAGCC8rDsLEFAp3WufXpuhRMqnaXuAJqxN5hU2ZeA`,
+ * `Hhugr5Bw2NpmM4zKgDcQpypnVG7UPjcFFtHeaTbz764h` (the SOL/USDC pool Jupiter
+ * itself routed every quote below through). Byte offsets (below) were
+ * ground-truthed by scanning ALL FOUR accounts for embedded pubkeys
+ * (`getMultipleAccounts`, checking which candidate 32-byte windows resolve to
+ * a real on-chain account) and cross-checking owners:
+ *
+ *   [22:54)   mintA   (owner = Tokenkeg — a real SPL mint; WSOL on 3 of 4 pools)
+ *   [54:86)   vaultA  (owner = Tokenkeg — an SPL token account holding mintA)
+ *   [95:127)  a Pyth-v2-format account (magic 0xa1b2c3d4, owner
+ *             `FsJ3A3u2vn5cTVofAjvy6y5kwABJAqYWpe4975bi2epH`, Pyth's mainnet
+ *             price-oracle program) — see "OBSERVED BUT UNUSED" below.
+ *   [137:169) mintB   (USDC on all 4 pools observed)
+ *   [169:201) vaultB
+ *   [210:242) a second Pyth-v2 account (USDC's; IDENTICAL address across all
+ *             4 pools, since mintB is USDC on every one observed)
+ *   [260:292) a further Tokenkeg-owned, Mint-shaped (82-byte rent) account,
+ *             UNIQUE per pool (plausibly an LP/fee mint) — not decoded, not
+ *             needed by anything below.
+ *   [301:397) three System-Program-owned pubkeys, IDENTICAL across all 4
+ *             pools (plausibly a shared treasury/authority) — not decoded,
+ *             not part of the swap account list evidenced below.
+ *
+ * OBSERVED BUT UNUSED — the embedded Pyth-v2 feeds are DEAD, not live: a
+ * live read of the SOL feed at `[95:127)`'s address
+ * (`H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG`, itself Pyth's well-known
+ * mainnet SOL/USD price account) has `last_slot_`/`valid_slot_` frozen at
+ * 281,687,928 / 299,058,481 while the cluster's current slot at read time was
+ * ~436,477,xxx — many tens of millions of slots stale (Pyth's own crank
+ * abandoned this legacy v2 account format years before this integration).
+ * Its stored `price`/`expo` (SOL ≈ $119.23, USDC ≈ $1.00) are accordingly an
+ * ancient snapshot, not a live rate. This model does NOT read either feed —
+ * see "QUOTE MODEL" below for what it reads instead, and for why a plain
+ * raw-vault-ratio price is *also* unsafe here.
+ *
+ * ── SWAP CPI — reverse-engineered via REAL `simulateTransaction` calls
+ * against the DEPLOYED program (sigVerify:false, replaceRecentBlockhash,
+ * innerInstructions:true), routed through Jupiter's OWN aggregator
+ * (`lite-api.jup.ag/swap/v1/{quote,swap}`, `onlyDirectRoutes=true,
+ * dexes=WhaleStreet`) so the exact bytes are Jupiter's real, currently-valid
+ * construction, not a guess — on the `Hhugr5Bw2Np...` SOL/USDC pool, at 4
+ * sizes (0.5, 1, 1 again, 2 SOL sells) plus one 100-USDC buy (the reverse
+ * direction) ──
+ *
+ * ACCOUNTS (8, order load-bearing, IDENTICAL across all 5 samples/both
+ * directions — confirmed via the transaction's own address-lookup-table
+ * resolution, not just the label the simulator printed):
+ *   0 pool         (writable)
+ *   1 user mintA-side ATA (writable) — source when selling mintA, dest when buying it
+ *   2 user mintB-side ATA (writable) — mirror of account 1
+ *   3 vaultA       (writable)
+ *   4 vaultB       (writable)
+ *   5 owner        (signer, writable)
+ *   6 token program (Tokenkeg, read-only)
+ *   7 instructions sysvar (read-only)
+ * Account POSITIONS do not swap when direction reverses (both the 1 SOL
+ * sell and the 100 USDC buy sample carry this exact 8-account shape/order);
+ * direction is therefore selected inside the (unrecovered — see below)
+ * instruction data, not by account order.
+ *
+ * INSTRUCTION DATA — 42 bytes total. `byte[0] = 0x01` plus a further 8-byte
+ * tag (`20ac01b7b55270e6`) were IDENTICAL across every one of the 5 samples
+ * (3 sizes + a repeat + the reverse direction) — this 9-byte prefix is
+ * real and reproducible, but was only cross-checked on ONE pool
+ * (`Hhugr5Bw2Np...`), not against a second pool, so it may be pool-specific
+ * rather than a global Anchor-style discriminator. The remaining 33 bytes
+ * are NOT recovered: exhaustively checked (every 4- and 8-byte-wide window,
+ * every offset) against amountIn and the realized outAmount via plain
+ * little-endian, XOR-with-a-fixed-mask, and affine-mod-2^64 hypotheses —
+ * none matched at any offset, across 3 independent sizes. What IS clear:
+ * the SAME amount at the SAME pool/direction produces byte-identical output
+ * across two separate requests a minute apart for the first ~25 of those 33
+ * bytes (a deterministic, amount-dependent encoding), while the LAST 8 bytes
+ * differ between those same two identical-amount requests (a per-request
+ * nonce/anti-replay value). Cracking either was not possible in the time
+ * available — same class of gap as this repo's `humidifi` venue (a
+ * per-transaction encoding this integration cannot reproduce) and `scorch`
+ * (a price transform "not recovered in the time available"). `buildSwapV2`
+ * below therefore emits the REAL, validated prefix/account plan but an
+ * EMPTY (incomplete) suffix — it does not compile into a working real
+ * trade — and the recipe-side gate on this family self-drops every
+ * candidate so a cook can never select it until this is resolved.
+ *
+ * CU — MEASURED directly from the real CPI (not a LiteSVM stand-in: the
+ * simulator's own per-program "consumed" log line for WhaleStreet's
+ * top-level invocation), across all 5 real samples: 95,403 / 95,404 / 95,416
+ * / 95,417 CU selling SOL->USDC (0.5, 2, repeat-1, 1 SOL) and 74,561 CU
+ * buying USDC->SOL (100 USDC). CU is measured on the final native path at
+ * request time (simulateBundle), not baked into any per-family constant.
+ *
+ * ── QUOTE MODEL — deliberately conservative, NOT WhaleStreet's real curve ──
+ * REJECTED FIRST HYPOTHESIS (kept as a citable mistake, not a footnote):
+ * pricing directly off the two vaults' raw SPL balances. Live state at
+ * capture time: vaultA (WSOL) = 1,892,908,784,339 raw (~1892.91 SOL), vaultB
+ * (USDC) = 164,646,915,519 raw (~164,646.92 USDC) — raw ratio implies ~86.98
+ * USDC/SOL. The REAL, simulated executed rate across 3 real trades (below)
+ * is ~72.96 USDC/SOL — the raw ratio is ~19.2% ABOVE the real rate, i.e. a
+ * plain constant-product-over-raw-balances model would be a gross
+ * FAVOURABLE mispricing, the exact hazard this integration guards against.
+ * This pool's real pricing is evidently NOT its own raw vault ratio (nor,
+ * per "OBSERVED BUT UNUSED" above, the embedded — dead — oracle accounts);
+ * WhaleStreet has some other, undisclosed pricing mechanism this
+ * integration cannot read.
+ *
+ * REAL calibration data (the venue's own REALIZED output — read from the
+ * simulated CPI's inner SPL `transfer` instruction, not the /quote
+ * estimate — for 3 real sells on the same live pool/vault state above):
+ *   500,000,000 raw SOL  -> 36,479,962 raw USDC  (72.9599 USDC/SOL)
+ *   1,000,000,000 raw SOL -> 72,960,538 raw USDC  (72.9605 USDC/SOL)
+ *   2,000,000,000 raw SOL -> 145,919,821 raw USDC (72.9599 USDC/SOL)
+ * (plus a wide-size sanity-only /quote estimate: 500,000,000,000 raw SOL ->
+ * 36,460,084,432 raw USDC, 72.9202 USDC/SOL — a QUOTE, not a simulated fill,
+ * used only to confirm the rate stays flat, not as a calibration point).
+ * The rate is nearly FLAT across 4 orders of magnitude of size — this reads
+ * as an oracle/PMM-anchored venue with very little reserve-depth decay
+ * within normal trade sizes, not a thin constant-product pool.
+ *
+ * THE SHIPPED MODEL: a plain symmetric constant-product curve over the two
+ * LIVE raw vault balances, with the OUTPUT side haircut by a fixed 30%
+ * (`OUT_HAIRCUT_NUM/DEN = 7/10`) before the curve runs. Real depth is real,
+ * on-chain, verifiable state, and a flat haircut on the OUTPUT side pins the
+ * curve's initial marginal rate safely BELOW the real rate without needing
+ * to know WhaleStreet's real formula. 0.7 * 86.98 ≈ 60.9 USDC/SOL initial
+ * marginal rate — comfortably (~16.5%) below every one of the 4 real rates
+ * measured above (72.92-72.96), with margin to spare over the ~19.2% the
+ * raw ratio itself was too high by. Monotone + concave by construction (a
+ * standard CP curve) — `predicted <= realized` holds at all 3 real sizes.
+ * The real on-chain CPI (once its instruction payload is someday recovered)
+ * still executes WhaleStreet's OWN pricing regardless of this model's
+ * accuracy — this curve only shapes off-chain election/sizing.
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "whalestreet";
+export const WHALESTREET_PROGRAM_ID = address("FW6zUqn4iKRaeopwwhwsquTY6ABWLLgjxtrC3VPnaWBf");
+const POOL_ACCOUNT_SIZE = 605;
+export const WHALESTREET_OFF_MINT_A = 22;
+export const WHALESTREET_OFF_VAULT_A = 54;
+export const WHALESTREET_OFF_MINT_B = 137;
+export const WHALESTREET_OFF_VAULT_B = 169;
+/**
+ * The REAL, validated 9-byte instruction-data prefix — opcode 0x01 plus an
+ * 8-byte tag observed identical across all 5 real captured samples (3
+ * sizes + a repeat + the reverse direction) on the ONE pool this
+ * integration validated against. See the module doc's "INSTRUCTION DATA".
+ */
+export const WHALESTREET_IX_PREFIX = Uint8Array.from([
+    0x01, 0x20, 0xac, 0x01, 0xb7, 0xb5, 0x52, 0x70, 0xe6,
+]);
+const codec = getAddressCodec();
+const pubkeyAt = (data, offset) => codec.decode(data.subarray(offset, offset + 32));
+function whalestreetConfig(cfg) {
+    if (cfg.venue !== SLUG)
+        throw new Error(`${SLUG} ladder adapter got a '${cfg.venue}' pool config`);
+    return cfg;
+}
+export async function fetchWhalestreetPoolConfig(load, pool) {
+    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 data is ${data.length} bytes, expected ${POOL_ACCOUNT_SIZE}`);
+    }
+    const mintA = pubkeyAt(data, WHALESTREET_OFF_MINT_A);
+    const mintB = pubkeyAt(data, WHALESTREET_OFF_MINT_B);
+    // This venue's swap CPI is legacy-SPL (Tokenkeg) only. 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). The LEGACY path is byte-identical; 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 _i = 0; _i < _mints.length; _i++) {
+        const mint = _mints[_i];
+        const mintData = _mintDatas[_i];
+        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("; ")}`);
+        }
+    }
+    return {
+        venue: SLUG,
+        pool,
+        direction: 0,
+        mintA,
+        mintB,
+        vaultA: pubkeyAt(data, WHALESTREET_OFF_VAULT_A),
+        vaultB: pubkeyAt(data, WHALESTREET_OFF_VAULT_B),
+    };
+}
+function quoteAccounts(base) {
+    const cfg = whalestreetConfig(base);
+    return [
+        { ref: "vaultA", address: cfg.vaultA },
+        { ref: "vaultB", address: cfg.vaultB },
+    ];
+}
+/** Partial v1-shaped helper (fetchPoolConfig/quoteAccounts only) — this venue is ladder-only (v2); see whalestreetLadder below for the full adapter surface. */
+export const whalestreet = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: WHALESTREET_PROGRAM_ID,
+    fetchPoolConfig: fetchWhalestreetPoolConfig,
+    quoteAccounts,
+};
+//# sourceMappingURL=index.js.map

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

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