@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/venues/perena-star/index.js

@@ -0,0 +1,256 @@
+/**
+ * Perena Star — the junior-tranche staking market of Perena's on-chain lending
+ * program ("bankineco", `save8RQVPMWNTzU18t3GBvBkN9hT7jsGjiCQ28FpD9H`). The
+ * bank mint for the (currently sole) live tranche is a vanity address
+ * literally prefixed `star9ag...` — the "Star" product this venue's label
+ * names. Atomic pair: `stake_junior` (bank mint in -> junior share token
+ * out) / `instant_unstake_junior` (junior share token in -> bank mint out,
+ * fee-charged, immediate). `request_unstake_junior` (+ `fulfill_unstake_junior`)
+ * is the QUEUED exit path — genuinely asynchronous (a lockup + a second,
+ * separately-signed instruction), out of scope for a single atomic CPI, and
+ * not implemented here. `deposit_in_lp`/`withdraw_from_lp` (the bank's OWN
+ * `yield_manager`-signed rebalancing into/out of its configured lending
+ * platform) are NOT a user-facing swap at all — `yield_manager` must sign,
+ * which this recipe cannot do — so they are correctly out of scope, not a gap.
+ *
+ * LAYOUT — ground-truthed against the REAL on-chain accounts, not just the
+ * IDL: the program's on-chain Anchor IDL account (17,482 bytes, fetched via
+ * the standard `createWithSeed(findProgramAddress([], programId), "anchor:idl",
+ * programId)` PDA) gives the exact struct field order for `TrancheState`
+ * (bump, _pad, bank: Pubkey, config: TrancheConfig, accounting:
+ * TrancheAccounting, _pad) and `BankState` (bump, bank_index, _pad, config:
+ * BankConfig, status: BankStatus, accounting: BankAccounting, mint: BankMint,
+ * vaults, _pad); this file hand-decodes both as fixed absolute byte offsets
+ * (verified against the ONE live tranche/bank pair on mainnet,
+ * `hXfEYpB5FB3ZWjGNc5C5JqLixmGdmZFyjXKJB2xFPgc` / `sM6P4mh53CnG4faN4Fo3seY7wMSAiHdy8o6gKjwQF7A`,
+ * TrancheState 448 bytes / BankState 1560 bytes, no `Option<T>`/variable-length
+ * fields anywhere in either struct's declared prefix — a true fixed-offset
+ * decode, unlike e.g. sanctum-stake-pool's cursor).
+ *
+ * QUOTE MATH — derived from a REAL `stake_junior` transaction's own log line
+ * plus THREE ground-truth `simulateTransaction` runs per direction against
+ * the live mainnet tranche (mainnet: `2FgdSkPkoxNrfRuVrpdxbfAYvPbdaBkFM1sosTdLbV6e`
+ * for stake — a real bank-mint holder — and `A7iAVavBmUHrYRrXUSkhT72B7riqmvcFDSJGu12xXVhP`
+ * for unstake — a real junior-share holder — at 1 / 1,000 / 50,000 tokens
+ * each, `sigVerify:false`, nothing submitted for real), with the unstake
+ * side additionally cross-checked against the REAL pre/post SPL balance
+ * delta (not just the log line) via `simulateTransaction`'s `accounts:`
+ * read-back:
+ *
+ *   STAKE:   value  = floor(amountIn * bankPrice / 1e6)
+ *            shares = floor(value * 1e6 / sharePrice)
+ *   (log-confirmed bit-for-bit at 1e6 / 1e9 / 5e10 raw bank-mint-in: "Staked
+ *   1000000 tokens (value 1083471) -> 1020554 junior shares minted" etc.)
+ *
+ *   UNSTAKE: gross = floor(sharesIn * sharePrice / 1e6)
+ *            fee   = floor(gross * feeBps / 1e4)
+ *            net   = gross - fee
+ *            out   = floor(net * 1e6 / bankPrice)
+ *   (balance-delta-confirmed exactly at 1e6 and 1e9 raw shares-in, and 2
+ *   lamports conservative — i.e. UNDER, never over — at 5e10: the live
+ *   program's own `fee` is consistently ~1-2 units below this `floor`
+ *   formula predicts, per the "Unstake early" log's `fee_value` vs this
+ *   formula's own `fee`, at every sampled size; this file deliberately does
+ *   NOT chase that last-lamport remainder — same "a model more favourable
+ *   than reality is a liveness hazard, plain floor already errs SAFE" call
+ *   sanctum-stake-pool's own header makes for its `ceil`-via-`floor+1`.
+ *   `feeBps` is `earlyUnstakeFeeBps` normally, or `lowStakeFeeBps` when
+ *   `lowStakeFeeEnabled` AND `virtualValue*1e4 < yieldingTvl*lowStakeThresholdBps`
+ *   — ground-truthed against `@perena/bankineco-sdk`'s own
+ *   `fetchUnstakeFee` (the maintainers' published npm client), which computes
+ *   the identical threshold off the identical two fields; that SDK's own
+ *   single-ratio `shares*sharePrice/bankPrice` shortcut for the GROSS amount
+ *   was checked against the real balance delta and found imprecise by
+ *   design (an acceptable off-chain estimate, not lamport-exact) — this file
+ *   uses the THREE-step form above instead, which matched the real transfer
+ *   exactly at two of three sampled sizes and was safely conservative at the
+ *   third.
+ *
+ * Both `bankPrice` (`BankState.mint.price`) and `sharePrice`
+ * (`TrancheState.accounting.share_price`) are ADMIN/YIELD-DRIVEN and read
+ * LIVE via `accountUint` (never baked as a compile-time param), exactly like
+ * every other family's admin-mutable rate. The formula is EXACTLY affine in
+ * the trade amount for a fixed live state (no curvature at all) up to the
+ * capacity clamp below, so `defaultRungs` is pinned at the framework floor
+ * (2) — a straight line loses nothing to a coarser grid, same call as
+ * sanctum-stake-pool's header.
+ *
+ * CAPACITY — STAKE is genuinely uncapped pool-side (mints proportional
+ * shares against whatever the trader can transfer; the live bank's own
+ * `max_yielding_tvl` is 0/disabled on the only live bank). UNSTAKE is
+ * capped: `instant_unstake_junior` transfers `net` bank-mint tokens OUT of
+ * `junior_escrow_ata`, and the escrow can hold LESS than an uncapped
+ * `net(sharesIn)` would demand — asking for more than that would abort the
+ * whole cook (SVM execution-time catch is a platform impossibility, see
+ * README). This adapter computes a CONSERVATIVE capacity in SHARES,
+ * `capShares = floor(escrowBalance * bankPrice / sharePrice)`, which is
+ * provably safe REGARDLESS of the fee (dropping the fee term only ever
+ * INCREASES the true payout bound, so capping on the fee-free upper bound
+ * can only under-quote, never over-quote): for any `S <= capShares`,
+ * `out(S) <= gross(S) <= S*sharePrice/bankPrice <= escrowBalance` (each `<=`
+ * from a `floor` never increasing its input, or from `S <= capShares`'s own
+ * definition) — so a fully-filled slot at `capShares` never asks the escrow
+ * for more than it holds. This is wired as the ladder framework's
+ * `capacityInputVar`/`referenceCapacities` mechanism (see obric-v2 for the
+ * same pattern): the codegen books each rung's `dIn` from this cap's own
+ * DELTA, so the merge's own patched CPI amount (`fill[i]`) can never exceed
+ * `capShares` either, even when this slot is the last one standing with
+ * budget still remaining (the "phantom capacity past the real cap" failure
+ * mode a plain `emitQuoteCall`-only clamp would NOT prevent, since the
+ * merge's `din[]` booking would still use the raw, uncapped grid span for
+ * `fill[i]` unless `capacityInputVar` tells it otherwise).
+ *
+ * SELF-DROP — `BankStatus.is_halted` (protocol-wide) plus the
+ * direction-specific `is_halted_deposit` / `is_halted_withdrawal` (both set
+ * by `trigger_bank_circuit_breaker`) are read LIVE in the fragment (not just
+ * at fetch time — SVM has no execution-time catch, so a flag that flips
+ * between prepare and cook must still zero the quote rather than let a
+ * doomed CPI launch) and force `capShares` to 0, which floors every rung's
+ * quote to 0 and keeps the merge from ever electing this slot — the same
+ * "deactivate rather than throw at cook time" shape obric-v2's oracle-status
+ * check uses. `fetchPoolConfig` ALSO throws immediately on an
+ * ALREADY-halted pool (protocol-wide `is_halted`) so a permanently-dead
+ * tranche never enters the universe at all; the direction-specific flags are
+ * snapshotted onto the config and re-checked in the family's `gate` hook
+ * (the consuming app SVM solver entry) as the same belt-and-suspenders prepare-time
+ * shortcut every other family's activation gate uses.
+ *
+ * ACCOUNTS — both instructions take a SINGLE `u64` arg (`amount`/`shares`)
+ * with NO trailing on-chain min-out param, so `suffix` is empty on both
+ * (the recipe's own terminal outAta delta check is the real bound, as
+ * always). `instant_unstake_junior` additionally declares 8 TRAILING
+ * `optional` accounts (a yielding-mint conversion detour this adapter never
+ * uses — `target_mint` is always `bank_mint`, the "plain" redemption case).
+ * Ground-truthed live: omitting them entirely fails
+ * (`AccountNotEnoughKeys`/0xbbd) — Anchor's own generated TS client
+ * (`@perena/bankineco-sdk`) instead passes the PROGRAM's OWN id as the
+ * "None" sentinel for each of the 8 slots (`accountsPartial({..., vaultState:
+ * yr?.vaultState ?? null, ...})`, which that SDK's Anchor version resolves to
+ * `programId` on the wire) — confirmed by re-simulating with exactly that
+ * (8 trailing `programId` accounts) and observing a clean success at all
+ * three sampled sizes, both via `unitsConsumed` and the real balance delta.
+ * `junior_mint`/`bank_mint` are assumed classic SPL Token (not Token-2022) —
+ * confirmed against the one live tranche's real transactions; the
+ * `AccountLoader` this framework's `fetchPoolConfig` receives carries no
+ * owner field to detect Token-2022 generically (unlike raydium-cp-swap,
+ * whose pool state stores each mint's owning program directly).
+ *
+ * CU — see ../budget.ts's `perena-star` entry for the measurement citation
+ * (real `simulateTransaction` runs against the live mainnet tranche, both
+ * instructions, three sizes each).
+ */
+import { address, getAddressDecoder } from "@solana/kit";
+import { memoizedFindAssociatedTokenPda } from "../pda-memo.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+export const PERENA_STAR_PROGRAM_ID = address("save8RQVPMWNTzU18t3GBvBkN9hT7jsGjiCQ28FpD9H");
+const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TRANCHE_STATE_DISCRIMINATOR = Uint8Array.from([212, 231, 254, 24, 238, 63, 92, 105]);
+const BANK_STATE_DISCRIMINATOR = Uint8Array.from([16, 169, 126, 99, 35, 169, 73, 200]);
+const TRANCHE_STATE_SIZE = 448;
+const BANK_STATE_SIZE = 1560;
+// TrancheState absolute byte offsets (8-byte Anchor discriminator included).
+const OFF_TRANCHE_BANK = 16; // pubkey
+const OFF_MINT = 48; // pubkey — TrancheConfig.mint (the bank mint, "senior" token)
+const OFF_SHARE_MINT = 80; // pubkey — TrancheConfig.share_mint (the junior share token)
+// BankState absolute byte offsets (8-byte Anchor discriminator included).
+const OFF_IS_HALTED = 152; // u8 (PodBool)
+const OFF_IS_HALTED_DEPOSIT = 153; // u8 (PodBool)
+const OFF_IS_HALTED_WITHDRAWAL = 154; // u8 (PodBool)
+function readUintLE(data, offset, width) {
+    if (offset + width > data.length)
+        throw new Error("perena-star: truncated account data");
+    let v = 0n;
+    for (let i = width - 1; i >= 0; i--)
+        v = (v << 8n) | BigInt(data[offset + i]);
+    return v;
+}
+async function fetchPerenaStarPoolConfig(load, pool) {
+    const decoder = getAddressDecoder();
+    const pubkey = (data, offset) => decoder.decode(data.subarray(offset, offset + 32));
+    const trancheData = await load(pool);
+    if (trancheData === null)
+        throw new Error(`perena-star tranche ${pool} not found`);
+    if (trancheData.length !== TRANCHE_STATE_SIZE) {
+        throw new Error(`perena-star tranche ${pool} data is ${trancheData.length} bytes, expected ${TRANCHE_STATE_SIZE}`);
+    }
+    for (let i = 0; i < 8; i++) {
+        if (trancheData[i] !== TRANCHE_STATE_DISCRIMINATOR[i]) {
+            throw new Error(`perena-star tranche ${pool} has a wrong discriminator (not a TrancheState account)`);
+        }
+    }
+    const bank = pubkey(trancheData, OFF_TRANCHE_BANK);
+    const bankMint = pubkey(trancheData, OFF_MINT);
+    const juniorMint = pubkey(trancheData, OFF_SHARE_MINT);
+    // Token-2022 safety: stake_junior/instant_unstake_junior move both mints via a
+    // legacy-SPL (Tokenkeg) token program, so a Token-2022 mint (or one carrying an
+    // un-routable extension) SELF-DROPS the pool via a thrown, clearly-described
+    // error — the SvmRoute orchestrator catches a fetchPoolConfig throw and drops
+    // the venue. The legacy path stays byte-identical: a classic 82-byte mint
+    // classifies as legacy → no throw, and an unreadable mint (not vendored by a
+    // fixture) falls back to legacy.
+    const mints = [bankMint, juniorMint];
+    const mintDatas = await Promise.all(mints.map((mint) => load(mint)));
+    for (let mi = 0; mi < mints.length; mi++) {
+        const mint = mints[mi];
+        const mintData = mintDatas[mi];
+        if (mintData === null)
+            continue;
+        if (classifyMintProgram(mint, mintData) === TOKEN_2022_PROGRAM_ID) {
+            throw new Error(`perena-star: 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(`perena-star: dropping pool ${pool} — mint ${mint} is un-routable: ${blocking.join("; ")}`);
+        }
+    }
+    const bankData = await load(bank);
+    if (bankData === null)
+        throw new Error(`perena-star bank ${bank} not found`);
+    if (bankData.length !== BANK_STATE_SIZE) {
+        throw new Error(`perena-star bank ${bank} data is ${bankData.length} bytes, expected ${BANK_STATE_SIZE}`);
+    }
+    for (let i = 0; i < 8; i++) {
+        if (bankData[i] !== BANK_STATE_DISCRIMINATOR[i]) {
+            throw new Error(`perena-star bank ${bank} has a wrong discriminator (not a BankState account)`);
+        }
+    }
+    const bankMintFromBank = pubkey(bankData, 320);
+    if (bankMintFromBank !== bankMint) {
+        throw new Error(`perena-star bank ${bank} mint ${bankMintFromBank} does not match tranche config mint ${bankMint}`);
+    }
+    const isHalted = readUintLE(bankData, OFF_IS_HALTED, 1) !== 0n;
+    if (isHalted) {
+        throw new Error(`perena-star tranche ${pool} is halted (BankStatus.is_halted, snapshot at fetch time)`);
+    }
+    const isHaltedDeposit = readUintLE(bankData, OFF_IS_HALTED_DEPOSIT, 1) !== 0n;
+    const isHaltedWithdrawal = readUintLE(bankData, OFF_IS_HALTED_WITHDRAWAL, 1) !== 0n;
+    const escrowAta = await memoizedFindAssociatedTokenPda({
+        owner: pool,
+        mint: bankMint,
+        tokenProgram: TOKEN_PROGRAM,
+    });
+    const lockedSharesAta = await memoizedFindAssociatedTokenPda({
+        owner: pool,
+        mint: juniorMint,
+        tokenProgram: TOKEN_PROGRAM,
+    });
+    return {
+        venue: "perena-star",
+        pool,
+        bank,
+        bankMint,
+        juniorMint,
+        escrowAta,
+        lockedSharesAta,
+        isHaltedDeposit,
+        isHaltedWithdrawal,
+        direction: "stake",
+    };
+}
+export const perenaStar = {
+    slug: "perena-star",
+    programId: PERENA_STAR_PROGRAM_ID,
+    fetchPoolConfig: fetchPerenaStarPoolConfig,
+};
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/perena-star/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/svm/venues/perena-star/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4IG;AACH,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,8BAA8B,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE,MAAM,CAAC,MAAM,sBAAsB,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAE7F,MAAM,aAAa,GAAG,OAAO,CAAC,6CAA6C,CAAC,CAAC;AAC7E,MAAM,2BAA2B,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;AAC3F,MAAM,wBAAwB,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;AAEvF,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAC/B,MAAM,eAAe,GAAG,IAAI,CAAC;AAE7B,6EAA6E;AAC7E,MAAM,gBAAgB,GAAG,EAAE,CAAC,CAAC,SAAS;AACtC,MAAM,QAAQ,GAAG,EAAE,CAAC,CAAC,8DAA8D;AACnF,MAAM,cAAc,GAAG,EAAE,CAAC,CAAC,6DAA6D;AACxF,0EAA0E;AAC1E,MAAM,aAAa,GAAG,GAAG,CAAC,CAAC,eAAe;AAC1C,MAAM,qBAAqB,GAAG,GAAG,CAAC,CAAC,eAAe;AAClD,MAAM,wBAAwB,GAAG,GAAG,CAAC,CAAC,eAAe;AACrD,SAAS,UAAU,CAAC,IAAgB,EAAE,MAAc,EAAE,KAAa;IACjE,IAAI,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzF,IAAI,CAAC,GAAG,EAAE,CAAC;IACX,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;QAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC,CAAC;IAC/E,OAAO,CAAC,CAAC;AACX,CAAC;AAgBD,KAAK,UAAU,yBAAyB,CACtC,IAAmB,EACnB,IAAa;IAEb,MAAM,OAAO,GAAG,iBAAiB,EAAE,CAAC;IACpC,MAAM,MAAM,GAAG,CAAC,IAAgB,EAAE,MAAc,EAAW,EAAE,CAC3D,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC;IAErD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,IAAI,WAAW,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,YAAY,CAAC,CAAC;IACnF,IAAI,WAAW,CAAC,MAAM,KAAK,kBAAkB,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CACb,uBAAuB,IAAI,YAAY,WAAW,CAAC,MAAM,oBAAoB,kBAAkB,EAAE,CAClG,CAAC;IACJ,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,2BAA2B,CAAC,CAAC,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CACb,uBAAuB,IAAI,yDAAyD,CACrF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;IAEvD,+EAA+E;IAC/E,gFAAgF;IAChF,6EAA6E;IAC7E,8EAA8E;IAC9E,0EAA0E;IAC1E,6EAA6E;IAC7E,iCAAiC;IACjC,MAAM,KAAK,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACrC,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACrE,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,KAAK,CAAC,EAAE,CAAE,CAAC;QACxB,MAAM,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAE,CAAC;QAChC,IAAI,QAAQ,KAAK,IAAI;YAAE,SAAS;QAChC,IAAI,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,qBAAqB,EAAE,CAAC;YAClE,MAAM,IAAI,KAAK,CACb,8BAA8B,IAAI,WAAW,IAAI,uDAAuD,CACzG,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,8BAA8B,IAAI,WAAW,IAAI,oBAAoB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3F,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,QAAQ,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,YAAY,CAAC,CAAC;IAC7E,IAAI,QAAQ,CAAC,MAAM,KAAK,eAAe,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CACb,oBAAoB,IAAI,YAAY,QAAQ,CAAC,MAAM,oBAAoB,eAAe,EAAE,CACzF,CAAC;IACJ,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CACb,oBAAoB,IAAI,sDAAsD,CAC/E,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,gBAAgB,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAC/C,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CACb,oBAAoB,IAAI,SAAS,gBAAgB,uCAAuC,QAAQ,EAAE,CACnG,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IAC/D,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,uBAAuB,IAAI,2DAA2D,CACvF,CAAC;IACJ,CAAC;IACD,MAAM,eAAe,GAAG,UAAU,CAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IAC9E,MAAM,kBAAkB,GAAG,UAAU,CAAC,QAAQ,EAAE,wBAAwB,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IAEpF,MAAM,SAAS,GAAG,MAAM,8BAA8B,CAAC;QACrD,KAAK,EAAE,IAAI;QACX,IAAI,EAAE,QAAQ;QACd,YAAY,EAAE,aAAa;KAC5B,CAAC,CAAC;IACH,MAAM,eAAe,GAAG,MAAM,8BAA8B,CAAC;QAC3D,KAAK,EAAE,IAAI;QACX,IAAI,EAAE,UAAU;QAChB,YAAY,EAAE,aAAa;KAC5B,CAAC,CAAC;IAEH,OAAO;QACL,KAAK,EAAE,aAAa;QACpB,IAAI;QACJ,IAAI;QACJ,QAAQ;QACR,UAAU;QACV,SAAS;QACT,eAAe;QACf,eAAe;QACf,kBAAkB;QAClB,SAAS,EAAE,OAAO;KACnB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,aAAsB;IAC5B,SAAS,EAAE,sBAAsB;IACjC,eAAe,EAAE,yBAAyB;CAC3C,CAAC"}

package/sdk/dist/svm/venues/perps-jlp/index.d.ts

@@ -0,0 +1,130 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "perps-jlp";
+export declare const PERPS_JLP_PROGRAM_ID: Address<"PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu">;
+/** The single production JLP pool (name "Pool", 6 custodies as of 2026-07-31). */
+export declare const JLP_POOL_ADDRESS: Address<"5BUwFW4nRbftYTDMbgxykoFWqWHPzahFSNAaaaJtVKsq">;
+/** sha256('global:swap2')[0..8]. */
+export declare const SWAP2_DISCRIMINATOR: number[];
+/** The full occupied Custody struct length (confirmed all-zero padding past this on 6 real mainnet custodies). */
+export declare const CUSTODY_ACCOUNT_SIZE = 1117;
+export declare const DOVES_PRICE_OFFSET = 73;
+export declare const DOVES_EXPO_OFFSET = 81;
+export declare const DOVES_TIMESTAMP_OFFSET = 82;
+export declare const DOVES_FEED_SIZE = 91;
+/**
+ * A "the feed is dead, not just latent" sanity ceiling (seconds) — the
+ * real on-chain custody enforces its OWN much tighter `oracle.maxPriceAgeSec`
+ * (observed 5s on the real mainnet SOL/USDC custodies 2026-07-31) at swap2
+ * execution time; that live, on-chain check is the authoritative freshness
+ * backstop and reverts the whole cook for this slot if violated, exactly
+ * like every other venue's runtime-failure self-drop. Trying to replicate a
+ * 5s bound OFF-CHAIN at prepare time would self-drop this venue almost
+ * unconditionally (any nonzero prepare-to-cook latency exceeds it) — a
+ * "NO PREMATURE GATING" violation, not a safety measure. This constant only
+ * catches a feed that has stopped updating entirely (an abandoned/broken
+ * Doves keeper), not ordinary staleness.
+ */
+export declare const DOVES_MAX_AGE_SEC = 3600n;
+/**
+ * Baked scale for `floor(c1 * c2 * 10^(e1+e2-te))` — the shared shape of
+ * every `checkedDecimalMul(c1, e1, c2, e2, te)` call this venue's math uses
+ * (both the exchange-rate conversion and every USD conversion). Because
+ * decimals/exponents are all baked (governance/feed constants), the SIGN of
+ * `targetPower` is known off-chain, so the fragment never needs a runtime
+ * branch: exactly one of `scaleUp`/`scaleDown` is ever != 1, so
+ * `floor(c1 * c2 * scaleUp / scaleDown)` reproduces the reference's two-way
+ * branch with ONE unconditional expression.
+ */
+export declare function bakedDecimalScale(e1: number, e2: number, targetExponent: number): {
+    scaleUp: bigint;
+    scaleDown: bigint;
+};
+/** `getSwapPrice`'s ORACLE_PRICE_SCALE / ORACLE_EXPONENT_SCALE constants. */
+declare const ORACLE_PRICE_SCALE = 1000000000n;
+export interface PerpsJlpPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    pool: Address;
+    mintIn: Address;
+    mintOut: Address;
+    custodyIn: Address;
+    custodyOut: Address;
+    tokenAccountIn: Address;
+    tokenAccountOut: Address;
+    dovesOracleIn: Address;
+    dovesOracleOut: Address;
+    pythAccountIn: Address;
+    pythAccountOut: Address;
+    tokenProgram: Address;
+    /** Program-wide constant PDAs, pre-derived at fetch time (buildSwapV2 is synchronous). */
+    transferAuthority: Address;
+    perpetuals: Address;
+    eventAuthority: Address;
+    decimalsIn: number;
+    decimalsOut: number;
+    /** Baked exchange-rate scale: amountOutBeforeFees = floor(amountIn * swapPriceCoeff * fxScaleUp / fxScaleDown). */
+    fxScaleUp: bigint;
+    fxScaleDown: bigint;
+    /** Baked per-side USD-conversion scale (getAssetAmountUsd at this side's own decimals/expo). */
+    usdScaleUpIn: bigint;
+    usdScaleDownIn: bigint;
+    usdScaleUpOut: bigint;
+    usdScaleDownOut: bigint;
+    isStableIn: boolean;
+    isStableOut: boolean;
+    targetRatioBpsIn: bigint;
+    targetRatioBpsOut: bigint;
+    /** The (baseFeeBps, taxFeeBps, multiplier) triple — stableSwap* iff BOTH custodies are stable. */
+    baseFeeBps: bigint;
+    taxFeeBps: bigint;
+    multiplier: bigint;
+    /** max(externalSwapFeeMultiplierBpsIn, externalSwapFeeMultiplierBpsOut, 10_000) — conservative bake, see module doc. */
+    externalMultiplierBps: bigint;
+    /** Dynamic byte offset of Pool.aumUsd (shifts if Jupiter ever adds/removes a custody or renames the pool). */
+    poolAumUsdOffset: bigint;
+    /** Dynamic byte offset of Pool.fees (== poolAumUsdOffset + 56, the Limit struct's fixed 40B + aumUsd's 16B). */
+    poolFeesOffset: bigint;
+}
+declare function perpsJlpConfig(cfg: PoolConfig): PerpsJlpPoolConfig;
+/** `findProgramAddress(["custody", pool, mint], PERPS_JLP_PROGRAM_ID)` — verified against real SOL custody. */
+export declare function custodyPda(pool: Address, mint: Address): Promise<Address>;
+/** `findProgramAddress(["transfer_authority"], PERPS_JLP_PROGRAM_ID)` — cached (program-wide constant). */
+export declare function transferAuthorityPda(): Promise<Address>;
+/** `findProgramAddress(["perpetuals"], PERPS_JLP_PROGRAM_ID)` — cached (program-wide constant). */
+export declare function perpetualsPda(): Promise<Address>;
+/** `findProgramAddress(["__event_authority"], PERPS_JLP_PROGRAM_ID)` — matches the published constant. */
+export declare function eventAuthorityPda(): Promise<Address>;
+/**
+ * Fetch + gate one directed (mintIn -> mintOut) JLP swap. Unlike every other
+ * family, this takes the DIRECTED PAIR (not just a pool-hint address) — see
+ * the module doc for why. `poolHint` is accepted for API symmetry with the
+ * other families' `fetch(load, pool)` shape (and sanity-asserted equal to
+ * the freshly-derived custodyIn PDA) but is not otherwise used: the pair
+ * fully determines both custody PDAs.
+ */
+/**
+ * `custodyIn` is the account to decode DIRECTLY (its `mint` field IS mintIn —
+ * self-discovered, never taken on faith from a caller) — the address-source
+ * derives it deterministically from `pair.inMint` (see ladder discovery
+ * wiring), so this function never needs the input mint as a separate
+ * argument. `mintOut` is the ONE piece of information genuinely external:
+ * a basket has no single account embedding both sides, so SOMETHING must
+ * name which of the OTHER custodies this trade targets. Both this function's
+ * callers (the discovery resolver and the pre-codegen re-fetch) have it —
+ * the former from the requested pair directly, the latter from the spec's
+ * own `direction` string (this family stores `mintOut`'s base58 there, see
+ * the consuming app SVM solver entry's FAMILIES entry) — so `fetchPoolConfig` never needs
+ * a signature wider than every other family's `(load, pool)` PLUS this one
+ * extra, always-a-plain-string `direction` parameter already threads through
+ * both call sites unchanged.
+ */
+export declare function fetchPerpsJlpConfig(load: AccountLoader, custodyIn: Address, mintOut: Address, now?: bigint): Promise<PerpsJlpPoolConfig>;
+/** Family facade for the recipe orchestrator (ladder-only — not in the v1 registry; see quantum/solfi-v2). */
+export declare const perpsJlp: {
+    slug: string;
+    programId: Address<"PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu">;
+    tokenProgram: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+    fetchPoolConfig: typeof fetchPerpsJlpConfig;
+};
+export { perpsJlpConfig, ORACLE_PRICE_SCALE };
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/perps-jlp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/perps-jlp/index.ts"],"names":[],"mappings":"AA2GA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK7D,QAAA,MAAM,IAAI,cAAc,CAAC;AAEzB,eAAO,MAAM,oBAAoB,wDAAyD,CAAC;AAG3F,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,yDAA0D,CAAC;AAMxF,oCAAoC;AACpC,eAAO,MAAM,mBAAmB,UAAmD,CAAC;AAEpF,kHAAkH;AAClH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAmBzC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAMxC;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,MAAM,GACrB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAIxC;AAID,6EAA6E;AAC7E,QAAA,MAAM,kBAAkB,cAAiB,CAAC;AAG1C,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,0FAA0F;IAC1F,iBAAiB,EAAE,OAAO,CAAC;IAC3B,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,mHAAmH;IACnH,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kGAAkG;IAClG,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,wHAAwH;IACxH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,8GAA8G;IAC9G,gBAAgB,EAAE,MAAM,CAAC;IACzB,gHAAgH;IAChH,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,iBAAS,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,kBAAkB,CAG3D;AAKD,+GAA+G;AAC/G,wBAAsB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAM/E;AAMD,2GAA2G;AAC3G,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAQ7D;AAED,mGAAmG;AACnG,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAQtD;AAED,0GAA0G;AAC1G,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAQ1D;AAqFD;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,OAAO,EAChB,GAAG,GAAE,MAA8C,GAClD,OAAO,CAAC,kBAAkB,CAAC,CAwI7B;AAED,8GAA8G;AAC9G,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC"}