@lethenymous/sdk 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,357 @@
+import { createHash } from "node:crypto";
+import { PublicKey, Transaction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, getAccount, getAssociatedTokenAddressSync, getMint, TOKEN_PROGRAM_ID, } from "@solana/spl-token";
+import { accountDiscriminator, PROGRAM_ID } from "./encoding.js";
+import { decodePool, decodeProtocolConfig, decodeShieldedState, decodeTreeState } from "./accounts.js";
+import { pda } from "./pda.js";
+import { addLiquidity as addLiquidityIx, initializePool, initializeShieldedState, removeLiquidity as removeLiquidityIx, swap as swapIx } from "./instructions.js";
+import { swapOutputPreservingLpClaims } from "./math.js";
+import { keyHierarchy, ownerCommitment } from "./crypto.js";
+import { EncryptedFileNoteStore } from "./store.js";
+import { ShieldedWallet } from "./wallet.js";
+const FINALIZED = "finalized";
+const MAX_U64 = 0xffffffffffffffffn;
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function encodeBase58(value) {
+    let number = BigInt(`0x${Buffer.from(value).toString("hex")}`);
+    let output = "";
+    while (number > 0n) {
+        const remainder = Number(number % 58n);
+        output = BASE58[remainder] + output;
+        number /= 58n;
+    }
+    let leading = 0;
+    while (leading < value.length && value[leading] === 0)
+        leading++;
+    return "1".repeat(leading) + output;
+}
+function signedSignature(transaction) {
+    const signature = transaction instanceof VersionedTransaction ? transaction.signatures[0] : transaction.signature;
+    if (!signature || signature.every(byte => byte === 0))
+        return undefined;
+    return encodeBase58(signature);
+}
+export function transactionSignatureFromBytes(serialized) {
+    try {
+        return signedSignature(VersionedTransaction.deserialize(serialized));
+    }
+    catch {
+        try {
+            return signedSignature(Transaction.from(Buffer.from(serialized)));
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+export class LookupTableRequiredError extends Error {
+    constructor() { super("A validated versioned lookup table is required for private proof transactions"); this.name = "LookupTableRequiredError"; }
+}
+export class TransactionFailedError extends Error {
+    outcome;
+    constructor(outcome) {
+        super(`Transaction finalized with an execution error: ${String(outcome.error)}`);
+        this.outcome = outcome;
+        this.name = "TransactionFailedError";
+    }
+}
+export class TransactionUnknownError extends Error {
+    outcome;
+    constructor(outcome) {
+        super(`Transaction outcome is unknown: ${outcome.reason}`);
+        this.outcome = outcome;
+        this.name = "TransactionUnknownError";
+    }
+}
+export class Lethenymous {
+    connection;
+    wallet;
+    programId;
+    witnessProvider;
+    lookupTables;
+    lookupTableCache = new Map();
+    lookupTableLoads = new Map();
+    constructor(config) {
+        this.connection = config.connection;
+        this.wallet = config.wallet;
+        this.programId = config.programId ?? PROGRAM_ID;
+        this.witnessProvider = config.witnessProvider;
+        this.lookupTables = (config.lookupTables ?? []).map(value => value instanceof PublicKey ? { address: value } : value);
+    }
+    async account(address, kind) {
+        const info = await this.connection.getAccountInfo(address, FINALIZED);
+        if (!info)
+            throw new Error(`Account not found: ${address.toBase58()}`);
+        if (!info.owner.equals(this.programId))
+            throw new Error(`Account is not owned by configured program: ${address.toBase58()}`);
+        if (info.data.length < 8 || !info.data.subarray(0, 8).equals(accountDiscriminator(kind)))
+            throw new Error(`Invalid ${kind} account discriminator: ${address.toBase58()}`);
+        return info.data.subarray(8);
+    }
+    async getPool(address) {
+        return decodePool(await this.account(address, "Pool"), address);
+    }
+    async getShieldedState(pool) {
+        const state = decodeShieldedState(await this.account(pda.shielded(pool, this.programId)[0], "ShieldedState"));
+        if (!state.pool.equals(pool) || !state.tree.equals(pda.tree(pool, this.programId)[0]))
+            throw new Error("Shielded state does not match pool");
+        return state;
+    }
+    async getTree(pool) {
+        const tree = decodeTreeState(await this.account(pda.tree(pool, this.programId)[0], "TreeState"));
+        if (!tree.pool.equals(pool))
+            throw new Error("Tree does not match pool");
+        return tree;
+    }
+    async getProtocolConfig() {
+        return decodeProtocolConfig(await this.account(pda.protocolConfig(this.programId)[0], "ProtocolConfig"));
+    }
+    async getReserves(pool) {
+        const [a, b] = await Promise.all([
+            getAccount(this.connection, pool.tokenAVault, FINALIZED, TOKEN_PROGRAM_ID),
+            getAccount(this.connection, pool.tokenBVault, FINALIZED, TOKEN_PROGRAM_ID),
+        ]);
+        if (!a.mint.equals(pool.tokenAMint) || !b.mint.equals(pool.tokenBMint))
+            throw new Error("Pool vault mint mismatch");
+        return { a: a.amount, b: b.amount };
+    }
+    async getLpSupply(pool) {
+        return (await getMint(this.connection, pool.lpMint, FINALIZED, TOKEN_PROGRAM_ID)).supply;
+    }
+    async validatedTables(instructions) {
+        if (!this.lookupTables.length)
+            return [];
+        const slot = await this.connection.getSlot(FINALIZED);
+        const tables = [];
+        for (const config of this.lookupTables) {
+            const key = config.address.toBase58();
+            let entry = this.lookupTableCache.get(key)?.slot === slot ? this.lookupTableCache.get(key) : undefined;
+            if (!entry) {
+                let load = this.lookupTableLoads.get(key);
+                if (!load) {
+                    load = (async () => {
+                        const response = await this.connection.getAddressLookupTable(config.address, { commitment: FINALIZED });
+                        const value = response.value;
+                        if (!value)
+                            throw new Error(`Configured address lookup table is unavailable: ${config.address.toBase58()}`);
+                        if (!value.key.equals(config.address))
+                            throw new Error(`Configured address lookup table returned the wrong account: ${config.address.toBase58()}`);
+                        const responseSlot = response.context?.slot ?? slot;
+                        if (!Number.isSafeInteger(responseSlot) || responseSlot < 0)
+                            throw new Error("Configured address lookup table returned an invalid context slot");
+                        return { slot: responseSlot, table: value };
+                    })();
+                    this.lookupTableLoads.set(key, load);
+                }
+                try {
+                    entry = await load;
+                    this.lookupTableCache.set(key, entry);
+                }
+                finally {
+                    if (this.lookupTableLoads.get(key) === load)
+                        this.lookupTableLoads.delete(key);
+                }
+            }
+            const value = entry.table;
+            const validationSlot = entry.slot;
+            const state = value.state;
+            const lastExtendedSlotStartIndex = state.lastExtendedSlotStartIndex ?? state.addresses.length;
+            if (BigInt(state.lastExtendedSlot) > BigInt(validationSlot) || (BigInt(state.lastExtendedSlot) === BigInt(validationSlot) && lastExtendedSlotStartIndex < state.addresses.length))
+                throw new Error("Configured address lookup table is not active at finalized slot");
+            if (state.deactivationSlot !== MAX_U64 && state.deactivationSlot <= BigInt(validationSlot))
+                throw new Error("Configured address lookup table is deactivated");
+            if (config.expectedAuthority !== undefined) {
+                const actual = state.authority ?? null;
+                if ((actual === null) !== (config.expectedAuthority === null) || (actual && !actual.equals(config.expectedAuthority)))
+                    throw new Error("Configured address lookup table authority mismatch");
+            }
+            if (config.expectedAddresses) {
+                const actual = new Set(state.addresses.map(address => address.toBase58()));
+                const expected = new Set(config.expectedAddresses.map(address => address.toBase58()));
+                if (expected.size !== config.expectedAddresses.length || actual.size !== expected.size)
+                    throw new Error("Configured address lookup table contents differ from the expected deployment");
+                for (const address of expected)
+                    if (!actual.has(address))
+                        throw new Error("Configured address lookup table is missing an expected address");
+            }
+            tables.push(value);
+        }
+        return tables;
+    }
+    async buildAndSendOutcome(instructions, options = {}) {
+        if (options.requireVersioned && !this.lookupTables.length)
+            throw new LookupTableRequiredError();
+        const latest = await this.connection.getLatestBlockhash(FINALIZED);
+        const tables = await this.validatedTables(instructions);
+        let raw;
+        if (tables.length) {
+            if (!this.wallet.signVersionedTransaction)
+                throw new Error("Wallet adapter must implement signVersionedTransaction when lookup tables are configured");
+            const message = new TransactionMessage({ payerKey: this.wallet.publicKey, recentBlockhash: latest.blockhash, instructions }).compileToV0Message(tables);
+            raw = await this.wallet.signVersionedTransaction(new VersionedTransaction(message));
+        }
+        else {
+            if (options.requireVersioned)
+                throw new LookupTableRequiredError();
+            const transaction = new Transaction();
+            transaction.feePayer = this.wallet.publicKey;
+            transaction.recentBlockhash = latest.blockhash;
+            transaction.lastValidBlockHeight = latest.lastValidBlockHeight;
+            transaction.add(...instructions);
+            raw = await this.wallet.signTransaction(transaction);
+        }
+        const serialized = raw.serialize();
+        if (options.onPrepared)
+            await options.onPrepared(serialized, BigInt(latest.lastValidBlockHeight));
+        let signature;
+        try {
+            signature = await this.connection.sendRawTransaction(serialized);
+        }
+        catch (error) {
+            signature = signedSignature(raw);
+            if (!signature)
+                throw new Error(`Transaction submission failed before a signature was returned: ${String(error)}`);
+            if (options.onSubmitted) {
+                try {
+                    await options.onSubmitted(signature);
+                }
+                catch { /* The transaction remains unknown and must not release local state. */ }
+            }
+            return { status: "unknown", signature, reason: "Transaction submission acknowledgement failed after signing" };
+        }
+        if (options.onSubmitted) {
+            try {
+                await options.onSubmitted(signature);
+            }
+            catch {
+                return { status: "unknown", signature, reason: "Transaction submitted; local submission state could not be journaled" };
+            }
+        }
+        try {
+            const confirmation = await this.connection.confirmTransaction({ signature, blockhash: latest.blockhash, lastValidBlockHeight: latest.lastValidBlockHeight }, FINALIZED);
+            if (confirmation.value.err !== null)
+                return { status: "finalized-failed", signature, error: confirmation.value.err };
+            return { status: "finalized-success", signature };
+        }
+        catch (error) {
+            return this.reconcileTransaction(signature, latest.lastValidBlockHeight, String(error));
+        }
+    }
+    async reconcileTransaction(signature, lastValidBlockHeight, reason = "confirmation did not complete") {
+        try {
+            const status = (await this.connection.getSignatureStatuses([signature], { searchTransactionHistory: true })).value[0];
+            if (status?.confirmationStatus === "finalized")
+                return { status: "finalized-success", signature };
+            const transaction = await this.connection.getTransaction(signature, { commitment: "finalized", maxSupportedTransactionVersion: 0 });
+            if (transaction?.meta?.err !== null && transaction?.meta?.err !== undefined)
+                return { status: "finalized-failed", signature, error: transaction.meta.err };
+            if (transaction?.meta && transaction.meta.err === null)
+                return { status: "finalized-success", signature };
+            if (status == null && lastValidBlockHeight !== undefined && await this.connection.getBlockHeight(FINALIZED) > lastValidBlockHeight)
+                return { status: "finalized-failed", signature, error: new Error("Blockhash expired before finalization") };
+            return { status: "unknown", signature, reason };
+        }
+        catch {
+            return { status: "unknown", signature, reason: "Transaction outcome could not be reconciled" };
+        }
+    }
+    async hasFinalizedProgramEvent(signature, name, needles = []) {
+        const transaction = await this.connection.getTransaction(signature, { commitment: "finalized", maxSupportedTransactionVersion: 0 });
+        if (!transaction || transaction.meta?.err !== null && transaction.meta?.err !== undefined)
+            return false;
+        const discriminator = createHash("sha256").update(`event:${name}`).digest().subarray(0, 8);
+        const stack = [];
+        for (const log of transaction.meta?.logMessages ?? []) {
+            const invoke = /^Program ([1-9A-HJ-NP-Za-km-z]+) invoke \[\d+\]$/.exec(log);
+            if (invoke) {
+                stack.push(invoke[1]);
+                continue;
+            }
+            const finished = /^Program ([1-9A-HJ-NP-z]+) (success|failed:.*)$/.exec(log);
+            if (finished) {
+                if (stack.length)
+                    stack.pop();
+                continue;
+            }
+            if (!log.startsWith("Program data: ") || stack.at(-1) !== this.programId.toBase58())
+                continue;
+            const data = Buffer.from(log.slice("Program data: ".length), "base64");
+            if (!data.subarray(0, 8).equals(discriminator))
+                continue;
+            if (needles.every(needle => data.includes(Buffer.from(needle))))
+                return true;
+        }
+        return false;
+    }
+    async buildAndSend(instructions, options = {}) {
+        const outcome = await this.buildAndSendOutcome(instructions, options);
+        if (outcome.status === "finalized-success")
+            return outcome.signature;
+        if (outcome.status === "finalized-failed")
+            throw new TransactionFailedError(outcome);
+        throw new TransactionUnknownError(outcome);
+    }
+    async initializePool(a, b, feeBps, creator = this.wallet.publicKey) {
+        return this.buildAndSend([initializePool(this.wallet.publicKey, this.wallet.publicKey, creator, a, b, feeBps, this.programId)]);
+    }
+    async initializeShieldedState(pool) {
+        const state = await this.getPool(pool);
+        return this.buildAndSend([initializeShieldedState(this.wallet.publicKey, pool, { pool, tokenAMint: state.tokenAMint, tokenBMint: state.tokenBMint }, this.programId)]);
+    }
+    async ata(mint, owner, allowOwnerOffCurve = false) {
+        const address = getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID);
+        const info = await this.connection.getAccountInfo(address, FINALIZED);
+        if (!info)
+            return { address, create: createAssociatedTokenAccountIdempotentInstruction(this.wallet.publicKey, address, owner, mint, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID) };
+        if (!info.owner.equals(TOKEN_PROGRAM_ID))
+            throw new Error("Existing ATA is not owned by the classic token program");
+        const account = await getAccount(this.connection, address, FINALIZED, TOKEN_PROGRAM_ID);
+        if (!account.mint.equals(mint) || !account.owner.equals(owner))
+            throw new Error("Existing ATA has the wrong mint or authority");
+        return { address };
+    }
+    async addLiquidity(poolAddress, amountA, amountB, minLp = 0n) {
+        const pool = await this.getPool(poolAddress);
+        const [a, b, lp] = await Promise.all([this.ata(pool.tokenAMint, this.wallet.publicKey), this.ata(pool.tokenBMint, this.wallet.publicKey), this.ata(pool.lpMint, this.wallet.publicKey)]);
+        return this.buildAndSend([a.create, b.create, lp.create, addLiquidityIx(this.wallet.publicKey, pool, a.address, b.address, lp.address, amountA, amountB, minLp, this.programId)].filter(Boolean));
+    }
+    async removeLiquidity(poolAddress, lpAmount, minA = 0n, minB = 0n) {
+        const pool = await this.getPool(poolAddress);
+        const [a, b, lp] = await Promise.all([this.ata(pool.tokenAMint, this.wallet.publicKey), this.ata(pool.tokenBMint, this.wallet.publicKey), this.ata(pool.lpMint, this.wallet.publicKey)]);
+        return this.buildAndSend([a.create, b.create, removeLiquidityIx(this.wallet.publicKey, pool, a.address, b.address, lp.address, lpAmount, minA, minB, this.programId)].filter(Boolean));
+    }
+    async quote(poolAddress, direction, amountIn) {
+        const pool = await this.getPool(poolAddress);
+        const [reserves, supply] = await Promise.all([this.getReserves(pool), this.getLpSupply(pool)]);
+        return swapOutputPreservingLpClaims(direction === "AToB" ? reserves.a : reserves.b, direction === "AToB" ? reserves.b : reserves.a, amountIn, pool.feeBps, supply);
+    }
+    async swap(poolAddress, direction, amountIn, minAmountOut) {
+        const pool = await this.getPool(poolAddress);
+        const [a, b] = await Promise.all([this.ata(pool.tokenAMint, this.wallet.publicKey), this.ata(pool.tokenBMint, this.wallet.publicKey)]);
+        return this.buildAndSend([a.create, b.create, swapIx(this.wallet.publicKey, pool, a.address, b.address, direction === "AToB" ? 0 : 1, amountIn, minAmountOut, this.programId)].filter(Boolean));
+    }
+    async ensureAta(mint, owner = this.wallet.publicKey, allowOwnerOffCurve = false) {
+        return (await this.ata(mint, owner, allowOwnerOffCurve)).address;
+    }
+    async ensureAtas(mintOwnerPairs) {
+        const entries = await Promise.all(mintOwnerPairs.map(entry => this.ata(entry.mint, entry.owner, entry.allowOwnerOffCurve ?? false)));
+        const missing = entries.flatMap(entry => entry.create ? [entry.create] : []);
+        if (missing.length)
+            await this.buildAndSend(missing);
+        return entries.map(entry => entry.address);
+    }
+    assertPrivateTransactionReady() {
+        if (!this.lookupTables.length || !this.wallet.signVersionedTransaction)
+            throw new LookupTableRequiredError();
+    }
+    async validatePrivateTransactionReady(instructions) {
+        this.assertPrivateTransactionReady();
+        await this.validatedTables(instructions);
+    }
+    shieldedWallet(seed, prover, options = {}) {
+        const noteStore = options.noteStore ?? (options.storagePath ? EncryptedFileNoteStore.fromSeed(options.storagePath, seed, ownerCommitment(keyHierarchy(seed).spendSecret)) : undefined);
+        if (!noteStore)
+            throw new Error("A persistent encrypted NoteStore is required; pass storagePath or noteStore");
+        return new ShieldedWallet(this, seed, prover, this.witnessProvider, noteStore);
+    }
+}

package/dist/crypto.d.ts

@@ -0,0 +1,24 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const NOTE_PLAINTEXT_LENGTH = 145;
+export declare const NOTE_PAYLOAD_LENGTH: number;
+export declare function hash2(a: Uint8Array, b: Uint8Array): Uint8Array;
+export declare function keyHierarchy(seed: Uint8Array): {
+    spendSecret: Uint8Array<ArrayBufferLike>;
+    viewKey: Uint8Array<ArrayBufferLike>;
+    storageKey: Uint8Array<ArrayBufferLike>;
+};
+export declare function noteStoreKey(seed: Uint8Array): Uint8Array;
+export declare function ownerCommitment(spend: Uint8Array): Uint8Array;
+export declare function noteCommitment(pool: PublicKey, asset: PublicKey, amount: bigint, owner: Uint8Array, randomness: Uint8Array): Uint8Array;
+export declare function nullifier(pool: PublicKey, asset: PublicKey, spend: Uint8Array, randomness: Uint8Array): Uint8Array;
+export declare function encodeNote(pool: PublicKey, asset: PublicKey, amount: bigint, owner: Uint8Array, randomness: Uint8Array): Buffer;
+export interface DecryptedNote {
+    pool: PublicKey;
+    asset: PublicKey;
+    amount: bigint;
+    ownerCommitment: Uint8Array;
+    randomness: Uint8Array;
+}
+export declare function encryptNote(note: Buffer, viewKey: Uint8Array, pool: PublicKey, asset: PublicKey, commitment: Uint8Array): Buffer;
+export declare function decryptNotePayload(payload: Uint8Array, viewKey: Uint8Array, pool: PublicKey, asset: PublicKey, commitment: Uint8Array): DecryptedNote;
+export declare function cryptoRandom(length: number): Uint8Array;

package/dist/crypto.js

@@ -0,0 +1,111 @@
+import { hkdf } from "@noble/hashes/hkdf";
+import { sha256 } from "@noble/hashes/sha256";
+import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { poseidon2, poseidon3, poseidon9 } from "poseidon-lite";
+import { PublicKey } from "@solana/web3.js";
+const DOMAIN = 0x5a4b43504d4d0003n;
+const OWNER_DOMAIN = 0x5a4b43504d4f0003n;
+const NULLIFIER_DOMAIN = 0x5a4b43504d4e0003n;
+const NOTE_VERSION = 2;
+const PAYLOAD_VERSION = 1;
+const AAD = Buffer.from("zkcpmm-v2/note-payload");
+export const NOTE_PLAINTEXT_LENGTH = 145;
+export const NOTE_PAYLOAD_LENGTH = 1 + 24 + NOTE_PLAINTEXT_LENGTH + 16;
+const zero32 = () => new Uint8Array(32);
+const be = (n) => { const b = Buffer.alloc(32); b.writeBigUInt64BE(n, 24); return b; };
+const big = (b) => BigInt(`0x${Buffer.from(b).toString("hex")}`);
+export function hash2(a, b) {
+    const n = poseidon2([big(a), big(b)]);
+    return Buffer.from(n.toString(16).padStart(64, "0"), "hex");
+}
+function limb(b) {
+    const out = zero32();
+    out.set(b.subarray(0, 16), 16);
+    return out;
+}
+export function keyHierarchy(seed) {
+    const spendSecret = hkdf(sha256, seed, Buffer.from("zkcpmm-v2/key-hierarchy"), Buffer.from("spend"), 32);
+    const viewKey = hkdf(sha256, seed, Buffer.from("zkcpmm-v2/key-hierarchy"), Buffer.from("view"), 32);
+    const storageKey = hkdf(sha256, seed, Buffer.from("zkcpmm-v2/key-hierarchy"), Buffer.from("note-store/v1"), 32);
+    return { spendSecret, viewKey, storageKey };
+}
+export function noteStoreKey(seed) {
+    return keyHierarchy(seed).storageKey;
+}
+function poseidonN(values, width) {
+    const n = (width === 3 ? poseidon3 : poseidon9)(values.map(big));
+    return Buffer.from(n.toString(16).padStart(64, "0"), "hex");
+}
+function fold(values) {
+    return values.reduce((a, b) => hash2(a, b));
+}
+export function ownerCommitment(spend) {
+    if (spend.length !== 32)
+        throw new Error("Spend secret must be 32 bytes");
+    return poseidonN([be(OWNER_DOMAIN), limb(spend), limb(spend.subarray(16))], 3);
+}
+export function noteCommitment(pool, asset, amount, owner, randomness) {
+    if (owner.length !== 32 || randomness.length !== 32)
+        throw new Error("Note fields must be 32 bytes");
+    const p = pool.toBytes();
+    const a = asset.toBytes();
+    return fold([be(DOMAIN), limb(p), limb(p.subarray(16)), limb(a), limb(a.subarray(16)), be(amount), owner, limb(randomness), limb(randomness.subarray(16))]);
+}
+export function nullifier(pool, asset, spend, randomness) {
+    if (spend.length !== 32 || randomness.length !== 32)
+        throw new Error("Nullifier fields must be 32 bytes");
+    const p = pool.toBytes();
+    const a = asset.toBytes();
+    return poseidonN([be(NULLIFIER_DOMAIN), limb(p), limb(p.subarray(16)), limb(a), limb(a.subarray(16)), limb(spend), limb(spend.subarray(16)), limb(randomness), limb(randomness.subarray(16))], 9);
+}
+export function encodeNote(pool, asset, amount, owner, randomness) {
+    if (owner.length !== 32 || randomness.length !== 32 || amount < 0n || amount > 0xffffffffffffffffn)
+        throw new Error("Invalid note");
+    const b = Buffer.alloc(NOTE_PLAINTEXT_LENGTH);
+    b[0] = NOTE_VERSION;
+    be(DOMAIN).subarray(24).copy(b, 1);
+    Buffer.from(pool.toBytes()).copy(b, 9);
+    Buffer.from(asset.toBytes()).copy(b, 41);
+    be(amount).subarray(24).copy(b, 73);
+    Buffer.from(owner).copy(b, 81);
+    Buffer.from(randomness).copy(b, 113);
+    return b;
+}
+export function encryptNote(note, viewKey, pool, asset, commitment) {
+    if (note.length !== NOTE_PLAINTEXT_LENGTH || viewKey.length !== 32 || commitment.length !== 32)
+        throw new Error("Invalid note payload");
+    const nonce = cryptoRandom(24);
+    const aad = Buffer.concat([AAD, pool.toBuffer(), asset.toBuffer(), Buffer.from(commitment)]);
+    const cipher = xchacha20poly1305(viewKey, nonce, aad).encrypt(note);
+    const payload = Buffer.concat([Buffer.from([PAYLOAD_VERSION]), nonce, Buffer.from(cipher)]);
+    if (payload.length !== NOTE_PAYLOAD_LENGTH)
+        throw new Error("Invalid encrypted note length");
+    return payload;
+}
+export function decryptNotePayload(payload, viewKey, pool, asset, commitment) {
+    if (payload.length !== NOTE_PAYLOAD_LENGTH || payload[0] !== PAYLOAD_VERSION)
+        throw new Error("Invalid encrypted note payload");
+    const aad = Buffer.concat([AAD, pool.toBuffer(), asset.toBuffer(), Buffer.from(commitment)]);
+    const plaintext = Buffer.from(xchacha20poly1305(viewKey, payload.subarray(1, 25), aad).decrypt(payload.subarray(25)));
+    if (plaintext.length !== NOTE_PLAINTEXT_LENGTH || plaintext[0] !== NOTE_VERSION)
+        throw new Error("Invalid note plaintext");
+    const decodedPool = new PublicKey(plaintext.subarray(9, 41));
+    const decodedAsset = new PublicKey(plaintext.subarray(41, 73));
+    const amount = plaintext.readBigUInt64BE(73);
+    const ownerCommitmentValue = plaintext.subarray(81, 113);
+    const randomness = plaintext.subarray(113, 145);
+    if (!decodedPool.equals(pool) || !decodedAsset.equals(asset))
+        throw new Error("Note payload identity mismatch");
+    if (!Buffer.from(noteCommitment(pool, asset, amount, ownerCommitmentValue, randomness)).equals(Buffer.from(commitment)))
+        throw new Error("Note commitment mismatch");
+    return { pool: decodedPool, asset: decodedAsset, amount, ownerCommitment: Uint8Array.from(ownerCommitmentValue), randomness: Uint8Array.from(randomness) };
+}
+export function cryptoRandom(length) {
+    if (!Number.isSafeInteger(length) || length <= 0)
+        throw new Error("Invalid randomness length");
+    if (!globalThis.crypto)
+        throw new Error("Secure randomness unavailable");
+    const out = new Uint8Array(length);
+    globalThis.crypto.getRandomValues(out);
+    return out;
+}

package/dist/encoding.d.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const PROGRAM_ID: PublicKey;
+export declare const SYSTEM_PROGRAM_ID: PublicKey;
+export declare const TOKEN_PROGRAM_ID: PublicKey;
+export declare function discriminator(name: string): Buffer;
+export declare function accountDiscriminator(name: string): Buffer;
+export declare function concat(...parts: Uint8Array[]): Buffer;
+export declare function u16(value: number): Buffer;
+export declare function u64(value: bigint): Buffer;
+export declare function vec(bytes: Uint8Array): Buffer;
+export declare function u32(value: number): Buffer;
+export declare function pubkey(value: PublicKey): Buffer;
+export declare function bytes32(value: Uint8Array): Buffer;
+export declare function bool(value: boolean): Buffer;
+export declare function enumByte(value: number): Buffer;
+export declare class Reader {
+    private readonly data;
+    private offset;
+    constructor(data: Uint8Array);
+    bytes(length: number): Buffer;
+    pubkey(): PublicKey;
+    u8(): number;
+    u16(): number;
+    u64(): bigint;
+    rest(): number;
+}

package/dist/encoding.js

@@ -0,0 +1,41 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { PublicKey } from "@solana/web3.js";
+export const PROGRAM_ID = new PublicKey("ZkCP47fAJJREdXNKSBvTsgJAuLoTKepgk6opmqsHobm");
+export const SYSTEM_PROGRAM_ID = new PublicKey("11111111111111111111111111111111");
+export const TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+export function discriminator(name) {
+    return Buffer.from(sha256(new TextEncoder().encode(`global:${name}`)).subarray(0, 8));
+}
+export function accountDiscriminator(name) {
+    return Buffer.from(sha256(new TextEncoder().encode(`account:${name}`)).subarray(0, 8));
+}
+export function concat(...parts) { return Buffer.concat(parts.map(Buffer.from)); }
+export function u16(value) { if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff)
+    throw new Error("Invalid u16"); const b = Buffer.alloc(2); b.writeUInt16LE(value); return b; }
+export function u64(value) { if (typeof value !== "bigint" || value < 0n || value > 0xffffffffffffffffn)
+    throw new Error("u64 requires a bigint in range"); const b = Buffer.alloc(8); b.writeBigUInt64LE(value); return b; }
+export function vec(bytes) { return concat(u32(bytes.length), bytes); }
+export function u32(value) { if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff)
+    throw new Error("Invalid u32"); const b = Buffer.alloc(4); b.writeUInt32LE(value); return b; }
+export function pubkey(value) { return Buffer.from(value.toBytes()); }
+export function bytes32(value) {
+    if (value.length !== 32)
+        throw new Error("Expected exactly 32 bytes");
+    return Buffer.from(value);
+}
+export function bool(value) { return Buffer.from([value ? 1 : 0]); }
+export function enumByte(value) { if (!Number.isSafeInteger(value) || value < 0 || value > 255)
+    throw new Error("Invalid enum"); return Buffer.from([value]); }
+export class Reader {
+    data;
+    offset = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    bytes(length) { const out = Buffer.from(this.data.subarray(this.offset, this.offset + length)); this.offset += length; return out; }
+    pubkey() { return new PublicKey(this.bytes(32)); }
+    u8() { return this.bytes(1)[0]; }
+    u16() { return this.bytes(2).readUInt16LE(); }
+    u64() { return this.bytes(8).readBigUInt64LE(); }
+    rest() { return this.data.length - this.offset; }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./encoding.js";
+export * from "./pda.js";
+export * from "./accounts.js";
+export * from "./math.js";
+export * from "./crypto.js";
+export * from "./merkle.js";
+export * from "./types.js";
+export * from "./instructions.js";
+export * from "./client.js";
+export * from "./wallet.js";
+export * from "./prover.js";
+export * from "./witness.js";
+export * from "./store.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from "./encoding.js";
+export * from "./pda.js";
+export * from "./accounts.js";
+export * from "./math.js";
+export * from "./crypto.js";
+export * from "./merkle.js";
+export * from "./types.js";
+export * from "./instructions.js";
+export * from "./client.js";
+export * from "./wallet.js";
+export * from "./prover.js";
+export * from "./witness.js";
+export * from "./store.js";

package/dist/instructions.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { PoolState, ShieldedState } from "./types.js";
+export declare function initializePool(payer: PublicKey, authority: PublicKey, creator: PublicKey, a: PublicKey, b: PublicKey, feeBps: number, programId?: PublicKey): TransactionInstruction;
+export declare function initializeShieldedState(payer: PublicKey, pool: PublicKey, state?: ShieldedState, programId?: PublicKey): TransactionInstruction;
+export declare function addLiquidity(provider: PublicKey, pool: PoolState, providerA: PublicKey, providerB: PublicKey, providerLp: PublicKey, a: bigint, b: bigint, minLp: bigint, programId?: PublicKey): TransactionInstruction;
+export declare function shield(depositor: PublicKey, pool: PoolState, state: ShieldedState, asset: number, amount: bigint, owner: Uint8Array, randomness: Uint8Array, encrypted: Uint8Array, depositorA: PublicKey, depositorB: PublicKey, programId?: PublicKey): TransactionInstruction;
+export declare function removeLiquidity(provider: PublicKey, pool: PoolState, providerA: PublicKey, providerB: PublicKey, providerLp: PublicKey, lpAmount: bigint, minA: bigint, minB: bigint, programId?: PublicKey): TransactionInstruction;
+export declare function swap(trader: PublicKey, pool: PoolState, traderA: PublicKey, traderB: PublicKey, direction: number, amountIn: bigint, minAmountOut: bigint, programId?: PublicKey): TransactionInstruction;
+export declare function unshield(payer: PublicKey, pool: PoolState, state: ShieldedState, asset: number, amount: bigint, root: Uint8Array, rootSequence: bigint, generation: bigint, nullifierValue: Uint8Array, recipient: PublicKey, recipientA: PublicKey, recipientB: PublicKey, proof: Uint8Array, publicInputs: Uint8Array, programId?: PublicKey): TransactionInstruction;
+export declare function privateSwap(payer: PublicKey, pool: PoolState, state: ShieldedState, direction: number, root: Uint8Array, rootSequence: bigint, generation: bigint, nullifierValue: Uint8Array, amountIn: bigint, amountOut: bigint, changeAmount: bigint, changeCommitment: Uint8Array, outputCommitment: Uint8Array, proof: Uint8Array, programId?: PublicKey): TransactionInstruction;