@eco-incorp/sauce 0.99.0

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

@@ -0,0 +1,197 @@
+/**
+ * XOrca (SvmRoute ladder fragment) — Orca's liquid-staking wrapper: stake
+ * ORCA into a single global vault and mint xORCA shares at the vault's live
+ * ratio. No on-chain IDL is published, but the program (`orca-so/xorca` on
+ * GitHub, Pinocchio + shank-generated) is open source; this adapter is a
+ * direct, byte-verified port of its instruction/state layout and math, NOT a
+ * reverse-engineered approximation.
+ *
+ * ── Why only ONE direction is a venue (see file header item below) ──
+ *
+ * The program exposes three swap-adjacent instructions: `Stake` (ORCA in,
+ * xORCA out, ATOMIC — mints and delivers in one instruction),
+ * `Unstake` (burns xORCA, creates a `PendingWithdraw` account, delivers
+ * NOTHING now), and `Withdraw` (delivers the ORCA, but only after
+ * `cool_down_period_s` has elapsed — LIVE-VERIFIED at 604,800s = exactly 7
+ * days by decoding the real State account, `state.json` in this venue's test
+ * fixtures, offset 16, matching Orca's own published 7-day unstake cooldown).
+ * `Unstake` therefore CANNOT be a Sauce venue leg: it does not deliver its
+ * output atomically, only a claim redeemable in a separate transaction days
+ * later. This is a STRUCTURAL fact about the program, not a permission or
+ * whitelist gap — this venue only ever supports the `Stake` direction
+ * (ORCA -> xORCA); there is no `direction` field to flip (unlike every other
+ * family in `FAMILIES`, which is why `the consuming app SVM solver entry`'s `xorca` entry
+ * carries no `REVERSE_DIRECTION` entry, the same shape as `saber-stableswap`
+ * and `orca-legacy-token-swap`, which are also single-direction-only).
+ *
+ * ── Verified account/instruction layout (orca-so/xorca @ main, fetched 2026-07-31) ──
+ *
+ * `solana-program/src/state/state.rs`: `State` is a fixed 2048-byte account,
+ * `#[repr(C)]`, discriminator(1) + padding(5) + bump(1) + vault_bump(1) +
+ * escrowed_orca_amount(u64 LE, offset 8) + cool_down_period_s(i64 LE, offset
+ * 16) + update_authority(32) + padding(1992). There is exactly ONE State
+ * account in existence (seed `["state"]`, no per-pair proliferation) — this
+ * is a SINGLETON venue, not a multi-pool family, so `pool` is always
+ * `XORCA_STATE_PDA` and there is no `getProgramAccounts` geometry to publish
+ * (mints are hardcoded program constants, `cpi/token/mod.rs`'s `ORCA_MINT_ID`/
+ * `XORCA_MINT_ID`, never stored as pool-account bytes at any offset — see
+ * `the consuming app SVM discovery module`'s `withXorcaStaticCandidates` for how this venue
+ * is discovered instead of via `SVM_FAMILY_FILTERS`).
+ *
+ * `solana-program/src/instructions/mod.rs`'s `Instruction` enum (Borsh,
+ * variant index = declaration order, 0-based; NOT reordered by
+ * `strum::EnumDiscriminants`, which only affects the DERIVED
+ * `InstructionDiscriminator` type, never Borsh's own enum tag): `Stake=0`,
+ * `Unstake=1`, `Withdraw=2`, `Initialize=3`, `Set=4`. `Stake{orca_stake_amount:u64}`
+ * therefore serializes to exactly 9 bytes: `[0][u64 LE]` — CONFIRMED against
+ * 3 real mainnet transactions (decoded instruction data `00...`, see below).
+ *
+ * `Stake`'s account list (`solana-program/src/instructions/stake.rs` +
+ * its `#[account(...)]` shank annotations):
+ *   0 staker_account       signer, writable  — the CPI caller (user.owner)
+ *   1 vault_account        writable          — XORCA_VAULT_ATA
+ *   2 staker_orca_ata      writable          — user.inAta
+ *   3 staker_xorca_ata     writable          — user.outAta
+ *   4 xorca_mint_account   writable          — XORCA_MINT_ID
+ *   5 state_account        (read-only)       — XORCA_STATE_PDA
+ *   6 orca_mint_account    (read-only)       — ORCA_MINT_ID
+ *   7 token_program_account (read-only)      — SPL_TOKEN_PROGRAM_ID
+ * CONFIRMED byte-for-byte against 3 real mainnet `Stake` transactions'
+ * `accountKeys` (getTransaction, 2026-07-31): every account at every index
+ * above matches, INCLUDING that `XORCA_STATE_PDA`/`XORCA_VAULT_ATA` (this
+ * file's constants, independently re-derived via `getProgramDerivedAddress`
+ * from the documented seeds) are the exact addresses those transactions use,
+ * and that `State.bump`/`State.vault_bump` decoded from the live account
+ * (250/254) equal the bumps those PDA derivations produce.
+ *
+ * ── Quote math — an EXACT port, not an approximation (`util/math.rs`) ──
+ *
+ * `convert_orca_to_xorca(orcaIn, nonEscrowedOrca, xorcaSupply)`:
+ *   nonEscrowedOrca == 0 || xorcaSupply == 0 -> return orcaIn (1:1 bootstrap,
+ *     dead in practice — the live pool has ~7.45M ORCA / ~4.77M xORCA, see
+ *     below — kept for completeness, never reachable via this ladder's
+ *     `qXorca` because both denominators below already carry the +100
+ *     virtual offset and can never be 0).
+ *   else -> floor(orcaIn * (xorcaSupply + 100) / (nonEscrowedOrca + 100))
+ * `nonEscrowedOrca = vault.amount - state.escrowed_orca_amount` (the vault
+ * ATA's live SPL balance minus the ORCA currently reserved for pending
+ * `Unstake` claims — `escrowed_orca_amount` is NOT itself a vault-balance
+ * concept, it lives on the `State` account).
+ * VIRTUAL_XORCA_SUPPLY = VIRTUAL_NON_ESCROWED_ORCA_AMOUNT = 100 (raw base
+ * units, ERC-4626-style inflation-attack offset) — negligible at the pool's
+ * real scale (millions of raw-unit-scaled tokens) but ported EXACTLY, not
+ * dropped, so this fragment's output matches the deployed program to the
+ * LAST WEI, not just approximately.
+ *
+ * Because minting shares does not touch any OTHER trader's counterparty
+ * reserve (staking is impact-FREE: after a stake of x, vault and supply both
+ * grow by the same relative amount, so the very next wei stakes at the exact
+ * same rate — verified analytically and empirically below), the quote curve
+ * is EXACTLY LINEAR over the rung grid: strictly monotone non-decreasing,
+ * trivially concave (a flat marginal price satisfies "non-increasing
+ * marginal" with equality). This is the BEST case for the merge, not the
+ * "coarse/non-monotone ladder gets allocated ZERO" hazard CLAUDE.md warns
+ * about — that hazard is about a WRONG curve, not a genuinely flat one.
+ *
+ * ── Validated against the REAL deployed program on REAL mainnet state ──
+ *
+ * Live state fetched 2026-07-31 (this venue's `test/svm/fixtures/xorca/`):
+ * vault.amount = 7,615,177,202,770 (7,615,177.202770 ORCA, 6 decimals),
+ * state.escrowed_orca_amount = 163,973,096,167, xORCA mint supply =
+ * 4,772,054,556,591 -> nonEscrowedOrca = 7,451,204,106,603.
+ *
+ * `qXorca` at four sizes on that exact snapshot: 1 ORCA (1e6) -> 640,440
+ * xORCA-raw; 1,000 ORCA (1e9) -> 640,440,724; 100,000 ORCA (1e11) ->
+ * 64,044,072,452; 5,000,000 ORCA (5e12) -> 3,202,203,622,632 — the marginal
+ * rate (out/in) is IDENTICAL to 10 significant figures across all four sizes
+ * (640,440.7245 per 1e6 in, every time), confirming the analytical
+ * flat-curve claim above, not just asserting it.
+ *
+ * Cross-checked against 3 REAL mainnet `Stake` transactions (getTransaction,
+ * 2026-07-31), applying THIS SAME formula to the CURRENT (not historical)
+ * snapshot above (state moves only via subsequent stakes/unstakes, so a
+ * residual is expected and is the ENTIRE explanation for the gap — see the
+ * relative errors, all three sub-0.005%, growing with how many slots have
+ * elapsed since each transaction, exactly as vault drift would predict):
+ *   staked=1,304,812        observed_mint=835,664         predicted=835,654    (-10,    -0.0012%, slot 436440052, ~newest)
+ *   staked=48,000,000       observed_mint=30,742,058      predicted=30,741,154 (-904,   -0.0029%, slot 436425717)
+ *   staked=10,787,576,727   observed_mint=6,909,119,305   predicted=6,908,803,454 (-315,851, -0.0046%, slot 436385363, ~oldest/most drift)
+ * The residual growing monotonically with transaction age (not with size) is
+ * exactly the signature of state drift, not formula error — this is the
+ * strongest available evidence the port is bit-exact without a full
+ * historical-state replay (public RPC does not serve arbitrary historical
+ * account snapshots).
+ *
+ * ── CU (`the consuming app SVM CU-budget module`'s `CU_FAMILIES.xorca`) ──
+ *
+ * MEASURED from 3 real mainnet `Stake` transactions' own compute logs
+ * (`getTransaction`, 2026-07-31) — "Program StaKE6XN...consumed N of ...
+ * compute units" where the log's N is the WHOLE Stake CPI including its two
+ * nested SPL Token CPIs (one `Transfer`, one `MintTo` — exactly
+ * `stake.rs`'s body): 5,735 / 5,891 / 6,008 CU (txs
+ * `Pxd7hDw9gi2KHi8PdJzRmqjrpy1FuiKwh7shn9dSz21udb1T7V1JCA8jZiu4vjTiWh7CMttTfbt8PH2XX1gzSxq`,
+ * `63EHsm4Pz1FdS1zf1MJU1CvYYVqHNVMiSsHdKxSf1HGheAH9KMqMDVYjzfX9SNdVeuR3JDrjftU7wKLXzEwtoB8k`,
+ * `5BThcy3gDcYyYSnAT2yqtJVnof5tfyWk66SWef1Dm2kgp8nsBui3WKrmD1FPvXXXCWd6wjXHZiznhD8N4bQKARMq`).
+ * This CPI (~6k CU) is dramatically CHEAPER than `raydium-cp-swap`'s (whose
+ * pin folds a real ~50k-CU CPI), so per the standing "existing pins omit the
+ * venue CPI" gap this pin deliberately does NOT reuse raydium-cp-swap's slot
+ * number outright (that would double-count a CPI cost this venue doesn't
+ * pay): it takes raydium-cp-swap's slot (183,187 — same-complexity NON-CPI
+ * analog: our setup is 3 live account reads + one virtual-offset `mulDiv`,
+ * raydium-cp-swap's is 2 vault reads + a fee-adjusted CP formula, comparable
+ * or cheaper) as the baseline and adds a margin over OUR OWN measured CPI
+ * instead (6,008 max + ~15% -> 6,900, rounded up to 7,000), so the pin only
+ * ever over-estimates. `rung` reuses raydium-cp-swap's 65,054 verbatim (our
+ * per-rung cost is a single `mulDiv` call over already-read setup locals —
+ * no extra account reads — at most as expensive as raydium-cp-swap's own
+ * per-rung fee-adjusted CP formula; the venue CPI itself runs once per SLOT,
+ * not once per rung).
+ */
+import { address } from "@solana/kit";
+const SLUG = "xorca";
+export const XORCA_PROGRAM_ID = address("StaKE6XNKVVhG8Qu9hDJBqCW3eRe7MDGLz17nJZetLT");
+/** Hardcoded program constants (`cpi/token/mod.rs`) — never stored as pool-account bytes. */
+export const ORCA_MINT_ID = address("orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE");
+export const XORCA_MINT_ID = address("xorcaYqbXUNz3474ubUMJAdu2xgPsew3rUCe5ughT3N");
+/**
+ * The single global State PDA — seed `["state"]` under `XORCA_PROGRAM_ID`,
+ * bump 250. The single vault ATA — seed `[statePda, tokenProgram, orcaMint]`
+ * under the ATA program, bump 254. Both re-derived independently via
+ * `getProgramDerivedAddress` and cross-checked against the live account's own
+ * `State.bump`/`State.vault_bump` fields (250/254 exactly) AND against 3 real
+ * mainnet `Stake` transactions' account lists (see file header) — hardcoded
+ * here rather than derived at call time because both are permanently fixed
+ * (there is exactly one xORCA vault; the mints never change).
+ */
+export const XORCA_STATE_PDA = address("CSqKhyW1cpdyjheAx5HXx4ibcnYrzpL5JywEMAkZixBK");
+export const XORCA_VAULT_ATA = address("Ce5j11WAsSzM3nkzrw4Kw6v6ic3nbyqpv5eywjYKeKc5");
+const STATE_LEN = 2048;
+const STATE_DISCRIMINATOR_STATE = 1;
+/** `State.escrowed_orca_amount`, u64 LE. */
+export const STATE_ESCROWED_OFFSET = 8;
+/** SPL `TokenAccount.amount`, u64 LE — the vault's live ORCA balance. */
+export const VAULT_AMOUNT_OFFSET = 64;
+/** SPL `Mint.supply`, u64 LE (4-byte COption tag + 32-byte pubkey precede it). */
+export const MINT_SUPPLY_OFFSET = 36;
+/**
+ * Singleton venue: `pool` must be `XORCA_STATE_PDA` (there is nothing else to
+ * resolve it to). `load` re-reads the live account so a program
+ * upgrade/migration is caught like any other vanished pool — never silently
+ * misquoted — rather than trusting the hardcoded address blindly.
+ */
+export async function fetchXorcaConfig(load, pool) {
+    if (pool !== XORCA_STATE_PDA) {
+        throw new Error(`${SLUG}: pool ${pool} is not the xORCA state singleton ${XORCA_STATE_PDA}`);
+    }
+    const raw = await load(pool);
+    if (raw === null)
+        throw new Error(`${SLUG}: state account ${pool} not found`);
+    if (raw.length !== STATE_LEN) {
+        throw new Error(`${SLUG}: state account ${pool} has length ${raw.length}, want ${STATE_LEN}`);
+    }
+    if (raw[0] !== STATE_DISCRIMINATOR_STATE) {
+        throw new Error(`${SLUG}: state account ${pool} has discriminator ${raw[0]}, want ${STATE_DISCRIMINATOR_STATE} (State)`);
+    }
+    return { venue: SLUG, pool, direction: "orcaToXorca" };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/svm/venues/xorca/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoJG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAItC,MAAM,IAAI,GAAG,OAAO,CAAC;AAErB,MAAM,CAAC,MAAM,gBAAgB,GAA2D,OAAO,CAC7F,6CAA6C,CAC9C,CAAC;AACF,6FAA6F;AAC7F,MAAM,CAAC,MAAM,YAAY,GAA2D,OAAO,CACzF,6CAA6C,CAC9C,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAA2D,OAAO,CAC1F,6CAA6C,CAC9C,CAAC;AACF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAA4D,OAAO,CAC7F,8CAA8C,CAC/C,CAAC;AACF,MAAM,CAAC,MAAM,eAAe,GAA4D,OAAO,CAC7F,8CAA8C,CAC/C,CAAC;AAEF,MAAM,SAAS,GAAG,IAAI,CAAC;AACvB,MAAM,yBAAyB,GAAG,CAAC,CAAC;AACpC,4CAA4C;AAC5C,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AACvC,yEAAyE;AACzE,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAQrC;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,IAAmB,EACnB,IAAa;IAEb,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,UAAU,IAAI,qCAAqC,eAAe,EAAE,CAAC,CAAC;IAC/F,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,GAAG,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,mBAAmB,IAAI,YAAY,CAAC,CAAC;IAC9E,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,mBAAmB,IAAI,eAAe,GAAG,CAAC,MAAM,UAAU,SAAS,EAAE,CAAC,CAAC;IAChG,CAAC;IACD,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,yBAAyB,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,mBAAmB,IAAI,sBAAsB,GAAG,CAAC,CAAC,CAAC,UAAU,yBAAyB,UAAU,CACxG,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC;AACzD,CAAC"}

package/sdk/dist/svm/venues/zerofi/ieee754.d.ts

@@ -0,0 +1,40 @@
+/**
+ * IEEE-754 binary64 -> baked integer-scale reduction, shared by index.ts
+ * (fetchPoolConfig, which runs this once per pool against the fetched
+ * oracle bytes) and ladder.ts (the on-chain fragment + its TS reference
+ * mirror). See ladder.ts's module doc for the full derivation and why this
+ * is necessary (the SVM target's arithmetic is pure-integer; the Wildcard
+ * oracle stores price as a real f64).
+ *
+ * Split into its own file (not index.ts or ladder.ts) purely to avoid a
+ * cross-import between those two — both need it, neither owns it.
+ */
+/** 2^52 - 1 (52-bit mantissa mask, IEEE-754 binary64). */
+export declare const MANTISSA_MASK = 4503599627370495n;
+/** 2^52 (the implicit leading mantissa bit, restored before use). */
+export declare const IMPLICIT_BIT = 4503599627370496n;
+/**
+ * Decode an IEEE-754 binary64 bit pattern into the ladder's baked constants
+ * for ONE pool: `bakedTop` (compared live on-chain every cook), `shiftPre`
+ * (a mantissa right-shift, FLOOR-only — never inflates the decoded price),
+ * and the canonical (num, den) rational such that, for any LIVE bit
+ * pattern whose top 12 bits (sign + biased exponent) still equal
+ * `bakedTop`:
+ *
+ *   liveMantissa = (liveBits & MANTISSA_MASK) | IMPLICIT_BIT
+ *   reduced      = liveMantissa >> shiftPre
+ *   price       ≈ reduced * num / den            (mintA -> mintB direction)
+ *   price       ≈ num / (reduced * den)          (mintB -> mintA direction, exact reciprocal)
+ *
+ * already folding the 2^(exponent-1075) term AND the mintA/mintB decimals
+ * difference, gcd-reduced so the on-chain fragment's live multiply/divide
+ * never needs to carry more than ~53 live mantissa bits through a plain
+ * `*`/`/` (see ladder.ts's module doc for why that matters).
+ */
+export declare function ieee754ScaleParams(rawBits: bigint, decimalsA: number, decimalsB: number): {
+    bakedTop: bigint;
+    shiftPre: bigint;
+    num: bigint;
+    den: bigint;
+};
+//# sourceMappingURL=ieee754.d.ts.map

package/sdk/dist/svm/venues/zerofi/ieee754.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ieee754.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/zerofi/ieee754.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,0DAA0D;AAC1D,eAAO,MAAM,aAAa,oBAAyB,CAAC;AACpD,qEAAqE;AACrE,eAAO,MAAM,YAAY,oBAAyB,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAsBlE"}

package/sdk/dist/svm/venues/zerofi/ieee754.js

@@ -0,0 +1,61 @@
+/**
+ * IEEE-754 binary64 -> baked integer-scale reduction, shared by index.ts
+ * (fetchPoolConfig, which runs this once per pool against the fetched
+ * oracle bytes) and ladder.ts (the on-chain fragment + its TS reference
+ * mirror). See ladder.ts's module doc for the full derivation and why this
+ * is necessary (the SVM target's arithmetic is pure-integer; the Wildcard
+ * oracle stores price as a real f64).
+ *
+ * Split into its own file (not index.ts or ladder.ts) purely to avoid a
+ * cross-import between those two — both need it, neither owns it.
+ */
+/** 2^52 - 1 (52-bit mantissa mask, IEEE-754 binary64). */
+export const MANTISSA_MASK = 4503599627370495n;
+/** 2^52 (the implicit leading mantissa bit, restored before use). */
+export const IMPLICIT_BIT = 4503599627370496n;
+/**
+ * Decode an IEEE-754 binary64 bit pattern into the ladder's baked constants
+ * for ONE pool: `bakedTop` (compared live on-chain every cook), `shiftPre`
+ * (a mantissa right-shift, FLOOR-only — never inflates the decoded price),
+ * and the canonical (num, den) rational such that, for any LIVE bit
+ * pattern whose top 12 bits (sign + biased exponent) still equal
+ * `bakedTop`:
+ *
+ *   liveMantissa = (liveBits & MANTISSA_MASK) | IMPLICIT_BIT
+ *   reduced      = liveMantissa >> shiftPre
+ *   price       ≈ reduced * num / den            (mintA -> mintB direction)
+ *   price       ≈ num / (reduced * den)          (mintB -> mintA direction, exact reciprocal)
+ *
+ * already folding the 2^(exponent-1075) term AND the mintA/mintB decimals
+ * difference, gcd-reduced so the on-chain fragment's live multiply/divide
+ * never needs to carry more than ~53 live mantissa bits through a plain
+ * `*`/`/` (see ladder.ts's module doc for why that matters).
+ */
+export function ieee754ScaleParams(rawBits, decimalsA, decimalsB) {
+    const top = rawBits >> 52n;
+    if (top === 0n || top >= 0x800n) {
+        throw new Error(`zerofi oracle price bit pattern 0x${rawBits.toString(16)} is subnormal/zero/negative/NaN-range`);
+    }
+    const sShiftFull = 1075n - top;
+    if (sShiftFull < 0n) {
+        throw new Error(`zerofi oracle price bit pattern 0x${rawBits.toString(16)} implies a value >= 2^53 (unexpected)`);
+    }
+    const shiftPre = sShiftFull > 63n ? sShiftFull - 63n : 0n;
+    const sShiftRemaining = sShiftFull - shiftPre;
+    const d = decimalsB - decimalsA;
+    let num = d >= 0 ? 10n ** BigInt(d) : 1n;
+    let den = (d >= 0 ? 1n : 10n ** BigInt(-d)) * (1n << sShiftRemaining);
+    const g = gcd(num, den);
+    num /= g;
+    den /= g;
+    return { bakedTop: top, shiftPre, num, den };
+}
+function gcd(a, b) {
+    let x = a < 0n ? -a : a;
+    let y = b < 0n ? -b : b;
+    while (y !== 0n) {
+        [x, y] = [y, x % y];
+    }
+    return x === 0n ? 1n : x;
+}
+//# sourceMappingURL=ieee754.js.map

package/sdk/dist/svm/venues/zerofi/ieee754.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ieee754.js","sourceRoot":"","sources":["../../../../src/svm/venues/zerofi/ieee754.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,0DAA0D;AAC1D,MAAM,CAAC,MAAM,aAAa,GAAG,iBAAsB,CAAC;AACpD,qEAAqE;AACrE,MAAM,CAAC,MAAM,YAAY,GAAG,iBAAsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAe,EACf,SAAiB,EACjB,SAAiB;IAEjB,MAAM,GAAG,GAAG,OAAO,IAAI,GAAG,CAAC;IAC3B,IAAI,GAAG,KAAK,EAAE,IAAI,GAAG,IAAI,MAAM,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,qCAAqC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,uCAAuC,CACjG,CAAC;IACJ,CAAC;IACD,MAAM,UAAU,GAAG,KAAK,GAAG,GAAG,CAAC;IAC/B,IAAI,UAAU,GAAG,EAAE,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,qCAAqC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,uCAAuC,CACjG,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1D,MAAM,eAAe,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC9C,MAAM,CAAC,GAAG,SAAS,GAAG,SAAS,CAAC;IAChC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACzC,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,eAAe,CAAC,CAAC;IACtE,MAAM,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACxB,GAAG,IAAI,CAAC,CAAC;IACT,GAAG,IAAI,CAAC,CAAC;IACT,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAC/C,CAAC;AAED,SAAS,GAAG,CAAC,CAAS,EAAE,CAAS;IAC/B,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;QAChB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC"}

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

@@ -0,0 +1,128 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, SwapUser, VenueAccount, VenueSwap } from "../types.js";
+declare const SLUG = "zerofi";
+export declare const ZEROFI_PROGRAM_ID: Address<"ZERor4xhbUycZ6gb9ntrhqscUcZmAbQDjEAtCf4hbZY">;
+export declare const POOL_ACCOUNT_SIZE = 38176;
+export declare const ORACLE_ACCOUNT_SIZE = 128;
+export declare const OFF_MINT_A = 72;
+export declare const OFF_MINT_B = 104;
+export declare const OFF_VAULT_A = 136;
+export declare const OFF_COMPANION_A = 168;
+export declare const OFF_VAULT_B = 200;
+export declare const OFF_COMPANION_B = 232;
+export declare const OFF_ORACLE = 2184;
+/** IEEE-754 f64 LE price word inside the oracle account (mintB per whole mintA). */
+export declare const PRICE_OFFSET = 48;
+/** `swap_v4`'s single-byte discriminator (NOT an 8-byte Anchor sighash). */
+export declare const ZEROFI_SWAP_DISCRIMINATOR = 16;
+/**
+ * Per-pool, per-direction fee/spread the ladder charges against the raw
+ * oracle mid, in parts-per-million, ROUNDED UP from the measured realized
+ * ratio (see module doc) so a predicted quote never exceeds the real fill —
+ * REFUSE (fetchPoolConfig throws), don't guess, for any pool not listed
+ * here. Keyed by pool account address (the 38,176-byte account), matching
+ * solfi-v2's POOL_K precedent: a pool is never assumed to share its
+ * neighbor's fee.
+ */
+export declare const ZEROFI_POOL_FEE_PPM: Readonly<Record<string, bigint>>;
+/**
+ * The registered authority + its own token-account pair, per pool — see the
+ * module doc's "ACCOUNT 8" note. UNCONFIGURED BY DEFAULT: there is no
+ * synthesizable value (a bare PDA does not satisfy the live program's
+ * check, see the module doc), so `fetchPoolConfig` throws for any pool
+ * without an entry here rather than wiring an address guaranteed to fail
+ * on-chain. Populate this once ZeroFi (or whatever registry backs the
+ * check) recognizes this deployment's own authority.
+ */
+export declare const ZEROFI_POOL_AUTHORITY: Readonly<Record<string, {
+    authority: Address;
+    authorityAtaA: Address;
+    authorityAtaB: Address;
+}>>;
+/**
+ * Conservative quotable-capacity divisor: the ladder never quotes more than
+ * `liveReserveOut / CAP_DIVISOR` output (see ladder.ts). 20 == 5% of the
+ * live output vault. This is NOT a measured venue depth limit (the true
+ * capacity model is unresolved — see the module doc's "ACCOUNTS 6/7" note);
+ * it is a deliberately-conservative ceiling picked so that every measured
+ * real fill in this integration's sample (largest: 262,787,635 raw USDC
+ * against a >29B raw USDC vault, ~0.9% of reserve) sat comfortably inside
+ * it, while still being far short of "unbounded" — an unbounded linear
+ * quote is unsafe on its own (a more-favourable-than-real quote wins merge
+ * elections it cannot actually fill).
+ */
+export declare const CAP_DIVISOR = 20n;
+export interface ZeroFiPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 0 = mintA -> mintB (vaultA is the deposit vault), 1 = mintB -> mintA. */
+    direction: 0 | 1;
+    mintA: Address;
+    mintB: Address;
+    vaultA: Address;
+    vaultB: Address;
+    companionA: Address;
+    companionB: Address;
+    oracle: Address;
+    tokenProgramA: Address;
+    tokenProgramB: Address;
+    decimalsA: number;
+    decimalsB: number;
+    /** See module doc "ACCOUNT 8" / ZEROFI_POOL_AUTHORITY — pending ZeroFi-side registration. */
+    authority: Address;
+    authorityAtaA: Address;
+    authorityAtaB: Address;
+    /** Verified per-pool fee/spread, ppm (see ZEROFI_POOL_FEE_PPM). */
+    feePpm: bigint;
+    /**
+     * Baked IEEE-754 scale constants derived from the oracle bytes AT FETCH
+     * TIME (see ladder.ts's `ieee754ScaleParams` / module doc) — decimals-
+     * adjusted, gcd-reduced. `bakedTop` is compared against the LIVE oracle
+     * bit pattern on-chain every cook (a mismatch deactivates the slot); the
+     * rest scale the live mantissa. Read-only re-derivation from the SAME
+     * oracle bytes fetchPoolConfig already loaded, exactly mirroring how
+     * obric-v2 bakes its own oracle-derived divX/mulX/divY/mulY into
+     * PoolConfig rather than re-reading them at paramsFor time.
+     */
+    scaleBakedTop: bigint;
+    scaleShiftPre: bigint;
+    scaleNum: bigint;
+    scaleDen: bigint;
+}
+export declare const zerofi: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"ZERor4xhbUycZ6gb9ntrhqscUcZmAbQDjEAtCf4hbZY">;
+    /**
+     * Off-chain gate + decode. `pool` is the 38,176-byte account (see module
+     * doc). Rejects: wrong size, missing account, a pool absent from the
+     * verified fee catalog, a pool without a registered authority (REFUSE,
+     * don't guess, for both — see ZEROFI_POOL_FEE_PPM / ZEROFI_POOL_AUTHORITY),
+     * and missing mint/oracle accounts. Tokenkeg-only (both sampled pools use
+     * plain Tokenkeg for both legs, confirmed from real swap_v4 account
+     * lists — slots 9/11 are always TokenkegQfeZy...; a Token-2022 pool
+     * changes wire semantics this adapter has not verified against, the
+     * same scope restriction obric-v2 documents for itself).
+     */
+    fetchPoolConfig(load: AccountLoader, pool: Address, direction?: 0 | 1): Promise<ZeroFiPoolConfig>;
+    quoteAccounts(cfg: PoolConfig): VenueAccount[];
+    /**
+     * v1 swap CPI (amount baked). disc(1) || amountIn u64 LE || minOut u64
+     * LE=1. NOTE (see module doc): this CPI settles through the registered
+     * `c.authority`'s own ATAs, not `user`'s — `user` is accepted for
+     * interface parity with every other adapter but is UNUSED here (there is
+     * no slot for an arbitrary caller-owned token account in this venue's
+     * instruction — see zerofiSwapAccounts).
+     */
+    buildSwap(cfg: PoolConfig, user: SwapUser, amountIn: bigint): VenueSwap;
+};
+/**
+ * The 14-account order for ZeroFi's `swap_v4` (disc 0x10) — see module doc
+ * for the full derivation and the measured fund-flow proof. The pool's own
+ * vaultA/vaultB (slots 3/5, direction-selected) and the registered
+ * authority's own ATA pair (slots 6/7) are the ONLY accounts that carry
+ * value; slot 8 is the authority's signature. There is deliberately no
+ * `user`-token-account parameter — see `zerofi.buildSwap`'s doc.
+ */
+export declare function zerofiSwapAccounts(c: ZeroFiPoolConfig, make: (ref: string, addr: Address, writable?: boolean) => VenueAccount, refFor?: (role: string) => string): VenueAccount[];
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/zerofi/index.ts"],"names":[],"mappings":"AA6GA,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;AAMhG,QAAA,MAAM,IAAI,WAAW,CAAC;AACtB,eAAO,MAAM,iBAAiB,wDAAyD,CAAC;AAGxF,eAAO,MAAM,iBAAiB,QAAS,CAAC;AACxC,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAGvC,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,UAAU,OAAO,CAAC;AAE/B,oFAAoF;AACpF,eAAO,MAAM,YAAY,KAAO,CAAC;AAEjC,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,KAAO,CAAC;AAM9C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUhE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAC1C,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAAC,CAClF,CAAC;AAEP;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,4EAA4E;IAC5E,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,6FAA6F;IAC7F,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;OASG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAcD,eAAO,MAAM,MAAM;;;;IAKjB;;;;;;;;;;OAUG;0BAEK,aAAa,QACb,OAAO,cACF,CAAC,GAAG,CAAC,GACf,OAAO,CAAC,gBAAgB,CAAC;uBAqHT,UAAU,GAAG,YAAY,EAAE;IAU9C;;;;;;;OAOG;mBACY,UAAU,QAAQ,QAAQ,YAAY,MAAM,GAAG,SAAS;CAiBxE,CAAC;AAKF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,gBAAgB,EACnB,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,CAuBhB"}