@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/token-program.d.ts

@@ -0,0 +1,58 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, OwnedAccountLoader } from "./venues/types.js";
+/** Legacy SPL Token program (classic Tokenkeg). */
+export declare const TOKEN_PROGRAM_ID: Address;
+/** Token-2022 program (extensions). */
+export declare const TOKEN_2022_PROGRAM_ID: Address;
+/** A classic SPL mint account is exactly this many bytes. */
+export declare const SPL_MINT_SIZE = 82;
+/**
+ * A Token-2022 mint with extensions pads its base region to this size, then
+ * writes the account-type discriminator at this offset (the value itself).
+ */
+export declare const T22_ACCOUNT_TYPE_OFFSET = 165;
+/** account_type == 1 means Mint (2 means token Account). */
+export declare const T22_ACCOUNT_TYPE_MINT = 1;
+/** First byte of the TLV extension region (right after the account-type byte). */
+export declare const T22_TLV_START = 166;
+/** Async owner lookup for the escape-hatch resolver — returns the OWNING program id. */
+export type OwnerLoader = (mint: Address) => Promise<Address | null>;
+/**
+ * Classify a mint's token program from its raw account data alone (pure, no
+ * I/O). Returns TOKEN_PROGRAM_ID for a classic 82-byte mint, TOKEN_2022_PROGRAM_ID
+ * for a >=166-byte extension mint with the Mint account-type byte. Throws on a
+ * length/type that is not a mint layout. See the file header for the one
+ * ambiguous case (extensionless T22 mint → classified legacy).
+ */
+export declare function classifyMintProgram(mint: Address, data: Uint8Array, owner?: Address): Address;
+/**
+ * Resolve the token program serving `mint` by reading its account via the
+ * AccountLoader and classifying the data shape. Throws a clear error if the
+ * mint account is missing. Resolve PER MINT — a pool can mix a legacy mint on
+ * one side and a Token-2022 mint on the other.
+ */
+export declare function resolveTokenProgram(load: AccountLoader, mint: Address): Promise<Address>;
+/**
+ * Resolve by the mint's OWNER, the only method that is correct for every mint.
+ *
+ * Prefer this over `resolveTokenProgram` wherever an `OwnedAccountLoader` is available: it settles
+ * the extensionless-Token-2022 case that the shape path cannot see, and needs no extra round trip
+ * because the owner arrives with the data.
+ */
+export declare function resolveTokenProgramOwned(load: OwnedAccountLoader, mint: Address): Promise<Address>;
+/**
+ * Escape hatch for the extensionless-T22 ambiguity: resolve strictly by the
+ * mint's OWNING program, via a lookup that can see the owner (unlike the
+ * data-only AccountLoader). Throws if the mint is missing or is owned by
+ * neither token program.
+ */
+export declare function resolveTokenProgramByOwner(mint: Address, ownerOf: OwnerLoader): Promise<Address>;
+/** True iff the mint data is a Token-2022 mint (>=166 bytes, Mint account-type byte). */
+export declare function isToken2022Mint(data: Uint8Array): boolean;
+/**
+ * A caching per-mint resolver: repeated resolves of the same mint within one
+ * pool/route read the account once. Returns a resolver function closing over a
+ * Map<mintBase58, Address>.
+ */
+export declare function createTokenProgramResolver(load: AccountLoader): (mint: Address) => Promise<Address>;
+//# sourceMappingURL=token-program.d.ts.map

package/sdk/dist/svm/token-program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-program.d.ts","sourceRoot":"","sources":["../../src/svm/token-program.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE3E,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,EAAE,OAAgE,CAAC;AAChG,uCAAuC;AACvC,eAAO,MAAM,qBAAqB,EAAE,OAEnC,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC;;;GAGG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,4DAA4D;AAC5D,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,kFAAkF;AAClF,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC,wFAAwF;AACxF,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAsB7F;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAI9F;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,OAAO,CAAC,CAKlB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CASlB;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,aAAa,GAClB,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CASrC"}

package/sdk/dist/svm/token-program.js

@@ -0,0 +1,137 @@
+/**
+ * Shared per-mint token-program resolver for the SVM venue adapters.
+ *
+ * A mint account is owned either by the legacy SPL Token program
+ * (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA) or by Token-2022
+ * (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb). The correct token program is
+ * the ACCOUNT OWNER of the mint. `OwnedAccountLoader` (see ./venues/types.ts)
+ * carries it, and `resolveTokenProgramOwned` is the correct resolver — prefer
+ * both. The data-only `AccountLoader` drops the owner, so where only that is
+ * available the resolver must infer the program from the mint's data SHAPE,
+ * with the unresolvable case below:
+ *
+ *   - A classic SPL mint is EXACTLY 82 bytes.
+ *   - A Token-2022 mint that carries at least one extension is padded to a
+ *     165-byte base, then a 1-byte account-type discriminator at offset 165
+ *     (== 1 for Mint), then a TLV extension region — so its length is >= 166.
+ *
+ * Layout cross-checked against the authoritative spl-token-2022 source (the
+ * `MintWithTransferFeeConfigLayout` proptest fixture in orca-so/whirlpools:
+ * `82 + 83 + 1 + 2 + 2 + 108`, and token-2022 `PodMint`/`PodStateWithExtensions`).
+ *
+ * THE ONE UNRESOLVABLE CASE, documented rather than papered over: a Token-2022
+ * mint with NO extensions is ALSO exactly 82 bytes and byte-for-byte identical
+ * to a legacy mint — the two are indistinguishable from data alone. This
+ * resolver classifies such a mint as legacy (the common, safe assumption: an
+ * extensionless T22 mint has no transfer fee and no blocking extension, so it
+ * routes identically to a legacy mint). When a caller genuinely needs the true
+ * owner for an extensionless mint (e.g. to pick the right token_program account
+ * for a CPI), use `resolveTokenProgramByOwner` with an owner lookup that can
+ * read the account's owning program (a full `getAccountInfo`, not the
+ * data-only AccountLoader).
+ */
+import { address } from "@solana/kit";
+/** Legacy SPL Token program (classic Tokenkeg). */
+export const TOKEN_PROGRAM_ID = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/** Token-2022 program (extensions). */
+export const TOKEN_2022_PROGRAM_ID = address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+/** A classic SPL mint account is exactly this many bytes. */
+export const SPL_MINT_SIZE = 82;
+/**
+ * A Token-2022 mint with extensions pads its base region to this size, then
+ * writes the account-type discriminator at this offset (the value itself).
+ */
+export const T22_ACCOUNT_TYPE_OFFSET = 165;
+/** account_type == 1 means Mint (2 means token Account). */
+export const T22_ACCOUNT_TYPE_MINT = 1;
+/** First byte of the TLV extension region (right after the account-type byte). */
+export const T22_TLV_START = 166;
+/**
+ * Classify a mint's token program from its raw account data alone (pure, no
+ * I/O). Returns TOKEN_PROGRAM_ID for a classic 82-byte mint, TOKEN_2022_PROGRAM_ID
+ * for a >=166-byte extension mint with the Mint account-type byte. Throws on a
+ * length/type that is not a mint layout. See the file header for the one
+ * ambiguous case (extensionless T22 mint → classified legacy).
+ */
+export function classifyMintProgram(mint, data, owner) {
+    // The owner is AUTHORITATIVE and settles the ambiguity below outright. Prefer it whenever the
+    // caller has it — `coalescingOwnedAccountLoader` now carries it through.
+    if (owner !== undefined) {
+        if (owner === TOKEN_PROGRAM_ID)
+            return TOKEN_PROGRAM_ID;
+        if (owner === TOKEN_2022_PROGRAM_ID)
+            return TOKEN_2022_PROGRAM_ID;
+        throw new Error(`token-program: mint ${mint} is owned by ${owner}, neither the legacy nor Token-2022 program`);
+    }
+    if (data.length === SPL_MINT_SIZE)
+        return TOKEN_PROGRAM_ID;
+    if (data.length < T22_TLV_START) {
+        throw new Error(`token-program: mint ${mint} data is ${data.length} bytes, not a mint account layout (want 82, or >=166 for token-2022)`);
+    }
+    if (data[T22_ACCOUNT_TYPE_OFFSET] !== T22_ACCOUNT_TYPE_MINT) {
+        throw new Error(`token-program: mint ${mint} account-type byte is ${data[T22_ACCOUNT_TYPE_OFFSET]}, expected ${T22_ACCOUNT_TYPE_MINT} (Mint)`);
+    }
+    return TOKEN_2022_PROGRAM_ID;
+}
+/**
+ * Resolve the token program serving `mint` by reading its account via the
+ * AccountLoader and classifying the data shape. Throws a clear error if the
+ * mint account is missing. Resolve PER MINT — a pool can mix a legacy mint on
+ * one side and a Token-2022 mint on the other.
+ */
+export async function resolveTokenProgram(load, mint) {
+    const data = await load(mint);
+    if (data === null)
+        throw new Error(`token-program: mint ${mint} account not found`);
+    return classifyMintProgram(mint, data);
+}
+/**
+ * Resolve by the mint's OWNER, the only method that is correct for every mint.
+ *
+ * Prefer this over `resolveTokenProgram` wherever an `OwnedAccountLoader` is available: it settles
+ * the extensionless-Token-2022 case that the shape path cannot see, and needs no extra round trip
+ * because the owner arrives with the data.
+ */
+export async function resolveTokenProgramOwned(load, mint) {
+    const account = await load(mint);
+    if (account === null)
+        throw new Error(`token-program: mint ${mint} account not found`);
+    return classifyMintProgram(mint, account.data, account.owner);
+}
+/**
+ * Escape hatch for the extensionless-T22 ambiguity: resolve strictly by the
+ * mint's OWNING program, via a lookup that can see the owner (unlike the
+ * data-only AccountLoader). Throws if the mint is missing or is owned by
+ * neither token program.
+ */
+export async function resolveTokenProgramByOwner(mint, ownerOf) {
+    const owner = await ownerOf(mint);
+    if (owner === null)
+        throw new Error(`token-program: mint ${mint} account not found (owner lookup)`);
+    if (owner === TOKEN_PROGRAM_ID)
+        return TOKEN_PROGRAM_ID;
+    if (owner === TOKEN_2022_PROGRAM_ID)
+        return TOKEN_2022_PROGRAM_ID;
+    throw new Error(`token-program: mint ${mint} is owned by ${owner}, neither the legacy nor Token-2022 program`);
+}
+/** True iff the mint data is a Token-2022 mint (>=166 bytes, Mint account-type byte). */
+export function isToken2022Mint(data) {
+    return data.length >= T22_TLV_START && data[T22_ACCOUNT_TYPE_OFFSET] === T22_ACCOUNT_TYPE_MINT;
+}
+/**
+ * A caching per-mint resolver: repeated resolves of the same mint within one
+ * pool/route read the account once. Returns a resolver function closing over a
+ * Map<mintBase58, Address>.
+ */
+export function createTokenProgramResolver(load) {
+    const cache = new Map();
+    return async (mint) => {
+        const cached = cache.get(mint);
+        if (cached !== undefined)
+            return cached;
+        const program = await resolveTokenProgram(load, mint);
+        cache.set(mint, program);
+        return program;
+    };
+}
+//# sourceMappingURL=token-program.js.map

package/sdk/dist/svm/token-program.js.map

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

package/sdk/dist/svm/transaction.d.ts

@@ -0,0 +1,13 @@
+import type { AddressesByLookupTableAddress, BlockhashLifetimeConstraint, Instruction, SendableTransaction, Transaction, TransactionSigner, TransactionWithBlockhashLifetime } from "@solana/kit";
+/** Byte length of the encoded wire transaction (kit's own measure; limit is 1232). */
+export { getTransactionSize } from "@solana/kit";
+export type SignedExecuteTransaction = SendableTransaction & Transaction & TransactionWithBlockhashLifetime;
+export interface BuildExecuteTransactionInput {
+    payer: TransactionSigner;
+    instructions: readonly Instruction[];
+    latestBlockhash: BlockhashLifetimeConstraint;
+    lookupTables?: AddressesByLookupTableAddress;
+}
+/** Builds and fully signs a v0 transaction, optionally compressed through address lookup tables. */
+export declare function buildExecuteTransaction({ payer, instructions, latestBlockhash, lookupTables, }: BuildExecuteTransactionInput): Promise<SignedExecuteTransaction>;
+//# sourceMappingURL=transaction.d.ts.map

package/sdk/dist/svm/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/svm/transaction.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,6BAA6B,EAC7B,2BAA2B,EAC3B,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gCAAgC,EACjC,MAAM,aAAa,CAAC;AAErB,sFAAsF;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,MAAM,wBAAwB,GAAG,mBAAmB,GACxD,WAAW,GACX,gCAAgC,CAAC;AAEnC,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IACrC,eAAe,EAAE,2BAA2B,CAAC;IAC7C,YAAY,CAAC,EAAE,6BAA6B,CAAC;CAC9C;AAED,oGAAoG;AACpG,wBAAsB,uBAAuB,CAAC,EAC5C,KAAK,EACL,YAAY,EACZ,eAAe,EACf,YAAY,GACb,EAAE,4BAA4B,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAelE"}

package/sdk/dist/svm/transaction.js

@@ -0,0 +1,14 @@
+import { appendTransactionMessageInstructions, assertIsTransactionWithBlockhashLifetime, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from "@solana/kit";
+/** Byte length of the encoded wire transaction (kit's own measure; limit is 1232). */
+export { getTransactionSize } from "@solana/kit";
+/** Builds and fully signs a v0 transaction, optionally compressed through address lookup tables. */
+export async function buildExecuteTransaction({ payer, instructions, latestBlockhash, lookupTables, }) {
+    const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(payer, m), (m) => appendTransactionMessageInstructions(instructions, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m));
+    const compressed = lookupTables
+        ? compressTransactionMessageUsingAddressLookupTables(message, lookupTables)
+        : message;
+    const transaction = await signTransactionMessageWithSigners(compressed);
+    assertIsTransactionWithBlockhashLifetime(transaction);
+    return transaction;
+}
+//# sourceMappingURL=transaction.js.map

package/sdk/dist/svm/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/svm/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oCAAoC,EACpC,wCAAwC,EACxC,kDAAkD,EAClD,wBAAwB,EACxB,IAAI,EACJ,mCAAmC,EACnC,2CAA2C,EAC3C,iCAAiC,GAClC,MAAM,aAAa,CAAC;AAWrB,sFAAsF;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAajD,oGAAoG;AACpG,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,EAC5C,KAAK,EACL,YAAY,EACZ,eAAe,EACf,YAAY,GACiB;IAC7B,MAAM,OAAO,GAAG,IAAI,CAClB,wBAAwB,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EACxC,CAAC,CAAC,EAAE,EAAE,CAAC,mCAAmC,CAAC,KAAK,EAAE,CAAC,CAAC,EACpD,CAAC,CAAC,EAAE,EAAE,CAAC,oCAAoC,CAAC,YAAY,EAAE,CAAC,CAAC,EAC5D,CAAC,CAAC,EAAE,EAAE,CAAC,2CAA2C,CAAC,eAAe,EAAE,CAAC,CAAC,CACvE,CAAC;IAEF,MAAM,UAAU,GAAG,YAAY;QAC7B,CAAC,CAAC,kDAAkD,CAAC,OAAO,EAAE,YAAY,CAAC;QAC3E,CAAC,CAAC,OAAO,CAAC;IACZ,MAAM,WAAW,GAAG,MAAM,iCAAiC,CAAC,UAAU,CAAC,CAAC;IACxE,wCAAwC,CAAC,WAAW,CAAC,CAAC;IAEtD,OAAO,WAAW,CAAC;AACrB,CAAC"}

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

@@ -0,0 +1,34 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+export declare const ALDRIN_V1_PROGRAM_ID: Address<"AMM55ShdkoGRB5jVYPjWziwk8m5MpwyDgsMWHaMSQWH6">;
+export declare const ALDRIN_V2_PROGRAM_ID: Address<"CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4">;
+export type AldrinDirection = "baseToQuote" | "quoteToBase";
+export interface AldrinPoolConfig extends PoolConfig {
+    venue: "aldrin" | "aldrin-v2";
+    version: 1 | 2;
+    poolMint: Address;
+    baseTokenVault: Address;
+    baseTokenMint: Address;
+    quoteTokenVault: Address;
+    quoteTokenMint: Address;
+    poolSigner: Address;
+    feePoolTokenAccount: Address;
+    tradeFeeNumerator: bigint;
+    tradeFeeDenominator: bigint;
+    ownerTradeFeeNumerator: bigint;
+    ownerTradeFeeDenominator: bigint;
+    /** V2 only — the external curve account the swap ix attaches (CP pools never read from it). */
+    curve?: Address;
+    direction: AldrinDirection;
+}
+export declare const aldrin: {
+    slug: "aldrin";
+    programId: Address<"AMM55ShdkoGRB5jVYPjWziwk8m5MpwyDgsMWHaMSQWH6">;
+    fetchPoolConfig: (load: AccountLoader, pool: Address) => Promise<AldrinPoolConfig>;
+};
+export declare const aldrinV2: {
+    slug: "aldrin-v2";
+    programId: Address<"CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4">;
+    fetchPoolConfig: (load: AccountLoader, pool: Address) => Promise<AldrinPoolConfig>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/aldrin/index.ts"],"names":[],"mappings":"AAwGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,eAAO,MAAM,oBAAoB,yDAA0D,CAAC;AAC5F,eAAO,MAAM,oBAAoB,yDAA0D,CAAC;AA0B5F,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,aAAa,CAAC;AAE5D,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9B,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wBAAwB,EAAE,MAAM,CAAC;IACjC,+FAA+F;IAC/F,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,eAAe,CAAC;CAC5B;AAmED,eAAO,MAAM,MAAM;;;4BAGO,aAAa,QAAQ,OAAO,KAAG,OAAO,CAAC,gBAAgB,CAAC;CAEjF,CAAC;AAEF,eAAO,MAAM,QAAQ;;;4BAGK,aAAa,QAAQ,OAAO,KAAG,OAAO,CAAC,gBAAgB,CAAC;CAEjF,CAAC"}

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

@@ -0,0 +1,193 @@
+/**
+ * Aldrin AMM — two sibling Anchor programs off the classic spl-token-swap-
+ * style constant-product curve (input-side trade fee + owner fee, both
+ * floored with the standard "min 1 raw unit if the numerator is nonzero"
+ * rule, then a ceiling-divided constant-product quote). SLUG `aldrin` = V1
+ * (program `AMM55ShdkoGRB5jVYPjWziwk8m5MpwyDgsMWHaMSQWH6`, CP-only — the
+ * on-chain account carries no curve-selector field at all). SLUG
+ * `aldrin-v2` = V2 (program `CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4`),
+ * whose pool account additionally carries a `curveType` byte (0 = the same
+ * constant product, 1 = a StableSwap curve driven by an external `curve`
+ * account) — measured live 2026-07-31 via `getProgramAccounts` filtered to
+ * the 474-byte pool layout: 301 of 304 live pools are curveType 0, 3 are
+ * curveType 1. This adapter implements CP for both programs and
+ * SELF-DROPS a curveType-1 V2 pool (fetchPoolConfig throws a named error,
+ * which the recipe's per-pool discovery gate turns into a drop, exactly
+ * like every other family's out-of-scope gate) rather than approximating
+ * the StableSwap curve with CP math.
+ *
+ * LAYOUT — not reverse-engineered, lifted from the published
+ * `@aldrin_exchange/sdk` npm package (`pools/layout.ts`'s
+ * `POOL_LAYOUT`/`POOL_V2_LAYOUT`, borsh via `@solana/buffer-layout`). Both
+ * are Anchor accounts: the leading 8 bytes are
+ * `sha256("account:Pool")[0..8]` = `f19a6d0411b16dbc` — byte-identical to
+ * this repo's own `pumpswap` adapter's "Pool" discriminator (an Anchor
+ * account discriminator is a function of the struct NAME alone, not the
+ * program, so two unrelated programs both naming their pool struct "Pool"
+ * collide on purpose). V1 span 441 bytes (21 live pools, ALL
+ * discriminator-valid). V2 span 474 bytes (304 live pools at the dataSize
+ * filter; 26 of those are all-zero/closed accounts that still match the
+ * size — `fetchPoolConfig` gates on the discriminator byte-for-byte, not
+ * merely on account length, so a closed pool self-drops instead of
+ * decoding garbage).
+ *
+ * QUOTE MATH — ground-truthed against SIX REAL SETTLED MAINNET SWAPS (three
+ * on a V1 pool, three on a V2 curveType=0 pool), not derived from the
+ * published SDK's own client-side estimate (which is NOT usable ground
+ * truth: `tokenSwap.ts`'s `resolveSwapInputs` applies NO fee at all to its
+ * `CURVE.PRODUCT` estimate, and stubs `CURVE.STABLE` as
+ * `minIncomeAmount = outcomeAmount` — not a real quote either way). Each of
+ * the six was read via `getTransaction`'s `preTokenBalances`/
+ * `postTokenBalances` at the pool's own two vault accounts (the vault
+ * delta, not the trader's external float account, which in every sampled
+ * tx was shared across other unrelated instructions in the same
+ * searcher-bundled transaction and carried a few raw units of unrelated
+ * noise): given the pool's pre-swap reserves and its own stored fee
+ * fractions, the formula below reproduced the realized output EXACTLY in
+ * all six cases, at sizes from ~5.35M to ~63.4M raw units. That formula is
+ * BYTE-IDENTICAL to this repo's own `orca-legacy-token-swap` adapter's
+ * `qOrca` — unsurprising, Aldrin's V1 program is a documented fork of the
+ * same spl-token-swap lineage Orca's V2 program forked too.
+ *
+ * SWAP CPI — `SWAP_INSTRUCTION_LAYOUT` is
+ * `[disc(8) global:swap][tokens u64 LE][minTokens u64 LE][side u8]`;
+ * disc = `sha256("global:swap")[0..8]` = `f8c69e91e17587c8` (also lifted
+ * from the SDK, confirmed byte-identical against the raw instruction data
+ * of the same six validation transactions). `tokens` is the exact
+ * specified INPUT regardless of side (all six real txs had a pool-vault
+ * delta matching `tokens`, modulo the unrelated-instruction noise above).
+ * `side` selects direction over a FIXED base/quote account order: Ask (1)
+ * = base in / quote out (all six validation txs used this side), Bid (0) =
+ * quote in / base out (the SDK's own `side: isInverted ? SIDE.ASK :
+ * SIDE.BID` mapping in `tokenSwap.ts` — the reverse direction is untested
+ * against a real transaction here, but the invariant is a symmetric CP
+ * curve over a fixed account list with no other source of asymmetry, so
+ * flipping which vault is read as the input reserve is the only change).
+ * Venue-level min_out is always 1 — the recipe's post-swap outAta delta
+ * check enforces the real bound, matching every other family.
+ *
+ * V1 swap accounts (10): pool, poolSigner, poolMint(w), baseVault(w),
+ * quoteVault(w), feePoolTokenAccount(w), owner(signer),
+ * userBaseTokenAccount(w), userQuoteTokenAccount(w), TOKEN_PROGRAM.
+ * V2 (11) inserts `curve` (readonly, stored on the pool account — required
+ * by the V2 program's account list even for a CP pool, though this adapter
+ * never reads its contents). `poolSigner` is stored directly as a pubkey
+ * FIELD on the pool account (unlike orca-legacy-token-swap's stored-bump
+ * `create_program_address` dance) — no PDA derivation needed, the fetch
+ * just reads it.
+ *
+ * CU — `CU_FAMILIES` in `../budget.ts` cites the measurement method (a
+ * standalone LiteSVM real-binary-CPI harness against the same two real
+ * mainnet pools this file's header validated, calibrated against this
+ * repo's own pinned `orca-legacy-token-swap` baseline measured the same
+ * way) rather than repeating it here.
+ *
+ * KNOWN, MEASURED, SAFE-DIRECTION QUIRK — the real program does not always
+ * debit EXACTLY `tokens` from the user: a raw hand-built instruction (no
+ * the consuming app engine involved) against the SAME V1 pool this file validates,
+ * at seven sizes from 10M to 1B raw units, measured the ACTUAL debit
+ * (verified equal to the vault's own credit — both sides agree) falling 0
+ * to 12 raw units SHORT of the requested `tokens`, NEVER over, and
+ * non-monotone in size (1_000_000_000 -> short 1; 100_000_000 -> short 12;
+ * 123_456_789 -> short 0) — not a simple proportional rounding term this
+ * adapter can reproduce bit-exactly without Aldrin's own source. It does
+ * NOT affect the predicted output (a <=12-unit shift in netIn against
+ * multi-billion-unit reserves cannot move the floored CP quote — confirmed:
+ * the realized output matched the prediction exactly at every size tested)
+ * and is economically identical to the ordinary "partial fill" case
+ * SvmRoute already handles structurally on SVM (the un-entered input
+ * simply never leaves the user's own `inAta` — there is no pot to
+ * reconcile). `the consuming app realcpi e2e test`'s `aldrin`/
+ * `aldrin-v2` cells assert this bound explicitly (`runQuad`'s `inputSlack`
+ * parameter) rather than exact-debit equality, unlike every other family.
+ */
+import { address, getAddressDecoder } from "@solana/kit";
+import { readUintLE } from "../math.js";
+export const ALDRIN_V1_PROGRAM_ID = address("AMM55ShdkoGRB5jVYPjWziwk8m5MpwyDgsMWHaMSQWH6");
+export const ALDRIN_V2_PROGRAM_ID = address("CURVGoZn8zycx6FXwwevgBTB2gVvdbGTEpvMJDbgs2t4");
+/** sha256("account:Pool")[0..8] — shared with this repo's pumpswap adapter; see module header. */
+const POOL_DISCRIMINATOR = [0xf1, 0x9a, 0x6d, 0x04, 0x11, 0xb1, 0x6d, 0xbc];
+const POOL_V1_SIZE = 441;
+const POOL_V2_SIZE = 474;
+// Offsets into POOL_FIELDS_COMMON (identical prefix on both versions).
+const OFF_POOL_MINT = 40;
+const OFF_BASE_VAULT = 72;
+const OFF_BASE_MINT = 104;
+const OFF_QUOTE_VAULT = 136;
+const OFF_QUOTE_MINT = 168;
+const OFF_POOL_SIGNER = 200;
+const OFF_FEE_POOL_TOKEN_ACCOUNT = 361;
+const OFF_TRADE_FEE_NUMERATOR = 393;
+const OFF_TRADE_FEE_DENOMINATOR = 401;
+const OFF_OWNER_FEE_NUMERATOR = 409;
+const OFF_OWNER_FEE_DENOMINATOR = 417;
+// V2-only trailer.
+const OFF_CURVE_TYPE = 441;
+const OFF_CURVE = 442;
+const CURVE_TYPE_PRODUCT = 0;
+function hasDiscriminator(data, discriminator) {
+    return data.length >= discriminator.length && discriminator.every((byte, i) => data[i] === byte);
+}
+async function fetchAldrinPoolConfig(load, pool, version) {
+    const slug = version === 1 ? "aldrin" : "aldrin-v2";
+    const data = await load(pool);
+    if (data === null)
+        throw new Error(`${slug} pool ${pool} account not found`);
+    const expectedSize = version === 1 ? POOL_V1_SIZE : POOL_V2_SIZE;
+    if (data.length !== expectedSize) {
+        throw new Error(`${slug} pool ${pool} data must be ${expectedSize} bytes, got ${data.length}`);
+    }
+    if (!hasDiscriminator(data, POOL_DISCRIMINATOR)) {
+        throw new Error(`${slug} pool ${pool} is not an initialized Aldrin Pool account (bad Anchor discriminator)`);
+    }
+    if (version === 2) {
+        const curveType = data[OFF_CURVE_TYPE];
+        if (curveType !== CURVE_TYPE_PRODUCT) {
+            throw new Error(`${slug} pool ${pool} curveType must be ${CURVE_TYPE_PRODUCT} (constant product), got ${curveType} — StableSwap curves are not implemented by this adapter`);
+        }
+    }
+    const decoder = getAddressDecoder();
+    const pubkeyAt = (offset) => decoder.decode(data.subarray(offset, offset + 32));
+    const u64 = (offset) => readUintLE(data, offset, 8);
+    const tradeFeeNumerator = u64(OFF_TRADE_FEE_NUMERATOR);
+    const tradeFeeDenominator = u64(OFF_TRADE_FEE_DENOMINATOR);
+    const ownerTradeFeeNumerator = u64(OFF_OWNER_FEE_NUMERATOR);
+    const ownerTradeFeeDenominator = u64(OFF_OWNER_FEE_DENOMINATOR);
+    for (const [name, numerator, denominator] of [
+        ["trade", tradeFeeNumerator, tradeFeeDenominator],
+        ["owner trade", ownerTradeFeeNumerator, ownerTradeFeeDenominator],
+    ]) {
+        if (numerator !== 0n && denominator === 0n) {
+            throw new Error(`${slug} pool ${pool} ${name} fee denominator is 0 with nonzero numerator ${numerator}`);
+        }
+    }
+    return {
+        venue: slug,
+        pool,
+        version,
+        poolMint: pubkeyAt(OFF_POOL_MINT),
+        baseTokenVault: pubkeyAt(OFF_BASE_VAULT),
+        baseTokenMint: pubkeyAt(OFF_BASE_MINT),
+        quoteTokenVault: pubkeyAt(OFF_QUOTE_VAULT),
+        quoteTokenMint: pubkeyAt(OFF_QUOTE_MINT),
+        poolSigner: pubkeyAt(OFF_POOL_SIGNER),
+        feePoolTokenAccount: pubkeyAt(OFF_FEE_POOL_TOKEN_ACCOUNT),
+        tradeFeeNumerator,
+        tradeFeeDenominator,
+        ownerTradeFeeNumerator,
+        ownerTradeFeeDenominator,
+        curve: version === 2 ? pubkeyAt(OFF_CURVE) : undefined,
+        direction: "baseToQuote",
+    };
+}
+export const aldrin = {
+    slug: "aldrin",
+    programId: ALDRIN_V1_PROGRAM_ID,
+    fetchPoolConfig: (load, pool) => fetchAldrinPoolConfig(load, pool, 1),
+};
+export const aldrinV2 = {
+    slug: "aldrin-v2",
+    programId: ALDRIN_V2_PROGRAM_ID,
+    fetchPoolConfig: (load, pool) => fetchAldrinPoolConfig(load, pool, 2),
+};
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,121 @@
+import type { Address } from "@solana/kit";
+import type { AccountLoader, PoolConfig } from "../types.js";
+declare const SLUG = "alphaq";
+export declare const ALPHAQ_PROGRAM_ID: Address<"ALPHAQmeA7bjrVuccPsYPiCvsi428SNwte66Srvs4pHA">;
+/** Minimal getProgramAccounts transport for the stats-account join (data included, unlike the
+ *  pubkey-only {@link GetProgramAccountsRpc} discovery.ts uses for candidate scans). */
+export interface AlphaqStatsRpc {
+    getProgramAccounts(program: Address, config: {
+        encoding: "base64";
+        filters: {
+            dataSize: bigint;
+        }[];
+    }): {
+        send(): Promise<readonly {
+            pubkey: Address;
+            account: {
+                data: [string, string];
+            };
+        }[]>;
+    };
+}
+/**
+ * One-time (idempotent, memoized) live join for markets not yet in
+ * {@link ALPHAQ_STATS_ACCOUNTS}. Safe to call repeatedly/concurrently — every
+ * call after the first returns the SAME in-flight/completed promise. A
+ * failure here never throws past the caller that awaits it losing anything
+ * beyond "no new markets discovered this run" — the static table still
+ * serves every market known at integration time.
+ *
+ * NOT auto-wired into `the consuming app SVM discovery module`'s gPA sweep (deliberately —
+ * it would add one extra getProgramAccounts call to EVERY discovery sweep for
+ * a table that is already complete for every market that exists today). A
+ * caller with its own boot sequence (the api, a CLI, a future cron) should
+ * invoke this once with a live `getProgramAccounts` transport to pick up any
+ * AlphaQ market added after this file was captured.
+ */
+export declare function primeAlphaqStatsAccounts(rpc: AlphaqStatsRpc): Promise<void>;
+/** Test-only: seed the runtime overlay without a real RPC (LiteSVM/jest fixtures). */
+export declare function __setAlphaqStatsAccountsForTest(entries: Readonly<Record<string, Address>>): void;
+/** Test-only: undo {@link __setAlphaqStatsAccountsForTest} / a completed prime. */
+export declare function __resetAlphaqStatsAccountsForTest(): void;
+declare function decodeSymbol(data: Uint8Array): string;
+export interface AlphaqPoolConfig extends PoolConfig {
+    venue: typeof SLUG;
+    /** 'AtoB' (default, mintA -> mintB) | 'BtoA'. */
+    direction: "AtoB" | "BtoA";
+    symbol: string;
+    mintA: Address;
+    mintB: Address;
+    vaultA: Address;
+    vaultB: Address;
+    decimalsA: number;
+    decimalsB: number;
+    /** The market's 336-byte hot-state companion account — WRITABLE in the swap CPI. */
+    statsAccount: Address;
+    /**
+     * AlphaQ's live oracle price of mintA in mintB, scaled by {@link PRICE_SCALE}
+     * (1e10), read from the stats account at {@link OFF_STATS_PRICE}. `1e10`
+     * (parity) for a genuine stablecoin pair; the real spot (e.g. ~1.178e10 for
+     * syrupUSDC) for a non-stable one. A non-stable pool is priced at this spot;
+     * a stablecoin pool keeps the byte-identical parity model and ignores it.
+     */
+    priceRaw: bigint;
+    /**
+     * The unix timestamp (seconds) the oracle price was last cranked, read from
+     * the stats account at {@link OFF_STATS_PRICE_TS}. The freshness anchor: a
+     * non-stable market is only served when this is recent (see
+     * {@link MAX_PRICE_AGE_SECONDS}); carried so the recipe fragment can re-check
+     * it LIVE at cook time. 0 for a never-cranked market.
+     */
+    priceTimestamp: bigint;
+    /**
+     * True iff BOTH mints are in the curated {@link STABLE_MINTS} set. Stable
+     * pools keep the original parity quote (byte/lamport-identical, regression-
+     * guarded); non-stable pools use the oracle-priced quote. See
+     * `fetchAlphaqPoolConfig`.
+     */
+    isStablePair: boolean;
+}
+/**
+ * Decode a market (672-byte) account. Throws (caller self-drops, per
+ * `resolveSvmPoolSpec`'s existing try/catch) on: a size mismatch; a blank
+ * symbol; either mint outside the curated `STABLE_MINTS` set (the "SCOPE
+ * GATE" — this ladder's quote model is only safe for a genuine stablecoin
+ * pair); mismatched decimals (the raw-unit depth comparison's precondition);
+ * or a stats account this integration has neither the static table nor a
+ * live prime for. A genuinely unknown/out-of-scope/future market is
+ * dropped, never crashed on.
+ */
+export declare function fetchAlphaqPoolConfig(load: AccountLoader, pool: Address, now?: bigint): Promise<AlphaqPoolConfig>;
+/**
+ * The symmetric constant-product model — see the module doc's "THE ACTUAL
+ * MODEL". `D = min(rawA, rawB)` (raw units; safe because
+ * `fetchAlphaqPoolConfig` gates decimalsA === decimalsB) is the conservative
+ * shared depth, pinning the spot price at parity (minus the haircut) rather
+ * than at the market's possibly-skewed raw reserve RATIO — the fix for the
+ * favourable-mispricing bug this file's own test caught (see the module
+ * doc's "REJECTED FIRST ATTEMPT").
+ */
+declare function cpQuote(x: bigint, rawA: bigint, rawB: bigint): bigint;
+/**
+ * The venue quote. For a STABLE pair this is the ORIGINAL parity model,
+ * byte/lamport-identical to before (spot pinned at 1:1). For a NON-stable pair
+ * it pins the spot at AlphaQ's live oracle price (`priceRaw`/{@link PRICE_SCALE},
+ * mintA->mintB) instead: the symmetric constant-product base
+ * (`net*D/(D+net)`, D = min raw vault — the same conservative, depth-
+ * understating shape) is scaled by the spot, `AtoB` multiplying by the price
+ * and `BtoA` dividing by it. Because the base is direction-symmetric and the
+ * spot scaling is applied last, the curve passes through the real spot at
+ * x->0 (fixing the parity mispricing that made syrupUSDC quote ~1.0 instead of
+ * ~0.849 per USDC) while still understating AlphaQ's true (deeper) depth — the
+ * safe direction, since the on-chain CPI executes AlphaQ's own pricing and the
+ * recipe's post-swap outAta-delta check bounds the fill.
+ *
+ * `rawA`/`rawB` are the live raw vault balances (mintA/mintB); `direction`
+ * is which way the trade goes ('AtoB' spends mintA). `x` is the gross input in
+ * the input side's raw units.
+ */
+declare function alphaqQuote(x: bigint, rawA: bigint, rawB: bigint, priceRaw: bigint, isStablePair: boolean, direction: "AtoB" | "BtoA"): bigint;
+export { cpQuote as __alphaqCpQuoteForTest, alphaqQuote as __alphaqQuoteForTest, decodeSymbol as __alphaqDecodeSymbolForTest, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svm/venues/alphaq/index.ts"],"names":[],"mappings":"AAqKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7D,QAAA,MAAM,IAAI,WAAW,CAAC;AACtB,eAAO,MAAM,iBAAiB,yDAA0D,CAAC;AA2IzF;wFACwF;AACxF,MAAM,WAAW,cAAc;IAC7B,kBAAkB,CAChB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,GAC9D;QAAE,IAAI,IAAI,OAAO,CAAC,SAAS;YAAE,MAAM,EAAE,OAAO,CAAC;YAAC,OAAO,EAAE;gBAAE,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;aAAE,CAAA;SAAE,EAAE,CAAC,CAAA;KAAE,CAAC;CAC7F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAa3E;AAED,sFAAsF;AACtF,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAGhG;AAED,mFAAmF;AACnF,wBAAgB,iCAAiC,IAAI,IAAI,CAGxD;AAMD,iBAAS,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAI9C;AAyBD,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,KAAK,EAAE,OAAO,IAAI,CAAC;IACnB,iDAAiD;IACjD,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,OAAO,EACb,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,CAAC,CA2F3B;AASD;;;;;;;;GAQG;AACH,iBAAS,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,WAAW,CAClB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,OAAO,EACrB,SAAS,EAAE,MAAM,GAAG,MAAM,GACzB,MAAM,CAKR;AAED,OAAO,EACL,OAAO,IAAI,sBAAsB,EACjC,WAAW,IAAI,oBAAoB,EACnC,YAAY,IAAI,2BAA2B,GAC5C,CAAC"}