@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,39 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "gavel";
+export declare const GAVEL_PROGRAM_ID: Address<"srAMMzfVHVAtgSJc8iH6CfKzuWuUTzLHVCE81QU1rgi">;
+/** u64 LE @0 — accounts.rs POOL_ACCOUNT_DISCRIMINATOR ([116,210,187,119,196,196,52,137]). */
+export declare const GAVEL_POOL_DISCRIMINANT = 9886743430086513268n;
+/** PoolHeader (528) + Amm (96) — bytemuck::Pod, cast at offset 0, no prefix. */
+export declare const GAVEL_POOL_SIZE = 624;
+/** processor/swap.rs / lib.rs — the sr-AMM snapshot rotates every 4 slots (~1.6-2s). */
+export declare const GAVEL_LEADER_SLOT_WINDOW = 4n;
+export interface GavelPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'baseIn' (default) sells base for quote; 'quoteIn' buys base with quote. */
+    direction: "baseIn" | "quoteIn";
+    baseMint: Address;
+    quoteMint: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    baseDecimals: number;
+    quoteDecimals: number;
+    /** bps, immutable post-init — baked as a compile-time param. */
+    feeInBps: bigint;
+}
+/**
+ * Fetch + gate one Gavel/Plasma pool: discriminant + size, a live LP-share /
+ * reserve liveness gate (mirrors every other family's "one bad pool never
+ * kills a cook" self-drop), and classic-SPL-only mints (the program's own
+ * token_program is hardcoded to Tokenkeg — see the module header).
+ */
+export declare function fetchGavelConfig(load: AccountLoader, pool: Address): Promise<GavelPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only — no v1 adapter, not in the v1 registry). */
+export declare const gavel: {
+    slug: string;
+    programId: Address<"srAMMzfVHVAtgSJc8iH6CfKzuWuUTzLHVCE81QU1rgi">;
+    tokenProgram: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+    fetchPoolConfig: typeof fetchGavelConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/gavel/index.ts"],"names":[],"mappings":"AAsJA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,UAAU,CAAC;AAErB,eAAO,MAAM,gBAAgB,wDAAyD,CAAC;AAGvF,6FAA6F;AAC7F,eAAO,MAAM,uBAAuB,uBAA6B,CAAC;AAClE,gFAAgF;AAChF,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,wFAAwF;AACxF,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAa3C,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,+EAA+E;IAC/E,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAMD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,eAAe,CAAC,CA6D1B;AAED,uGAAuG;AACvG,eAAO,MAAM,KAAK;;;;;CAKjB,CAAC"}

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

@@ -0,0 +1,242 @@
+/**
+ * Gavel / "Plasma" (Ellipsis Labs sr-AMM, program `srAMMzfVHVAtgSJc8iH6CfKzuWuUTzLHVCE81QU1rgi`) —
+ * a sandwich-resistant constant-product AMM. This is NOT a CLOB: the whole
+ * pool state (a fixed-size `PoolAccount`, no dynamic order book) fits one
+ * account, so the quote is fully closed-form and needs no off-chain-shipped
+ * window/levels at all.
+ *
+ * SOURCE: the program is OPEN-SOURCE, BUSL-1.1-licensed
+ * (github.com/Ellipsis-Labs/plasma, verified build deployed at the program id
+ * above per Ellipsis Labs' own "Introducing Gavel"/"Introducing Plasma" posts
+ * and the Helius "Solana's Proprietary AMM Revolution" writeup) — every
+ * offset and formula below is TRANSCRIBED from `crates/plasma_state/src/
+ * {accounts,amm}.rs`, not reverse-engineered, and cross-verified against a
+ * REAL mainnet pool (`CcWf5D6BhUTv2tD4ebFFcmCdTUgBWMc8CqqoJvFHGGXi`, the
+ * IBRL/wSOL launch pool referenced in Ellipsis Labs' own "IBRL" test-coin
+ * writeup): the discriminator decoded to the pinned constant below,
+ * base/quote decimals (6/9) and mints matched the real IBRL/wSOL pair, and
+ * quotes at 4 sizes each way matched the REAL `plasma-amm-state` crate's own
+ * `Amm::simulate_{buy,sell}_exact_in` bit-for-bit (built from the cloned repo
+ * via `cargo build`, fed the live dumped account bytes — see the "sr-AMM
+ * healing" section below for why this crate-level check, not a
+ * `simulateTransaction`, is the strongest available verification: the crate
+ * needs no trader/vault accounts to exercise, and it IS the real program's
+ * logic, not a re-implementation of it).
+ *
+ * ── Account layout (`PoolHeader` + `Amm`, `#[repr(C)]` + `bytemuck::Pod`,
+ *    cast directly from account bytes at offset 0 — `initialize.rs`'s
+ *    `try_from_bytes_mut::<PoolAccount>(&mut pool_bytes)`, no prefix) ──
+ *
+ * `PoolHeader`: discriminator([u8;8])@0, sequence_number(u64)@8,
+ * base_params(TokenParams)@16, quote_params(TokenParams)@88,
+ * fee_recipients(ProtocolFeeRecipients, 264 bytes)@160,
+ * swap_sequence_number(u64)@424, padding@432 — 528 bytes total.
+ * `TokenParams` (72 bytes): decimals(u32)@0, vault_bump(u32)@4,
+ * mint_key(Pubkey)@8, vault_key(Pubkey)@40.
+ * `Amm` starts at 528 (528 % 16 == 0, so this holds regardless of the
+ * platform alignment of the `I80F48`/`i128` `reward_factor` field):
+ * fee_in_bps(u32)@528, protocol_allocation_in_pct(u32)@532,
+ * lp_vesting_window(u64)@536, reward_factor(i128)@544, total_lp_shares(u64)@560,
+ * slot_snapshot(u64)@568, base_reserves_snapshot(u64)@576,
+ * quote_reserves_snapshot(u64)@584, base_reserves(u64)@592,
+ * quote_reserves(u64)@600, cumulative_quote_lp_fees(u64)@608,
+ * cumulative_quote_protocol_fees(u64)@616 — 624 bytes total (GAVEL_POOL_SIZE).
+ * All offsets confirmed by decoding 112 real mainnet pools via
+ * getProgramAccounts (memcmp on the discriminant + dataSize 624) and finding
+ * sane fee_in_bps (25/30 bps)/reserves/decimals at every one.
+ *
+ * fee_in_bps is IMMUTABLE post-init (no admin instruction in
+ * `PlasmaInstruction` mutates it — only `WithdrawProtocolFees`, a payout, and
+ * `WithdrawLpFees`), so it is baked as a compile-time PARAM (like fluxbeam's
+ * trade-fee numerators) rather than re-read live each trade.
+ *
+ * ── sr-AMM "healing" — a virtual, ONE-LEVEL limit order at the window's
+ *    anchor price (amm.rs `get_limit_order_size_in_base_and_quote` +
+ *    `buy_exact_in`/`sell_exact_in`) ──
+ *
+ * Every `Swap` instruction first calls (processor/swap.rs)
+ * `let slot = Clock::get()?.slot; let snapshot_slot = (slot / LEADER_SLOT_WINDOW) * LEADER_SLOT_WINDOW;`
+ * (`LEADER_SLOT_WINDOW = 4`, lib.rs) then `Amm::maybe_update_snapshot(snapshot_slot)`:
+ * if `snapshot_slot > self.slot_snapshot` (a NEW 4-slot leader window since
+ * this pool was last touched), the snapshot RESETS to the pool's own CURRENT
+ * reserves (so the virtual level's size — see below — collapses to exactly
+ * 0, a pure constant-product swap); otherwise (this pool already traded
+ * within the SAME window) the STORED snapshot stays in force.
+ *
+ * When the stored snapshot differs from current reserves, one side carries a
+ * virtual limit order priced EXACTLY at the snapshot's price ratio, sized so
+ * consuming it exactly restores that ratio (the closed-form in
+ * `get_limit_order_size_in_base_and_quote`'s doc comment). CRITICALLY — and
+ * this inverts the naive intuition — the side that gets a virtual level is
+ * whichever one trades AGAINST the direction the price has ALREADY moved
+ * this window (a buyer gets an ask only when price has already DROPPED
+ * — `quote_snapshot*base_reserves > base_snapshot*quote_reserves`, i.e.
+ * snapshot price > current price — and it fills at that HIGHER, WORSE-for-
+ * the-buyer snapshot price; symmetrically a seller's bid only appears when
+ * price has RISEN and fills at the LOWER, WORSE-for-the-seller snapshot
+ * price). This is NOT a "the taker always benefits" mechanism: it is a
+ * "trade back toward the window's anchor price regardless of who benefits"
+ * mechanism, and its actual anti-sandwich effect is neutralizing a would-be
+ * attacker's BACK-RUN leg (which sells back into a price the attacker's own
+ * front-run inflated) — see the module-level measured example below.
+ * PROVEN, not assumed: an EARLIER analysis in this exact investigation
+ * assumed the opposite sign (that ignoring the level is a strictly
+ * CONSERVATIVE approximation) and was REFUTED by a controlled scenario
+ * before it shipped — a same-window SELL then BUY (or BUY then SELL)
+ * measured the real crate returning STRICTLY LESS than a plain
+ * current-reserves constant-product quote for the same input (e.g. a
+ * same-window sell of 30_000_000_000 lowering price, then a 2_000_000_000
+ * buy: real crate 174,752,288,804 base out vs 175,499,103,175 if the level
+ * were ignored) — so a "just use current reserves" shortcut would be a
+ * FAVORABLE ERROR (over-promising), exactly the class of bug this repo's
+ * integration policy calls a liveness hazard. This module therefore
+ * implements the FULL two-piece close (virtual level + constant-product
+ * tail), not an approximation, and both branches are validated bit-for-bit
+ * against the real `plasma-amm-state` crate (see the module doc above and
+ * `test/svm/venues/gavel.test.ts`).
+ *
+ * WHY THIS IS COMPUTABLE ON-CHAIN WITHOUT A SHIPPED WINDOW (unlike
+ * manifest/phoenix's order books): `slot_snapshot` / `*_reserves_snapshot` /
+ * `base_reserves` / `quote_reserves` are all FIXED-OFFSET fields on the ONE
+ * pool account already being read — no tree walk. The one missing datum
+ * (`Clock::get()?.slot`, the LIVE current slot) is read via SauceScript's
+ * `ctx.blockNumber()`, which the SVM engine profile documents as having a
+ * fork-parity analog for every EVM chain op (the compiler's saucer/
+ * svm-profile.js) — EMPIRICALLY CONFIRMED here (not merely trusted from that
+ * comment) by compiling `function main(){ return abi.encode(ctx.blockNumber(),
+ * ctx.timestamp()) }` for target 'svm' and executing it on the real engine.so
+ * inside a LiteSVM harness pinned via `svm.warpToSlot(1000)` +
+ * `svm.setClock(new Clock(1000, 0n, 0n, 0n, 12345n))`: it returned
+ * `(1000, 12345)` — `ctx.blockNumber()` is exactly the Solana slot, `ctx.timestamp()`
+ * exactly the Clock's unix_timestamp, independently steerable (the SAME
+ * mechanism `solfi-v2` already established for its own live-slot read — see
+ * `the consuming app cu e2e test`'s `SOLFI_SLOT` comment). So `referenceQuote`'s
+ * `now` parameter, for THIS family, is the CURRENT SLOT (not a unix
+ * timestamp) — the same convention solfi-v2 set; `now` absent defaults to 0n
+ * (same as solfi-v2), which — since a real `slot_snapshot` is always > 0
+ * once a pool has ever swapped — takes the "trust the stored snapshot"
+ * branch, never the reset.
+ *
+ * ── Swap CPI (`PlasmaInstruction::Swap` = 0, instruction.rs) ──
+ *
+ * Accounts (shank-declared): [0] `plasma_program` (this program's own id,
+ * readonly — self-CPI for event logging, the same idiom manifest/phoenix
+ * use), [1] `log_authority` (readonly PDA seeds=[b"log"], hardcoded in
+ * lib.rs as `37zgQb6PjFuxah6R8CTk67gEvLrpqPQ61E7vh9ARPGFD` and asserted there
+ * by a `check_pda` test), [2] `pool` (writable), [3] `trader` (signer, NOT
+ * writable), [4] `base_account` (trader's, writable), [5] `quote_account`
+ * (trader's, writable), [6] `base_vault` (writable), [7] `quote_vault`
+ * (writable), [8] `token_program`. `token_program` is HARDCODED to
+ * `spl_token::id()` in every account loader in this program
+ * (validation/loaders.rs) — classic-Tokenkeg only, no Token-2022 path exists,
+ * so (unlike fluxbeam) mints are gated to exactly 82 bytes with no
+ * SOUND-vs-heuristic ambiguity.
+ *
+ * Data: ONE leading instruction-selector byte (`PlasmaInstruction::Swap as
+ * u8` = 0 — easy to miss since `Swap`'s own variant tag is ALSO 0, but it is
+ * a separate byte the entrypoint's dispatch consumes before `SwapParams` is
+ * even parsed; a real-CPI run without it dispatched into `AddLiquidity`,
+ * `PlasmaInstruction::to_vec`'s `vec![*self as u8]` confirms the shape) then
+ * Borsh `SwapParams { side: Side, swap_type: SwapType }` — `Side` is a unit
+ * enum (`Buy=0, Sell=1` by declaration order in amm.rs), `SwapType` an enum
+ * whose `ExactIn{amount_in: u64, min_amount_out: u64}` variant is tag 0
+ * (declaration order in processor/swap.rs). Full wire: `[ix tag=0 (Swap)]
+ * [side u8][swap_type tag=0 u8][amount_in u64 LE (patched)][min_amount_out
+ * u64 LE = 1]` — venue-level min_out is 1, the recipe's own terminal outAta
+ * delta check is the real floor (the solswap/manifest/phoenix discipline).
+ * PROVEN against the real dumped mainnet binary, not just this transcription
+ * — see `the consuming app realcpi e2e test`'s `gavel` quadrilateral.
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { readUintLE } from "../math.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "gavel";
+export const GAVEL_PROGRAM_ID = address("srAMMzfVHVAtgSJc8iH6CfKzuWuUTzLHVCE81QU1rgi");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/** u64 LE @0 — accounts.rs POOL_ACCOUNT_DISCRIMINATOR ([116,210,187,119,196,196,52,137]). */
+export const GAVEL_POOL_DISCRIMINANT = 9886743430086513268n;
+/** PoolHeader (528) + Amm (96) — bytemuck::Pod, cast at offset 0, no prefix. */
+export const GAVEL_POOL_SIZE = 624;
+/** processor/swap.rs / lib.rs — the sr-AMM snapshot rotates every 4 slots (~1.6-2s). */
+export const GAVEL_LEADER_SLOT_WINDOW = 4n;
+const OFF_BASE_DECIMALS = 16;
+const OFF_BASE_MINT = 24;
+const OFF_BASE_VAULT = 56;
+const OFF_QUOTE_DECIMALS = 88;
+const OFF_QUOTE_MINT = 96;
+const OFF_QUOTE_VAULT = 128;
+const OFF_FEE_IN_BPS = 528;
+const OFF_TOTAL_LP_SHARES = 560;
+const OFF_BASE_RESERVES = 592;
+const OFF_QUOTE_RESERVES = 600;
+function decodeAddress(data, offset) {
+    return getAddressCodec().decode(data.subarray(offset, offset + 32));
+}
+/**
+ * Fetch + gate one Gavel/Plasma pool: discriminant + size, a live LP-share /
+ * reserve liveness gate (mirrors every other family's "one bad pool never
+ * kills a cook" self-drop), and classic-SPL-only mints (the program's own
+ * token_program is hardcoded to Tokenkeg — see the module header).
+ */
+export async function fetchGavelConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG}: pool ${pool} account not found`);
+    if (data.length !== GAVEL_POOL_SIZE) {
+        throw new Error(`${SLUG}: pool ${pool} must be ${GAVEL_POOL_SIZE} bytes (PoolHeader+Amm), got ${data.length}`);
+    }
+    if (readUintLE(data, 0, 8) !== GAVEL_POOL_DISCRIMINANT) {
+        throw new Error(`${SLUG}: pool ${pool} has a foreign discriminator (not a Gavel PoolAccount)`);
+    }
+    const totalLpShares = readUintLE(data, OFF_TOTAL_LP_SHARES, 8);
+    const baseReserves = readUintLE(data, OFF_BASE_RESERVES, 8);
+    const quoteReserves = readUintLE(data, OFF_QUOTE_RESERVES, 8);
+    if (totalLpShares <= 0n || baseReserves <= 0n || quoteReserves <= 0n) {
+        throw new Error(`${SLUG}: pool ${pool} is uninitialized or drained (lpShares=${totalLpShares}, base=${baseReserves}, quote=${quoteReserves})`);
+    }
+    const baseMint = decodeAddress(data, OFF_BASE_MINT);
+    const quoteMint = decodeAddress(data, OFF_QUOTE_MINT);
+    // The Swap ix's token_program is hardcoded to spl_token::id() in every
+    // loader (validation/loaders.rs) — Tokenkeg-only, so a Token-2022 mint (or
+    // one carrying an un-routable extension) cannot actually be swapped here.
+    // Detect via the shared data-shape resolver and SELF-DROP such a pool (the
+    // thrown error is the graceful-drop signal the SvmRoute orchestrator catches).
+    // The LEGACY path is byte-identical: a classic 82-byte mint classifies as
+    // Tokenkeg, parses no extensions, and the config is built unchanged.
+    const mintList = [baseMint, quoteMint];
+    const mintDatas = await Promise.all(mintList.map((mint) => load(mint)));
+    for (let mi = 0; mi < mintList.length; mi++) {
+        const mint = mintList[mi];
+        const mintData = mintDatas[mi];
+        if (mintData === null)
+            continue; // an unreadable mint falls back to the legacy assumption
+        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: "baseIn",
+        baseMint,
+        quoteMint,
+        baseVault: decodeAddress(data, OFF_BASE_VAULT),
+        quoteVault: decodeAddress(data, OFF_QUOTE_VAULT),
+        baseDecimals: Number(readUintLE(data, OFF_BASE_DECIMALS, 4)),
+        quoteDecimals: Number(readUintLE(data, OFF_QUOTE_DECIMALS, 4)),
+        feeInBps: readUintLE(data, OFF_FEE_IN_BPS, 4),
+    };
+}
+/** Family facade for the recipe orchestrator (ladder-only — no v1 adapter, not in the v1 registry). */
+export const gavel = {
+    slug: SLUG,
+    programId: GAVEL_PROGRAM_ID,
+    tokenProgram: TOKEN_PROGRAM,
+    fetchPoolConfig: fetchGavelConfig,
+};
+//# sourceMappingURL=index.js.map

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

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

package/sdk/dist/svm/venues/goonfi-v2/index.d.ts

@@ -0,0 +1,85 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, SwapUser, VenueAccount, VenueSwap } from "../types.js";
+declare const SLUG = "goonfi-v2";
+export declare const GOONFI_V2_PROGRAM_ID: Address<"goonuddtQRrWqqn5nFyczVKaie28f3kDkHWkHtURSLE">;
+/** The 719,000-byte account every sampled pool's swap attaches read-only (account #9) — owned by
+ *  the GoonFi program itself, NOT written by swap (confirmed via the real tx's writable-flags
+ *  decode), so it is genuine keeper-maintained state the swap only consults. Its internal layout
+ *  is >98% zero-padded and not yet decoded; this adapter does not read it directly (the per-pool
+ *  oracle-relay account below carries the live price signal instead). */
+export declare const GOONFI_GLOBAL_STATE: Address<"BNrK9LpEn65QA4TyBLVSMdngW3XHj3xLfFPwGdCBv8wV">;
+/** sha256-style single-byte tag observed on all 4 real captured swaps. */
+export declare const GOONFI_SWAP_TAG = 1;
+export declare const GOONFI_OFF_MINT_A = 80;
+export declare const GOONFI_OFF_MINT_B = 112;
+export declare const GOONFI_OFF_VAULT_A = 144;
+export declare const GOONFI_OFF_VAULT_B = 176;
+/** The per-pool oracle-relay account (swap account #8; see module doc). */
+export declare const GOONFI_OFF_ORACLE = 208;
+export declare const OFF_ORACLE_P1 = 0;
+export declare const OFF_ORACLE_P2 = 8;
+export declare const OFF_ORACLE_SLOT = 16;
+export declare const OFF_ORACLE_DENOM = 20;
+/** The denominator observed on all 4 sampled oracle-relay accounts — a fail-closed assumption:
+ *  the live denom is still read and gated against this at cook time (see ladder.ts), so a future
+ *  pool with a genuinely different denom self-deactivates instead of silently mispricing. */
+export declare const GOONFI_ASSUMED_DENOM = 1000000n;
+/** The empirically-validated fee schedule (ppm, i.e. parts-per-1e6) — see module doc for the
+ *  measurement this pins against (tier 5 = 2200 ppm = 22.00 bps, matching a real Jupiter-quoted
+ *  10,000 USDC price impact of ~21.8 bps). Read LIVE from the pool's own bytes (not baked) so a
+ *  pool with a genuinely different admin-configured schedule is priced from its own table.
+ */
+export interface GoonfiFeeSchedule {
+    /** 9 ascending cumulative-size thresholds, in the CALLER-SIDE mint's raw units for this
+     *  direction (already decimals-adjusted at fetch time — see paramsFor in ladder.ts). */
+    sizeTiers: readonly bigint[];
+    /** 9 fee rates in ppm, ascending, one per tier upper bound. */
+    feeTiersPpm: readonly bigint[];
+}
+export interface GoonfiV2PoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'xToY' (default — mintA in, mintB out) | 'yToX'. */
+    direction: "xToY" | "yToX";
+    mintA: Address;
+    mintB: Address;
+    decimalsA: number;
+    decimalsB: number;
+    vaultA: Address;
+    vaultB: Address;
+    oracle: Address;
+    tokenProgram: Address;
+    /** Fee schedule read from the pool's own bytes, already oriented for `direction` (mintB-raw
+     *  cumulative thresholds for yToX; snapshot-price-converted to mintA-raw for xToY — see
+     *  ladder.ts's paramsFor doc for why xToY's thresholds are a one-time approximation). */
+    feeSchedule: GoonfiFeeSchedule;
+}
+/** denomAdjusted = ASSUMED_DENOM * 10^decimalsA / 10^decimalsB — the single scale constant the
+ *  live-price formula divides (xToY) or multiplies (yToX) by. Shared between fetchPoolConfig
+ *  (threshold baking) and the ladder (the runtime param) so the two can never diverge. */
+export declare function denomAdjustedFor(decimalsA: number, decimalsB: number): bigint;
+export declare const goonfiV2: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"goonuddtQRrWqqn5nFyczVKaie28f3kDkHWkHtURSLE">;
+    /**
+     * Off-chain gate + decode. Rejects: wrong size/discriminator, an unreadable
+     * oracle-relay or mint account, a non-ascending fee-tier table (a corrupt or
+     * unrecognized layout variant — fail closed rather than guess).
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<GoonfiV2PoolConfig>;
+    quoteAccounts(cfg: PoolConfig): VenueAccount[];
+    /** v1 swap CPI (amount baked) — the real 14-account `swap` ix (tag 1). */
+    buildSwap(cfg: PoolConfig, user: SwapUser, amountIn: bigint): VenueSwap;
+};
+/**
+ * The 14-account order for GoonFi's real `swap` (shared by v1 buildSwap and v2 buildSwapV2) — read
+ * back off a real captured transaction's own writable/signer flags (not guessed):
+ *   0 user(signer,w) · 1 pool(w) · 2 user mintA-ATA(w) · 3 user mintB-ATA(w) · 4 vaultA(w) ·
+ *   5 vaultB(w) · 6 mintA · 7 mintB · 8 oracle-relay · 9 GOONFI_GLOBAL_STATE · 10 ix-sysvar ·
+ *   11 token program · 12 token program (again) · 13 GOONFI_CONST_ACCOUNT_13.
+ * User ATA order is FIXED (mintA-ATA, mintB-ATA) regardless of direction — only the tag-1 direction
+ * byte decides which side is pulled from vs paid into, exactly like vaultA/vaultB.
+ */
+export declare function goonfiSwapAccounts(c: GoonfiV2PoolConfig, user: SwapUser, make: (ref: string, addr: Address, writable?: boolean) => VenueAccount, refFor?: (role: string) => string): VenueAccount[];
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/goonfi-v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/goonfi-v2/index.ts"],"names":[],"mappings":"AAwEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIhG,QAAA,MAAM,IAAI,cAAc,CAAC;AAEzB,eAAO,MAAM,oBAAoB,wDAAyD,CAAC;AAS3F;;;;yEAIyE;AACzE,eAAO,MAAM,mBAAmB,yDAA0D,CAAC;AAE3F,0EAA0E;AAC1E,eAAO,MAAM,eAAe,IAAI,CAAC;AASjC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAWrC,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC;;6FAE6F;AAC7F,eAAO,MAAM,oBAAoB,WAAa,CAAC;AAI/C;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;4FACwF;IACxF,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,+DAA+D;IAC/D,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,uDAAuD;IACvD,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB;;6FAEyF;IACzF,WAAW,EAAE,iBAAiB,CAAC;CAChC;AAMD;;0FAE0F;AAC1F,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7E;AA4BD,eAAO,MAAM,QAAQ;;;;IAKnB;;;;OAIG;0BACyB,aAAa,QAAQ,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAC;uBAqGnE,UAAU,GAAG,YAAY,EAAE;IAU9C,0EAA0E;mBAC3D,UAAU,QAAQ,QAAQ,YAAY,MAAM,GAAG,SAAS;CAiBxE,CAAC;AAKF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,kBAAkB,EACrB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,YAAY,EACtE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAChC,YAAY,EAAE,CAqBhB"}