@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,77 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "taurusfi";
+export declare const TAURUSFI_PROGRAM_ID: Address<"9VX8EKBg6vM6tA68xaDsPkbrx26XConZjkQmhVApUptc">;
+/** Fixed-point scale for the decoded price (10^9 — ~9-10 significant decimal digits of headroom). */
+export declare const TAURUSFI_PRICE_SCALE = 1000000000n;
+/**
+ * Decodes a raw f64 bit pattern (as read off-chain OR the exact on-chain
+ * `accountUint` value) into a `TAURUSFI_PRICE_SCALE`-fixed-point integer,
+ * LOCKSTEP with the on-chain formula in `emitSetup` below (same masks, same
+ * mulDiv-shaped floor division) — bit-exact by construction, not merely
+ * "close". Degrades to exactly 0 for an unpriced market (bits === 0n) with
+ * no special case (see file header).
+ */
+export declare function decodeTaurusFiPriceScaled(bits: bigint): bigint;
+export interface TaurusFiRegistryEntry {
+    /** BASE mint's SPL vault. */
+    vault0: Address;
+    /** QUOTE mint's SPL vault. */
+    vault1: Address;
+    mint0: Address;
+    mint1: Address;
+    decimals0: number;
+    decimals1: number;
+    /** PDA owning both vaults (SPL "owner" field of both — confirmed identical). */
+    vaultAuthority: Address;
+    /** Venue-wide fixed account, account 6 in the swap ix — exact role not recovered. */
+    globalConfig: Address;
+    /** Venue-wide fixed account, account 8 in the swap ix — exact role not recovered; never a signer. */
+    globalAuthority: Address;
+    /** The market's own price/oracle state PDA (also the registry key). */
+    priceAccount: Address;
+}
+/**
+ * Hand-verified TaurusFi markets: for each, a real mainnet swap CPI (inside a
+ * Jupiter route) was decoded and the vault/mint addresses were cross-checked
+ * against `preTokenBalances`/`postTokenBalances`, and the price account was
+ * independently confirmed against a same-slot keeper-crank update. Only one
+ * live-priced market was observed during integration; a second market
+ * account (`HFqA7kAqgUMjNCo5zDSN1tnKvE8GVBXGPDyK2nizJm11`) exists but reads an
+ * all-zero (unpriced/inactive) price and has no known vault/mint pair, so it
+ * is deliberately NOT seeded here — extend by repeating the same
+ * verification once it (or another market) goes live.
+ */
+export declare const TAURUSFI_POOL_REGISTRY: Record<string, TaurusFiRegistryEntry>;
+export interface TaurusFiPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** '0to1' (default) sells mint0 for mint1; '1to0' sells mint1 for mint0. */
+    direction: "0to1" | "1to0";
+    vault0: Address;
+    vault1: Address;
+    mint0: Address;
+    mint1: Address;
+    decimals0: number;
+    decimals1: number;
+    vaultAuthority: Address;
+    globalConfig: Address;
+    globalAuthority: Address;
+    priceAccount: Address;
+    /** Decoded once at fetch time — the gate's ONLY read (see the recipe's `FAMILIES.taurusfi.gate`). */
+    priceScaled: bigint;
+}
+/**
+ * Registry lookup + live decode: reads the market's price account (for the
+ * gate) and both vaults (mint-integrity check, mirroring gamma's/bisonfi's
+ * own vault verification) — nothing else is decodable off this venue's pool
+ * state (no plaintext pool-identity account exists at all; see file header).
+ */
+export declare function fetchTaurusFiConfig(load: AccountLoader, pool: Address): Promise<TaurusFiPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only, like raydium-amm-v4/raydium-cp-swap). */
+export declare const taurusfi: {
+    slug: string;
+    programId: Address<"9VX8EKBg6vM6tA68xaDsPkbrx26XConZjkQmhVApUptc">;
+    fetchPoolConfig: typeof fetchTaurusFiConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/taurusfi/index.ts"],"names":[],"mappings":"AAgKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,aAAa,CAAC;AACxB,eAAO,MAAM,mBAAmB,EAAE,OAAO,CAAC,8CAA8C,CAEvF,CAAC;AAWF,qGAAqG;AACrG,eAAO,MAAM,oBAAoB,cAAiB,CAAC;AAMnD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK9D;AAED,MAAM,WAAW,qBAAqB;IACpC,6BAA6B;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,8BAA8B;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,cAAc,EAAE,OAAO,CAAC;IACxB,qFAAqF;IACrF,YAAY,EAAE,OAAO,CAAC;IACtB,qGAAqG;IACrG,eAAe,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAexE,CAAC;AAEF,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,qGAAqG;IACrG,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,kBAAkB,CAAC,CA6D7B;AAED,oGAAoG;AACpG,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

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

@@ -0,0 +1,284 @@
+/**
+ * TaurusFi (SvmRoute ladder fragment) — program `9VX8EKBg6vM6tA68xaDsPkbrx26
+ * XConZjkQmhVApUptc`, Jupiter's own label per `benchmark/adapters/fixtures/
+ * jupiter-program-id-to-label.json`. No on-chain IDL ships for this program;
+ * everything below is recovered by live transaction/account archaeology
+ * (`getSignaturesForAddress` + `getTransaction` + `getAccountInfo` against
+ * mainnet, plus a real Jupiter-routed swap CPI found in the sample), the same
+ * method that produced bisonfi/humidifi/obric-v2/solfi-v2. Ported verbatim
+ * (relocation, not a rewrite) from sauce-recipes' `the consuming app SVM venues
+ * taurusfi.ts` — the same non-gPA shape humidifi uses (static pool-registry
+ * discovery, since neither is gPA-discoverable by a mint-pair memcmp).
+ *
+ * ── What the program actually is (a real, load-bearing finding) ──
+ * The OVERWHELMING majority of this program's traffic (191 of 200 sampled
+ * signatures in a ~400s window, one transaction every 1-2s) is NOT a swap at
+ * all — it is a keeper CRANK: a 2-account, ~505-byte instruction
+ * (disc byte + a near-verbatim 504-byte overwrite of the target account's own
+ * state) that updates a per-market PRICE/STATE account owned by this program.
+ * Two markets were observed: `EWqXjWSd4sfVsZHdSc25DoD1QfMbMrVpQZPpayoiFPSP`
+ * (live-priced, SOL/USDC) and `HFqA7kAqgUMjNCo5zDSN1tnKvE8GVBXGPDyK2nizJm11`
+ * (all-zero — an inactive/unpriced market). Only 1-in-~25 sampled
+ * transactions is a real SWAP CPI (found via a Jupiter multi-hop route,
+ * signature `3GFzSaARr63Jgr4aFYz9dRCHMX7Ta8JZbyGg2D8tjBaP7eFL2Gn8cNETTXu6t8ReMxxAXjkcJkyo3Ht4fcmV8XMk`,
+ * plus 7 more single-hop samples gathered separately) — a Lifinity/SolFi-class
+ * ORACLE-PRICED prop-AMM: a keeper continuously pushes a price, and swaps
+ * execute at (a haircut of) that price, NOT at the raw vault reserve ratio.
+ *
+ * ── The price account layout (504 bytes, decoded via a repeated-double scan
+ *    cross-checked against a same-slot crank update) ──
+ * Offset 0: an IEEE-754 binary64 (little-endian) — the live price, QUOTE
+ * human-units per BASE human-unit (e.g. ~73.03 USDC per SOL, matching every
+ * sampled trade to within measurement noise — see below). Offset 8: a second
+ * f64, observed constant at 0.0001 (a confidence/tick-size-looking constant,
+ * unused by this adapter). Offsets 48/56 repeat the same (price, 0.0001)
+ * shape with a different price value (~144.83 at capture time) — plausibly a
+ * second window/reference price this adapter does not need and does not use.
+ * The account carries no plaintext pubkeys anywhere (verified: this is why
+ * the family is NOT gPA-discoverable by a mint-pair memcmp — see
+ * `withTaurusFiStaticCandidates` in the recipes' discovery.ts, the same
+ * non-gPA shape humidifi uses).
+ *
+ * ── Validation: our zero-fee oracle-price prediction vs. 4 REAL swaps,
+ *    each checked against a crank update in the SAME (or immediately
+ *    adjacent) slot ──
+ *   - slot 436472057 (sig `4Xbp3Sp6…B22T`): amountIn 513,854 USDC-µ, realized
+ *     7,042,878 SOL-lamports out. Same-slot crank price 72.98968844357817.
+ *     Naive prediction (amountIn/price, no fee) = 7,040,090 — realized is
+ *     +0.040% ABOVE that (favourable to the venue's own model, i.e. our
+ *     zero-fee prediction is itself already conservative here).
+ *   - slot 436467023 (sigs `2hcJL8Zf…VHe`, `5gTnZy1c…sHn`) and 436467025
+ *     (sig `5ZiFvLWFv5…4He`): realized output is -0.032% to -0.037% BELOW
+ *     the same nearby-slot naive prediction across all three.
+ *   All four land within ±5bps of a pure `amountOut = amountIn / price`
+ *   relationship — this is a real, validated oracle-priced venue, not a
+ *   vault-ratio curve (constant-product over the two live vault balances
+ *   diverges from the realized output by **12.7x** on the first sample —
+ *   the vaults are evidently an omnibus multi-market pool, not a dedicated
+ *   SOL/USDC reserve pair, so their ratio carries no pricing information at
+ *   all).
+ *
+ * ── SECOND, independent validation: OUR OWN constructed instruction (this
+ *    exact account plan + byte layout), LIVE-EXECUTED via `simulateTransaction`
+ *    (`sigVerify:false`, borrowing a real trader's wallet/ATAs — the standard
+ *    technique for probing a program without funds) against the REAL deployed
+ *    program on REAL current mainnet state, both directions, 3 sizes each —
+ *    6 of 6 succeeded (2 large backward-direction sizes failed only on the
+ *    borrowed wallet's OWN insufficient current balance, not on our encoding;
+ *    the successful cells prove the instruction/account list this ladder
+ *    emits is byte-for-byte accepted by the real program) ──
+ *   backward (USDC->SOL, wallet `ttcZfmd9…PbNDq`): 100,000 USDC-µ in ->
+ *     1,369,195 SOL-lamports realized; our model (this file's formula, live
+ *     vault state) predicts 1,355,585 — realized/model = 1.0040 (model
+ *     conservative by ~0.4%).
+ *   forward (SOL->USDC, wallet `yUwUyouf…T9aH`): 1,000 / 100,000 / 5,000,000
+ *     SOL-lamports in -> 72 / 7,295 / 364,747 USDC-µ realized; model predicts
+ *     72 / 7,229 / 361,481 — realized/model = 1.000 / 1.0091 / 1.0090 (model
+ *     conservative by ~0-0.9%, i.e. NEVER favourable, at real sizes spanning
+ *     3 orders of magnitude).
+ *
+ * ── On-chain price decode: no floating point in SauceScript, so the f64 bit
+ *    pattern is decoded with pure integer ops (the compiler DOES support
+ *    runtime bitAnd/bitOr/bitXor/shl/shr) ──
+ * `bits = accountUint(price, 0, 8)` (the raw u64 bit pattern). For a normal
+ * (non-subnormal, non-negative — true of every real price observed) double:
+ *   exp    = (bits >> 52) & 0x7FF                       (11-bit biased exponent)
+ *   mant   = (bits & (2^52-1)) | 2^52                    (52-bit mantissa + implicit leading bit)
+ *   priceScaled = mulDiv(mant, PRICE_SCALE, 2^(1075-exp))  (1075 = 1023 bias + 52 mantissa bits)
+ * This is EXACT (no precision loss beyond PRICE_SCALE's own resolution) for
+ * any realistic price and, as a bonus, degrades SAFELY on an unpriced market
+ * (bits = 0 -> exp = 0 -> the divisor 2^1075 is so large the mulDiv floors to
+ * exactly 0 regardless of the unconditionally-OR'd implicit bit — no branch
+ * needed on-chain). A priceScaled of 0 is caught at PREPARE TIME
+ * (the recipe's `FAMILIES.taurusfi.gate`, mirroring every other prepare-time-
+ * only gate — orca-whirlpool/raydium-clmm/manifest all work the same way),
+ * so the on-chain division-by-price this ladder performs is never fed a live
+ * zero by construction.
+ *
+ * ── Quote curve (deliberately conservative — the true depth-decay curve, if
+ *    any, was not recovered) ──
+ * A virtual constant-product curve is shaped so `rout` is the REAL, live
+ * output-vault balance (the honest hard capacity ceiling this curve
+ * asymptotes to and can never exceed — undiscounted, so the cap itself is
+ * never overstated) and `rin = rout / (rate * NUM/DEN)` = `rin_true *
+ * DEN/NUM` (`rin` INFLATED by the reciprocal of a 1% haircut,
+ * `OUT_DISCOUNT_NUM/DEN = 99/100`), where `rate` is the haircut-free
+ * validated oracle rate. Inflating `rin` (rather than shrinking `rout`, which
+ * would cancel out of the small-x marginal rate `rout/rin` entirely — a
+ * discount applied equally to both terms is not a discount at all at the
+ * margin, only at the asymptote) means the SMALL-x marginal rate is
+ * genuinely ~1% BELOW the true oracle rate — comfortably past the <=5bps of
+ * noise measured above, and a much tighter, better-calibrated margin than
+ * bisonfi/humidifi could achieve since neither had oracle ground truth at
+ * all — while the curve still asymptotes to the REAL, undiscounted vault
+ * capacity as x grows. `qTaurusFi(x, rin, rout) = mulDiv(x, rout, rin + x)`
+ * — the same monotone, strictly concave shape as every other CP-style
+ * fragment in this file (bisonfi/gamma/humidifi/raydium-cp-swap), so it
+ * cannot trigger the "coarse ladder allocated ZERO" hazard.
+ *
+ * ── Account plan (14 accounts, verified against 8 independent real trades
+ *    — both directions were inferred from the trailing mint-order flip;
+ *    only the sell-quote (USDC->SOL) direction has a *clean* (uncorrelated
+ *    to a co-occurring hop) balance-delta confirmation, but the vaults/mints/
+ *    fixed accounts are IDENTICAL either way, so the reverse direction is a
+ *    same-mechanism inference, not a separate guess) ──
+ *   0 vault0  (writable)           — BASE mint's SPL vault (fixed per market)
+ *   1 vault1  (writable)           — QUOTE mint's SPL vault (fixed per market)
+ *   2 owner   (writable, signer)   — the taker's own wallet (confirmed: IS the
+ *     outer transaction's fee-payer/signer on every single-hop sample)
+ *   3 userAta (writable)           — taker's ATA for vault0's mint
+ *   4 userAta (writable)           — taker's ATA for vault1's mint
+ *   5 vaultAuthority (writable)    — PDA owning BOTH vaults (SPL "owner" field
+ *     of both vault0 and vault1 — confirmed identical for both, every sample)
+ *   6 (readonly)                   — venue-wide fixed account, exact role not
+ *     recovered (`ECADA9SPXrZTTbWG5JJTCC7KsagYR2MLZhw2KgFhivu9`)
+ *   7 priceAccount (readonly)      — the market's own oracle/state PDA
+ *   8 (readonly)                   — venue-wide fixed account, exact role not
+ *     recovered (`Hg2PTGCBUwRvp7S3AF5BF4tfawNshXc1N2DDWijjJndo`) — UNLIKE
+ *     bisonfi's analogous 9th account, this one is NEVER a signer in any
+ *     sampled swap, so there is no third-party-cosign blocker here.
+ *   9 TOKEN_PROGRAM (readonly)
+ *  10 TOKEN_PROGRAM (readonly, again — verified against real chain data on
+ *     every sample, not a transcription artifact, same as bisonfi's 6/7)
+ *  11 mintIn  (readonly)           — direction signal: this position's mint
+ *  12 mintOut (readonly)           — IS the input in every real sample (the
+ *     vault/ATA positions 0/1/3/4 stay FIXED regardless of direction; only
+ *     this trailing pair flips)
+ *  13 SysvarInstructions (readonly)
+ * Instruction data (11 bytes, `patch: 'in'`): disc(1)=0x08 ++ amountIn u64 LE
+ * (patched at runtime) ++ tail(2) = [0x00, 0x01] — IDENTICAL across all 7
+ * clean samples (different sizes: 3,072,612 to 982,452,558; both directions;
+ * times 5 minutes apart), so treated as a fixed structural constant exactly
+ * like bisonfi's TAIL_FLAG.
+ *
+ * ── CU (venue-side CPI cost; recipe-side budget pin is out of scope for this
+ *    SDK module — see the recipes' `CU_FAMILIES.taurusfi` in budget.ts) ──
+ * The venue's own CPI cost is UNUSUALLY FLAT (not size-tiered, unlike
+ * bisonfi): 113,624-119,290 CU across 8 samples spanning ~0.001 to ~1 SOL
+ * notional, both directions.
+ */
+import { address } from "@solana/kit";
+import { 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 = "taurusfi";
+export const TAURUSFI_PROGRAM_ID = address("9VX8EKBg6vM6tA68xaDsPkbrx26XConZjkQmhVApUptc");
+/** Standard SPL token account field offsets (mint@0, amount@64) — the vaults are plain SPL accounts. */
+const VAULT_MINT_OFFSET = 0;
+const VAULT_AMOUNT_OFFSET = 64;
+// ── IEEE-754 binary64 bit-decode constants (see file header) ──
+const F64_EXP_MASK = 2047n; // 0x7FF, 11 bits
+const F64_MANTISSA_MASK = 4503599627370495n; // 2^52 - 1
+const F64_IMPLICIT_BIT = 4503599627370496n; // 2^52
+const F64_BIAS_PLUS_MANTISSA_BITS = 1075n; // 1023 + 52
+/** Fixed-point scale for the decoded price (10^9 — ~9-10 significant decimal digits of headroom). */
+export const TAURUSFI_PRICE_SCALE = 1000000000n;
+const codec = getAddressCodec();
+const pubkeyAt = (data, offset) => codec.decode(data.subarray(offset, offset + 32));
+/**
+ * Decodes a raw f64 bit pattern (as read off-chain OR the exact on-chain
+ * `accountUint` value) into a `TAURUSFI_PRICE_SCALE`-fixed-point integer,
+ * LOCKSTEP with the on-chain formula in `emitSetup` below (same masks, same
+ * mulDiv-shaped floor division) — bit-exact by construction, not merely
+ * "close". Degrades to exactly 0 for an unpriced market (bits === 0n) with
+ * no special case (see file header).
+ */
+export function decodeTaurusFiPriceScaled(bits) {
+    const exp = (bits >> 52n) & F64_EXP_MASK;
+    const mant = (bits & F64_MANTISSA_MASK) | F64_IMPLICIT_BIT;
+    const shiftAmt = F64_BIAS_PLUS_MANTISSA_BITS - exp;
+    return (mant * TAURUSFI_PRICE_SCALE) / (1n << shiftAmt);
+}
+/**
+ * Hand-verified TaurusFi markets: for each, a real mainnet swap CPI (inside a
+ * Jupiter route) was decoded and the vault/mint addresses were cross-checked
+ * against `preTokenBalances`/`postTokenBalances`, and the price account was
+ * independently confirmed against a same-slot keeper-crank update. Only one
+ * live-priced market was observed during integration; a second market
+ * account (`HFqA7kAqgUMjNCo5zDSN1tnKvE8GVBXGPDyK2nizJm11`) exists but reads an
+ * all-zero (unpriced/inactive) price and has no known vault/mint pair, so it
+ * is deliberately NOT seeded here — extend by repeating the same
+ * verification once it (or another market) goes live.
+ */
+export const TAURUSFI_POOL_REGISTRY = {
+    // SOL / USDC (native, EPjF...) — the only market observed live-priced and
+    // live-traded during integration.
+    EWqXjWSd4sfVsZHdSc25DoD1QfMbMrVpQZPpayoiFPSP: {
+        vault0: address("BA6hdJwgzayrm3Q7Z6MPq1wVgPcUMJDbQcUwxJ9Nfu1H"),
+        vault1: address("7qPQugSL2cJgnVDQWNPt6woSidEF4XQhjPDkYrdnv8CK"),
+        mint0: address("So11111111111111111111111111111111111111112"),
+        mint1: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+        decimals0: 9,
+        decimals1: 6,
+        vaultAuthority: address("544UsNRFNU7tzWKcHGZorwy7UKnsso9x83N9WWMvY5JX"),
+        globalConfig: address("ECADA9SPXrZTTbWG5JJTCC7KsagYR2MLZhw2KgFhivu9"),
+        globalAuthority: address("Hg2PTGCBUwRvp7S3AF5BF4tfawNshXc1N2DDWijjJndo"),
+        priceAccount: address("EWqXjWSd4sfVsZHdSc25DoD1QfMbMrVpQZPpayoiFPSP"),
+    },
+};
+/**
+ * Registry lookup + live decode: reads the market's price account (for the
+ * gate) and both vaults (mint-integrity check, mirroring gamma's/bisonfi's
+ * own vault verification) — nothing else is decodable off this venue's pool
+ * state (no plaintext pool-identity account exists at all; see file header).
+ */
+export async function fetchTaurusFiConfig(load, pool) {
+    const entry = TAURUSFI_POOL_REGISTRY[pool];
+    if (entry === undefined) {
+        throw new Error(`${SLUG}: pool ${pool} is not in TAURUSFI_POOL_REGISTRY — this venue has no plaintext pool-identity ` +
+            "account to decode a new market from; see sdk/src/svm/venues/taurusfi/index.ts for how to add one");
+    }
+    const priceData = await load(entry.priceAccount);
+    if (priceData === null)
+        throw new Error(`${SLUG}: price account ${entry.priceAccount} not found`);
+    if (priceData.length < 8) {
+        throw new Error(`${SLUG}: price account ${entry.priceAccount} is ${priceData.length} bytes, expected >= 8`);
+    }
+    const priceScaled = decodeTaurusFiPriceScaled(readUintLE(priceData, 0, 8));
+    const _vaultPairs = [
+        [entry.vault0, entry.mint0],
+        [entry.vault1, entry.mint1],
+    ];
+    const _vaultDatas = await Promise.all(_vaultPairs.map(([vault]) => load(vault)));
+    for (let _i = 0; _i < _vaultPairs.length; _i++) {
+        const [vault, mint] = _vaultPairs[_i];
+        const vaultData = _vaultDatas[_i];
+        if (vaultData === null)
+            throw new Error(`${SLUG}: vault ${vault} not found`);
+        if (vaultData.length < VAULT_AMOUNT_OFFSET + 8) {
+            throw new Error(`${SLUG}: vault ${vault} is ${vaultData.length} bytes, expected an SPL token account`);
+        }
+        const vaultMint = pubkeyAt(vaultData, VAULT_MINT_OFFSET);
+        if (vaultMint !== mint)
+            throw new Error(`${SLUG}: vault ${vault} holds mint ${vaultMint}, expected ${mint}`);
+    }
+    // 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 = [entry.mint0, entry.mint1];
+    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: "0to1", priceScaled, ...entry };
+}
+/** Family facade for the recipe orchestrator (ladder-only, like raydium-amm-v4/raydium-cp-swap). */
+export const taurusfi = {
+    slug: SLUG,
+    programId: TAURUSFI_PROGRAM_ID,
+    fetchPoolConfig: fetchTaurusFiConfig,
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,144 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "tesserav";
+export declare const TESSERAV_PROGRAM_ID: Address<"TessVdML9pBGgG9yGks7o4HewRaXVAMuoVj4x83GLQH">;
+export declare const TOKEN_PROGRAM: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+export declare const OFF_MID = 144;
+export declare const MID_SCALE = 1000000000000000n;
+export declare const OFF_LADDER_AB = 168;
+export declare const AB_STRIDE = 24;
+export declare const AB_OFF_PRICE = 0;
+export declare const AB_OFF_CUM = 16;
+export declare const OFF_LADDER_BA = 640;
+export declare const BA_STRIDE = 24;
+export declare const BA_OFF_CUM = 0;
+export declare const BA_OFF_PRICE = 8;
+export declare const TESSERAV_LEVEL_SLOTS = 10;
+export declare const PRICE_PPM_DEN = 1000000n;
+/** Minimum pool account size this adapter reads from (level 9's last byte + 1). */
+export declare const TESSERAV_MIN_POOL_SIZE: number;
+export interface TesseraVPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'aToB' sells mintA for mintB (ix direction byte 1); 'bToA' is the reverse (byte 0). */
+    direction: "aToB" | "bToA";
+    mintA: Address;
+    mintB: Address;
+    /**
+     * The program's GLOBAL vault-authority singleton (TESSERAV_GLOBAL_AUTH) —
+     * read-only in the swap ix. NOT a per-pool fact and NOT a PDA/registry (see
+     * TESSERAV_GLOBAL_AUTH's doc).
+     */
+    auth: Address;
+    /** Global-per-mint vault for mintA (authority = auth). */
+    vaultA: Address;
+    /** Global-per-mint vault for mintB (authority = auth). */
+    vaultB: Address;
+    /**
+     * The three GLOBAL read-only accounts the upgraded swap ix appends at wire
+     * positions [11], [12], [13] — always `TESSERAV_SWAP_GLOBAL_ACCOUNTS` (a
+     * program-global trio, not per-pool; see that constant's doc). Carried on the
+     * config so the downstream CPI builder gets the FULL account set from here —
+     * they were not derivable downstream, which is why they live in the SDK.
+     */
+    swapGlobalAccounts: readonly Address[];
+}
+/**
+ * The TesseraV vault-AUTHORITY — a FIXED GLOBAL SINGLETON, correcting the
+ * earlier "per-pool fact" framing. It is one program-owned (owner =
+ * TessVdML…), 10240-byte account that is byte-identical as the swap CPI's
+ * account[0] across every pool traced (SOL/USDC, cbBTC/USDC, BONK/USDC). It is
+ * NOT a PDA of the program under any tried seed, and NOT a mint→vault registry
+ * (the 10240 bytes contain none of the mint or vault bytes) — so it is carried
+ * as this verified constant, never derived. Verified against live swap-CPI
+ * traces (SOL/USDC sig 3p2JFpLN…, cbBTC/USDC sig 4KZPEcyC…, BONK/USDC sig
+ * 3JZMZyMy…), all giving account[0] = 8ekCy2….
+ */
+export declare const TESSERAV_GLOBAL_AUTH: Address<"8ekCy2jHHUbW2yeNGFWYJT9Hm9FW7SvZcZK66dSZCDiF">;
+/**
+ * The swap instruction discriminator. The mainnet upgrade bumped it 0x10 ->
+ * 0x11 (see the SWAP CPI note in this file's header); a program compiled to the
+ * old 0x10 tag now reverts. Exported so the downstream CPI builder reads the tag
+ * from one place rather than hardcoding it.
+ */
+export declare const TESSERAV_SWAP_TAG = 17;
+/**
+ * The three GLOBAL read-only accounts the upgraded swap ix (tag 0x11) APPENDS
+ * after the two token-program slots — wire positions [11], [12], [13]. ORDER IS
+ * LOAD-BEARING.
+ *
+ * These are program GLOBALS, not per-pool PDAs, and are carried as verified
+ * CONSTANTS for exactly the reason TESSERAV_GLOBAL_AUTH is: they were BYTE-
+ * IDENTICAL across 25 landing swaps on 3 distinct pools (SOL/USDC `FLckH…`,
+ * `Ce8W…`, `7sJf…`) on 2026-09-11, all read-only — so there is nothing per-pool
+ * to derive. (Deriving a per-pool PDA here would be WRONG: the chain shows one
+ * fixed trio for every pool.) There is no on-chain IDL (closed-source), so the
+ * names below are ROLES INFERRED from each account's on-chain owner/size, not
+ * asserted semantics — re-verify on any re-capture:
+ *   [0] 8xeaWCsJ…tb3d — owner = System Program, 0 bytes  → global authority/holder
+ *   [1] BAT1Ndpu…vdhK — owner = TessVdML… (the program), 2048 bytes → global config/state
+ *   [2] 4cG31VNF…brhPs — owner = tickUcs…ULWY6N (a tick/oracle program), 88 bytes → global oracle/tick
+ * Verified against landing swap sig `3ViRTJm9…` (positions 11-13).
+ */
+export declare const TESSERAV_SWAP_GLOBAL_ACCOUNTS: readonly Address[];
+/**
+ * Committed global-per-mint vault cache. Each TesseraV vault is a plain
+ * keypair-generated legacy-SPL token account that is (a) authority =
+ * TESSERAV_GLOBAL_AUTH and (b) GLOBAL PER MINT — one shared vault per token,
+ * reused by every pool touching that token (measured: the SOL/USDC and
+ * cbBTC/USDC pools share the SAME USDC vault 9t4P5w…). Vaults are stable, so
+ * this map is the RPC-free fast path; a mint NOT here resolves through the
+ * optional `resolveVault` (getTokenAccountsByOwner) arg of fetchTesseraVConfig
+ * — which `pickTesseraVVault` implements — or self-drops. Refresh this map with
+ * that same owner-scoped sweep, keyed off TESSERAV_GLOBAL_AUTH. Only vaults
+ * verified byte-exactly against a live swap-CPI trace are seeded here.
+ */
+export declare const TESSERAV_KNOWN_VAULTS: Readonly<Record<string, Address>>;
+/**
+ * One legacy-SPL token account owned by an authority, as returned by an RPC
+ * `getTokenAccountsByOwner(owner, { mint })`. `amount` (the u64 token balance)
+ * is optional and consulted ONLY to break a >1 ambiguity (largest wins).
+ */
+export interface TesseraVOwnedTokenAccount {
+    address: Address;
+    amount?: bigint;
+}
+/**
+ * Resolver for a global-per-mint TesseraV vault: given the authority and a
+ * mint, return the vault address, or null to self-drop when no vault exists
+ * yet. A real caller backs this with an RPC
+ * `getTokenAccountsByOwner(owner, { mint })` fed through `pickTesseraVVault`.
+ * Threaded into fetchTesseraVConfig because the single-account AccountLoader
+ * cannot express an owner-scoped scan.
+ */
+export type TesseraVVaultResolver = (owner: Address, mint: Address) => Promise<Address | null>;
+/**
+ * Exclude-ATA vault picker — the GENERAL derivation core. Of the legacy-SPL
+ * token accounts owned by `owner` for `mint`, drop the canonical
+ * ATA(owner, mint, TOKEN_PROGRAM) (observed as a dust account for USDC: the
+ * real vault 9t4P5w… alongside its ATA at ~50000) and return the single
+ * remainder. 0 remainders → null (the global vault does not exist yet →
+ * self-drop). >1 remainders → the largest-balance one when balances are known,
+ * else null (ambiguous → self-drop rather than guess) — the caveat the debug
+ * flagged for the >1 case.
+ */
+export declare function pickTesseraVVault(owner: Address, mint: Address, owned: readonly TesseraVOwnedTokenAccount[]): Promise<Address | null>;
+/** Level-0 price (ppm of 1e6) for a direction — non-increasing across slots, this adapter ships slot 0 only. */
+export declare function level0PriceOffset(direction: "aToB" | "bToA"): number;
+/** Level-0 capacity, in OUTPUT-token raw units, for a direction. */
+export declare function level0CumOffset(direction: "aToB" | "bToA"): number;
+/**
+ * Fetch + gate one TesseraV pool. Read-only against the loader. Gates: wrong
+ * owner/size, an unprimed mid (0 — a pool the maker bot has never quoted),
+ * and a zero/absent level-0 price or capacity (an empty book for this
+ * direction — self-drop, not a revert, at the orchestrator layer).
+ */
+export declare function fetchTesseraVConfig(load: AccountLoader, pool: Address, direction: "aToB" | "bToA", resolveVault?: TesseraVVaultResolver): Promise<TesseraVPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only — not in the v1 registry). */
+export declare const tesserav: {
+    slug: string;
+    programId: Address<"TessVdML9pBGgG9yGks7o4HewRaXVAMuoVj4x83GLQH">;
+    tokenProgram: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+    fetchPoolConfig: typeof fetchTesseraVConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/tesserav/index.ts"],"names":[],"mappings":"AAiGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,aAAa,CAAC;AAExB,eAAO,MAAM,mBAAmB,wDAAyD,CAAC;AAC1F,eAAO,MAAM,aAAa,wDAAyD,CAAC;AAOpF,eAAO,MAAM,OAAO,MAAM,CAAC;AAC3B,eAAO,MAAM,SAAS,oBAAyB,CAAC;AAGhD,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,KAAK,CAAC;AAG7B,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,aAAa,WAAa,CAAC;AAExC,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,QAAmD,CAAC;AAEvF,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,0FAA0F;IAC1F,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;OAMG;IACH,kBAAkB,EAAE,SAAS,OAAO,EAAE,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,yDAA0D,CAAC;AAE5F;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,KAAO,CAAC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,OAAO,EAI1D,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAalE,CAAC;AAEH;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAE/F;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,SAAS,yBAAyB,EAAE,GAC1C,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAazB;AAgCD,gHAAgH;AAChH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEpE;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,YAAY,CAAC,EAAE,qBAAqB,GACnC,OAAO,CAAC,kBAAkB,CAAC,CA0E7B;AAED,wFAAwF;AACxF,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC"}