@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,263 @@
+/**
+ * Trends (label `"Trends"` in Jupiter's `program-id-to-label` map,
+ * `benchmark/adapters/fixtures/jupiter-program-id-to-label.json`) — a
+ * pump.fun-style bonding-curve launchpad. Anchor program id
+ * `CURVEmPpijXDTNdqrA9PGP1io2rkgiVXH26xdXVGLLfz`, on-chain IDL name
+ * `bonding_curve`. Every field offset, every formula, and every fee constant
+ * below was derived from LIVE mainnet reads — zero guesswork, zero vendored
+ * docs — as follows (fully reproducible: public RPC, no API key):
+ *
+ * 1. **The IDL itself is on-chain.** Anchor programs store their IDL at the
+ *    deterministic `create_with_seed(find_program_address([], programId).0,
+ *    "anchor:idl", programId)` address — for this program that resolves to
+ *    `A66SjFD23xu9WSUp9kn4nPohwyejWfutmrrTLjfowBSs`, a 3,170-byte `IdlAccount`
+ *    (matches the brief's byte count exactly) whose payload is a zlib-deflated
+ *    JSON IDL. Decoding it (disc(8) + authority(32) + data_len(u32) +
+ *    zlib-inflate) gives the EXACT `Pool`/`Config` account layouts, every
+ *    instruction's accounts/args/discriminators, and the full error table —
+ *    below, not reverse-engineered from bytes.
+ * 2. **Pool account** (`bytemuck`, `repr(C)`, 312 bytes total incl. the
+ *    8-byte Anchor discriminator `f19a6d0411b16dbc`): `creator` pubkey@8,
+ *    `base_mint`@40, `base_vault`@72, `quote_vault`@104, `base_reserve`
+ *    u64@136, `quote_reserve` u64@144, `virtual_base_reserve` u64@152,
+ *    `virtual_quote_reserve` u64@160, `creator_fee` u64@168 (cumulative
+ *    UNCLAIMED creator fee, still sitting in quote_vault — NOT part of the
+ *    tradeable reserve), `protocol_fee` u64@176 (same, protocol's cut),
+ *    `is_migrated` u8@184 (0/1). Confirmed field-for-field against 1,737 real
+ *    pool accounts (`getProgramAccounts` filtered on `dataSize:312`) — every
+ *    `base_mint` decodes to a real mint ending in the vanity suffix `TRND`,
+ *    every `base_vault`/`quote_vault` decodes to real SPL/Token-2022 accounts
+ *    matching `base_mint`/wSOL.
+ * 3. **`quote_mint` is a hardcoded Anchor `address` constraint
+ *    (`So11111111111111111111111111111111111111112`), not a stored field** —
+ *    every Trends pool quotes against wSOL exclusively (confirmed via the
+ *    `swap` instruction's IDL account list AND every sampled live transaction).
+ *    So the pool account carries only ONE mint (`base_mint`@40) — there is no
+ *    `mintBOffset` to filter on in `SVM_FAMILY_FILTERS`; see
+ *    `discovery.ts`'s `SvmFamilyFilter.fixedMintB`, added for exactly this
+ *    shape.
+ * 4. **The curve: constant product over (real + virtual) reserves,
+ *    pump.fun-style.** `virtual_base_reserve`/`virtual_quote_reserve` ARE the
+ *    live pricing reserves (read directly, no derivation needed); the
+ *    invariant `virtual_base_reserve · virtual_quote_reserve = k` holds
+ *    per-trade (verified: a real SELL's `new_vbr = vbr_pre + amount_in`
+ *    EXACTLY, decoded from the program's own `emit_cpi!` `SwapEvent` self-CPI
+ *    log — see point 5). `virtual_X_reserve − X_reserve` (X = base or quote)
+ *    is a per-pool CONSTANT set at creation (observed both 0 (base) / 20 SOL
+ *    (quote) and 73,000,000 tokens (base) / 30 SOL (quote) "tiers" live on
+ *    mainnet, confirmed constant across a pool's full trade history by
+ *    replaying its transactions) — this module never bakes a tier constant,
+ *    it re-derives the live offset every quote from
+ *    `virtual_X_reserve − X_reserve`, so any tier (or a value the program
+ *    adds later) is handled identically.
+ * 5. **The fee model and the exact-match validation.** The `swap` instruction
+ *    (Anchor discriminator `sha256('global:swap')[0..8]` = `[248, 198, 158,
+ *    145, 225, 117, 135, 200]`) emits a self-CPI `SwapEvent`
+ *    (`emit_cpi!`, outer discriminator `e445a52e51cb9a1d` + event discriminator
+ *    `40c6cde8260871e2`, both from the on-chain IDL) carrying
+ *    `{amount_in, actual_amount_in, actual_amount_out, creator_fee,
+ *    protocol_fee, referral_fee, base_reserve, quote_reserve,
+ *    virtual_base_reserve, virtual_quote_reserve}` — ALL post-trade. Decoding
+ *    this event from real mainnet transactions (`getTransaction`,
+ *    `innerInstructions`) and reconciling against the transaction's own
+ *    `pre/postTokenBalances` gave every number in this file, bit-exact:
+ *      - SELL (`base_reserve`/`quote_reserve` untouched by fee-accrual
+ *        confusion once cross-checked: `vault balance = quote_reserve +
+ *        creator_fee(cumulative) + protocol_fee(cumulative)`, confirmed
+ *        exactly on a real trade: 2,365,303,595 = 2,248,318,259 + 23,867,048
+ *        + 93,118,288): `grossOut = floor(vqr·amountIn / (vbr+amountIn))`
+ *        (a real 9,019,958,233,576-token sell, sig `3KUgMY5k…`, matched
+ *        `gross=294,062,703` exactly against the event's
+ *        `actualOut+creatorFee+protocolFee+referralFee`); `fee =
+ *        floor(gross·200/10000)` (exactly 2.00000...% on every sampled
+ *        trade, `creator_fee` alone is ALWAYS `floor(gross·100/10000)`
+ *        exact across every one of 7 sampled real sells); `actualOut =
+ *        gross − fee`.
+ *      - BUY (sig `4btBYQ4w…`, a clean 150,000,000-lamport buy on a virgin
+ *        pool, `base_reserve` pre = 1e15 exactly, `quote_reserve` pre = 0):
+ *        `fee = floor(amountIn·200/10000)` (exactly 3,000,000 = 2% of
+ *        150,000,000), `effIn = amountIn − fee` (147,000,000, matches the
+ *        event's `actual_amount_in` exactly), `actualOut =
+ *        floor(vbr·effIn/(vqr+effIn))` (matched the event's
+ *        `actual_amount_out` = 5,232,062,891,830 to the last atom).
+ *      - `referral_fee` (an optional kickback account, `Option<Account>`
+ *        Anchor-encoded — absent ⇒ the caller passes the PROGRAM'S OWN id as
+ *        the sentinel, confirmed via a real no-referral tx's account list)
+ *        is 0 whenever this module's `buildSwapV2` runs (it never supplies a
+ *        referral account) — the creator/protocol split of the remaining fee
+ *        is then an exact 50/50 (`creator_fee === protocol_fee` on every
+ *        sampled no-referral trade), irrelevant to this module either way:
+ *        only the TOTAL 2% (creator+protocol+referral) leaves the tradeable
+ *        reserve, and `min_amount_out=1` (like every ladder here) defers the
+ *        real floor to the recipe's own terminal outAta delta check.
+ *      - **This module's SELL fee is `floor(gross·200/10000)` applied ONCE**
+ *        (not creator/protocol each floored independently, which is what the
+ *        real program does) — measured across 8 independent real sell
+ *        transactions, this is a SAFE LOWER BOUND on the real output: the
+ *        real total fee is NEVER larger than this module's single floor, so
+ *        the predicted `actualOut` is either bit-exact (7 of 8 sampled) or
+ *        exactly 1 raw atomic unit BELOW the real realized output (1 of 8,
+ *        `test/svm/venues/trends.test.ts`'s dAVAhNb2… case) — never above.
+ *        BUY has no such gap: the input-side fee is a single floor on both
+ *        sides, matched bit-exact on every sampled example.
+ * 6. **Real-reserve capacity clamp (SATURATING, not collapsing).** The curve
+ *    alone would happily promise up to `virtual_X_reserve` of output even
+ *    when the REAL `base_reserve`/`quote_reserve` (what the vault can
+ *    actually pay out) is far smaller — exactly the failure class the
+ *    obric-v2/meteora-damm-v2/orca-legacy-token-swap headers warn against
+ *    ("a model MORE favourable than the venue's own math… wins elections").
+ *    Since `virtual_X = X + offset` with a per-pool CONSTANT `offset` (point
+ *    4), the largest deliverable gross input has a closed form:
+ *      - SELL: `grossOut <= quote_reserve` ⟺ `amountIn <= quote_reserve ·
+ *        virtual_base_reserve / quoteOffset` (quoteOffset = vqr−qr; 0 ⇒
+ *        uncapped — the curve's own asymptote already respects the real
+ *        reserve when offset is 0, since then vqr==qr exactly).
+ *      - BUY: fee is charged on the INPUT, so the real constraint is on
+ *        EFFECTIVE input (`effIn <= base_reserve · virtual_quote_reserve /
+ *        baseOffset`); converting that to a GROSS-input cap (the unit
+ *        `capacityInputVar` must report) needs inverting `effIn(x) = x −
+ *        floor(x·200/10000)`. Exploiting `floor(x/50)` structure:
+ *        `grossCap = effCap + floor(effCap/49)` is the EXACT (brute-force
+ *        verified, 0 to 20,000 and spot-checked well beyond) largest `x`
+ *        with `effIn(x) <= effCap` — no bounded search loop needed on-chain.
+ * 7. **`is_migrated`** (offset 184) is the loud, unambiguous gate — a
+ *    migrated pool no longer trades on the curve at all (see the IDL's
+ *    `AlreadyMigrated`/`PoolCompleted` errors); this module rejects it in
+ *    `fetchPoolConfig`. There is a SEPARATE reserve-threshold "pool
+ *    completed, not yet migrated" state (`PoolCompleted`, error 6007) this
+ *    module does NOT gate on — no threshold constant is exposed anywhere
+ *    on-chain (not in `Pool`, not in the all-zero-padding `Config`), so it is
+ *    presumably a hardcoded program constant; a pool in that narrow window
+ *    would self-drop the SAME way any other live-state race does (the
+ *    recipe's minOut floor + the merge's per-cook fresh-state read), not a
+ *    gate this adapter can add without guessing a number.
+ * 8. **Base mint is Token-2022 in the wild** (every sampled pool):
+ *    `detectBaseTokenProgram` mirrors pumpswap's mint-length/TLV-scan
+ *    convention (82 bytes ⇒ classic Tokenkeg; else scan Token-2022 TLV
+ *    extensions, REJECTING a `TransferFeeConfig` extension — vault deltas
+ *    would silently diverge from the quoted amount). `quote_token_program`
+ *    is always classic Tokenkeg (wSOL is a classic mint).
+ * 9. **`config` (seeds `["config"]`) / `pool_authority` (a hardcoded Anchor
+ *    `address` constraint) / `event_authority` (seeds `["__event_authority"]`)
+ *    are GLOBAL constants, not per-pool** — confirmed identical across two
+ *    unrelated pools' real swap transactions — so this module hardcodes them
+ *    (like pumpswap hardcodes its own global PDAs) rather than re-deriving a
+ *    PDA on every `fetchPoolConfig`.
+ *
+ * No absolute floor/depth surprises for a virgin pool: `depthReserves` uses
+ * the VIRTUAL reserves (always substantial — 1e15/20-30e9 raw at genesis),
+ * not the real ones, because a brand-new pool's real `quote_reserve` is
+ * genuinely 0 (nobody has sold into it yet) which would zero BOTH
+ * directions' `isqrt(reserveIn·reserveOut)` depth if real reserves were used
+ * — incorrectly filtering out a pool that is, in fact, immediately buyable.
+ * The real-reserve capacity clamp above (point 6) is what actually protects
+ * against over-promising; depth is purely the coarse liveness/significance
+ * signal the relative-depth survivor gate uses.
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "trends";
+export const TRENDS_PROGRAM_ID = address("CURVEmPpijXDTNdqrA9PGP1io2rkgiVXH26xdXVGLLfz");
+export const WSOL_MINT = address("So11111111111111111111111111111111111111112");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+/** Global `config` PDA (seeds `["config"]`) — same account for every pool (verified live). */
+export const TRENDS_CONFIG_PDA = address("BMejsRsPsaMypBsexufEmEGh8vjxfp2CMVHZE2PTTetj");
+/** Global `pool_authority` — a hardcoded Anchor `address` constraint, identical for every pool. */
+export const TRENDS_POOL_AUTHORITY = address("C6B7knNSF8X8YfW54D8jQvM3VUCifsphHEQZSCyAERoE");
+/** Global `event_authority` PDA (seeds `["__event_authority"]`) — same for every pool. */
+export const TRENDS_EVENT_AUTHORITY = address("87jkvJSERNjGmzftppK4Kt4Trv6tDh25K66aatP9esXQ");
+export const POOL_ACCOUNT_SIZE = 312;
+/** sha256('account:Pool')[0..8] (the `bonding_curve` Pool account — see module header point 2). */
+export const POOL_DISCRIMINATOR = [0xf1, 0x9a, 0x6d, 0x04, 0x11, 0xb1, 0x6d, 0xbc];
+const OFF_BASE_MINT = 40;
+const OFF_BASE_VAULT = 72;
+const OFF_QUOTE_VAULT = 104;
+const OFF_IS_MIGRATED = 184;
+function hasDiscriminator(data, discriminator) {
+    return discriminator.every((byte, i) => data[i] === byte);
+}
+/**
+ * Mirrors pumpswap's `detectTokenProgram` convention: a classic Tokenkeg mint
+ * is always exactly 82 bytes; anything longer is Token-2022, whose TLV
+ * extension tail (starting at byte 166) is scanned for a `TransferFeeConfig`
+ * extension (type 1) — REJECTED, since a transfer fee would make vault
+ * deltas diverge from the quoted/user amount.
+ */
+function detectBaseTokenProgram(mint, data) {
+    if (data.length === 82)
+        return TOKEN_PROGRAM;
+    if (data.length < 166) {
+        throw new Error(`${SLUG}: base mint ${mint} data is ${data.length} bytes, not a recognizable mint layout`);
+    }
+    if (data[165] !== 1) {
+        throw new Error(`${SLUG}: base mint ${mint} token-2022 account type is ${data[165]}, expected 1 (mint)`);
+    }
+    // A NonTransferable / DefaultAccountState=frozen base mint genuinely cannot
+    // route — self-drop it. PermanentDelegate/Confidential are advisories (a
+    // routable T22 mint keeps routing), never blocking.
+    const { blocking } = parseMintExtensions(data);
+    if (blocking.length > 0) {
+        throw new Error(`${SLUG}: gate: base mint ${mint} is un-routable: ${blocking.join("; ")}`);
+    }
+    let offset = 166;
+    while (offset + 4 <= data.length) {
+        const extensionType = data[offset] | (data[offset + 1] << 8);
+        const extensionLength = data[offset + 2] | (data[offset + 3] << 8);
+        if (extensionType === 0)
+            break; // uninitialized tail
+        if (extensionType === 1) {
+            // TODO(t22-fee-netting): the base mint's transfer fee is REJECTED rather
+            // than fee-netted. This is a WSOL-quoted bonding curve whose reserves are
+            // read live and whose real-reserve capacity clamp assumes the full
+            // requested amount lands in the vault; a mint-level transfer fee breaks
+            // that assumption in a way simple leg-netting (net(amount, cfg, epoch) per
+            // leg) does not cleanly model, and this facade exposes no referenceQuote /
+            // epoch to net against anyway. Rejecting self-limits (safe); a wrong net
+            // silently mis-quotes — so keep the no-op (reject) path.
+            throw new Error(`${SLUG}: gate: base mint ${mint} carries a token-2022 TransferFeeConfig extension (vault deltas would not match the quoted amount)`);
+        }
+        offset += 4 + extensionLength;
+    }
+    return TOKEN_2022_PROGRAM;
+}
+/** Fetch + decode one Pool account. Read-only against the loader; reserves are read LIVE on-chain
+ *  at swap time (see emitSetup) — nothing about the curve state is baked here. */
+export async function fetchTrendsPoolConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG}: pool account ${pool} not found`);
+    if (data.length !== POOL_ACCOUNT_SIZE) {
+        throw new Error(`${SLUG}: pool ${pool} has ${data.length} bytes, expected ${POOL_ACCOUNT_SIZE}`);
+    }
+    if (!hasDiscriminator(data, POOL_DISCRIMINATOR)) {
+        throw new Error(`${SLUG}: pool ${pool} has a foreign discriminator (not a bonding_curve Pool account)`);
+    }
+    if (data[OFF_IS_MIGRATED] !== 0) {
+        throw new Error(`${SLUG}: pool ${pool} has migrated (is_migrated = true) — no more swaps on the curve`);
+    }
+    const codec = getAddressCodec();
+    const baseMint = codec.decode(data.subarray(OFF_BASE_MINT, OFF_BASE_MINT + 32));
+    const baseVault = codec.decode(data.subarray(OFF_BASE_VAULT, OFF_BASE_VAULT + 32));
+    const quoteVault = codec.decode(data.subarray(OFF_QUOTE_VAULT, OFF_QUOTE_VAULT + 32));
+    const mintData = await load(baseMint);
+    if (mintData === null)
+        throw new Error(`${SLUG}: base mint ${baseMint} of pool ${pool} not found`);
+    const baseTokenProgram = detectBaseTokenProgram(baseMint, mintData);
+    return {
+        venue: SLUG,
+        pool,
+        direction: "quoteToBase",
+        baseMint,
+        baseVault,
+        quoteVault,
+        baseTokenProgram,
+    };
+}
+/** Family facade for the recipe orchestrator (ladder-only, like obric-v2/solfi-v2). */
+export const trends = {
+    slug: SLUG,
+    programId: TRENDS_PROGRAM_ID,
+    fetchPoolConfig: fetchTrendsPoolConfig,
+};
+//# sourceMappingURL=index.js.map

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

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

package/sdk/dist/svm/venues/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Venue-adapter framework for the multi-venue solswap recipe: one adapter per
+ * on-chain venue (raydium, pumpswap, orca, saber, meteora, ...) that decodes
+ * pool state off-chain, emits the in-VM SauceScript quote fragment, builds the
+ * venue's swap CPI, and mirrors the quote math in TS for tests.
+ */
+import type { Address } from "@solana/kit";
+/**
+ * RPC-or-fixture account source: address in, raw account data out (null when
+ * the account does not exist). fetchPoolConfig takes one of these so LiteSVM
+ * fixture tests run without any RPC.
+ */
+export type AccountLoader = (address: Address) => Promise<Uint8Array | null>;
+/**
+ * The same source, WITH the owning program.
+ *
+ * Owner-based classification is the only correct way to tell a legacy SPL mint from a Token-2022
+ * one — an extensionless T22 mint is byte-identical to a classic 82-byte mint, so no amount of data
+ * inspection can separate them. `AccountLoader` drops the owner at this boundary, which made that
+ * classification structurally impossible for an adapter; this hands it through.
+ *
+ * Additive on purpose: the data-only loader stays the argument every adapter takes, so adapters
+ * move over one at a time rather than in one 64-file sweep.
+ */
+export type OwnedAccountLoader = (address: Address) => Promise<{
+    data: Uint8Array;
+    owner: Address;
+} | null>;
+/**
+ * Point-in-time account state keyed by base58 address — what referenceQuote
+ * reads instead of the chain.
+ */
+export type AccountBytesMap = Record<string, Uint8Array>;
+/**
+ * Base shape of a decoded pool configuration. Each adapter extends it with
+ * the venue-specific fields its quote emitter and swap builder need (vault
+ * addresses, fee parameters, curve constants, ...) — everything is resolved
+ * once, off-chain, by fetchPoolConfig.
+ */
+export interface PoolConfig {
+    /** Slug of the adapter that produced this config. */
+    venue: string;
+    /** Pool state account address. */
+    pool: Address;
+}
+/**
+ * One account attached to the generated program. `ref` is the symbolic
+ * account-plan ref used in generated SauceScript; `address` is present when
+ * the adapter resolved it from PoolConfig and absent for caller-resolved refs
+ * (the user's token accounts / owner from SwapUser).
+ */
+export interface VenueAccount {
+    ref: string;
+    address?: Address;
+    writable?: boolean;
+    signer?: boolean;
+    /**
+     * quoteRefs only: the account may legitimately NOT EXIST on-chain (e.g. an
+     * uninitialized whirlpool TickArray PDA beyond the readable window). The
+     * orchestrator's state fetch skips it when missing instead of throwing;
+     * the fragment must never read it (a param/live gate decides), though it
+     * still rides the transaction account list for the venue CPI.
+     */
+    optional?: boolean;
+}
+/**
+ * User-side refs for buildSwap. Refs, not addresses: the caller resolves them
+ * (resolveAccounts) when sending.
+ */
+export interface SwapUser {
+    /** Ref of the user's output-token account. */
+    outAta: string;
+    /** Ref of the user's input-token account. */
+    inAta: string;
+    /** Ref of the user's wallet — token authority, attached as signer. */
+    owner: string;
+}
+/**
+ * A ready-to-CPI venue swap: raw instruction data plus its ordered accounts.
+ * Venue-level min_out is always 1 — the recipe's post-swap outAta delta check
+ * enforces the real bound.
+ */
+export interface VenueSwap {
+    /** CALL target program id, baked into the bytecode. */
+    programId: Address;
+    /** Raw instruction data, discriminator included. */
+    data: Uint8Array;
+    /** Ordered exactly as the venue instruction expects. */
+    accounts: VenueAccount[];
+}
+export interface SvmVenueAdapter {
+    slug: string;
+    kind: "constant-product" | "stable" | "sqrt-price";
+    /** Mainnet program id. */
+    programId: Address;
+    /**
+     * Off-chain, once per pool: fetch + decode the pool account (and its
+     * config/vault deps), returning everything the emitter and swap builder
+     * need. Accepts raw account data via the AccountLoader so LiteSVM fixtures
+     * work without RPC. Throws a clear error naming the gate when the pool is
+     * out of scope (status bits, curve_type, depeg, transfer-fee extensions).
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<PoolConfig>;
+    /** Accounts to attach READ-ONLY for quoting (refs + resolved addresses from PoolConfig). */
+    quoteAccounts(cfg: PoolConfig): VenueAccount[];
+    /**
+     * SauceScript fragment computing `const q<i> = <amountOut>` for exactIn
+     * amountIn (bigint literal baked). May call shared helper functions
+     * (declared once by the generator).
+     */
+    emitQuote(cfg: PoolConfig, i: number, amountIn: bigint): string;
+    /**
+     * Swap CPI: raw instruction data + ordered account entries; venue-level
+     * min_out set to 1 (the post-swap delta check enforces the real bound).
+     */
+    buildSwap(cfg: PoolConfig, user: SwapUser, amountIn: bigint): VenueSwap;
+    /**
+     * TS mirror of emitQuote for tests — MUST be independently derived from the
+     * venue's quote formula in docs/svm-venues.md, not from reading the emitted
+     * SauceScript. `state`
+     * carries the accounts emitQuote reads; `now` is the unix timestamp for
+     * time-dependent venues (amp ramps, locked-profit decay).
+     */
+    referenceQuote(cfg: PoolConfig, state: AccountBytesMap, amountIn: bigint, now: bigint): bigint;
+}
+//# sourceMappingURL=types.d.ts.map

package/sdk/dist/svm/venues/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/svm/venues/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;AAE7E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,OAAO,KACb,OAAO,CAAC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;IACnB,oDAAoD;IACpD,IAAI,EAAE,UAAU,CAAC;IACjB,wDAAwD;IACxD,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,kBAAkB,GAAG,QAAQ,GAAG,YAAY,CAAC;IACnD,0BAA0B;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;;OAMG;IACH,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACzE,4FAA4F;IAC5F,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,YAAY,EAAE,CAAC;IAC/C;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAChE;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACxE;;;;;;OAMG;IACH,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CAChG"}

package/sdk/dist/svm/venues/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/sdk/dist/svm/venues/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/svm/venues/types.ts"],"names":[],"mappings":""}

package/sdk/dist/svm/venues/vault-liquid-unstake/index.d.ts

@@ -0,0 +1,36 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, VenueAccount } from "../types.js";
+declare const SLUG = "vault-liquid-unstake";
+export interface VaultLiquidUnstakePoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** The LST mint this LstInfo trades (inMint; outMint is always wrapped SOL). */
+    mint: Address;
+    /** The underlying SPL Stake Pool account backing this LST's exchange rate. */
+    stakePool: Address;
+    /** ATA(POOL_ADDRESS, mint) — the pool's own LST inventory account (account index 1 of `sell_lst`). */
+    poolLstAta: Address;
+}
+/**
+ * The pure quote math, LOCKSTEP with the emitted SauceScript helper below
+ * (`qVaultLiquidUnstake`) — same integer ops, same rounding (ceil the fee,
+ * so the on-chain and off-chain outputs match to the wei and both stay on
+ * the conservative side of the real program).
+ */
+export declare function vaultLiquidUnstakeQuote(x: bigint, rateNum: bigint, rateDen: bigint, before: bigint, target: bigint): bigint;
+export declare const vaultLiquidUnstake: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"2rU1oCHtQ7WJUvy15tKtFvxdYNNSc3id7AzUcjeFSddo">;
+    /**
+     * Off-chain, once per pool. `pool` is the LstInfo account address (this
+     * family's "pool", matching every other family's convention — see
+     * SvmRoutePoolSpec). Rejects: a missing/undecodable LstInfo, the wrong
+     * discriminator, the unsupported 225-byte extended layout (SCOPE, module
+     * doc), a missing/malformed global Pool singleton, or a stake-pool
+     * account whose shape doesn't match the canonical SPL Stake Pool struct.
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<VaultLiquidUnstakePoolConfig>;
+    quoteAccounts(cfg: PoolConfig): VenueAccount[];
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/vault-liquid-unstake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/vault-liquid-unstake/index.ts"],"names":[],"mappings":"AA0FA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3E,QAAA,MAAM,IAAI,yBAAyB,CAAC;AAiDpC,MAAM,WAAW,4BAA6B,SAAQ,UAAU;IAC9D,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,gFAAgF;IAChF,IAAI,EAAE,OAAO,CAAC;IACd,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;IACnB,sGAAsG;IACtG,UAAU,EAAE,OAAO,CAAC;CACrB;AAOD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAeR;AAED,eAAO,MAAM,kBAAkB;;;;IAI7B;;;;;;;OAOG;0BACyB,aAAa,QAAQ,OAAO,GAAG,OAAO,CAAC,4BAA4B,CAAC;uBAqE7E,UAAU,GAAG,YAAY,EAAE;CAO/C,CAAC"}