@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,306 @@
+/**
+ * Flint (aka "Flint Trade") venue adapter — a closed-source proprietary AMM
+ * ("prop AMM") on Solana, program `FLiNTXPwppyoJabCoxc2uiiRygAHpmMXajiDXo2Ub1z`.
+ * No on-chain Anchor IDL ships for this program, so everything below is
+ * recovered by transaction archaeology (`getSignaturesForAddress` +
+ * `getTransaction`, jsonParsed encoding) against a 4000-signature sample of
+ * REAL, LANDED mainnet transactions — the same method that produced
+ * bisonfi/humidifi/aquifer — cross-checked with our own `simulateTransaction`
+ * probes (`sigVerify:false`, the standard technique for probing a program
+ * without funds: the account-meta signer BIT drives execution without
+ * needing that key's real signature). Full derivation trail:
+ * `docs/flint-evidence.md`.
+ *
+ * ── Architecture: a HUB, not a per-pair pool ──
+ * Unlike every other family in this repo, Flint has NO per-pair pool account
+ * holding both mints. Instead, each of Flint's "market" accounts is a
+ * SINGLE-MINT inventory vault-owner (variable size across markets observed —
+ * 7728/9984/7388/9644/2368 bytes — so no fixed `dataSize` gPA filter exists
+ * either): confirmed via `getTokenAccountsByOwner` for 6 real markets —
+ * `35JazRP82XNsPLWL31Y3kwxYr3SABLufx9UnUJLnpkZz` -> USDT vault
+ * `67nP7KoBRgrM6uJgPwVjDsxeV132471AvtJABLhj6jq5`,
+ * `Dj9TPFLUsN9BmGMMC3GEbRb2Nuu3q5RMCQ7rzY8tg1Ww` -> USDC vault
+ * `EiyYcHeonaax5m3BaUK55GkjevQrueatjCDaUoUQ7FJU`,
+ * `BSDnuUchVVbadoc4ZDA4jPszHsH1WX4GMA9HVtKBq4bc` -> a Token-2022
+ * pump.fun-launched mint (`pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn`) vault
+ * `zh96VSSGmkGLHiKTFpEidDS4kdJuu5Yddric3cqcbyi`, plus wSOL/cbBTC/a long-tail
+ * SPL markets observed but NOT covered by this adapter (see "Scope" below).
+ * A single swap instruction debits one market's vault and credits another's —
+ * ANY two markets can pair, so there is no `SVM_FAMILY_FILTERS` memcmp
+ * geometry to write (no account embeds a counterparty mint at any offset).
+ * Discovery is therefore a small CURATED registry
+ * (`FLINT_PAIR_REGISTRY` below), wired via `withFlintStaticCandidates` in
+ * discovery.ts — the exact same shape `HUMIDIFI_POOL_REGISTRY` already
+ * established for a venue with no gPA geometry.
+ *
+ * ── Scope: 2 curated, REAL-evidence-backed pairs ──
+ * `resolveSvmPoolSpec` treats a pool's REVERSE direction as gated by
+ * `REVERSE_DIRECTION['flint']` in index.ts (set to `'BtoA'`); THIS module's
+ * own `applyDirection` decides, PER POOL, whether that reverse is actually
+ * supported (`entry.reversible`) — a pool that isn't simply throws, which
+ * `resolveSvmPoolSpec`'s catch turns into a silent drop (never a crash), the
+ * same shape as every other family's direction gate.
+ *   1. USDT <-> USDC (`pool` = the USDC market `Dj9TPFLUsN9BmGMMC3GEbRb2Nuu
+ *      3q5RMCQ7rzY8tg1Ww`) — ONE direction only (USDT->USDC, marketA->marketB
+ *      here). REAL evidence: 10 landed T1TAN-router legs across a 4000-sig
+ *      survey, sizes 1,134,870 to 17,703,755 raw USDT, EVERY one settling at
+ *      essentially the same ~99.91% rate (e.g. tx `2ZAZQRGzKGkusQQQQea6CFf2D
+ *      KLQSSoZkyKFvjCySdKNadJjfWcksZysMMD4ByLKZNa6xekZFEppWV8AUnJcjNur` moved
+ *      17,703,755 in / 17,687,395 out) — confirmed BOTH via the venue
+ *      vaults' own pre/post SPL balances AND via T1TAN's own per-leg log
+ *      event (disc `65ccefa2fc2edc8a`). The REVERSE (USDC->USDT) is NOT
+ *      shipped (`reversible: false`): a `simulateTransaction` probe reusing
+ *      the SAME disc/shape with marketA/marketB swapped failed
+ *      (`AccountLoaderError{context:"spot", err:"invalid discriminant"}`) —
+ *      unlike the pumpCmXq pair below, swapping this pair's roles is NOT a
+ *      same-shape operation, so shipping it would be a guess, not evidence.
+ *   2. pumpCmXq (Token-2022) <-> USDT (`pool` = the pumpCmXq market
+ *      `BSDnuUchVVbadoc4ZDA4jPszHsH1WX4GMA9HVtKBq4bc`) — BOTH directions,
+ *      REVERSIBLE (`reversible: true`), same disc/tailZeros either way. REAL
+ *      evidence: 5 landed pumpCmXq->USDT legs matched via T1TAN's own log
+ *      event (14,839,219 to 24,959,817 raw pumpCmXq in; e.g. tx
+ *      `5b2zhXvvXNGFai5gD3CYjYZMxR1DsBqThzFtV4j4vREoyKxApeiYrEYJTBX8u6JcB6jC
+ *      uEakb8izPAmYd1PqXDJL` moved 24,959,817 in / 53,342 raw USDT out; 4 of
+ *      the 5 additionally have a self-consistent pre-trade-reserve match and
+ *      ride in `test/svm/fixtures/flint-probes.json` — the 5th's
+ *      `preTokenBalances` lookup came back empty for unrelated reasons, see
+ *      `docs/flint-evidence.md`) PLUS 2 landed USDT->pumpCmXq legs (the
+ *      reverse direction, e.g. tx `4sRYkDt4nCdn6SH6L7ZZEgfJEUMJ9PRkGFbjX5oAC
+ *      8uTiR3soYJkpndhnLktn9ZUmoA2keVyHCYnDYpLbNVvuKdo` moved 1,699,349 raw
+ *      USDT in / 811,952,353 raw pumpCmXq out, both with a pre-trade-reserve
+ *      match) — the reverse leg's own inner-instruction dump was read
+ *      byte-for-byte to confirm the account order below holds with
+ *      marketA/marketB (and the ata/vault roles) simply swapped, same
+ *      disc=6/tailZeros=1, mint-account position unchanged (always the
+ *      Token-2022 mint, regardless of which role it plays).
+ * NOT shipped: the wSOL/cbBTC/long-tail markets we've also identified
+ * (`7AQ4LkrxUtk8iC1tyZiv5dzFFk68XUAa5qJjtuPuY8GN` /
+ * `DxYBaDH2BVzfpakAtpAopr9Z1m5DDG8cgXnPSkEGN8pY` — both also seen pairing
+ * with the pumpCmXq market in the same survey, same disc=6 shape) — a future
+ * slice can add them the same way once each is independently validated; this
+ * is a coverage gap, never a safety gap (this family self-drops on any
+ * fetch/gate failure — see `resolveSvmPoolSpec`'s catch — so a WRONG
+ * discriminator would simply drop the pool, never mis-execute, but shipping
+ * one without evidence defeats the point of this recovery method).
+ *
+ * ── Swap instruction (RE'd from 17+ real landed transactions across the two
+ *    pairs above, cross-referenced against T1TAN's own per-leg log event) ──
+ * `disc(1 byte) ++ amountIn(u64 LE, 8 bytes, PATCHED at runtime) ++
+ * tail(N zero bytes)`. `disc`/`N` are NOT a single global constant — they
+ * are stored per-registry-entry, exactly as chain-observed for THAT pair
+ * (11 total bytes for USDT<->USDC, 10 for pumpCmXq<->USDT, either
+ * direction); see `FLINT_PAIR_REGISTRY`.
+ *
+ * ── Accounts (11, or 12 when either mint is Token-2022 — FIXED order,
+ *    ground-truthed against real transactions, BOTH directions where
+ *    reversible) ──
+ *   0 authority   (signer)            — token-authority for BOTH the input
+ *                 debit and (via the market's own PDA-signed internal CPI)
+ *                 the output credit; `SwapUser.owner` in production.
+ *   1 Sysvar1nstructions (readonly)
+ *   2 marketIn    (writable)          — input-side market/state account
+ *   3 marketOut   (writable)          — output-side market/state account
+ *   4 traderAtaIn (writable)          — authority's input-mint token account
+ *   5 vaultIn     (writable)          — marketIn's own SPL vault (CREDITED)
+ *   6 traderAtaOut(writable)          — authority's output-mint token account
+ *   7 vaultOut    (writable)          — marketOut's own SPL vault (DEBITED)
+ *   [8 mint (readonly)]               — ONLY when one side is Token-2022
+ *                                        (needed for transferChecked); the
+ *                                        Token-2022 side's own mint —
+ *                                        UNCHANGED by direction (it is
+ *                                        always the same physical mint,
+ *                                        regardless of which role it plays).
+ *   8/9 tokenProgramIn  (readonly)
+ *   9/10 tokenProgramOut (readonly)
+ *   10/11 FLINT program itself (readonly) — Flint lists its own program id as
+ *                 a trailing account (used internally for a ~98 CU self-CPI
+ *                 bookkeeping call after the transfers — entirely INTERNAL to
+ *                 Flint's own logic; the caller never constructs that self-CPI).
+ *
+ * ── Quote curve — HONEST LIMITATION (same shape as bisonfi/humidifi) ──
+ * Flint's real price is NOT a plain fixed-point scalar anywhere in either
+ * market account's ~2-10KB of data (an oracle-crank keeper wallet posts
+ * price/inventory updates roughly every 10-20 seconds via a SEPARATE,
+ * distinctly-shaped instruction — disc=0, a repeating 24-byte-per-market
+ * record — but the record's internal fields did not resolve to a plain
+ * price scalar in the time available; see the evidence doc). What IS
+ * live-readable and unobfuscated is each market's own vault's SPL `amount`
+ * (standard offset 64). This ladder therefore quotes a virtual
+ * constant-product curve over the two vaults' live balances, with an
+ * ADDITIONAL haircut on top — but UNLIKE bisonfi/humidifi, naive CP over
+ * the vaults' OWN reserves is NOT reliably conservative here: re-fetching
+ * each of the 16 usable real fills' EXACT pre-trade vault balances (not a
+ * single later "current" snapshot — Flint's thin vaults drift by 10s of %
+ * within minutes, which a frozen snapshot badly aliases; see
+ * `docs/flint-evidence.md`) shows naive CP (no haircut) slightly EXCEEDING
+ * the real output for one USDT->USDC fill (ratio 1.0152) and MATERIALLY
+ * exceeding it for both observed USDT->pumpCmXq (reverse) fills (ratio
+ * 2.35-3.36x over) — a structural consequence of that direction dividing by
+ * the THIN USDT reserve while the pumpCmXq reserve is ~1000x larger, not a
+ * measurement fluke. The haircut is therefore PER DIRECTION, sized to the
+ * worst real ratio observed for that direction plus a comfortable margin,
+ * not one global constant:
+ *   - USDT->USDC (`FLINT_HAIRCUT_USDT_USDC_PPM`): worst real naive-CP ratio
+ *     1.0152 (10 fills) -> 700,000 ppm (0.7 x 1.0152 = 0.711, comfortably
+ *     under 1).
+ *   - pumpCmXq->USDT, the AtoB default for that pool
+ *     (`FLINT_HAIRCUT_PUMPCMXQ_TO_USDT_PPM`): worst real naive-CP ratio
+ *     0.5249 (4 fills) -> 900,000 ppm (0.9 x 0.5249 = 0.472).
+ *   - USDT->pumpCmXq, the BtoA reverse (`FLINT_HAIRCUT_USDT_TO_PUMPCMXQ_PPM`):
+ *     worst real naive-CP ratio 3.3597 (only 2 fills — a THIN evidence base,
+ *     so this margin is deliberately much larger than the ratio alone would
+ *     require) -> 150,000 ppm (0.15 x 3.3597 = 0.504).
+ * Safe for election (a worse model never wins a share it doesn't deserve)
+ * and trivially monotone/concave (a plain x/(r+x) curve, scaled by a
+ * constant fraction, for any fixed positive scale). The real Flint CPI
+ * still delivers its own authoritative output at cook time — this quote
+ * only shapes off-chain ranking and the on-chain slot's own
+ * predicted-output bookkeeping, never the real transfer.
+ *
+ * ── CU (measured 2026-08-01, REAL mainnet transaction logs — the "consumed
+ *    X of Y compute units" line for Flint's own invoke, across BOTH shipped
+ *    pairs and both directions) ──
+ * pumpCmXq<->USDT (12 accounts, Token-2022 side): 12,201-17,963 CU per real
+ * landed leg (7 samples, both directions). USDT->USDC (11 accounts, both
+ * classic SPL): 12,201 CU per real landed leg. Both are markedly CHEAPER
+ * than every other pinned family in `budget.ts` (the next-cheapest CP
+ * family, raydium-amm-v4, is 163k+62k). `CU_FAMILIES.flint` is pinned
+ * generously above the observed ceiling (see that file) — these are REAL
+ * total-instruction measurements (not a stand-in harness), so unlike the
+ * "omits the venue CPI" gap flagged for the original 12 pins, this pin's
+ * `slot` term already reflects the real end-to-end cost; no local engine.so
+ * re-measurement was available in this session to further split slot/rung,
+ * so the split is conservative (see budget.ts's comment) — re-pin with
+ * ECO_SVM_CU_PRINT=1 once one is.
+ */
+import { address } from "@solana/kit";
+const SLUG = "flint";
+export const FLINT_PROGRAM_ID = address("FLiNTXPwppyoJabCoxc2uiiRygAHpmMXajiDXo2Ub1z");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+/**
+ * Per-direction haircut applied ON TOP OF naive constant-product (ppm of
+ * 1_000_000) — see the file header "Quote curve" section for the exact real
+ * fill data and margin behind each of these three constants. Naive CP alone
+ * is NOT reliably conservative for this venue (unlike bisonfi/humidifi), so
+ * there is no single global constant.
+ */
+export const FLINT_HAIRCUT_USDT_USDC_PPM = 700000n;
+export const FLINT_HAIRCUT_PUMPCMXQ_TO_USDT_PPM = 900000n;
+export const FLINT_HAIRCUT_USDT_TO_PUMPCMXQ_PPM = 150000n;
+const USDT_MINT = address("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB");
+const USDC_MINT = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+const PUMPCMXQ_MINT = address("pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn");
+const USDT_MARKET = address("35JazRP82XNsPLWL31Y3kwxYr3SABLufx9UnUJLnpkZz");
+const USDT_VAULT = address("67nP7KoBRgrM6uJgPwVjDsxeV132471AvtJABLhj6jq5");
+const USDC_MARKET = address("Dj9TPFLUsN9BmGMMC3GEbRb2Nuu3q5RMCQ7rzY8tg1Ww");
+const USDC_VAULT = address("EiyYcHeonaax5m3BaUK55GkjevQrueatjCDaUoUQ7FJU");
+const PUMPCMXQ_MARKET = address("BSDnuUchVVbadoc4ZDA4jPszHsH1WX4GMA9HVtKBq4bc");
+const PUMPCMXQ_VAULT = address("zh96VSSGmkGLHiKTFpEidDS4kdJuu5Yddric3cqcbyi");
+/**
+ * Curated registry, keyed by the "pool" address this family is discovered
+ * under — the NON-USDT side of each pair (USDT is the common factor in both
+ * shipped pairs today). See file header "Scope" for the evidence backing
+ * each entry and each entry's reversibility.
+ */
+export const FLINT_PAIR_REGISTRY = {
+    [USDC_MARKET]: {
+        marketA: USDT_MARKET,
+        vaultA: USDT_VAULT,
+        mintA: USDT_MINT,
+        tokenProgramA: TOKEN_PROGRAM,
+        marketB: USDC_MARKET,
+        vaultB: USDC_VAULT,
+        mintB: USDC_MINT,
+        tokenProgramB: TOKEN_PROGRAM,
+        disc: 11,
+        tailZeros: 2,
+        reversible: false,
+        haircutAtoBPpm: FLINT_HAIRCUT_USDT_USDC_PPM,
+    },
+    [PUMPCMXQ_MARKET]: {
+        marketA: PUMPCMXQ_MARKET,
+        vaultA: PUMPCMXQ_VAULT,
+        mintA: PUMPCMXQ_MINT,
+        tokenProgramA: TOKEN_2022_PROGRAM,
+        marketB: USDT_MARKET,
+        vaultB: USDT_VAULT,
+        mintB: USDT_MINT,
+        tokenProgramB: TOKEN_PROGRAM,
+        disc: 6,
+        tailZeros: 1,
+        checkedMint: PUMPCMXQ_MINT,
+        reversible: true,
+        haircutAtoBPpm: FLINT_HAIRCUT_PUMPCMXQ_TO_USDT_PPM,
+        haircutBtoAPpm: FLINT_HAIRCUT_USDT_TO_PUMPCMXQ_PPM,
+    },
+};
+function flintConfig(cfg) {
+    if (cfg.venue !== SLUG)
+        throw new Error(`${SLUG} ladder adapter got a '${cfg.venue}' pool config`);
+    return cfg;
+}
+/** The directed (in, out) roles for a config, resolving its `direction` against its `entry`. */
+function directed(cfg) {
+    const e = cfg.entry;
+    return cfg.direction === "BtoA"
+        ? {
+            marketIn: e.marketB,
+            vaultIn: e.vaultB,
+            mintIn: e.mintB,
+            tokenProgramIn: e.tokenProgramB,
+            marketOut: e.marketA,
+            vaultOut: e.vaultA,
+            mintOut: e.mintA,
+            tokenProgramOut: e.tokenProgramA,
+        }
+        : {
+            marketIn: e.marketA,
+            vaultIn: e.vaultA,
+            mintIn: e.mintA,
+            tokenProgramIn: e.tokenProgramA,
+            marketOut: e.marketB,
+            vaultOut: e.vaultB,
+            mintOut: e.mintB,
+            tokenProgramOut: e.tokenProgramB,
+        };
+}
+async function fetchPoolConfig(load, pool) {
+    // Per-side token programs are threaded from the curated registry (tokenProgramA/
+    // tokenProgramB), each real-evidence-confirmed per pair — the Token-2022 side
+    // (pumpCmXq) carries TOKEN_2022_PROGRAM and its own `checkedMint` for the swap
+    // ix's transferChecked. Opposite sides differ (pumpCmXq is Token-2022, its USDT
+    // counterparty is legacy), which the registry captures explicitly.
+    // TODO(t22-fee-netting): the curated pumpCmXq (Token-2022) mint is NOT
+    // transfer-fee-netted here. Flint's quote is a per-direction constant-product
+    // haircut over live vault balances (see the "Quote curve" header) sized to the
+    // WORST observed real-fill ratio plus a large margin, so any small wire fee is
+    // already absorbed conservatively; and there is no referenceQuote in this
+    // fetch-only adapter to net a fee on. If a curated pair's Token-2022 side is
+    // ever found to carry a material effective fee, net it in the consuming app's
+    // Flint quote fragment rather than here — a missed netting is a safe self-limit.
+    const entry = FLINT_PAIR_REGISTRY[pool];
+    if (entry === undefined) {
+        throw new Error(`${SLUG}: ${pool} is not a curated pair (see FLINT_PAIR_REGISTRY)`);
+    }
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG} market ${pool} account not found`);
+    return { venue: SLUG, pool, entry, direction: "AtoB" };
+}
+function quoteAccounts(base) {
+    const cfg = flintConfig(base);
+    const d = directed(cfg);
+    return [
+        { ref: `${cfg.pool}:vaultIn`, address: d.vaultIn },
+        { ref: `${cfg.pool}:vaultOut`, address: d.vaultOut },
+    ];
+}
+export const flint = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: FLINT_PROGRAM_ID,
+    fetchPoolConfig,
+    quoteAccounts,
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/svm/venues/flint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8KG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAItC,MAAM,IAAI,GAAG,OAAO,CAAC;AACrB,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AACvF,MAAM,aAAa,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAC7E,MAAM,kBAAkB,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,OAAQ,CAAC;AACpD,MAAM,CAAC,MAAM,kCAAkC,GAAG,OAAQ,CAAC;AAC3D,MAAM,CAAC,MAAM,kCAAkC,GAAG,OAAQ,CAAC;AAE3D,MAAM,SAAS,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC1E,MAAM,SAAS,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC1E,MAAM,aAAa,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAE7E,MAAM,WAAW,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC5E,MAAM,UAAU,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC3E,MAAM,WAAW,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC5E,MAAM,UAAU,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAC3E,MAAM,eAAe,GAAG,OAAO,CAAC,8CAA8C,CAAC,CAAC;AAChF,MAAM,cAAc,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AA0B9E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAmC;IACjE,CAAC,WAAqB,CAAC,EAAE;QACvB,OAAO,EAAE,WAAW;QACpB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,SAAS;QAChB,aAAa,EAAE,aAAa;QAC5B,OAAO,EAAE,WAAW;QACpB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,SAAS;QAChB,aAAa,EAAE,aAAa;QAC5B,IAAI,EAAE,EAAE;QACR,SAAS,EAAE,CAAC;QACZ,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,2BAA2B;KAC5C;IACD,CAAC,eAAyB,CAAC,EAAE;QAC3B,OAAO,EAAE,eAAe;QACxB,MAAM,EAAE,cAAc;QACtB,KAAK,EAAE,aAAa;QACpB,aAAa,EAAE,kBAAkB;QACjC,OAAO,EAAE,WAAW;QACpB,MAAM,EAAE,UAAU;QAClB,KAAK,EAAE,SAAS;QAChB,aAAa,EAAE,aAAa;QAC5B,IAAI,EAAE,CAAC;QACP,SAAS,EAAE,CAAC;QACZ,WAAW,EAAE,aAAa;QAC1B,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,kCAAkC;QAClD,cAAc,EAAE,kCAAkC;KACnD;CACF,CAAC;AASF,SAAS,WAAW,CAAC,GAAe;IAClC,IAAI,GAAG,CAAC,KAAK,KAAK,IAAI;QACpB,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,0BAA0B,GAAG,CAAC,KAAK,eAAe,CAAC,CAAC;IAC7E,OAAO,GAAsB,CAAC;AAChC,CAAC;AAED,gGAAgG;AAChG,SAAS,QAAQ,CAAC,GAAoB;IACpC,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC;IACpB,OAAO,GAAG,CAAC,SAAS,KAAK,MAAM;QAC7B,CAAC,CAAC;YACE,QAAQ,EAAE,CAAC,CAAC,OAAO;YACnB,OAAO,EAAE,CAAC,CAAC,MAAM;YACjB,MAAM,EAAE,CAAC,CAAC,KAAK;YACf,cAAc,EAAE,CAAC,CAAC,aAAa;YAC/B,SAAS,EAAE,CAAC,CAAC,OAAO;YACpB,QAAQ,EAAE,CAAC,CAAC,MAAM;YAClB,OAAO,EAAE,CAAC,CAAC,KAAK;YAChB,eAAe,EAAE,CAAC,CAAC,aAAa;SACjC;QACH,CAAC,CAAC;YACE,QAAQ,EAAE,CAAC,CAAC,OAAO;YACnB,OAAO,EAAE,CAAC,CAAC,MAAM;YACjB,MAAM,EAAE,CAAC,CAAC,KAAK;YACf,cAAc,EAAE,CAAC,CAAC,aAAa;YAC/B,SAAS,EAAE,CAAC,CAAC,OAAO;YACpB,QAAQ,EAAE,CAAC,CAAC,MAAM;YAClB,OAAO,EAAE,CAAC,CAAC,KAAK;YAChB,eAAe,EAAE,CAAC,CAAC,aAAa;SACjC,CAAC;AACR,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,IAAmB,EAAE,IAAa;IAC/D,iFAAiF;IACjF,8EAA8E;IAC9E,+EAA+E;IAC/E,gFAAgF;IAChF,mEAAmE;IACnE,uEAAuE;IACvE,8EAA8E;IAC9E,+EAA+E;IAC/E,+EAA+E;IAC/E,0EAA0E;IAC1E,6EAA6E;IAC7E,8EAA8E;IAC9E,iFAAiF;IACjF,MAAM,KAAK,GAAG,mBAAmB,CAAC,IAAc,CAAC,CAAC;IAClD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,IAAI,kDAAkD,CAAC,CAAC;IACtF,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,IAAI,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,WAAW,IAAI,oBAAoB,CAAC,CAAC;IAC/E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AACzD,CAAC;AAED,SAAS,aAAa,CAAC,IAAgB;IACrC,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9B,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IACxB,OAAO;QACL,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC,IAAI,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;QAClD,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;KACrD,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,IAAI;IACV,IAAI,EAAE,kBAA2B;IACjC,SAAS,EAAE,gBAAgB;IAC3B,eAAe;IACf,aAAa;CACd,CAAC"}

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

@@ -0,0 +1,47 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "fluxbeam";
+export declare const FLUXBEAM_PROGRAM_ID: Address<"FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X">;
+/** `SwapVersion::pack` = 1-byte version tag + the 323-byte `SwapV1` body. */
+export declare const FLUXBEAM_POOL_SIZE = 324;
+export interface FluxBeamFeeTier {
+    epoch: bigint;
+    max: bigint;
+    bps: bigint;
+}
+export interface FluxBeamPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    swapAuthority: Address;
+    tokenProgramPool: Address;
+    vaultA: Address;
+    vaultB: Address;
+    poolMint: Address;
+    mintA: Address;
+    mintB: Address;
+    poolFeeAccount: Address;
+    tokenProgramA: Address;
+    tokenProgramB: Address;
+    tradeFeeNumerator: bigint;
+    tradeFeeDenominator: bigint;
+    ownerTradeFeeNumerator: bigint;
+    ownerTradeFeeDenominator: bigint;
+    /** Wire (Token-2022) transfer fee on the mintA leg — {0n,0n} when classic or fee-less. */
+    feeA: {
+        bps: bigint;
+        max: bigint;
+    };
+    /** Wire (Token-2022) transfer fee on the mintB leg — {0n,0n} when classic or fee-less. */
+    feeB: {
+        bps: bigint;
+        max: bigint;
+    };
+}
+export declare function fetchFluxBeamPoolConfig(load: AccountLoader, pool: Address): Promise<FluxBeamPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only, like orca-legacy-token-swap). */
+export declare const fluxbeam: {
+    slug: string;
+    programId: Address<"FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X">;
+    fetchPoolConfig: typeof fetchFluxBeamPoolConfig;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/fluxbeam/index.ts"],"names":[],"mappings":"AA2GA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,QAAA,MAAM,IAAI,aAAa,CAAC;AACxB,eAAO,MAAM,mBAAmB,yDAA0D,CAAC;AAK3F,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAyBtC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAUD,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wBAAwB,EAAE,MAAM,CAAC;IACjC,0FAA0F;IAC1F,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,0FAA0F;IAC1F,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAgFD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,kBAAkB,CAAC,CA8E7B;AAED,4FAA4F;AAC5F,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

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

@@ -0,0 +1,284 @@
+/**
+ * FluxBeam (program `FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X`) — a
+ * permissionless constant-product AMM factory, Token-2022-capable on both
+ * legs. Byte layout is IDENTICAL to spl-token-swap's `SwapV1` (the same
+ * 324-byte, no-discriminator `SwapVersion::pack` shape `orca-legacy-token-swap`
+ * already decodes — `version(1)+is_initialized(1)+bump_seed(1)+token_program(32)
+ * +token_a(32)+token_b(32)+pool_mint(32)+token_a_mint(32)+token_b_mint(32)
+ * +pool_fee_account(32)+Fees(8×u64=64)+SwapCurve(curve_type u8 + 32-byte
+ * calculator)`), CONFIRMED byte-for-byte against two real mainnet pools:
+ *   - `CZEZDGDkzsn4zTfdw6XRm4U1o6GatotMhhRmVEzdwGS3` (SOL/USDC, curve_type 0,
+ *     trade_fee 20/1000, owner_trade_fee 5/1000, classic Tokenkeg legs) —
+ *     this repo's off-chain quote matched Jupiter's own `dexes=FluxBeam`
+ *     single-venue quote BIT-EXACT at 0.1/1/5 SOL.
+ *   - `M6N5wxWzSjwpPzH1F7YMNfGxHDfuM88Ey7KAruAxn5N` (a Token-2022
+ *     TransferFeeConfig mint `BHHyGwamPG2sihrP4qTs6c5T88DB65oqoBpTQc8kdPS7` /
+ *     SOL, bps=200 i.e. 2%, maximumFee effectively unreachable) — the wire
+ *     transfer-fee model below (see `qFluxBeam`) is what makes this repo's
+ *     quote match the real program's realized output on that pool; without
+ *     it the quote overshoots by exactly the 2% wire fee the vault never
+ *     actually receives. Jupiter itself refuses to quote this specific mint
+ *     (`TOKEN_NOT_TRADABLE`, a risk-list policy, not a math question), so the
+ *     cross-check for THIS pool is the real-CPI LiteSVM lane
+ *     (test/svm/venues/fluxbeam.test.ts + the realcpi e2e cell), not Jupiter.
+ *
+ * REAL-CPI PROOF (the consuming app realcpi e2e test's `fluxbeam` cells, SAUCE_VENUE_PROGRAMS-
+ * gated): the actual mainnet `fluxbeam.so` binary, executed via LiteSVM on the two real pools above
+ * through the full production `svmRoute` compile path, realizes OUTPUT bit-exact to this ladder's
+ * predicted quote on BOTH pools (71_656_795 at 1 SOL classic; 197 at ~1.95e9 raw wire-fee-mint
+ * input) — the load-bearing invariant `minOut` enforces. DISCLOSED, MEASURED, and NOT a quoting
+ * error: the real binary's own internal transfer sizing pulls a few raw units LESS than the
+ * instructed `amount_in` from the user's account on BOTH pools (6 units on the classic pool with no
+ * fee involved at all; ~0.49% on the wire-fee pool) — the un-pulled remainder simply stays in the
+ * user's own account (never lost, never double-counted), and OUTPUT is unaffected either way; see
+ * that test file's `expectedDebit` param and its cell-level comments for the exact pinned numbers.
+ *
+ * The Clock sysvar (`SysvarC1ock11111111111111111111111111111111`, epoch @ offset 16) is read
+ * OFF-CHAIN, lazily, only when a leg mint carries a TransferFeeConfig extension — never checked in
+ * as a fixture file: a real dump of this widely-shared sysvar address, loaded into a harness that
+ * pins its OWN clock (every jest engine harness in this repo does, via `startEngine`), silently
+ * overwrote that pin and broke an UNRELATED family's time-dependent measurement (meteora-dlmm's
+ * dynamic fee) the one time this was tried — see the git history of
+ * the consuming app cu e2e test and test/svm/venues/fluxbeam.test.ts for the concrete lesson:
+ * synthesize sysvar/canonical-mint bytes in-memory in tests instead of dumping them to disk.
+ *
+ * The stored `token_program` field (offset 3) is NOT a per-leg signal — on
+ * BOTH sampled pools it reads the Token-2022 program even though the SOL/USDC
+ * pool's actual leg mints are classic Tokenkeg. FluxBeam always mints its LP
+ * token (`pool_mint`) under Token-2022 regardless of what the trade legs use,
+ * and that field is for the pool_mint/pool_fee_account CPIs only (accounts 7/8
+ * below) — the real per-leg token programs (accounts 11/12) were recovered by
+ * decoding a live inner CPI instruction (see the swap-account-order note on
+ * `buildSwapV2`), not from any pool-stored field.
+ *
+ * DIRECTION: AtoB ONLY (mintA in, mintB out) — the SAME scope limitation this
+ * repo already accepts for `orca-legacy-token-swap`. Every real swap sampled
+ * on `CZEZDGDkzsn4zTfdw6XRm4U1o6GatotMhhRmVEzdwGS3` traded SOL(A)->USDC(B); no
+ * live B->A instance was found to confirm whether the trailing mint/
+ * token-program accounts (9-13) reorder for the reverse direction (unlike
+ * accounts 4/5, whose swap does flip which vault is `swap_source` per
+ * spl-token-swap convention) — FluxBeam's own program is closed-source, so
+ * guessing that order for a real swap CPI risks a wrong-program transfer
+ * rather than a clean revert. Both mint orderings are still discovered
+ * (`SVM_FAMILY_FILTERS` queries both), so a pool is simply dropped when the
+ * requested pair is the reverse of its stored A/B order — exactly like
+ * orca-legacy-token-swap today.
+ *
+ * TOKEN-2022 MINT DETECTION: `AccountLoader` returns only account BYTES (no
+ * owner), and unlike raydium-cp-swap's `PoolState` (which stores each leg's
+ * owning program explicitly, added specifically for Token-2022 support),
+ * FluxBeam's pool account carries no per-leg program field at all. The
+ * classic Tokenkeg program's `Mint::unpack` requires EXACTLY 82 bytes — it
+ * cannot create or read an account of any other length — so any mint account
+ * longer than 82 bytes MUST be owned by Token-2022 (that program is the only
+ * one supporting the longer, extension-carrying layout); `scanMint` uses this
+ * as a SOUND (not merely heuristic) direction. The one residual gap runs the
+ * other way: a Token-2022 mint deployed with ZERO extensions is also exactly
+ * 82 bytes and is indistinguishable from a classic mint by data alone, so it
+ * would be mis-tagged Tokenkeg here. This is a disclosed, narrow residual —
+ * no extension means no different transfer behavior either way except the
+ * CPI's target program id, and a bare-extensionless Token-2022 mint actively
+ * trading on a permissionless AMM is vanishingly unlikely (the entire reason
+ * to mint under Token-2022 over classic is to use an extension) — a
+ * misclassification there fails the swap CPI loudly (wrong owning program),
+ * never silently mis-quotes.
+ *
+ * TRANSFER-FEE TIER SELECTION: a Token-2022 `TransferFeeConfig` extension
+ * carries an `older`/`newer` double-buffered fee (the newer only takes effect
+ * once the cluster's epoch reaches `newer.epoch`, so an authority's fee change
+ * cannot apply retroactively mid-epoch). `fetchPoolConfig` resolves the
+ * ACTIVE tier at fetch time by reading the live Clock sysvar
+ * (`SysvarC1ock11111111111111111111111111111111`, epoch @ offset 16) — fetched
+ * lazily, only when a leg mint actually carries the extension — and bakes the
+ * resolved bps/maximumFee as compile-time params, the SAME treatment this
+ * repo already gives `orca-legacy-token-swap`'s (also nominally admin-settable
+ * but never re-read live) trade/owner fee numerators. A fee bumped between
+ * fetch and cook is the same class of drift every venue's quote already has
+ * relative to live execution, backstopped by `minOut` — not a new gap.
+ *
+ * A TransferHook (ExtensionType 14) or NonTransferable (ExtensionType 9)
+ * extension on either leg self-drops the WHOLE pool (`fetchPoolConfig`
+ * throws): a hook can run arbitrary logic requiring extra accounts this
+ * adapter does not attach, and a non-transferable mint cannot be swapped at
+ * all — both are the venue-robustness "one bad pool never kills a cook"
+ * self-drop class already used throughout this recipe.
+ */
+import { createHash } from "node:crypto";
+import { address, getAddressCodec } from "@solana/kit";
+import { readUintLE } from "../math.js";
+const SLUG = "fluxbeam";
+export const FLUXBEAM_PROGRAM_ID = address("FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X");
+const TOKENKEG_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+const CLOCK_SYSVAR = address("SysvarC1ock11111111111111111111111111111111");
+/** `SwapVersion::pack` = 1-byte version tag + the 323-byte `SwapV1` body. */
+export const FLUXBEAM_POOL_SIZE = 324;
+// SwapV1 offsets (identical to orca-legacy-token-swap's — same upstream spl-token-swap layout).
+const OFF_VERSION = 0;
+const OFF_IS_INITIALIZED = 1;
+const OFF_BUMP_SEED = 2;
+const OFF_TOKEN_PROGRAM_POOL = 3;
+const OFF_VAULT_A = 35;
+const OFF_VAULT_B = 67;
+const OFF_POOL_MINT = 99;
+const OFF_MINT_A = 131;
+const OFF_MINT_B = 163;
+const OFF_POOL_FEE_ACCOUNT = 195;
+const OFF_TRADE_FEE_NUMERATOR = 227;
+const OFF_TRADE_FEE_DENOMINATOR = 235;
+const OFF_OWNER_TRADE_FEE_NUMERATOR = 243;
+const OFF_OWNER_TRADE_FEE_DENOMINATOR = 251;
+const OFF_CURVE_TYPE = 291;
+/** ExtensionType ordinals this adapter cares about (spl-token-2022's `extension::ExtensionType`). */
+const EXT_TRANSFER_FEE_CONFIG = 1;
+const EXT_NON_TRANSFERABLE = 9;
+const EXT_TRANSFER_HOOK = 14;
+/** Base SPL account size Token-2022 pads to before the account-type + TLV tail. */
+const TOKEN_2022_BASE_LEN = 165;
+function getAddressEncoded(value) {
+    return new Uint8Array(getAddressCodec().encode(value));
+}
+/**
+ * `create_program_address([pool, bump_seed], program_id)` — the same
+ * off-curve PDA scheme spl-token-swap forks use for the swap authority,
+ * verified against the REAL authority of both sampled mainnet pools
+ * (`Fv9Yjbk4BXV4nwdP3xKaRT3xiSUKTojsKgqSgwvjujLK` for
+ * `CZEZDGDkzsn4zTfdw6XRm4U1o6GatotMhhRmVEzdwGS3`, bump 255).
+ */
+function deriveSwapAuthority(pool, bumpSeed) {
+    const codec = getAddressCodec();
+    return codec.decode(createHash("sha256")
+        .update(getAddressEncoded(pool))
+        .update(Uint8Array.of(bumpSeed))
+        .update(getAddressEncoded(FLUXBEAM_PROGRAM_ID))
+        .update("ProgramDerivedAddress")
+        .digest());
+}
+/**
+ * Decodes one leg's mint: the owning token program (SOUND for >82 bytes — see
+ * the file header) plus its TransferFeeConfig tiers, if any. Throws on a
+ * TransferHook/NonTransferable extension (unsupported — self-drops the pool).
+ */
+function scanMint(mint, data) {
+    if (data.length < 82) {
+        throw new Error(`fluxbeam: mint ${mint} is ${data.length} bytes, too short to be an SPL mint`);
+    }
+    if (data.length === 82)
+        return { tokenProgram: TOKENKEG_PROGRAM, tiers: null };
+    // > 82 bytes is possible ONLY under Token-2022 (Tokenkeg's Mint::unpack requires exactly 82).
+    if (data.length <= TOKEN_2022_BASE_LEN || data[TOKEN_2022_BASE_LEN] !== 1) {
+        // Extended allocation with no parseable extension tail (or an account-type byte other than
+        // Mint=1, which should not happen for a real mint) — no fee we can see either way.
+        return { tokenProgram: TOKEN_2022_PROGRAM, tiers: null };
+    }
+    let offset = TOKEN_2022_BASE_LEN + 1;
+    let tiers = null;
+    while (offset + 4 <= data.length) {
+        const type = Number(readUintLE(data, offset, 2));
+        if (type === 0)
+            break; // Uninitialized — trailing padding
+        const length = Number(readUintLE(data, offset + 2, 2));
+        const value = offset + 4;
+        if (type === EXT_TRANSFER_HOOK) {
+            throw new Error(`fluxbeam: mint ${mint} carries a TransferHook extension (unsupported — cannot safely CPI without the hook's extra accounts)`);
+        }
+        if (type === EXT_NON_TRANSFERABLE) {
+            throw new Error(`fluxbeam: mint ${mint} is NonTransferable (cannot be swapped)`);
+        }
+        if (type === EXT_TRANSFER_FEE_CONFIG) {
+            // TransferFeeConfig (108 bytes): authority(32)+withdrawAuthority(32)+withheldAmount(8)+
+            // older{epoch(8),maximumFee(8),bps(2)}+newer{epoch(8),maximumFee(8),bps(2)}.
+            tiers = {
+                older: {
+                    epoch: readUintLE(data, value + 72, 8),
+                    max: readUintLE(data, value + 80, 8),
+                    bps: readUintLE(data, value + 88, 2),
+                },
+                newer: {
+                    epoch: readUintLE(data, value + 90, 8),
+                    max: readUintLE(data, value + 98, 8),
+                    bps: readUintLE(data, value + 106, 2),
+                },
+            };
+        }
+        offset += 4 + length;
+    }
+    return { tokenProgram: TOKEN_2022_PROGRAM, tiers };
+}
+const activeTier = (tiers, epoch) => epoch >= tiers.newer.epoch ? tiers.newer : tiers.older;
+export async function fetchFluxBeamPoolConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG}: pool ${pool} account not found`);
+    if (data.length !== FLUXBEAM_POOL_SIZE) {
+        throw new Error(`${SLUG}: pool ${pool} data must be ${FLUXBEAM_POOL_SIZE} bytes (SwapVersion::SwapV1), got ${data.length}`);
+    }
+    if (data[OFF_VERSION] !== 1)
+        throw new Error(`${SLUG}: pool ${pool} version must be 1 (SwapV1), got ${data[OFF_VERSION]}`);
+    if (data[OFF_IS_INITIALIZED] !== 1)
+        throw new Error(`${SLUG}: pool ${pool} is not initialized`);
+    if (data[OFF_CURVE_TYPE] !== 0) {
+        throw new Error(`${SLUG}: pool ${pool} curve_type must be 0 (constant product), got ${data[OFF_CURVE_TYPE]}`);
+    }
+    const codec = getAddressCodec();
+    const pubkey = (offset) => codec.decode(data.subarray(offset, offset + 32));
+    const u64 = (offset) => readUintLE(data, offset, 8);
+    const bumpSeed = data[OFF_BUMP_SEED];
+    const mintA = pubkey(OFF_MINT_A);
+    const mintB = pubkey(OFF_MINT_B);
+    const tradeFeeNumerator = u64(OFF_TRADE_FEE_NUMERATOR);
+    const tradeFeeDenominator = u64(OFF_TRADE_FEE_DENOMINATOR);
+    const ownerTradeFeeNumerator = u64(OFF_OWNER_TRADE_FEE_NUMERATOR);
+    const ownerTradeFeeDenominator = u64(OFF_OWNER_TRADE_FEE_DENOMINATOR);
+    for (const [name, numerator, denominator] of [
+        ["trade", tradeFeeNumerator, tradeFeeDenominator],
+        ["owner trade", ownerTradeFeeNumerator, ownerTradeFeeDenominator],
+    ]) {
+        if (numerator !== 0n && denominator === 0n) {
+            throw new Error(`${SLUG}: pool ${pool} ${name} fee denominator is 0 with nonzero numerator ${numerator}`);
+        }
+    }
+    const [mintAData, mintBData] = await Promise.all([load(mintA), load(mintB)]);
+    if (mintAData === null)
+        throw new Error(`${SLUG}: mint ${mintA} of pool ${pool} not found`);
+    if (mintBData === null)
+        throw new Error(`${SLUG}: mint ${mintB} of pool ${pool} not found`);
+    const infoA = scanMint(mintA, mintAData);
+    const infoB = scanMint(mintB, mintBData);
+    let epoch = 0n;
+    if (infoA.tiers !== null || infoB.tiers !== null) {
+        const clockData = await load(CLOCK_SYSVAR);
+        if (clockData === null)
+            throw new Error(`${SLUG}: could not read the Clock sysvar to resolve pool ${pool}'s active transfer-fee tier`);
+        epoch = readUintLE(clockData, 16, 8);
+    }
+    const feeA = infoA.tiers === null ? { bps: 0n, max: 0n } : activeTier(infoA.tiers, epoch);
+    const feeB = infoB.tiers === null ? { bps: 0n, max: 0n } : activeTier(infoB.tiers, epoch);
+    return {
+        venue: SLUG,
+        pool,
+        swapAuthority: deriveSwapAuthority(pool, bumpSeed),
+        tokenProgramPool: pubkey(OFF_TOKEN_PROGRAM_POOL),
+        vaultA: pubkey(OFF_VAULT_A),
+        vaultB: pubkey(OFF_VAULT_B),
+        poolMint: pubkey(OFF_POOL_MINT),
+        mintA,
+        mintB,
+        poolFeeAccount: pubkey(OFF_POOL_FEE_ACCOUNT),
+        tokenProgramA: infoA.tokenProgram,
+        tokenProgramB: infoB.tokenProgram,
+        tradeFeeNumerator,
+        tradeFeeDenominator,
+        ownerTradeFeeNumerator,
+        ownerTradeFeeDenominator,
+        feeA: { bps: feeA.bps, max: feeA.max },
+        feeB: { bps: feeB.bps, max: feeB.max },
+    };
+}
+/** Family facade for the recipe orchestrator (ladder-only, like orca-legacy-token-swap). */
+export const fluxbeam = {
+    slug: SLUG,
+    programId: FLUXBEAM_PROGRAM_ID,
+    fetchPoolConfig: fetchFluxBeamPoolConfig,
+};
+//# sourceMappingURL=index.js.map