@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../src/svm/venues/math.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBlF"}

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

@@ -0,0 +1,34 @@
+/**
+ * Shared bigint helpers for venue adapters. All venue math is bigint with
+ * floors/ceils exactly as docs/svm-venues.md states; division floors natively.
+ */
+/** Ceiling division: smallest q with q * b >= a. Non-negative dividends only. */
+export function ceilDiv(a, b) {
+    if (a < 0n)
+        throw new Error(`ceilDiv dividend must be non-negative, got ${a}`);
+    if (b <= 0n)
+        throw new Error(`ceilDiv divisor must be positive, got ${b}`);
+    return (a + b - 1n) / b;
+}
+/**
+ * Little-endian unsigned field read — the TS mirror of the compiler's
+ * accountUint(ref, offset, width). All seven venues are pure-LE; BE never
+ * occurs. width is in bytes, 1..=32 (SPL token amount = readUintLE(data, 64, 8)).
+ */
+export function readUintLE(data, offset, width) {
+    if (!Number.isInteger(offset) || offset < 0) {
+        throw new Error(`readUintLE offset must be a non-negative integer, got ${offset}`);
+    }
+    if (!Number.isInteger(width) || width < 1 || width > 32) {
+        throw new Error(`readUintLE width must be an integer in 1..=32, got ${width}`);
+    }
+    if (offset + width > data.length) {
+        throw new Error(`readUintLE reads [${offset}, ${offset + width}) beyond ${data.length}-byte data`);
+    }
+    let value = 0n;
+    for (let i = width - 1; i >= 0; i--) {
+        value = (value << 8n) | BigInt(data[offset + i]);
+    }
+    return value;
+}
+//# sourceMappingURL=math.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sourceRoot":"","sources":["../../../src/svm/venues/math.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,iFAAiF;AACjF,MAAM,UAAU,OAAO,CAAC,CAAS,EAAE,CAAS;IAC1C,IAAI,CAAC,GAAG,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,EAAE,CAAC,CAAC;IAC/E,IAAI,CAAC,IAAI,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,EAAE,CAAC,CAAC;IAC3E,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAAgB,EAAE,MAAc,EAAE,KAAa;IACxE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,yDAAyD,MAAM,EAAE,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,EAAE,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,sDAAsD,KAAK,EAAE,CAAC,CAAC;IACjF,CAAC;IACD,IAAI,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,qBAAqB,MAAM,KAAK,MAAM,GAAG,KAAK,YAAY,IAAI,CAAC,MAAM,YAAY,CAClF,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,GAAG,EAAE,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,25 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "mercurial";
+export declare const MERCURIAL_PROGRAM_ID: Address<"MERLuDFBMmsHnsBPZw2sDQZHvXFMwp8EdjudcU2HKky">;
+export interface MercurialPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    direction: "aToB" | "bToA";
+    nonce: number;
+    authority: Address;
+    vaultA: Address;
+    vaultB: Address;
+    mintA: Address;
+    mintB: Address;
+}
+/** Fetch + decode one Mercurial SwapV2 pool, plus its two vaults' mints. Read-only against the loader. */
+export declare function fetchMercurialPoolConfig(load: AccountLoader, pool: Address): Promise<MercurialPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only, like orca-whirlpool/raydium-clmm/saber-stableswap). */
+export declare const mercurial: {
+    slug: string;
+    programId: Address<"MERLuDFBMmsHnsBPZw2sDQZHvXFMwp8EdjudcU2HKky">;
+    tokenProgram: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+    fetchPoolConfig: typeof fetchMercurialPoolConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/mercurial/index.ts"],"names":[],"mappings":"AAqHA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,cAAc,CAAC;AAEzB,eAAO,MAAM,oBAAoB,wDAAyD,CAAC;AAa3F,MAAM,WAAW,mBAAoB,SAAQ,UAAU;IACrD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB;AAyBD,0GAA0G;AAC1G,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,mBAAmB,CAAC,CAoF9B;AAED,kHAAkH;AAClH,eAAO,MAAM,SAAS;;;;;CAKrB,CAAC"}

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

@@ -0,0 +1,236 @@
+/**
+ * Mercurial Finance Stable Swap (`stable-swap-n-pool`) — the pre-Meteora
+ * multi-token stableswap, program `MERLuDFBMmsHnsBPZw2sDQZHvXFMwp8EdjudcU2HKky`
+ * (same address on mainnet-beta and devnet; Saber's own `stable-swap`
+ * program is a documented fork of this exact codebase, which is why the
+ * Newton math below matches saber-stableswap's `ann = amp*2` convention
+ * bit-for-bit rather than the generalized Curve `ann = amp*n^n`).
+ *
+ * Layout source: `mercurial-finance/stable-swap-n-pool-instructions`
+ * (`src/state.rs`'s `SwapV2`, `src/instruction.rs`'s `SwapInstruction`) and
+ * `mercurial-finance/stable-swap-n-pool-js` (`src/index.ts`'s
+ * `FEE_DENOMINATOR = 1e10`, the client account ordering for `Exchange`).
+ * `SwapV2` is a Vec-backed struct but every array is declared at its
+ * compile-time MAX (`PoolParameter::MAX_N_COINS = 4`), so every pool account
+ * is a FIXED 265 bytes (1 version tag + `SwapV2::LEN` 264) regardless of how
+ * many of the 4 coin slots are actually in use — `getProgramAccounts`
+ * filtered on `dataSize: 265` finds every pool with no memcmp needed (the
+ * -32010 the brief warns about is a Helius secondary-index limit on an
+ * UNFILTERED gPA call; a plain `dataSize` filter is a primary index and
+ * works directly, confirmed live: 24 pools returned in one call).
+ *
+ * THIS ADAPTER IS 2-COIN ONLY (a deliberate, checked scope limit, not a
+ * layout gap): `stableComputeD`/`stableComputeYWarm` (shared with
+ * saber-stableswap and meteora-damm-v1-stable) implement the CLASSIC 2-asset
+ * invariant (`ann = amp*2`); a genuinely N>2 Mercurial pool (real examples
+ * exist on-chain, e.g. 3- and 4-coin USD baskets) needs the generalized
+ * N-coin Newton iteration (`ann = amp*n^n`, D/Y summed over every balance),
+ * which is different math this repo does not implement. `fetchPoolConfig`
+ * throws (self-drops the pool, never emits wrong-math bytecode) whenever
+ * `tokens_len !== 2`.
+ *
+ * PRECISION MULTIPLIERS — the wrinkle Saber's 2-token-only design never
+ * needed: each coin slot carries a live `precision_multipliers[i]` (u64,
+ * `SetPrecisionMultipliers`-admin-settable) that both aligns decimals AND
+ * bakes in a fixed exchange-rate snapshot for yield-bearing pairs (measured
+ * live 2026-07-31: the mSOL/SOL pool `MAR1zHjHaQcniE2gXsDptkyKUnNfMEsLBVcfP7vLyv7`
+ * carries `[1000, 1128]` — 1.128 being that pool's mSOL/SOL rate at whatever
+ * point an admin last called `SetPrecisionMultipliers`, NOT live-updating
+ * per-trade). The invariant math runs on VIRTUAL balances
+ * `raw_reserve_i * precision_multipliers[i]` — homogeneous-degree-1 in the
+ * multiplier choice, so D/Y math is exact for ANY shared scale, and only the
+ * de-normalization (`virtual / precision_multipliers[dst]`) and the FEE
+ * matter for byte-exactness. VALIDATED against the REAL deployed program
+ * (see below) that the fee itself must be taken IN VIRTUAL SPACE before
+ * de-normalizing — `dyRaw = floor((dyVirtual - floor(dyVirtual*fn/1e10)) / dstMult)`,
+ * NOT `floor(dyVirtual/dstMult) - floor(floor(dyVirtual/dstMult)*fn/1e10)` —
+ * the latter is off by up to a few raw units on any pool with a non-unit
+ * multiplier (measured +1 raw-unit residual at 2 of 3 tested sizes on the
+ * mSOL/SOL pool before the fix; 0 residual after, at all tested sizes on all
+ * three real pools below).
+ *
+ * NO AMP RAMP: unlike Saber (and unlike Curve's usual `start/target/ramp_ts`
+ * quad), Mercurial's `SwapV2.amplification_coefficient` is a single live u64
+ * that `AdminSetting::SetAmplificationCoefficient` overwrites INSTANTLY —
+ * there is no time-interpolated ramp field in the account at all (confirmed
+ * from `state.rs`: the struct has no `initial_amp`/`target_amp`/ramp
+ * timestamps, only the one field). The fragment therefore just reads amp
+ * live, no branch.
+ *
+ * `admin_fee_numerator` is a stored-but-UNUSED field (`state.rs`'s own doc
+ * comment: "Admin fee numerator, not implemented") — every sampled live pool
+ * (24, all admin_fee_numerator = 0) confirms it; this adapter never reads it.
+ * `FEE_DENOMINATOR` is a fixed protocol constant (`1e10`, from the JS SDK),
+ * NOT a per-pool stored field, so it is baked as a compile-time literal.
+ *
+ * BIDIRECTIONAL: unlike Saber (asymmetric admin-fee-destination account,
+ * A->B only in this codebase) and meteora-damm-v1-stable, Mercurial's
+ * `Exchange` instruction accounts are fully symmetric — both vaults ride the
+ * account list in STORED order regardless of which mint is source/dest, and
+ * there is no direction-specific admin-fee account at all. So this adapter
+ * serves BOTH `aToB` and `bToA`, doubling real coverage over the Saber
+ * precedent for no extra on-chain cost.
+ *
+ * VALIDATED against the REAL deployed program on REAL mainnet state (LiteSVM
+ * `simulateTransaction`, `sigVerify:false` impersonating a real token holder
+ * as `userTransferAuthority` — never a funds-moving tx) at 3+ sizes on THREE
+ * independent real pools, RE-CONFIRMED at fixture-capture time (2026-07-31;
+ * these pools trade continuously — a pool's live reserves are a MOVING
+ * TARGET, so `test/svm/venues/mercurial.test.ts`'s pinned numbers are a
+ * regression pin against its OWN checked-in fixture snapshot, not a
+ * permanent real-time truth — re-derive if the fixtures are ever recaptured):
+ *  - `SoLw5ovBPNfodtAbxqEKHLGppyrdB4aZthdGwpfpQgi` (mult=[1,1], SOL vs an
+ *    unlabeled SPL mint): 1/10/50 tokens, bit-exact at all three.
+ *  - `MAR1zHjHaQcniE2gXsDptkyKUnNfMEsLBVcfP7vLyv7` (SOL/mSOL, mult=[1000,1128]):
+ *    1/5/20 mSOL, bit-exact at all three (post-fix; see the fee-rounding note
+ *    above for the pre-fix residual).
+ *  - `LiDoU8ymvYptqxenJ4YpcURBchn4ef63tcbdznBCKJh` (stSOL/SOL, mult=[1122,1000]):
+ *    1/10/30 stSOL, bit-exact at all three.
+ * See `test/svm/venues/mercurial.test.ts` for the pinned worked examples.
+ *
+ * NO `the consuming app realcpi e2e test` CELL (unlike every other SAUCE_VENUE_PROGRAMS-gated
+ * venue): driving the real dumped `mercurial.so` through a raw single Exchange
+ * CPI in LiteSVM (same pool/accounts/encoding the real-network probe above
+ * validates) reproducibly fails a RUNTIME-LEVEL "sum of account balances
+ * before and after instruction do not match" check — AFTER the program's own
+ * logic (GetFeeAmount, GetDyUnderlying, both inner SPL transfers) already
+ * completes correctly and reproduces the exact real-network quote. This is
+ * independent of pool / precision-multiplier / lamport magnitude / SPL
+ * `is_native` flagging / LiteSVM feature set (all varied individually, zero
+ * change in outcome or CU) and is read as a LiteSVM-specific compatibility
+ * gap with this one 2021-era non-Anchor binary — `simulateTransaction`
+ * against REAL mainnet-beta runs the SAME Agave runtime code path as full
+ * execution (unlike LiteSVM's independent reimplementation) and succeeds
+ * cleanly, which is why the real-network probe above is trusted as the
+ * fund-safety proof. budget.ts's `mercurial` CU_FAMILIES entry documents the
+ * real CPI's OWN measured compute cost (61_473 CU, captured before that
+ * runtime check fires) and folds it into the pin with a safety margin.
+ *
+ * Gates: 265-byte account size, version byte == 2 (SwapV2), initialized,
+ * exactly 2 coin slots, both vault accounts classic-SPL (165 bytes) and
+ * owned by the derived authority. `swap_enabled` is a live-reversible admin
+ * toggle (same class as Saber's `is_paused`) — NOT a fetch-time gate; the
+ * fragment re-checks it live every trade (a disabled pool quotes 0 and never
+ * pays its CPI, the same self-drop-by-zero-quote convention Saber uses).
+ */
+import { createHash } from "node:crypto";
+import { address, getAddressDecoder, getAddressEncoder, isOffCurveAddress } 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 = "mercurial";
+export const MERCURIAL_PROGRAM_ID = address("MERLuDFBMmsHnsBPZw2sDQZHvXFMwp8EdjudcU2HKky");
+// Mercurial predates Token-2022; every sampled vault is classic Tokenkeg.
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/** 1 (version tag) + SwapV2::LEN (264, PoolParameter::MAX_N_COINS = 4 baked into the fixed-size arrays). */
+const SWAP_STATE_LEN = 265;
+/** Classic (non-Token-2022) SPL Token Account encoding length. */
+const SPL_TOKEN_ACCOUNT_LEN = 165;
+// SwapV2 offsets (absolute, i.e. including the leading version-tag byte — see module header).
+const OFF_NONCE = 2;
+const OFF_TOKENS_LEN = 27;
+const OFF_VAULT_A = 71;
+const OFF_VAULT_B = 103;
+/**
+ * create_program_address([pool (32B), [nonce]], programId) — identical
+ * scheme to saber-stableswap's `deriveSwapAuthority` (Mercurial's own client
+ * derives the SAME seeds via `findProgramAddress([pool], programId)`, whose
+ * auto-appended bump IS the stored nonce for any canonically-initialized
+ * pool; using the STORED nonce directly, like Saber, is exact even for a
+ * hypothetical non-canonical nonce).
+ */
+async function deriveMercurialAuthority(pool, nonce) {
+    const encoder = getAddressEncoder();
+    const digest = createHash("sha256")
+        .update(encoder.encode(pool))
+        .update(Uint8Array.of(nonce))
+        .update(encoder.encode(MERCURIAL_PROGRAM_ID))
+        .update("ProgramDerivedAddress")
+        .digest();
+    const authority = getAddressDecoder().decode(digest);
+    if (!isOffCurveAddress(authority)) {
+        throw new Error(`${SLUG} pool ${pool} nonce ${nonce} derives an on-curve swap authority`);
+    }
+    return authority;
+}
+/** Fetch + decode one Mercurial SwapV2 pool, plus its two vaults' mints. Read-only against the loader. */
+export async function fetchMercurialPoolConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG}: pool account ${pool} not found`);
+    if (data.length !== SWAP_STATE_LEN) {
+        throw new Error(`${SLUG}: pool ${pool} data must be ${SWAP_STATE_LEN} bytes (SwapState), got ${data.length}`);
+    }
+    if (data[0] !== 2)
+        throw new Error(`${SLUG}: pool ${pool} is not SwapV2 (version tag ${data[0]})`);
+    if (data[1] !== 1)
+        throw new Error(`${SLUG}: pool ${pool} is not initialized`);
+    const tokensLen = Number(readUintLE(data, OFF_TOKENS_LEN, 4));
+    if (tokensLen !== 2) {
+        throw new Error(`${SLUG}: pool ${pool} has ${tokensLen} coin slots — only 2-coin pools are supported (see module header)`);
+    }
+    const nonce = data[OFF_NONCE];
+    const pubkey = getAddressDecoder();
+    const vaultA = pubkey.decode(data, OFF_VAULT_A);
+    const vaultB = pubkey.decode(data, OFF_VAULT_B);
+    const authority = await deriveMercurialAuthority(pool, nonce);
+    const [vaultAData, vaultBData] = await Promise.all([load(vaultA), load(vaultB)]);
+    if (vaultAData === null)
+        throw new Error(`${SLUG}: pool ${pool} vault A ${vaultA} not found`);
+    if (vaultBData === null)
+        throw new Error(`${SLUG}: pool ${pool} vault B ${vaultB} not found`);
+    if (vaultAData.length !== SPL_TOKEN_ACCOUNT_LEN) {
+        throw new Error(`${SLUG}: pool ${pool} vault A ${vaultA} is not a classic SPL token account`);
+    }
+    if (vaultBData.length !== SPL_TOKEN_ACCOUNT_LEN) {
+        throw new Error(`${SLUG}: pool ${pool} vault B ${vaultB} is not a classic SPL token account`);
+    }
+    const mintA = pubkey.decode(vaultAData, 0);
+    const mintB = pubkey.decode(vaultBData, 0);
+    // Mercurial's `Exchange` ix is legacy-SPL only (Tokenkeg vaults). SELF-DROP a
+    // Token-2022 mint (or one carrying an un-routable extension) by throwing — the
+    // SvmRoute orchestrator catches a fetchPoolConfig throw and drops the venue. An
+    // unreadable mint falls back to the legacy assumption (keeps existing tests green).
+    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("; ")}`);
+        }
+    }
+    const vaultAOwner = pubkey.decode(vaultAData, 32);
+    const vaultBOwner = pubkey.decode(vaultBData, 32);
+    if (vaultAOwner !== authority) {
+        throw new Error(`${SLUG}: pool ${pool} vault A owner ${vaultAOwner} does not match the derived authority ${authority}`);
+    }
+    if (vaultBOwner !== authority) {
+        throw new Error(`${SLUG}: pool ${pool} vault B owner ${vaultBOwner} does not match the derived authority ${authority}`);
+    }
+    return {
+        venue: SLUG,
+        pool,
+        direction: "aToB",
+        nonce,
+        authority,
+        vaultA,
+        vaultB,
+        mintA,
+        mintB,
+    };
+}
+/** Family facade for the recipe orchestrator (ladder-only, like orca-whirlpool/raydium-clmm/saber-stableswap). */
+export const mercurial = {
+    slug: SLUG,
+    programId: MERCURIAL_PROGRAM_ID,
+    tokenProgram: TOKEN_PROGRAM,
+    fetchPoolConfig: fetchMercurialPoolConfig,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/svm/venues/mercurial/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE/F,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE,MAAM,IAAI,GAAG,WAAW,CAAC;AAEzB,MAAM,CAAC,MAAM,oBAAoB,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAC3F,0EAA0E;AAC1E,MAAM,aAAa,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAE7E,4GAA4G;AAC5G,MAAM,cAAc,GAAG,GAAG,CAAC;AAC3B,kEAAkE;AAClE,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,8FAA8F;AAC9F,MAAM,SAAS,GAAG,CAAC,CAAC;AACpB,MAAM,cAAc,GAAG,EAAE,CAAC;AAC1B,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB,MAAM,WAAW,GAAG,GAAG,CAAC;AAYxB;;;;;;;GAOG;AACH,KAAK,UAAU,wBAAwB,CAAC,IAAa,EAAE,KAAa;IAClE,MAAM,OAAO,GAAG,iBAAiB,EAAE,CAAC;IACpC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC;SAChC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAe,CAAC;SAC1C,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;SAC5B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAe,CAAC;SAC1D,MAAM,CAAC,uBAAuB,CAAC;SAC/B,MAAM,EAAE,CAAC;IACZ,MAAM,SAAS,GAAG,iBAAiB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACrD,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,SAAS,IAAI,UAAU,KAAK,qCAAqC,CAAC,CAAC;IAC5F,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,0GAA0G;AAC1G,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,IAAmB,EACnB,IAAa;IAEb,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,IAAI,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,kBAAkB,IAAI,YAAY,CAAC,CAAC;IAC9E,IAAI,IAAI,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,UAAU,IAAI,iBAAiB,cAAc,2BAA2B,IAAI,CAAC,MAAM,EAAE,CAC7F,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,+BAA+B,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAClF,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,qBAAqB,CAAC,CAAC;IAE/E,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9D,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,UAAU,IAAI,QAAQ,SAAS,mEAAmE,CAC1G,CAAC;IACJ,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9B,MAAM,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAE9D,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACjF,IAAI,UAAU,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,YAAY,MAAM,YAAY,CAAC,CAAC;IAC9F,IAAI,UAAU,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,YAAY,MAAM,YAAY,CAAC,CAAC;IAC9F,IAAI,UAAU,CAAC,MAAM,KAAK,qBAAqB,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,YAAY,MAAM,qCAAqC,CAAC,CAAC;IAChG,CAAC;IACD,IAAI,UAAU,CAAC,MAAM,KAAK,qBAAqB,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,YAAY,MAAM,qCAAqC,CAAC,CAAC;IAChG,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAE3C,8EAA8E;IAC9E,+EAA+E;IAC/E,gFAAgF;IAChF,oFAAoF;IACpF,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9B,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACvE,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,UAAU,CAAC,EAAE,CAAE,CAAC;QACjC,IAAI,QAAQ,KAAK,IAAI;YAAE,SAAS;QAChC,IAAI,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,qBAAqB,EAAE,CAAC;YAClE,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,mBAAmB,IAAI,WAAW,IAAI,uDAAuD,CACrG,CAAC;QACJ,CAAC;QACD,MAAM,EAAE,QAAQ,EAAE,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,mBAAmB,IAAI,WAAW,IAAI,oBAAoB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACvF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAClD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,UAAU,IAAI,kBAAkB,WAAW,yCAAyC,SAAS,EAAE,CACvG,CAAC;IACJ,CAAC;IACD,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,UAAU,IAAI,kBAAkB,WAAW,yCAAyC,SAAS,EAAE,CACvG,CAAC;IACJ,CAAC;IAED,OAAO;QACL,KAAK,EAAE,IAAI;QACX,IAAI;QACJ,SAAS,EAAE,MAAM;QACjB,KAAK;QACL,SAAS;QACT,MAAM;QACN,MAAM;QACN,KAAK;QACL,KAAK;KACN,CAAC;AACJ,CAAC;AAED,kHAAkH;AAClH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,IAAI;IACV,SAAS,EAAE,oBAAoB;IAC/B,YAAY,EAAE,aAAa;IAC3B,eAAe,EAAE,wBAAwB;CAC1C,CAAC"}

package/sdk/dist/svm/venues/metadao-futarchy/index.d.ts

@@ -0,0 +1,34 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "metadao-futarchy";
+export declare const METADAO_FUTARCHY_PROGRAM_ID: Address<"FUTARELBfJfQ8RDGhg1wdhddq1odMAJUePHFuBYfUxKq">;
+/**
+ * PDA(["__event_authority"], METADAO_FUTARCHY_PROGRAM_ID) — Anchor's
+ * `#[event_cpi]` self-log signer, fixed for this program (independent of any
+ * pool). Computed via `getProgramDerivedAddress` and confirmed byte-for-byte
+ * against two real mainnet `spotSwap` transactions' account lists (see the
+ * file header).
+ */
+export declare const METADAO_FUTARCHY_EVENT_AUTHORITY: Address;
+export interface MetaDaoFutarchySpotPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'buy' (default, quote in -> base out, SwapType::Buy=0) | 'sell' (base in -> quote out, SwapType::Sell=1). */
+    direction: "buy" | "sell";
+    baseMint: Address;
+    quoteMint: Address;
+    ammBaseVault: Address;
+    ammQuoteVault: Address;
+    tokenProgram: Address;
+}
+/**
+ * Off-chain gate + decode: rejects the wrong account shape (size/discriminator),
+ * an active-proposal dao (PoolState::Futarchy — see the file header), and a
+ * drained side (Pool::swap requires both reserves nonzero). `pool` here is
+ * the Dao account address itself (the AMM lives embedded on it, not on a
+ * separate pool account).
+ */
+export declare function fetchMetaDaoFutarchySpotConfig(load: AccountLoader, pool: Address): Promise<MetaDaoFutarchySpotPoolConfig>;
+/** The COLD, venue-exact quote (see the file header's derivation). */
+export declare function metadaoFutarchySpotQuote(x: bigint, rin: bigint, rout: bigint): bigint;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/metadao-futarchy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/metadao-futarchy/index.ts"],"names":[],"mappings":"AAuEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI7D,QAAA,MAAM,IAAI,qBAAqB,CAAC;AAEhC,eAAO,MAAM,2BAA2B,EAAE,OAAO,CAAC,8CAA8C,CACvC,CAAC;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,EAAE,OAE9C,CAAC;AAkCF,MAAM,WAAW,6BAA8B,SAAQ,UAAU;IAC/D,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,gHAAgH;IAChH,SAAS,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;CACvB;AAMD;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,6BAA6B,CAAC,CA6DxC;AAED,sEAAsE;AACtE,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKrF"}

package/sdk/dist/svm/venues/metadao-futarchy/index.js

@@ -0,0 +1,185 @@
+/**
+ * MetaDAO Futarchy AMM — spot leg (SvmRoute ladder fragment).
+ *
+ * MetaDAO's `futarchy` program (fully open source,
+ * github.com/metaDAOproject/programs, `programs/futarchy/src/`) embeds a
+ * `FutarchyAmm` directly on each `Dao` account: `amm.state` is a `PoolState`
+ * enum, `Spot { spot: Pool }` (no proposal in flight — a plain two-reserve
+ * constant-product AMM) or `Futarchy { spot, pass, fail }` (an active
+ * proposal — three linked pools). This module wires ONLY the `Spot` variant
+ * (per the integration plan): a `spotSwap` against a `Futarchy`-state dao
+ * ALSO runs `arbitrage_after_spot_swap` — a 100-step off-chain-style search
+ * that rebalances spot against the conditional pass/fail markets
+ * (`programs/programs/futarchy/src/state/futarchy_amm.rs:60-83` at the
+ * `2d4ceb`-adjacent tree fetched 2026-07-31) — which this recipe does not
+ * model. Conditional (pass/fail) markets stay OUT of the universe until that
+ * leg lands; `fetchPoolConfig` below gates any `Futarchy`-state dao with a
+ * named error (self-drop, same shape as every other prepare-time gate in
+ * this recipe) rather than emitting a wrong quote for it.
+ *
+ * SAFE ON A LATE STATE FLIP (prepare fetched Spot, the dao transitions to
+ * Futarchy before the cook lands): `arbitrage_after_spot_swap`'s search only
+ * ever ACCEPTS a candidate that raises `best_profit` above 0
+ * (`state/futarchy_amm.rs:671-677`), so the real output is always
+ * `spot_output + arbitrage_result.spot_profit` with `spot_profit >= 0` — the
+ * plain two-reserve quote below is a FLOOR on the real fill, never an
+ * over-promise. `minOut` (the recipe's sole atomic bound) stays safe either
+ * way; no on-chain state-tag re-check is worth the extra codegen.
+ *
+ * QUOTE MATH (`Pool::swap`, `state/futarchy_amm.rs:495-546`): a protocol fee
+ * is taken off the input, then the REMAINDER runs a plain Uniswap-v1-style
+ * constant-product swap (LP_TAKER_FEE_BPS is 0 today, so the "LP fee" leg is
+ * an identity multiply that cancels exactly — see the derivation below):
+ *
+ *   netIn  = floor(x * (MAX_BPS - PROTOCOL_TAKER_FEE_BPS) / MAX_BPS)   [protocol fee]
+ *   out    = floor(netIn * reserveOut / (reserveIn + netIn))
+ *
+ * Full derivation of the collapse (`programs/futarchy/src/lib.rs:42-50` pins
+ * MAX_BPS=10_000, PROTOCOL_TAKER_FEE_BPS=50, LP_TAKER_FEE_BPS=0 — program-wide
+ * constants, not stored per-pool on chain, so this adapter bakes them at
+ * compile time like any other closed-source-equivalent constant; re-verify
+ * against the cited lines if MetaDAO ever redeploys with different fees):
+ * `input_amount_after_lp_fee = netIn * (MAX_BPS - LP_TAKER_FEE_BPS) = netIn *
+ * MAX_BPS` (exact, no floor, since the multiplier is a whole `MAX_BPS`);
+ * `numerator = input_amount_after_lp_fee * reserveOut = netIn * MAX_BPS *
+ * reserveOut`; `denominator = reserveIn * MAX_BPS + input_amount_after_lp_fee
+ * = MAX_BPS * (reserveIn + netIn)`. `MAX_BPS` divides numerator and
+ * denominator exactly, so `floor(numerator / denominator) === floor(netIn *
+ * reserveOut / (reserveIn + netIn))` bit-for-bit — the two-step Rust
+ * computation and the one-step form above always agree. Monotone
+ * non-decreasing and concave in `x` (a haircut constant-product is still a
+ * constant-product), so it cannot trigger the "coarse ladder gets allocated
+ * ZERO" failure mode.
+ *
+ * ACCOUNTS: `spotSwap`'s 9-account order (dao, userBaseAccount,
+ * userQuoteAccount, ammBaseVault, ammQuoteVault, user, tokenProgram,
+ * eventAuthority, program — `programs/futarchy/src/instructions/spot_swap.rs`)
+ * was cross-checked against two real mainnet transactions on two different
+ * Spot-state daos (signatures `3rJxfuQ...` and `4MtVuNv...`/`2NPHutC...`,
+ * fetched via a keyless `getTransaction`) — both matched this order exactly,
+ * INCLUDING `eventAuthority` (Anchor's `#[event_cpi]` self-log PDA,
+ * `["__event_authority"]` off the program id — computed once, pinned below,
+ * and matched byte-for-byte against both transactions' account lists).
+ *
+ * CPI CU: measured directly off those two real mainnet transactions' logs
+ * ("Program FUTARELB...consumed 40708 of..." on the flagship META/USDC dao,
+ * "...consumed 39309 of..." on the SoLo/USDC dao — both PoolState::Spot,
+ * both already including the nested `emit_cpi` self-log's own ~3634 CU) —
+ * see `the consuming app SVM CU-budget module`'s `CU_FAMILIES.metadao-futarchy` for how that
+ * folds into the pin.
+ */
+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 = "metadao-futarchy";
+export const METADAO_FUTARCHY_PROGRAM_ID = address("FUTARELBfJfQ8RDGhg1wdhddq1odMAJUePHFuBYfUxKq");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/**
+ * PDA(["__event_authority"], METADAO_FUTARCHY_PROGRAM_ID) — Anchor's
+ * `#[event_cpi]` self-log signer, fixed for this program (independent of any
+ * pool). Computed via `getProgramDerivedAddress` and confirmed byte-for-byte
+ * against two real mainnet `spotSwap` transactions' account lists (see the
+ * file header).
+ */
+export const METADAO_FUTARCHY_EVENT_AUTHORITY = address("DGEympSS4qLvdr9r3uGHTfACdN8snShk4iGdJtZPxuBC");
+/** sha256("account:Dao")[0:8] (Anchor account discriminator). */
+const DAO_DISCRIMINATOR = [0xa3, 0x09, 0x2f, 0x1f, 0x34, 0x55, 0xc5, 0x31];
+/**
+ * Fixed Dao account size REGARDLESS of PoolState variant (verified against
+ * 82 real mainnet dao accounts, 80 Spot-state + 2 Futarchy-state, all
+ * exactly 1205 bytes) — the account is pre-allocated at the `Futarchy`-sized
+ * worst case (`resizeDao` exists but a fresh dao already carries the max
+ * space), so `dataSize` alone is a safe, cheap gPA prune.
+ */
+const DAO_ACCOUNT_SIZE = 1205;
+const STATE_TAG_OFFSET = 8; // 8-byte disc, then the PoolState enum's 1-byte variant tag.
+const STATE_SPOT = 0; // PoolState::Spot { spot: Pool }
+const SPOT_POOL_OFFSET = 9; // Pool starts right after the 1-byte tag.
+// Pool { oracle: TwapOracle(100 bytes), quote_reserves: u64, base_reserves: u64,
+//        quote_protocol_fee_balance: u64, base_protocol_fee_balance: u64 } = 132 bytes.
+const SPOT_POOL_SIZE = 132;
+const QUOTE_RESERVES_OFFSET = SPOT_POOL_OFFSET + 100; // 109
+const BASE_RESERVES_OFFSET = QUOTE_RESERVES_OFFSET + 8; // 117
+// FutarchyAmm continues after PoolState: total_liquidity: u128 (16 bytes), then the four Pubkeys.
+const BASE_MINT_OFFSET = SPOT_POOL_OFFSET + SPOT_POOL_SIZE + 16; // 157
+const QUOTE_MINT_OFFSET = BASE_MINT_OFFSET + 32; // 189
+const AMM_BASE_VAULT_OFFSET = QUOTE_MINT_OFFSET + 32; // 221
+const AMM_QUOTE_VAULT_OFFSET = AMM_BASE_VAULT_OFFSET + 32; // 253
+// Program-wide fee constants (`programs/futarchy/src/lib.rs:42-50`) — NOT
+// stored per-pool on chain, so baked at compile time (see the file header's
+// derivation for why the LP-fee leg collapses to an identity at 0 bps today).
+const MAX_BPS = 10000n;
+const PROTOCOL_TAKER_FEE_BPS = 50n;
+const NET_FEE_NUM = MAX_BPS - PROTOCOL_TAKER_FEE_BPS; // 9_950n
+const codec = getAddressCodec();
+const pubkeyAt = (data, offset) => codec.decode(data.subarray(offset, offset + 32));
+/**
+ * Off-chain gate + decode: rejects the wrong account shape (size/discriminator),
+ * an active-proposal dao (PoolState::Futarchy — see the file header), and a
+ * drained side (Pool::swap requires both reserves nonzero). `pool` here is
+ * the Dao account address itself (the AMM lives embedded on it, not on a
+ * separate pool account).
+ */
+export async function fetchMetaDaoFutarchySpotConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG} dao ${pool} account not found`);
+    if (data.length !== DAO_ACCOUNT_SIZE) {
+        throw new Error(`${SLUG} dao ${pool} account is ${data.length} bytes, expected ${DAO_ACCOUNT_SIZE}`);
+    }
+    if (!DAO_DISCRIMINATOR.every((byte, i) => data[i] === byte)) {
+        throw new Error(`${SLUG} dao ${pool} is not a Dao account (discriminator mismatch)`);
+    }
+    const stateTag = data[STATE_TAG_OFFSET];
+    if (stateTag !== STATE_SPOT) {
+        throw new Error(`${SLUG} dao ${pool} has an active proposal (PoolState::Futarchy, tag ${stateTag}) — conditional markets are ` +
+            "not yet served by this adapter, only PoolState::Spot (see the consuming app metadao-futarchy venue module)");
+    }
+    const quoteReserves = readUintLE(data, QUOTE_RESERVES_OFFSET, 8);
+    const baseReserves = readUintLE(data, BASE_RESERVES_OFFSET, 8);
+    if (quoteReserves === 0n || baseReserves === 0n) {
+        throw new Error(`${SLUG} dao ${pool} has a zero-reserve side (quote=${quoteReserves}, base=${baseReserves}) — unquotable`);
+    }
+    const baseMint = pubkeyAt(data, BASE_MINT_OFFSET);
+    const quoteMint = pubkeyAt(data, QUOTE_MINT_OFFSET);
+    // `spotSwap` is legacy-SPL only (classic `token::transfer`). SELF-DROP a
+    // Token-2022 mint (or one carrying an un-routable extension) by throwing — the
+    // SvmRoute orchestrator catches a fetchPoolConfig throw and drops the venue. An
+    // unreadable mint falls back to the legacy assumption (keeps existing tests green).
+    const _mints = [baseMint, quoteMint];
+    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: "buy",
+        baseMint,
+        quoteMint,
+        ammBaseVault: pubkeyAt(data, AMM_BASE_VAULT_OFFSET),
+        ammQuoteVault: pubkeyAt(data, AMM_QUOTE_VAULT_OFFSET),
+        tokenProgram: TOKEN_PROGRAM,
+    };
+}
+/** The COLD, venue-exact quote (see the file header's derivation). */
+export function metadaoFutarchySpotQuote(x, rin, rout) {
+    if (x === 0n)
+        return 0n;
+    const netIn = (x * NET_FEE_NUM) / MAX_BPS;
+    if (netIn === 0n)
+        return 0n;
+    return (netIn * rout) / (rin + netIn);
+}
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/metadao-futarchy/index.js.map

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

package/sdk/dist/svm/venues/meteora-damm-v1-stable/index.d.ts

@@ -0,0 +1,35 @@
+import type { Address } from "@solana/kit";
+import type { PoolConfig, SvmVenueAdapter } from "../types.js";
+export interface MeteoraDammV1StablePoolConfig extends PoolConfig {
+    tokenAMint: Address;
+    tokenBMint: Address;
+    aVault: Address;
+    bVault: Address;
+    /** Pool-owned SPL token account holding vault A LP (also the pool authority PDA). */
+    aVaultLp: Address;
+    bVaultLp: Address;
+    /** Protocol-fee token account of the INPUT (A) side — swap account 11 for A->B. */
+    protocolTokenAFee: Address;
+    /** VaultA.token_vault — the vault's idle SPL float, swap account 5. */
+    aTokenVault: Address;
+    /** VaultB.token_vault — out-side idle float; bounds the quote (strict <). */
+    bTokenVault: Address;
+    /** VaultA.lp_mint read from vault offset 115 (NOT reliably the canonical PDA). */
+    aLpMint: Address;
+    bLpMint: Address;
+    tradeFeeNumerator: bigint;
+    tradeFeeDenominator: bigint;
+    protocolTradeFeeNumerator: bigint;
+    protocolTradeFeeDenominator: bigint;
+    /** Amplification coefficient, used directly (ann = amp * 2 inside the helpers). */
+    amp: bigint;
+    /** 10^(precision_factor - decimals); 1 for equal-decimal pairs. Immutable. */
+    tokenAMultiplier: bigint;
+    tokenBMultiplier: bigint;
+    /** Non-zero only for bootstrapping pools; unit selected by activationType. */
+    activationPoint: bigint;
+    /** 0 = slot, 1 = unix timestamp. */
+    activationType: number;
+}
+export declare const meteoraDammV1Stable: SvmVenueAdapter;
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/meteora-damm-v1-stable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/meteora-damm-v1-stable/index.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAGV,UAAU,EACV,eAAe,EAIhB,MAAM,aAAa,CAAC;AA2DrB,MAAM,WAAW,6BAA8B,SAAQ,UAAU;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,qFAAqF;IACrF,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,mFAAmF;IACnF,iBAAiB,EAAE,OAAO,CAAC;IAC3B,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC;IACrB,6EAA6E;IAC7E,WAAW,EAAE,OAAO,CAAC;IACrB,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yBAAyB,EAAE,MAAM,CAAC;IAClC,2BAA2B,EAAE,MAAM,CAAC;IACpC,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,8EAA8E;IAC9E,eAAe,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,cAAc,EAAE,MAAM,CAAC;CACxB;AAkHD,eAAO,MAAM,mBAAmB,EAAE,eAmTjC,CAAC"}