@eco-incorp/sauce 0.99.0

package/sdk/dist/svm/kitchen.js

@@ -0,0 +1,388 @@
+/**
+ * The v12 **kitchen** — the Anchor loader that stages bytecode and owns Pots.
+ *
+ * The engine used to do its own staging (`INIT_BUFFER`, `EXECUTE_AND_CLOSE`). It no longer does:
+ * the released engine is a pure interpreter with exactly three instructions (`execute`,
+ * `executeFromAccount`, `closeAccount`), and everything else moved here. The two instruction sets
+ * do not overlap, so this is a new surface rather than a migration — sending the old staging
+ * discriminators to the current engine yields `InvalidInstruction` (`Custom(11)`).
+ *
+ * Two things a caller should know before reading further:
+ *
+ * **The engine is named per call, not compiled in.** `cook`, `create_pot` and `close_pot` all take
+ * an `engine_program` account. The kitchen validates nothing about it (its own IDL says so): naming
+ * an address with no program behind it produces an unusable Pot whose rent is stranded. Choosing
+ * the interpreter is the caller's business, exactly as it is on the EVM side.
+ *
+ * **A Pot is named AND attached, and it is attached UNSIGNED.** Both cooks take a readonly `pot`
+ * account whose `seeds` constraint validates the address; the kitchen then signs for it with
+ * `invoke_signed` from `["pot", owner, salt]`. A program that writes Pot storage attaches the Pot a
+ * SECOND time in the caller's tail, writable — the named slot proves which Pot, the tail slot is
+ * where the program addresses it. A program's manifest marks that tail slot `writable_signer` (what
+ * the PROGRAM needs) while the transaction attaches it unsigned (what the TRANSACTION provides);
+ * `resolve.ts`'s per-ref `signer: false` is what expresses that difference.
+ *
+ * **Every cook pays an execution fee**, quoted from the canonical `["execution_fee"]` config PDA and
+ * capped by the caller's signed `maxExecutionFee`. The three fee accounts sit after `pot` and never
+ * enter the engine's account list, so bytecode indices and `MSG_SENDER` keep their meanings. A zero
+ * configured fee performs no transfer at all; the config must still exist and be writable, because
+ * an absent one is a failure rather than a free cook.
+ */
+import { getAddressEncoder, getProgramDerivedAddress, AccountRole } from "@solana/kit";
+/** Anchor discriminators, verbatim from the release's `kitchen-idl.json`. */
+const DISCRIMINATOR = {
+    closeCodeBuffer: new Uint8Array([195, 203, 47, 242, 198, 177, 247, 6]),
+    closePot: new Uint8Array([214, 103, 62, 202, 132, 229, 27, 86]),
+    cook: new Uint8Array([147, 233, 205, 239, 200, 21, 190, 159]),
+    cookFromAccount: new Uint8Array([247, 166, 195, 248, 78, 176, 147, 84]),
+    createCodeBuffer: new Uint8Array([94, 72, 190, 83, 17, 60, 103, 35]),
+    createPot: new Uint8Array([232, 45, 123, 181, 204, 121, 131, 9]),
+    finalizeCodeBuffer: new Uint8Array([191, 246, 136, 59, 56, 1, 0, 48]),
+    growCodeBuffer: new Uint8Array([152, 136, 215, 167, 37, 51, 197, 62]),
+    initializeExecutionFee: new Uint8Array([68, 234, 94, 137, 217, 86, 56, 118]),
+    setExecutionFee: new Uint8Array([118, 2, 66, 35, 4, 211, 24, 114]),
+    withdrawExecutionFees: new Uint8Array([231, 223, 184, 186, 204, 49, 248, 119]),
+    writeCodeBuffer: new Uint8Array([205, 152, 182, 5, 148, 70, 20, 25]),
+};
+/** The kitchen's own `#[constant]`s, from the same IDL. */
+export const CODE_BUFFER_SEED = "buffer";
+export const CODE_SEED = "code";
+export const POT_SEED = "pot";
+export const EXECUTION_FEE_SEED = "execution_fee";
+/** One `grow_code_buffer` step: `MAX_PERMITTED_DATA_INCREASE`, the most a CPI-created account can
+ *  grow in a single instruction. IDL-guarded by `engine-wire-drift.test.ts`. */
+export const GROWTH_STEP = 10_240;
+export const MAX_CODE_LEN = 1_048_576;
+export const MAX_POT_LEN = 10_240;
+/** A Pot's salt and a code buffer's `expected_sha256` are both exactly 32 bytes. */
+export const SALT_BYTES = 32;
+const SYSTEM_PROGRAM = "11111111111111111111111111111111";
+/** The loader that owns every upgradeable program's `ProgramData`, which is where the fee
+ *  instructions read the kitchen's live upgrade authority from. */
+export const BPF_LOADER_UPGRADEABLE = "BPFLoaderUpgradeab1e11111111111111111111111";
+function assertLength(value, bytes, what) {
+    if (!(value instanceof Uint8Array) || value.length !== bytes) {
+        const got = value instanceof Uint8Array ? `${value.length} bytes` : "a non-Uint8Array";
+        throw new Error(`${what} must be exactly ${bytes} bytes, got ${got}`);
+    }
+}
+function u32(value) {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, true);
+    return bytes;
+}
+function u64(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, value, true);
+    return bytes;
+}
+/** Borsh `bytes`: a u32 length prefix then the payload. */
+function borshBytes(value) {
+    const out = new Uint8Array(4 + value.length);
+    out.set(u32(value.length), 0);
+    out.set(value, 4);
+    return out;
+}
+/** Borsh `Option<[u8; 32]>`: a 1-byte tag, then the value when present. */
+function borshOption32(value) {
+    if (value === undefined)
+        return new Uint8Array([0]);
+    assertLength(value, 32, "an optional 32-byte field");
+    const out = new Uint8Array(33);
+    out[0] = 1;
+    out.set(value, 1);
+    return out;
+}
+/** Borsh `Option<u64>`: a 1-byte tag, then a little-endian u64 when present. */
+function borshOptionU64(value) {
+    if (value === undefined)
+        return new Uint8Array([0]);
+    const out = new Uint8Array(9);
+    out[0] = 1;
+    out.set(u64(value), 1);
+    return out;
+}
+function data(discriminator, ...parts) {
+    const total = discriminator.length + parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(total);
+    out.set(discriminator, 0);
+    let offset = discriminator.length;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+// --- PDAs -------------------------------------------------------------------
+/**
+ * A Pot: `["pot", owner, salt]`. The salt is what lets one owner hold many — it is raw bytes, not a
+ * counter, so a caller with a natural 32-byte id (an intent hash, say) passes it directly.
+ */
+export async function derivePotPda(kitchen, owner, salt) {
+    assertLength(salt, SALT_BYTES, "a pot salt");
+    const [address, bump] = await getProgramDerivedAddress({
+        programAddress: kitchen,
+        seeds: [POT_SEED, getAddressEncoder().encode(owner), salt],
+    });
+    return { address, bump };
+}
+/**
+ * The execution-fee config: `["execution_fee"]`, one per kitchen.
+ *
+ * It is both the fee's source of truth and the treasury the fees accumulate in, so every cook takes
+ * it writable even when the configured fee is zero.
+ */
+export async function deriveExecutionFeeConfigPda(kitchen) {
+    const [address, bump] = await getProgramDerivedAddress({
+        programAddress: kitchen,
+        seeds: [EXECUTION_FEE_SEED],
+    });
+    return { address, bump };
+}
+/**
+ * A program's `ProgramData` under the upgradeable loader: `[program]`.
+ *
+ * The fee instructions authorize against the authority recorded there rather than a stored admin
+ * key, so whoever can upgrade the kitchen is whoever can price it.
+ */
+export async function deriveProgramDataPda(program) {
+    const [address, bump] = await getProgramDerivedAddress({
+        programAddress: BPF_LOADER_UPGRADEABLE,
+        seeds: [getAddressEncoder().encode(program)],
+    });
+    return { address, bump };
+}
+/** A code buffer's metadata account: `["buffer", owner, nonce_le]`. */
+export async function deriveCodeBufferPda(kitchen, owner, nonce) {
+    const [address, bump] = await getProgramDerivedAddress({
+        programAddress: kitchen,
+        seeds: [CODE_BUFFER_SEED, getAddressEncoder().encode(owner), u64(nonce)],
+    });
+    return { address, bump };
+}
+/**
+ * The bytes account for a buffer: `["code", code_buffer]`.
+ *
+ * Seeded on the METADATA account's address, so the pair is bound by derivation and neither needs to
+ * store a pointer to the other for the kitchen to validate.
+ */
+export async function deriveCodePda(kitchen, codeBuffer) {
+    const [address, bump] = await getProgramDerivedAddress({
+        programAddress: kitchen,
+        seeds: [CODE_SEED, getAddressEncoder().encode(codeBuffer)],
+    });
+    return { address, bump };
+}
+export function buildCreatePotInstruction({ kitchen, owner, engineProgram, pot, salt, space, }) {
+    assertLength(salt, SALT_BYTES, "a pot salt");
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: engineProgram, role: AccountRole.READONLY },
+            { address: pot, role: AccountRole.WRITABLE },
+            { address: SYSTEM_PROGRAM, role: AccountRole.READONLY },
+        ],
+        data: data(DISCRIMINATOR.createPot, salt, u32(space)),
+    };
+}
+export function buildClosePotInstruction({ kitchen, owner, engineProgram, pot, salt, }) {
+    assertLength(salt, SALT_BYTES, "a pot salt");
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: engineProgram, role: AccountRole.READONLY },
+            { address: pot, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.closePot, salt),
+    };
+}
+/** The `ExecutionFee` group both cooks carry, flattened in the order Anchor declares it. */
+function executionFeeAccounts(feeConfig, feePayer) {
+    return [
+        { address: feeConfig, role: AccountRole.WRITABLE },
+        { address: feePayer, role: AccountRole.WRITABLE_SIGNER },
+        { address: SYSTEM_PROGRAM, role: AccountRole.READONLY },
+    ];
+}
+/**
+ * `cook` — stage-free execution: the bytecode travels in the instruction data.
+ *
+ * **The transaction MUST carry a RequestHeapFrame(`HEAP_FRAME_BYTES`).** The kitchen CPIs into the
+ * engine, whose interpreter memory lives in the transaction's heap frame and not in accounts, so
+ * without it the ENGINE access-violates before any opcode runs — surfacing from the kitchen as an
+ * opaque `ProgramFailedToComplete`. Use `buildHeapFramePrepend()` (`./prepends.js`). Pot and
+ * code-buffer lifecycle instructions need no such thing; only the two cooks execute.
+ *
+ * Note there is no `pot` account here. The kitchen derives it from `pot_salt` and `owner` and signs
+ * for it, so a Pot the program touches belongs in `tail` **unsigned**.
+ */
+export function buildCookInstruction({ kitchen, owner, engineProgram, potSalt, pot, feeConfig, bytecode, maxExecutionFee, feePayer = owner, tail = [], }) {
+    assertLength(potSalt, SALT_BYTES, "a pot salt");
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.READONLY_SIGNER },
+            { address: engineProgram, role: AccountRole.READONLY },
+            { address: pot, role: AccountRole.READONLY },
+            ...executionFeeAccounts(feeConfig, feePayer),
+            ...tail,
+        ],
+        data: data(DISCRIMINATOR.cook, potSalt, borshBytes(bytecode), u64(maxExecutionFee)),
+    };
+}
+/**
+ * `cook_from_account` — the staged transport: the bytecode is read from a finalized code account.
+ *
+ * Needs the same RequestHeapFrame as `cook` — see there.
+ */
+export function buildCookFromAccountInstruction({ kitchen, owner, codeBuffer, code, engineProgram, potSalt, pot, feeConfig, pin, maxExecutionFee, feePayer = owner, tail = [], }) {
+    assertLength(potSalt, SALT_BYTES, "a pot salt");
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.READONLY_SIGNER },
+            { address: codeBuffer, role: AccountRole.READONLY },
+            { address: code, role: AccountRole.READONLY },
+            { address: engineProgram, role: AccountRole.READONLY },
+            { address: pot, role: AccountRole.READONLY },
+            ...executionFeeAccounts(feeConfig, feePayer),
+            ...tail,
+        ],
+        data: data(DISCRIMINATOR.cookFromAccount, potSalt, borshOption32(pin), u64(maxExecutionFee)),
+    };
+}
+/**
+ * Creates the `codeBuffer` metadata account and its `code` data account, sized for `capacity`.
+ *
+ * `capacity` must be 1..=`MAX_CODE_LEN`; the kitchen rejects anything else with
+ * `CapacityOutOfRange`, and this throws first so the bound is visible without a simulation.
+ *
+ * **A create allocates at most ONE `GROWTH_STEP`.** The runtime caps how much an account can grow
+ * per instruction, so a `capacity` above that is only partly allocated here and needs
+ * `Math.ceil(capacity / GROWTH_STEP) - 1` further `buildGrowCodeBufferInstruction` calls before the
+ * `code` account is the full size. The cap resets per instruction, so those repeats can share one
+ * transaction. Writing before the account is fully grown fails with `WriteOutOfBounds`.
+ */
+export function buildCreateCodeBufferInstruction({ kitchen, owner, codeBuffer, code, nonce, capacity, }) {
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > MAX_CODE_LEN) {
+        throw new Error(`a code buffer capacity must be an integer in 1..=${MAX_CODE_LEN}, got ${capacity}`);
+    }
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: codeBuffer, role: AccountRole.WRITABLE },
+            { address: code, role: AccountRole.WRITABLE },
+            { address: SYSTEM_PROGRAM, role: AccountRole.READONLY },
+        ],
+        data: data(DISCRIMINATOR.createCodeBuffer, u64(nonce), u32(capacity)),
+    };
+}
+/**
+ * One growth step. A CPI-created account cannot be allocated more than `GROWTH_STEP` at once, so a
+ * larger buffer repeats this — the runtime's limit resets per instruction, so the repeats fit in one
+ * transaction.
+ */
+export function buildGrowCodeBufferInstruction({ kitchen, owner, codeBuffer, code, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: codeBuffer, role: AccountRole.READONLY },
+            { address: code, role: AccountRole.WRITABLE },
+            { address: SYSTEM_PROGRAM, role: AccountRole.READONLY },
+        ],
+        data: data(DISCRIMINATOR.growCodeBuffer),
+    };
+}
+export function buildWriteCodeBufferInstruction({ kitchen, owner, codeBuffer, code, offset, chunk, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.READONLY_SIGNER },
+            { address: codeBuffer, role: AccountRole.READONLY },
+            { address: code, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.writeCodeBuffer, u32(offset), borshBytes(chunk)),
+    };
+}
+/**
+ * Seals the buffer at `len` and pins its digest.
+ *
+ * The kitchen shrinks the code account to exactly `len` here, which is the security property: the
+ * engine executes the account's whole data slice and bounds jumps only by that slice's length, so
+ * any byte past `len` would be jump-reachable but outside the hash.
+ */
+export function buildFinalizeCodeBufferInstruction({ kitchen, owner, codeBuffer, code, len, expectedSha256, }) {
+    assertLength(expectedSha256, 32, "expectedSha256");
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: codeBuffer, role: AccountRole.WRITABLE },
+            { address: code, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.finalizeCodeBuffer, u32(len), expectedSha256),
+    };
+}
+/** Closes both accounts and refunds their rent. `expectedSha256` gates the close on the staged bytes. */
+export function buildCloseCodeBufferInstruction({ kitchen, owner, codeBuffer, code, expectedSha256, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: owner, role: AccountRole.WRITABLE_SIGNER },
+            { address: codeBuffer, role: AccountRole.WRITABLE },
+            { address: code, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.closeCodeBuffer, borshOption32(expectedSha256)),
+    };
+}
+/** `initialize_execution_fee` — creates the config PDA. The initial fee must be greater than zero;
+ *  a kitchen is unusable until it is priced, and a later `set` may take it back to zero. */
+export function buildInitializeExecutionFeeInstruction({ kitchen, authority, programData, feeConfig, payer = authority, initialFee, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: authority, role: AccountRole.READONLY_SIGNER },
+            { address: payer, role: AccountRole.WRITABLE_SIGNER },
+            { address: kitchen, role: AccountRole.READONLY },
+            { address: programData, role: AccountRole.READONLY },
+            { address: feeConfig, role: AccountRole.WRITABLE },
+            { address: SYSTEM_PROGRAM, role: AccountRole.READONLY },
+        ],
+        data: data(DISCRIMINATOR.initializeExecutionFee, u64(initialFee)),
+    };
+}
+/** `set_execution_fee` — repricing, including back to zero. */
+export function buildSetExecutionFeeInstruction({ kitchen, authority, programData, feeConfig, fee, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: authority, role: AccountRole.READONLY_SIGNER },
+            { address: kitchen, role: AccountRole.READONLY },
+            { address: programData, role: AccountRole.READONLY },
+            { address: feeConfig, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.setExecutionFee, u64(fee)),
+    };
+}
+/** `withdraw_execution_fees` — collect what the config PDA holds. `amount` omitted sweeps everything
+ *  ABOVE the account's rent-exempt minimum, which the withdrawal never spends: that same account is
+ *  the config every cook reads, and a zero balance would have the runtime reap it. The recipient
+ *  must already be rent-exempt, or the runtime refuses the transaction for leaving it rent-paying. */
+export function buildWithdrawExecutionFeesInstruction({ kitchen, authority, programData, feeConfig, recipient, amount, }) {
+    return {
+        programAddress: kitchen,
+        accounts: [
+            { address: authority, role: AccountRole.READONLY_SIGNER },
+            { address: kitchen, role: AccountRole.READONLY },
+            { address: programData, role: AccountRole.READONLY },
+            { address: feeConfig, role: AccountRole.WRITABLE },
+            { address: recipient, role: AccountRole.WRITABLE },
+        ],
+        data: data(DISCRIMINATOR.withdrawExecutionFees, borshOptionU64(amount)),
+    };
+}
+//# sourceMappingURL=kitchen.js.map

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * The staged payload-args data shapes, owned by the SDK.
+ *
+ * These describe the byte layout of a staged SVM program's per-execution args — the contract
+ * `args.ts` encodes against and `verify.ts` checks. They are plain data the SDK is HANDED, not
+ * values it must receive from a compiler: `SvmClient`'s `StagedArgs` takes a layout as an INPUT
+ * field, and `decodeSvmSettleArgs` validates a fixed known shape. So they live here rather than
+ * being re-exported from a compiler package.
+ */
+/** A struct arg at the main() boundary, encoded as a TUPLE with fields sorted ALPHABETICALLY. */
+export interface ArgObject {
+    [key: string]: ArgValue;
+}
+export type ArgValue = bigint | string | ArgValue[] | ArgObject;
+export type ArgsLayoutKind = "scalar" | "bytes";
+export interface ArgsLayoutSlot {
+    /** main() parameter position this slot feeds (slot i ↔ arg i, in order). */
+    arg: number;
+    kind: ArgsLayoutKind;
+    /** Byte offset within the payload args (composite CALLDATA offset = programLength + offset). */
+    offset: number;
+    /** Slot byte length (32 for scalars; the fixed compile-time length for bytes). */
+    length: number;
+}
+export interface ArgsLayout {
+    /** Args transport: per-execution values ride the instruction payload, read via CALLDATA. */
+    mode: "calldata";
+    /** Compiled program byte length L — arg i lives at composite offset L + slots[i].offset. */
+    programLength: number;
+    /** Total payload-arg bytes (slots laid out back to back, no padding). */
+    byteLength: number;
+    slots: ArgsLayoutSlot[];
+}
+//# sourceMappingURL=layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../src/svm/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,iGAAiG;AACjG,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC;CACzB;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,EAAE,GAAG,SAAS,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,cAAc,CAAC;IACrB,gGAAgG;IAChG,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,4FAA4F;IAC5F,IAAI,EAAE,UAAU,CAAC;IACjB,4FAA4F;IAC5F,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB"}

package/sdk/dist/svm/layout.js

@@ -0,0 +1,11 @@
+/**
+ * The staged payload-args data shapes, owned by the SDK.
+ *
+ * These describe the byte layout of a staged SVM program's per-execution args — the contract
+ * `args.ts` encodes against and `verify.ts` checks. They are plain data the SDK is HANDED, not
+ * values it must receive from a compiler: `SvmClient`'s `StagedArgs` takes a layout as an INPUT
+ * field, and `decodeSvmSettleArgs` validates a fixed known shape. So they live here rather than
+ * being re-exported from a compiler package.
+ */
+export {};
+//# sourceMappingURL=layout.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/svm/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

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

@@ -0,0 +1,73 @@
+/**
+ * Batched account loading for prepare/quote flows.
+ *
+ * The venue adapters consume the one-address AccountLoader (fixture tests
+ * feed it directly), but a naive RPC binding costs one round-trip per
+ * account — an SvmRoute prepare over k pools touches 3-8 accounts each.
+ * `coalescingAccountLoader` keeps the adapter surface unchanged while
+ * batching transport: every load() issued in the same microtask turn joins
+ * ONE getMultipleAccounts sweep (deduped, chunked at the RPC's 100-account
+ * cap), so a parallelized prepare resolves in O(dependency-depth) sweeps —
+ * pool accounts first, then their vault/config satellites — regardless of
+ * pool count.
+ *
+ * A sweep's chunks go out concurrently but no more than
+ * `maxConcurrentChunks` at a time: unbounded fan-out means a batch of k
+ * addresses opens ceil(k / chunkSize) simultaneous requests, which at
+ * k = 1,000,000 is 10,000. The cap is PER SWEEP, so independent concurrent
+ * prepares never queue behind one another and the O(dependency-depth)
+ * property above is preserved.
+ *
+ * Owner checks are PRESERVED through batching: getMultipleAccounts returns
+ * each account's owner, and the loader hands (address, owner) to the
+ * `expectOwner` hook before releasing the data — a per-account rejection
+ * there fails that account's load() alone, exactly like a single-account
+ * loader that verifies owners. NOTE: nothing currently passes `expectOwner` —
+ * `quoteSvmRoute`/`svmRoute` do not wire owner expectations, contrary to what
+ * this said. The owner is now carried on the loaded account instead, which is
+ * where mint classification needs it.
+ */
+import type { Address } from "@solana/kit";
+import type { AccountLoader, OwnedAccountLoader } from "./venues/types.js";
+export interface LoadedAccount {
+    data: Uint8Array;
+    owner: Address;
+}
+/** Batch transport: addresses in, (data + owner) per account out (null = not found). */
+export type BatchAccountLoader = (addresses: readonly Address[]) => Promise<(LoadedAccount | null)[]>;
+export interface CoalescingLoaderOptions {
+    /** getMultipleAccounts cap per request (public RPC limit: 100). */
+    chunkSize?: number;
+    /** Chunk requests in flight at once WITHIN one sweep (default 16). */
+    maxConcurrentChunks?: number;
+    /** Per-account owner check — throw to reject that account's load(). */
+    expectOwner?: (address: Address, owner: Address) => void;
+}
+/**
+ * Wraps a batch transport as a single-account AccountLoader that coalesces
+ * same-turn loads into deduped, chunked sweeps.
+ */
+export declare function coalescingOwnedAccountLoader(loadMany: BatchAccountLoader, options?: CoalescingLoaderOptions): OwnedAccountLoader;
+/**
+ * The data-only loader the venue adapters take, as a projection of the owner-aware one.
+ *
+ * Keeping both means an adapter can be moved to owner-based mint classification on its own, instead
+ * of all 64 changing in one sweep.
+ */
+export declare function coalescingAccountLoader(loadMany: BatchAccountLoader, options?: CoalescingLoaderOptions): AccountLoader;
+/** The slice of a @solana/kit RPC this loader needs (Rpc<GetMultipleAccountsApi>). */
+export interface GetMultipleAccountsRpc {
+    getMultipleAccounts(addresses: readonly Address[], config: {
+        encoding: "base64";
+    }): {
+        send(): Promise<{
+            value: ({
+                data: readonly [string, string];
+                owner: Address;
+            } | null)[];
+        }>;
+    };
+}
+/** Batch transport over a @solana/kit RPC's getMultipleAccounts (base64). */
+export declare function kitBatchAccountLoader(rpc: GetMultipleAccountsRpc): BatchAccountLoader;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/svm/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAO3E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,wFAAwF;AACxF,MAAM,MAAM,kBAAkB,GAAG,CAC/B,SAAS,EAAE,SAAS,OAAO,EAAE,KAC1B,OAAO,CAAC,CAAC,aAAa,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;AAEvC,MAAM,WAAW,uBAAuB;IACtC,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uEAAuE;IACvE,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1D;AAOD;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,uBAA4B,GACpC,kBAAkB,CA0FpB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,uBAA4B,GACpC,aAAa,CAKf;AAED,sFAAsF;AACtF,MAAM,WAAW,sBAAsB;IACrC,mBAAmB,CACjB,SAAS,EAAE,SAAS,OAAO,EAAE,EAC7B,MAAM,EAAE;QAAE,QAAQ,EAAE,QAAQ,CAAA;KAAE,GAC7B;QACD,IAAI,IAAI,OAAO,CAAC;YAAE,KAAK,EAAE,CAAC;gBAAE,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAAC,KAAK,EAAE,OAAO,CAAA;aAAE,GAAG,IAAI,CAAC,EAAE,CAAA;SAAE,CAAC,CAAC;KAC5F,CAAC;CACH;AAED,6EAA6E;AAC7E,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,sBAAsB,GAAG,kBAAkB,CASrF"}

package/sdk/dist/svm/loader.js

@@ -0,0 +1,110 @@
+/** getMultipleAccounts pubkey cap on public RPCs. */
+const DEFAULT_CHUNK_SIZE = 100;
+/** 16 x DEFAULT_CHUNK_SIZE = 1,600 accounts per wave — ~200-500 pools at 3-8 accounts each. */
+const DEFAULT_MAX_CONCURRENT_CHUNKS = 16;
+/**
+ * Wraps a batch transport as a single-account AccountLoader that coalesces
+ * same-turn loads into deduped, chunked sweeps.
+ */
+export function coalescingOwnedAccountLoader(loadMany, options = {}) {
+    const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+        throw new Error(`coalescingAccountLoader chunkSize must be a positive integer, got ${chunkSize}`);
+    }
+    const maxConcurrentChunks = options.maxConcurrentChunks ?? DEFAULT_MAX_CONCURRENT_CHUNKS;
+    if (!Number.isInteger(maxConcurrentChunks) || maxConcurrentChunks < 1) {
+        throw new Error(`coalescingAccountLoader maxConcurrentChunks must be a positive integer, got ${maxConcurrentChunks}`);
+    }
+    let pending = null;
+    // One chunk's sweep: load it, then resolve/reject every waiter for its
+    // addresses. Never rejects — failures are delivered to that chunk's own
+    // waiters, so one bad chunk can't sink the others under Promise.all below.
+    const sweepChunk = async (batch, chunk) => {
+        let results;
+        try {
+            results = await loadMany(chunk);
+            if (results.length !== chunk.length) {
+                throw new Error(`batch loader returned ${results.length} accounts for ${chunk.length} addresses`);
+            }
+        }
+        catch (error) {
+            for (const address of chunk)
+                for (const waiter of batch.get(address))
+                    waiter.reject(error);
+            return;
+        }
+        chunk.forEach((address, i) => {
+            const result = results[i];
+            for (const waiter of batch.get(address)) {
+                if (result === null) {
+                    waiter.resolve(null);
+                    continue;
+                }
+                try {
+                    options.expectOwner?.(address, result.owner);
+                    // Fresh copy per waiter — callers may mutate their view. The owner rides along: it is
+                    // what tells a legacy mint from an extensionless Token-2022 one, and dropping it here is
+                    // what made that classification impossible downstream.
+                    waiter.resolve({ data: new Uint8Array(result.data), owner: result.owner });
+                }
+                catch (error) {
+                    waiter.reject(error);
+                }
+            }
+        });
+    };
+    const flush = async (batch) => {
+        const addresses = [...batch.keys()];
+        // Chunks are independent getMultipleAccounts round-trips (chunkSize is the
+        // RPC's per-call pubkey cap) — fire them in parallel, not one after another,
+        // but never more than maxConcurrentChunks at a time. Each worker drains the
+        // shared cursor, so the wave refills as soon as a chunk lands.
+        const chunks = [];
+        for (let at = 0; at < addresses.length; at += chunkSize) {
+            chunks.push(addresses.slice(at, at + chunkSize));
+        }
+        let next = 0;
+        const drainChunks = async () => {
+            while (next < chunks.length) {
+                const chunk = chunks[next++];
+                await sweepChunk(batch, chunk);
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(maxConcurrentChunks, chunks.length) }, drainChunks));
+    };
+    return (address) => new Promise((resolve, reject) => {
+        if (pending === null) {
+            pending = new Map();
+            const batch = pending;
+            queueMicrotask(() => {
+                pending = null;
+                void flush(batch);
+            });
+        }
+        const waiters = pending.get(address);
+        if (waiters === undefined)
+            pending.set(address, [{ resolve, reject }]);
+        else
+            waiters.push({ resolve, reject });
+    });
+}
+/**
+ * The data-only loader the venue adapters take, as a projection of the owner-aware one.
+ *
+ * Keeping both means an adapter can be moved to owner-based mint classification on its own, instead
+ * of all 64 changing in one sweep.
+ */
+export function coalescingAccountLoader(loadMany, options = {}) {
+    const owned = coalescingOwnedAccountLoader(loadMany, options);
+    return async (address) => (await owned(address))?.data ?? null;
+}
+/** Batch transport over a @solana/kit RPC's getMultipleAccounts (base64). */
+export function kitBatchAccountLoader(rpc) {
+    return async (addresses) => {
+        const { value } = await rpc.getMultipleAccounts(addresses, { encoding: "base64" }).send();
+        return value.map((account) => account === null
+            ? null
+            : { data: new Uint8Array(Buffer.from(account.data[0], "base64")), owner: account.owner });
+    };
+}
+//# sourceMappingURL=loader.js.map