@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/venues/runner-rodeo/index.d.ts

@@ -0,0 +1,27 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG: "runner-rodeo";
+export declare const RUNNER_RODEO_PROGRAM_ID: Address;
+export interface RunnerRodeoPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** exactIn side: 'quoteToBase' (default, buy) | 'baseToQuote' (sell). */
+    direction: "quoteToBase" | "baseToQuote";
+    configAccount: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    baseMint: Address;
+    quoteMint: Address;
+    baseTokenProgram: Address;
+    creatorFeeVault: Address;
+    creatorFeeBps: bigint;
+    protocolFeeBpsA: bigint;
+    protocolFeeBpsB: bigint;
+}
+export declare const runnerRodeo: {
+    slug: "runner-rodeo";
+    kind: "constant-product";
+    programId: Address;
+    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<RunnerRodeoPoolConfig>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/runner-rodeo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/runner-rodeo/index.ts"],"names":[],"mappings":"AAmHA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,QAAA,MAAM,IAAI,EAAG,cAAuB,CAAC;AAMrC,eAAO,MAAM,uBAAuB,SAA0D,CAAC;AAyG/F,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,yEAAyE;IACzE,SAAS,EAAE,aAAa,GAAG,aAAa,CAAC;IACzC,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,WAAW;;;;0BAIM,aAAa,QAAQ,OAAO,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA0F1F,CAAC"}

package/sdk/dist/svm/venues/runner-rodeo/index.js

@@ -0,0 +1,293 @@
+/**
+ * RunnerRodeo (program `runnrXXdsSRkdueCRYxKDvSWfv6nAnrG5dcM29qj1HA`) — a bonding-curve
+ * launch-AMM, no published IDL, no anchor.projects/GitHub source found. EVERYTHING below is
+ * ground-truthed against REAL mainnet state and REAL simulated + landed transactions on the
+ * deployed program (no third-party SDK, no assumptions):
+ *
+ *  - `getSignaturesForAddress` + `getTransaction` on a real landed SELL
+ *    (`25vT8CzEZJjMaoKjw8AuHG6pnqkU4ekNBsseswD9ZwjwvetQQ4rMPWeLCxpJkb3z5hBytiTvvN28mtV5kiEwPAAG`,
+ *    slot 418131643) and a real landed BUY on the same pool, routed via Jupiter's RouteV2
+ *    (`4zRoTtapfsFT2nQ3oej6QgwmTrWyjY2kLTTUH8pwD4nEMZAxmLLJQxFnWycCUPNbYNF7N2BDdMZdMq87Upikt6Sd`)
+ *    gave the exact 18-account order, the instruction discriminator + arg layout, and the fee
+ *    split (see FEE MODEL below) byte-exact from the inner `transferChecked`s.
+ *  - The pool-state PDA's raw bytes (`getAccountInfo`, base64) were reverse engineered by
+ *    scanning every byte offset for known pubkeys (mints/vaults/config) and, for the numeric
+ *    reserve fields, by SOLVING for the exact virtual-reserve constants from the landed
+ *    trades' pre/post vault deltas, then CONFIRMING the closed form against 8 independent
+ *    real `simulateTransaction` calls (`sigVerify:false`) at sizes spanning 1e6 to 1.5e13
+ *    raw units (both directions) — every one matched the program's real output BIT-EXACT
+ *    (see VALIDATION below). The program's own binary was additionally dumped
+ *    (`solana program dump`, ELF loader-owned, 946,792 bytes) to measure the real CPI's CU
+ *    cost (see sauce-recipes' `the consuming app SVM CU-budget module`'s `CU_FAMILIES['runner-rodeo']` comment).
+ *
+ * POOL-STATE ACCOUNT (313 bytes, Anchor-discriminated, disc = d5d2e3bf30aade72 — gated at
+ * fetch time):
+ *   configAccount    Pubkey @8      creatorRef (unused) Pubkey @40
+ *   baseVault        Pubkey @72     quoteVault          Pubkey @104
+ *   totalSupplyLike  u64    @136 (unused by the curve — looks like a fixed 800,000,000-token
+ *                                  constant; kept undecoded, not needed for the quote)
+ *   virtualBaseRaw   u64    @144   quoteVirtualOffset   u64 @152
+ *   virtualBaseSub   u64    @160   quoteCacheMirror     u64 @168 (mirrors the live quote
+ *                                  vault balance exactly at last touch — unused, we read the
+ *                                  live vault instead so a re-fetch is never stale)
+ *   unused           u64    @176   unused byte          u8  @184
+ *   baseMint         Pubkey @185   quoteMint            Pubkey @217
+ *   reserved/padding        @249..313 (all-zero on every account sampled)
+ *
+ * THE CURVE (fully closed form, EXACT — not a haircut): the program does NOT use the raw
+ * vault balances as its constant-product reserves at all (a naive `vault*vault` model
+ * mis-predicts every trade by >20x) — it uses two DERIVED reserves:
+ *   R_eff (effective base reserve) = virtualBaseRaw - virtualBaseSub   (BOTH from pool-state,
+ *                                    read live — never cached, since either could move on a
+ *                                    real trade)
+ *   Q_eff (effective quote reserve) = liveQuoteVaultBalance + quoteVirtualOffset
+ * BUY  (quoteToBase, exact quote in `x`):
+ *   fees = floor(x*creatorFeeBps/1e4) + floor(x*protoBpsA/1e4) + floor(x*protoBpsB/1e4)
+ *   net  = x - fees  (0 if net <= 0)
+ *   out  = floor(R_eff * net / (Q_eff + net))
+ * SELL (baseToQuote, exact base in `x`):
+ *   gross = floor(Q_eff * x / (R_eff + x))
+ *   fees  = floor(gross*creatorFeeBps/1e4) + floor(gross*protoBpsA/1e4) + floor(gross*protoBpsB/1e4)
+ *   out   = fees >= gross ? 0 : gross - fees
+ * Every floor is a real integer division (no ceiling anywhere, unlike pumpfun-bonding-curve's
+ * per-component ceilDiv) — confirmed component-by-component against 8 real trades, not just
+ * the net total (see VALIDATION).
+ *
+ * FEE MODEL: three components, ALL read LIVE from the pool's `configAccount` (never
+ * hardcoded, so a live bps change is picked up on the next fetch) — `creatorFeeBps` (u16 @73,
+ * =60 observed), `protocolFeeBpsA` (u16 @75, =5 observed), `protocolFeeBpsB` (u16 @77, =55
+ * observed); a second, byte-identical [60,5,55] triple sits at @79/81/83 in the same account
+ * (unexplained — possibly a redundant/secondary tier — the FIRST triple is what every
+ * validated trade matches, so that is the one this module reads). The creator-fee VAULT is
+ * DERIVED per pool: `configAccount`'s own Pubkey @9 (a partner/creator wallet, DIFFERENT per
+ * pool observed to coincide with the fee vault's real SPL owner) ATA'd against the pool's
+ * quote mint under the classic Token program. The two protocol-fee VAULTS
+ * (`PROTOCOL_FEE_VAULT_A`/`_B` below) are NOT derivable from either account (exhaustively
+ * scanned for both a literal-pubkey match and a short-seed PDA match — neither hit) — both
+ * are owned, in the SPL sense, by the `["authority"]` PDA (itself a plain, provably
+ * program-wide constant, see AUTHORITY below), so they are hardcoded here as PROTOCOL-WIDE
+ * constants, the same disclosed-constant pattern pumpfun-bonding-curve's own module uses for
+ * its own `GLOBAL`/`FEE_CONFIG`/`EVENT_AUTHORITY`. If RunnerRodeo ever rotates them this
+ * module needs a re-pin — there is no way to detect that from on-chain data alone without a
+ * second pool to diff against.
+ *
+ * GLOBAL PDAs (both independently RE-DERIVED via `getProgramDerivedAddress` and confirmed
+ * byte-for-byte against the real accounts used in both landed transactions — not guesses):
+ *   AUTHORITY       = PDA(["authority"], program)          = 7Eg1rRYr2WqEWTvqkzG1ApuB91WbZ4qzY7V6BfXtjwQR
+ *   EVENT_AUTHORITY = PDA(["__event_authority"], program)  = KND1vJVGccL2qojg6qidWH4hN7VGgL3sRwUXfVbwQQX
+ * (the latter is Anchor's standard self-CPI event-log account — hardcoded rather than
+ * re-derived per fetch since it never varies by pool, matching every other family's constant
+ * PDAs in this repo.)
+ *
+ * SCOPE (a real, disclosed narrowing, not a refusal — mirrors pumpfun-bonding-curve's own
+ * SCOPE section): this module serves only WSOL-quoted pools (`quoteMint` == the wSOL mint —
+ * the only variant observed live; gated at fetch time, named error otherwise). On the base
+ * mint's Token-2022 `TransferFeeConfig`: the real validated pool's mint carries an ACTIVE fee
+ * (120bps, confirmed live via `getAccountInfo` jsonParsed — an EARLIER draft of this module
+ * wrongly inferred "inactive" from vault deltas alone, see `mintTransferFeeConfig`'s doc for
+ * the correction), but `withdrawWithheldAuthority` on that mint is the pool's own
+ * `["authority"]` PDA, and the `Swap` instruction unconditionally self-harvests via a nested
+ * `WithdrawWithheldTokensFromAccounts` CPI after every transfer (visible in every real
+ * transaction's logs), netting the fee to zero real effect — this is why this module gates on
+ * `withdrawWithheldAuthority == AUTHORITY`, not on the bps value or the extension's mere
+ * presence the way pumpfun-bonding-curve's blanket rejection does (that blanket rejection
+ * would incorrectly self-drop the exact pool this module is validated against): a mint whose
+ * fee is NOT harvestable by this program's own authority would corrupt the constant-product
+ * math above (which assumes the full requested amount reaches the vault), so THAT combination
+ * is rejected instead.
+ *
+ * VALIDATION (sauce-recipes' `test/svm/venues/runner-rodeo.test.ts` pins these as golden
+ * values — real `simulateTransaction` calls against the deployed program, current mainnet
+ * pool state, `R_eff=1015974936239489`,
+ * `Q_eff=liveQuoteVaultBalance(899666879)+19681274900`):
+ *   SELL    1,000,000,000 base in -> gross   20,257 / net    20,015 quote
+ *   SELL 1,000,000,000,000 base in -> gross 20,237,412 / net 19,994,565 quote
+ *   SELL 5,000,000,000,000 base in -> gross 100,790,631 / net 99,581,145 quote
+ *   SELL 15,000,000,000,000 base in -> gross 299,439,022 / net 295,845,755 quote
+ *   BUY      1,000,000 quote in -> net in    988,000 -> 48,770,122,519 base out
+ *   BUY     10,000,000 quote in -> net in  9,880,000 -> 487,490,614,885 base out
+ *   BUY    100,000,000 quote in -> net in 98,800,000 -> 4,853,944,733,603 base out
+ *   BUY  1,000,000,000 quote in -> net in 988,000,000 -> 46,538,362,766,685 base out
+ * Every one of the 8 reproduces the real program's output to the integer, both the gross/net
+ * split (per-component floor) and the curve itself.
+ */
+import { getAddressDecoder, getAddressEncoder } from "@solana/kit";
+import { memoizedGetProgramDerivedAddress } from "../pda-memo.js";
+import { readUintLE } from "../math.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "runner-rodeo";
+function address_(s) {
+    return s;
+}
+export const RUNNER_RODEO_PROGRAM_ID = address_("runnrXXdsSRkdueCRYxKDvSWfv6nAnrG5dcM29qj1HA");
+const WSOL = address_("So11111111111111111111111111111111111111112");
+const TOKEN_PROGRAM = address_("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_2022_PROGRAM = address_("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+const ASSOCIATED_TOKEN_PROGRAM = address_("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+/** PDA(["authority"], program) — re-derived + confirmed, see module header. */
+const AUTHORITY = address_("7Eg1rRYr2WqEWTvqkzG1ApuB91WbZ4qzY7V6BfXtjwQR");
+const POOL_STATE_DISCRIMINATOR = [0xd5, 0xd2, 0xe3, 0xbf, 0x30, 0xaa, 0xde, 0x72];
+function hasDiscriminator(data, discriminator) {
+    return data.length >= 8 && discriminator.every((byte, i) => data[i] === byte);
+}
+function pubkeyAt(data, offset) {
+    return getAddressDecoder().decode(data.subarray(offset, offset + 32));
+}
+async function pda(seeds, programAddress) {
+    const encoder = getAddressEncoder();
+    const rawSeeds = seeds.map((s) => typeof s === "string" ? new Uint8Array(encoder.encode(s)) : s);
+    return memoizedGetProgramDerivedAddress(programAddress, rawSeeds);
+}
+async function ata(owner, mint, tokenProgram) {
+    return pda([owner, tokenProgram, mint], ASSOCIATED_TOKEN_PROGRAM);
+}
+async function loadAccount(load, addr, what) {
+    const data = await load(addr);
+    if (data === null)
+        throw new Error(`runner-rodeo ${what} ${addr} not found`);
+    return data;
+}
+/**
+ * Token-2022 mint TransferFeeConfig (extension type 1) — walks the TLV extension chain from
+ * offset 166 (the same starting point pumpfun-bonding-curve's own `detectTokenProgram` uses)
+ * and returns `null` if the mint carries no such extension at all (a classic Tokenkeg mint, or
+ * a token-2022 mint with no TransferFeeConfig — no fee risk either way). Layout
+ * (spl-token-2022 `TransferFeeConfig`, 108 bytes of extension data after the 4-byte TLV
+ * header): configAuthority:Pubkey(32) + withdrawWithheldAuthority:Pubkey(32) +
+ * withheldAmount:u64(8) + olderTransferFee{epoch:u64(8), maximumFee:u64(8), bps:u16(2)} +
+ * newerTransferFee{epoch:u64(8), maximumFee:u64(8), bps:u16(2)}.
+ *
+ * THE REAL VALIDATED POOL'S MINT CARRIES AN ACTIVE 120bps FEE (confirmed live via
+ * `getAccountInfo` jsonParsed on `84fPk12yZNH27JWWyCcdm2YBiwzA7vL5RorfQTRZ9zC2` — both fee
+ * epochs at 120bps) — an EARLIER draft of this module wrongly inferred "inactive" from every
+ * observed vault delta landing at the FULL requested amount; the real mechanism is that
+ * `withdrawWithheldAuthority` on this mint is the pool's OWN `["authority"]` PDA (confirmed
+ * live: `transferFeeConfigAuthority`/`withdrawWithheldAuthority` both equal `7Eg1rR...`), and
+ * the program's `Swap` instruction unconditionally issues a nested `WithdrawWithheldTokensFromAccounts`
+ * CPI (visible in every real transaction's logs, both directions) immediately after each
+ * `transferChecked`, self-harvesting whatever was just withheld on the account it JUST
+ * credited back into that SAME account's spendable balance — netting the fee to ZERO real
+ * effect regardless of the configured bps. This is why the gate below checks
+ * `withdrawWithheldAuthority`, not the bps value: a nonzero fee is SAFE exactly when the pool's
+ * own authority can (and, per every observed trade, does) neutralize it; a fee this program
+ * cannot harvest back would NOT be neutralized and WOULD corrupt the constant-product math
+ * above, which assumes the full requested amount always lands.
+ */
+function mintTransferFeeConfig(data) {
+    if (data.length <= 166)
+        return null;
+    let offset = 166;
+    while (offset + 4 <= data.length) {
+        const extensionType = data[offset] | (data[offset + 1] << 8);
+        const extensionLength = data[offset + 2] | (data[offset + 3] << 8);
+        if (extensionType === 0)
+            break;
+        if (extensionType === 1) {
+            const extData = offset + 4;
+            const olderBps = readUintLE(data, extData + 88, 2);
+            const newerBps = readUintLE(data, extData + 106, 2);
+            return {
+                bpsActive: olderBps !== 0n || newerBps !== 0n,
+                withdrawWithheldAuthority: pubkeyAt(data, extData + 32),
+            };
+        }
+        offset += 4 + extensionLength;
+    }
+    return null;
+}
+/**
+ * Which token program owns this mint, from its account data alone — a classic Tokenkeg mint
+ * is EXACTLY 82 bytes; anything longer is token-2022 TLV. Mirrors (and stays byte-compatible
+ * with) pumpfun-bonding-curve's own `detectTokenProgram`, minus its blanket TransferFeeConfig
+ * rejection — see this module's SCOPE section for why that check is done separately, gated on
+ * the LIVE bps rather than the extension's presence.
+ */
+function detectTokenProgram(mint, data) {
+    if (data.length === 82)
+        return TOKEN_PROGRAM;
+    if (data.length < 166) {
+        throw new Error(`runner-rodeo mint ${mint} data is ${data.length} bytes, not a token mint layout`);
+    }
+    if (data[165] !== 1) {
+        throw new Error(`runner-rodeo mint ${mint} token-2022 account type is ${data[165]}, expected 1 (mint)`);
+    }
+    return TOKEN_2022_PROGRAM;
+}
+export const runnerRodeo = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: RUNNER_RODEO_PROGRAM_ID,
+    async fetchPoolConfig(load, pool) {
+        const psData = await loadAccount(load, pool, "pool state");
+        if (!hasDiscriminator(psData, POOL_STATE_DISCRIMINATOR)) {
+            throw new Error(`runner-rodeo pool ${pool} discriminator mismatch (not a RunnerRodeo pool-state account)`);
+        }
+        if (psData.length < 249) {
+            throw new Error(`runner-rodeo pool ${pool} data is ${psData.length} bytes, expected at least 249`);
+        }
+        const configAccount = pubkeyAt(psData, 8);
+        const baseVault = pubkeyAt(psData, 72);
+        const quoteVault = pubkeyAt(psData, 104);
+        const baseMint = pubkeyAt(psData, 185);
+        const quoteMint = pubkeyAt(psData, 217);
+        if (quoteMint !== WSOL) {
+            throw new Error(`runner-rodeo pool ${pool} gate: quote mint ${quoteMint} is not wSOL (only wSOL-quoted pools are supported)`);
+        }
+        const [cfgData, mintData] = await Promise.all([
+            loadAccount(load, configAccount, "config"),
+            loadAccount(load, baseMint, "base mint"),
+        ]);
+        if (cfgData.length < 79) {
+            throw new Error(`runner-rodeo pool ${pool} config ${configAccount} is ${cfgData.length} bytes, expected at least 79`);
+        }
+        const partnerWallet = pubkeyAt(cfgData, 9);
+        const creatorFeeBps = readUintLE(cfgData, 73, 2);
+        const protocolFeeBpsA = readUintLE(cfgData, 75, 2);
+        const protocolFeeBpsB = readUintLE(cfgData, 77, 2);
+        const baseTokenProgram = detectTokenProgram(baseMint, mintData);
+        // A NonTransferable / DefaultAccountState=frozen base mint genuinely cannot route through the
+        // program's transferChecked — self-drop it (safe; a dropped pool just self-limits).
+        // PermanentDelegate/Confidential are advisories, not blocking, so a routable T22 mint passes.
+        const { blocking } = parseMintExtensions(mintData);
+        if (blocking.length > 0) {
+            throw new Error(`runner-rodeo pool ${pool} gate: base mint ${baseMint} is un-routable: ${blocking.join("; ")}`);
+        }
+        const feeConfig = mintTransferFeeConfig(mintData);
+        // A nonzero mint-level fee is SAFE iff this program's own authority can harvest it back
+        // (see mintTransferFeeConfig's doc — the Swap CPI always self-harvests, netting it to zero
+        // real effect); if some OTHER authority controls withdrawal, a nonzero fee would silently
+        // corrupt the constant-product math above, so THAT combination is the actual gate.
+        // TODO(t22-fee-netting): the non-self-harvestable case below is REJECTED, not fee-netted.
+        // Unlike a plain pool-transfer venue, this program self-harvests the withheld fee back into
+        // the vault after each transferChecked, so when it CAN harvest (authority == AUTHORITY) the
+        // fee nets to zero and the full amount lands — netting the quote would be WRONG. When it
+        // CANNOT harvest, the withheld-but-unreturned fee corrupts the virtual-reserve curve in a way
+        // simple per-leg net(amount, cfg, epoch) does not model (and this facade has no epoch to net
+        // against). Rejecting self-limits (safe); keep the no-op (reject) path.
+        if (feeConfig !== null &&
+            feeConfig.bpsActive &&
+            feeConfig.withdrawWithheldAuthority !== AUTHORITY) {
+            throw new Error(`runner-rodeo pool ${pool} gate: base mint ${baseMint} carries an ACTIVE Token-2022 transfer fee ` +
+                `whose withdrawWithheldAuthority (${feeConfig.withdrawWithheldAuthority}) is NOT this program's own ` +
+                `authority PDA — it cannot self-harvest the fee, so the constant-product math above (which assumes ` +
+                `the full requested amount reaches the vault) would be wrong`);
+        }
+        const creatorFeeVault = await ata(partnerWallet, quoteMint, TOKEN_PROGRAM);
+        return {
+            venue: SLUG,
+            pool,
+            direction: "quoteToBase",
+            configAccount,
+            baseVault,
+            quoteVault,
+            baseMint,
+            quoteMint,
+            baseTokenProgram,
+            creatorFeeVault,
+            creatorFeeBps,
+            protocolFeeBpsA,
+            protocolFeeBpsB,
+        };
+    },
+};
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/runner-rodeo/index.js.map

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

package/sdk/dist/svm/venues/saber-decimals-wrapper/index.d.ts

@@ -0,0 +1,30 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig, VenueAccount } from "../types.js";
+declare const SLUG = "saber-decimals-wrapper";
+export declare const SABER_DECIMALS_WRAPPER_PROGRAM_ID: Address<"DecZY86MU5Gj7kppfUCEmd4LbXXuyZH1yHaP2NTqdiZB">;
+export declare const OFF_DECIMALS = 8;
+export declare const OFF_MULTIPLIER = 9;
+export declare const OFF_UNDERLYING_MINT = 17;
+export declare const OFF_UNDERLYING_TOKENS = 49;
+export declare const OFF_WRAPPER_MINT = 81;
+export type SaberDecimalsWrapperDirection = "deposit" | "withdraw";
+export interface SaberDecimalsWrapperPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    decimals: number;
+    multiplier: bigint;
+    underlyingMint: Address;
+    vault: Address;
+    wrapperMint: Address;
+    direction: SaberDecimalsWrapperDirection;
+}
+declare function fetchPoolConfig(load: AccountLoader, pool: Address): Promise<SaberDecimalsWrapperPoolConfig>;
+declare function quoteAccounts(base: PoolConfig): VenueAccount[];
+export declare const saberDecimalsWrapper: {
+    slug: string;
+    kind: "constant-product";
+    programId: Address<"DecZY86MU5Gj7kppfUCEmd4LbXXuyZH1yHaP2NTqdiZB">;
+    fetchPoolConfig: typeof fetchPoolConfig;
+    quoteAccounts: typeof quoteAccounts;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/saber-decimals-wrapper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/saber-decimals-wrapper/index.ts"],"names":[],"mappings":"AAqFA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3E,QAAA,MAAM,IAAI,2BAA2B,CAAC;AACtC,eAAO,MAAM,iCAAiC,yDAE7C,CAAC;AAIF,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,mBAAmB,KAAK,CAAC;AACtC,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAInC,MAAM,MAAM,6BAA6B,GAAG,SAAS,GAAG,UAAU,CAAC;AAEnE,MAAM,WAAW,8BAA+B,SAAQ,UAAU;IAChE,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,6BAA6B,CAAC;CAC1C;AAQD,iBAAe,eAAe,CAC5B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,8BAA8B,CAAC,CAwDzC;AAMD,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,EAAE,CAGvD;AAED,eAAO,MAAM,oBAAoB;;;;;;CAMhC,CAAC"}

package/sdk/dist/svm/venues/saber-decimals-wrapper/index.js

@@ -0,0 +1,167 @@
+/**
+ * Saber Decimal Wrapper venue adapter (SvmRoute ladder fragment, adapter
+ * contract v2) — program `DecZY86MU5Gj7kppfUCEmd4LbXXuyZH1yHaP2NTqdiZB`
+ * (`saber-hq/saber-periphery`'s `add-decimals` program, source verified —
+ * see below). This is NOT a priced AMM: it is an EXACT, FIXED-RATE 1:multiplier
+ * conversion between an "underlying" SPL mint and a "wrapper" SPL mint that
+ * exists purely to give the underlying more decimals (a Saber stableswap pool
+ * needs both sides at the same decimal scale, so a token with fewer decimals
+ * than its pair is wrapped through here first). Zero fee, zero slippage,
+ * zero curve — the ENTIRE quote is one multiply (deposit) or one floor-divide
+ * (withdraw). Because Saber pools are an already-served family
+ * (`saber-stableswap`), this venue multiplies the REACH of that existing
+ * coverage rather than adding a standalone market: any underlying token can
+ * now route through its decimal wrapper into (or out of) a Saber pool that
+ * only lists the wrapped mint.
+ *
+ * ── Source verified against `saber-hq/saber-periphery`'s
+ * `programs/add-decimals/src/lib.rs` (`declare_id!` matches the program id
+ * above) ──
+ *
+ *   pub struct WrappedToken {          // #[account], Anchor 8-byte disc first
+ *       pub decimals: u8,              // @8  (offset AFTER the 8-byte disc)
+ *       pub multiplier: u64,           // @9  == 10^(wrapper.decimals - underlying.decimals)
+ *       pub wrapper_underlying_mint: Pubkey,    // @17
+ *       pub wrapper_underlying_tokens: Pubkey,  // @49  (the vault SPL token account)
+ *       pub wrapper_mint: Pubkey,               // @81
+ *       __nonce: u8,                            // @113 (bump seed, unused here)
+ *   }                                            // LEN = 8 + 106 = 114 bytes total
+ *
+ *   to_wrapped_amount(x)    = multiplier.checked_mul(x)   // deposit: underlying -> wrapped
+ *   to_underlying_amount(x) = x.checked_div(multiplier)   // withdraw: wrapped -> underlying (floors; the
+ *                                                          // un-recovered remainder, "dust", stays UN-BURNED
+ *                                                          // in the caller's wrapped-token account)
+ *
+ * Ground-truthed against 22 REAL mainnet WrappedToken accounts (all 114
+ * bytes, decimals 8-15, multiplier 10-1_000_000, every underlying/vault/
+ * wrapper-mint field a live, real pubkey) via `getProgramAccounts`
+ * (`dataSize: 114`), and against a REAL landed on-chain `deposit` call
+ * (signature `3rvS6p6y...BDB6`, slot 436160738, pool
+ * `AnKLLfpMcceM6YXtJ9nGxYekVXqfWy8WNsMZXoQTCVQk`): the inner instruction's
+ * data decodes to discriminator `f223c68952e1f2b6` (== `sha256("global:deposit")[0..8]`,
+ * computed independently) followed by `amountIn=21252713` LE u64 — exactly
+ * the vault's measured pre/post balance delta — and its account list is
+ * `[wrapper, wrapper_mint, wrapper_underlying_tokens, owner(signer),
+ * user_underlying_tokens, user_wrapped_tokens, token_program, <one extra
+ * account appended by the caller's own router, ignored — Anchor's Accounts
+ * struct only consumes the 7 it declares>]`, matching `UserStake` below
+ * field-for-field. `withdraw`'s discriminator (`sha256("global:withdraw")[0..8]`
+ * = `b712469c946da122`) is the same computation, unexercised by that specific
+ * transaction but identical in derivation and instruction shape (disc(8) ++
+ * amount u64 LE(8), no suffix — `withdraw`'s single arg is `max_burn_amount`,
+ * the wrapped amount to spend; the real burn floors to a multiple of
+ * `multiplier`, same as `to_underlying_amount` below).
+ *
+ * ── UserStake (both `deposit` and `withdraw`) — 7 accounts, fixed order ──
+ *   0 wrapper                  (readonly)         — the WrappedToken PDA ("pool")
+ *   1 wrapper_mint              (mut)              — the wrapped SPL mint
+ *   2 wrapper_underlying_tokens (mut)              — the vault (SPL token account)
+ *   3 owner                     (signer)            — authority over the user's two token accounts
+ *   4 user_underlying_tokens    (mut)
+ *   5 user_wrapped_tokens       (mut)
+ *   6 token_program             (readonly)
+ * `deposit`: 4=inAta (underlying), 5=outAta (wrapped). `withdraw`: 4=outAta
+ * (underlying), 5=inAta (wrapped) — the swap direction flips which user ATA
+ * plays which role; the account POSITIONS never change.
+ *
+ * ── Capacity / self-drop (the vault is the ONLY real constraint) ──
+ * `withdraw` cannot pay out more underlying than the vault
+ * (`wrapper_underlying_tokens`) actually holds — the real program's SPL
+ * transfer would fail past that. `deposit` cannot mint past `u64::MAX` total
+ * wrapped supply — and because the program's own invariant keeps
+ * `wrapped_supply == multiplier * vault_balance` at all times (every deposit/
+ * withdraw pair moves both sides by the same multiplier-scaled amount), the
+ * live vault balance alone reconstructs BOTH caps with no extra account
+ * read. Both directions clamp their OWN output to this real ceiling — never
+ * favourable, never negative — so a rung asking for more than the venue can
+ * deliver quotes the flat ceiling instead of a wrong (too-generous) number;
+ * the merge simply doesn't over-elect this slot's share past what the real
+ * CPI would actually pay out.
+ *
+ * ── CU ── see `../../../../the consuming app SVM CU-budget module`'s (sauce-recipes)
+ * `CU_FAMILIES['saber-decimals-wrapper']` for the measured coefficients —
+ * this SDK package carries the adapter only, not the recipe's own CU model.
+ */
+import { address, getAddressCodec } from "@solana/kit";
+import { readUintLE } from "../math.js";
+import { TOKEN_2022_PROGRAM_ID, classifyMintProgram } from "../../token-program.js";
+import { parseMintExtensions } from "../../token-extensions.js";
+const SLUG = "saber-decimals-wrapper";
+export const SABER_DECIMALS_WRAPPER_PROGRAM_ID = address("DecZY86MU5Gj7kppfUCEmd4LbXXuyZH1yHaP2NTqdiZB");
+/** WrappedToken account layout (8-byte Anchor disc, then the fields below). */
+const WRAPPED_TOKEN_SIZE = 114;
+export const OFF_DECIMALS = 8;
+export const OFF_MULTIPLIER = 9;
+export const OFF_UNDERLYING_MINT = 17;
+export const OFF_UNDERLYING_TOKENS = 49;
+export const OFF_WRAPPER_MINT = 81;
+const addressCodec = getAddressCodec();
+function wrapperConfig(cfg) {
+    if (cfg.venue !== SLUG)
+        throw new Error(`${SLUG} ladder adapter got a '${cfg.venue}' pool config`);
+    return cfg;
+}
+async function fetchPoolConfig(load, pool) {
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${SLUG} wrapper ${pool} account not found`);
+    if (data.length !== WRAPPED_TOKEN_SIZE) {
+        throw new Error(`${SLUG} wrapper ${pool} account data is ${data.length} bytes, expected ${WRAPPED_TOKEN_SIZE}`);
+    }
+    const decimals = data[OFF_DECIMALS];
+    const multiplier = readUintLE(data, OFF_MULTIPLIER, 8);
+    if (multiplier === 0n) {
+        throw new Error(`${SLUG} wrapper ${pool} has a zero multiplier (not a real initialized WrappedToken)`);
+    }
+    const underlyingMint = pubkeyAt(data, OFF_UNDERLYING_MINT);
+    const vault = pubkeyAt(data, OFF_UNDERLYING_TOKENS);
+    const wrapperMint = pubkeyAt(data, OFF_WRAPPER_MINT);
+    if (underlyingMint === wrapperMint) {
+        throw new Error(`${SLUG} wrapper ${pool} has identical underlying/wrapper mints — corrupt account`);
+    }
+    // The deposit/withdraw CPI is legacy-SPL (Tokenkeg) only for now, so
+    // SELF-DROP a wrapper whose underlying or wrapper mint is Token-2022 (or
+    // carries an un-routable extension) — the thrown error is the graceful-drop
+    // signal (SvmRoute drops the venue on a fetchPoolConfig throw). An unreadable
+    // mint falls back to the legacy assumption, keeping the legacy path unchanged.
+    const mints = [underlyingMint, wrapperMint];
+    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(`${SLUG}: dropping wrapper ${pool} — mint ${mint} is Token-2022 (this venue's swap is legacy-SPL only)`);
+        }
+        const { blocking } = parseMintExtensions(mintData);
+        if (blocking.length > 0) {
+            throw new Error(`${SLUG}: dropping wrapper ${pool} — mint ${mint} is un-routable: ${blocking.join("; ")}`);
+        }
+    }
+    return {
+        venue: SLUG,
+        pool,
+        decimals,
+        multiplier,
+        underlyingMint,
+        vault,
+        wrapperMint,
+        direction: "deposit",
+    };
+}
+function pubkeyAt(data, offset) {
+    return addressCodec.decode(data.subarray(offset, offset + 32));
+}
+function quoteAccounts(base) {
+    const cfg = wrapperConfig(base);
+    return [{ ref: "vault", address: cfg.vault }];
+}
+export const saberDecimalsWrapper = {
+    slug: SLUG,
+    kind: "constant-product",
+    programId: SABER_DECIMALS_WRAPPER_PROGRAM_ID,
+    fetchPoolConfig,
+    quoteAccounts,
+};
+//# sourceMappingURL=index.js.map

package/sdk/dist/svm/venues/saber-decimals-wrapper/index.js.map

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

package/sdk/dist/svm/venues/saber-stableswap/index.d.ts

@@ -0,0 +1,33 @@
+import type { Address } from "@solana/kit";
+import type { PoolConfig, SvmVenueAdapter } from "../types.js";
+declare const SLUG = "saber-stableswap";
+export declare const SABER_STABLESWAP_PROGRAM_ID: Address<"SSwpkEEcbUqx4vtoEByFjSkhKdCT862DNVb52nZg1UZ">;
+export interface SaberPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** Stored bump for the swap authority (SwapInfo byte 2) — create_program_address, NOT find. */
+    nonce: number;
+    /** create_program_address([pool (32B), [nonce]], programId) — owner of both vaults. */
+    swapAuthority: Address;
+    initialAmpFactor: bigint;
+    targetAmpFactor: bigint;
+    /** i64 unix seconds, read unsigned (sign bit never set for real timestamps). */
+    startRampTs: bigint;
+    /** i64 unix seconds; 0 or past means amp == targetAmpFactor. */
+    stopRampTs: bigint;
+    /** SPL token account holding token A reserves (quote-input side). */
+    vaultA: Address;
+    /** SPL token account holding token B reserves (quote-output side). */
+    vaultB: Address;
+    mintA: Address;
+    mintB: Address;
+    adminFeeA: Address;
+    /** Admin fee account of the OUTPUT token for A -> B swaps (instruction account 7). */
+    adminFeeB: Address;
+    tradeFeeNumerator: bigint;
+    tradeFeeDenominator: bigint;
+    adminTradeFeeNumerator: bigint;
+    adminTradeFeeDenominator: bigint;
+}
+export declare const saberStableswap: SvmVenueAdapter;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/sdk/dist/svm/venues/saber-stableswap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/saber-stableswap/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAGV,UAAU,EACV,eAAe,EAIhB,MAAM,aAAa,CAAC;AAIrB,QAAA,MAAM,IAAI,qBAAqB,CAAC;AAEhC,eAAO,MAAM,2BAA2B,wDAAyD,CAAC;AAQlG,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,+FAA+F;IAC/F,KAAK,EAAE,MAAM,CAAC;IACd,uFAAuF;IACvF,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,MAAM,EAAE,OAAO,CAAC;IAChB,sEAAsE;IACtE,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,sFAAsF;IACtF,SAAS,EAAE,OAAO,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wBAAwB,EAAE,MAAM,CAAC;CAClC;AAiGD,eAAO,MAAM,eAAe,EAAE,eAgN7B,CAAC"}