@voidifydao/sdk 1.0.0

package/dist/utils/proof.js

@@ -0,0 +1,91 @@
+import { MerkleTree } from "fixed-merkle-tree";
+import { buildBn128, utils } from "ffjavascript";
+import { publicKeyToLoHi } from "../utils/bytes.js";
+const { unstringifyBigInts } = utils;
+const ZERO_ELEMENT = BigInt("0x28940deeacd1ca2831336874e87429db0e728a67a472b7ac8195c43c2fb13009").toString();
+export async function generateMerkleProof(commitment, commitments) {
+    const { buildPoseidon } = await import("circomlibjs");
+    const poseidon = await buildPoseidon();
+    const leaves = commitments;
+    const tree = new MerkleTree(20, leaves, {
+        hashFunction: (a, b) => poseidon.F.toString(poseidon([BigInt(a), BigInt(b)])),
+        zeroElement: ZERO_ELEMENT,
+    });
+    const root = tree.root;
+    const leafIndex = leaves.findIndex((l) => l === commitment);
+    if (leafIndex === -1) {
+        throw new Error("Commitment not found in the on-chain tree. " +
+            "Ensure the deposit was confirmed before calling generateMerkleProof.");
+    }
+    const { pathElements, pathIndices } = tree.path(leafIndex);
+    return { pathElements, pathIndices, root };
+}
+export async function generateProof(nullifier, secret, amount, commitment, nullifierHash, recipient, relayer, fee, refund, commitments, wasmPath, zkeyPath) {
+    const { root, pathElements, pathIndices } = await generateMerkleProof(commitment, commitments);
+    const { lo: recipientLo, hi: recipientHi } = publicKeyToLoHi(recipient);
+    const { lo: relayerLo, hi: relayerHi } = publicKeyToLoHi(relayer);
+    const input = {
+        root,
+        nullifierHash: nullifierHash,
+        recipient_lo: recipientLo.toString(),
+        recipient_hi: recipientHi.toString(),
+        relayer_lo: relayerLo.toString(),
+        relayer_hi: relayerHi.toString(),
+        fee: fee.toString(),
+        refund: refund.toString(),
+        nullifier: nullifier,
+        secret: secret,
+        amount: amount,
+        pathElements,
+        pathIndices,
+    };
+    let snarkjs;
+    try {
+        snarkjs = await import("snarkjs");
+    }
+    catch (error) {
+        throw new Error("Failed to load snarkjs library. Please ensure it is installed.", {
+            cause: error,
+        });
+    }
+    try {
+        const { proof } = await snarkjs.groth16.fullProve(input, wasmPath, zkeyPath);
+        return { root, proof };
+    }
+    catch (error) {
+        throw new Error("Failed to generate zero-knowledge proof.", {
+            cause: error,
+        });
+    }
+}
+function g1UncompressedNegated(curve, p1Raw) {
+    const p1 = curve.G1.fromObject(p1Raw);
+    const negP1 = curve.G1.neg(p1);
+    const buff = new Uint8Array(64);
+    curve.G1.toRprUncompressed(buff, 0, negP1);
+    return Buffer.from(buff);
+}
+function g1Uncompressed(curve, p1Raw) {
+    let p1 = curve.G1.fromObject(p1Raw);
+    let buff = new Uint8Array(64);
+    curve.G1.toRprUncompressed(buff, 0, p1);
+    return Buffer.from(buff);
+}
+function g2Uncompressed(curve, p2Raw) {
+    let p2 = curve.G2.fromObject(p2Raw);
+    let buff = new Uint8Array(128);
+    curve.G2.toRprUncompressed(buff, 0, p2);
+    return Buffer.from(buff);
+}
+export const proofToBytes = async (proof) => {
+    let proofProc = unstringifyBigInts(proof);
+    let curve = await buildBn128();
+    const pi_a = g1UncompressedNegated(curve, proofProc.pi_a);
+    const pi_b = g2Uncompressed(curve, proofProc.pi_b);
+    const pi_c = g1Uncompressed(curve, proofProc.pi_c);
+    const allBytes = Buffer.concat([pi_a, pi_b, pi_c]);
+    if (allBytes.length !== 256) {
+        throw new Error(`Expected 256 bytes, but got ${allBytes.length}`);
+    }
+    return Array.from(allBytes);
+};

package/dist/utils/tx.d.ts

@@ -0,0 +1,11 @@
+import { TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { Context } from "../context.js";
+import { SignReturn } from "../types/index.js";
+export declare function buildTx(ctx: Context, txOrIxs: TransactionInstruction[] | VersionedTransaction): Promise<{
+    tx: VersionedTransaction;
+    blockhash: string;
+    lastValidBlockHeight: number;
+}>;
+export declare function signAndSend(ctx: Context, txOrIxs: TransactionInstruction[] | VersionedTransaction): Promise<string>;
+export declare function signOrBuild<S extends boolean = true>(ctx: Context, ixs: TransactionInstruction[], sign?: S): Promise<SignReturn<S>>;
+export declare function makeCommand<TArgs extends unknown[]>(ixFn: (ctx: Context, ...args: TArgs) => Promise<TransactionInstruction[]>): <S extends boolean = true>(ctx: Context, ...args: [...TArgs, sign?: S]) => Promise<SignReturn<S>>;

package/dist/utils/tx.js

@@ -0,0 +1,62 @@
+import { TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+import bs58 from "bs58";
+export async function buildTx(ctx, txOrIxs) {
+    if (Array.isArray(txOrIxs)) {
+        if (!ctx.wallet) {
+            throw new Error("wallet is required to build a transaction from ixs");
+        }
+        const latest = await ctx.connection.getLatestBlockhash("confirmed");
+        const tx = new VersionedTransaction(new TransactionMessage({
+            payerKey: ctx.wallet.publicKey,
+            recentBlockhash: latest.blockhash,
+            instructions: txOrIxs,
+        }).compileToV0Message());
+        return {
+            tx,
+            blockhash: latest.blockhash,
+            lastValidBlockHeight: latest.lastValidBlockHeight,
+        };
+    }
+    const tx = txOrIxs;
+    return {
+        tx,
+        blockhash: tx.message.recentBlockhash,
+        lastValidBlockHeight: (await ctx.connection.getBlockHeight("confirmed")) + 150,
+    };
+}
+export async function signAndSend(ctx, txOrIxs) {
+    if (!ctx.wallet) {
+        throw new Error("wallet is required to sign transactions");
+    }
+    const { tx, blockhash, lastValidBlockHeight } = await buildTx(ctx, txOrIxs);
+    const signedTx = await ctx.wallet.signTransaction(tx);
+    const signature = bs58.encode(signedTx.signatures[0]);
+    try {
+        await ctx.connection.sendTransaction(signedTx, {
+            preflightCommitment: "processed",
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!msg.toLowerCase().includes("already been processed")) {
+            throw err;
+        }
+    }
+    await ctx.connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
+    return signature;
+}
+export async function signOrBuild(ctx, ixs, sign = true) {
+    if (sign)
+        return (await signAndSend(ctx, ixs));
+    return (await buildTx(ctx, ixs)).tx;
+}
+export function makeCommand(ixFn) {
+    return async (ctx, ...rest) => {
+        const argCount = ixFn.length - 1;
+        const hasSign = rest.length > argCount;
+        const args = (hasSign ? rest.slice(0, argCount) : rest);
+        const sign = (hasSign ? rest[argCount] : true);
+        const ixs = await ixFn(ctx, ...args);
+        return signOrBuild(ctx, ixs, sign);
+    };
+}

package/dist/voidify/deposit.d.ts

@@ -0,0 +1,10 @@
+import { TransactionInstruction } from "@solana/web3.js";
+import { Context } from "../context.js";
+import type { DepositRecord } from "../substream/types.js";
+export declare function depositIx(ctx: Context, commitment: string, denomination: bigint): Promise<TransactionInstruction[]>;
+export declare const deposit: <S extends boolean = true>(ctx: Context, commitment: string, denomination: bigint, sign?: S | undefined) => Promise<import("../index.js").SignReturn<S>>;
+export declare function listDeposits(ctx: Context, denomination: bigint, options?: {
+    offset?: number;
+    limit?: number;
+    output?: string;
+}): Promise<DepositRecord[]>;

package/dist/voidify/deposit.js

@@ -0,0 +1,40 @@
+import { PublicKey } from "@solana/web3.js";
+import { bigIntToBytes } from "../utils/bytes.js";
+import { makeCommand } from "../utils/tx.js";
+import { SubstreamCliClient } from "../substream/client.js";
+import { VoidifyProgram } from "./program.js";
+export async function depositIx(ctx, commitment, denomination) {
+    const commitmentBytes = bigIntToBytes(BigInt(commitment));
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const poolPDA = voidifyProgram.pool(denomination);
+    const treasuryPDA = voidifyProgram.treasury();
+    const commitmentPDA = voidifyProgram.commitment(commitmentBytes);
+    const ix = await voidifyProgram.program.methods
+        .deposit(Array.from(commitmentBytes))
+        .accountsPartial({
+        sender: ctx.publicKey,
+        pool: poolPDA,
+        poolTreasury: treasuryPDA,
+        commitmentAccount: commitmentPDA,
+        systemProgram: PublicKey.default,
+    })
+        .instruction();
+    return [ix];
+}
+export const deposit = makeCommand(depositIx);
+export async function listDeposits(ctx, denomination, options) {
+    const client = new SubstreamCliClient(ctx);
+    await client.init();
+    const depositModule = client.module("deposit");
+    await depositModule.sync(denomination);
+    const deposits = await depositModule.list(denomination, {
+        offset: options?.offset,
+        limit: options?.limit,
+    });
+    if (options?.output) {
+        const fs = await import("fs/promises");
+        const data = JSON.stringify(deposits, (_, v) => (typeof v === "bigint" ? v.toString() : v), 2);
+        await fs.writeFile(options.output, data, "utf-8");
+    }
+    return deposits;
+}

package/dist/voidify/index.d.ts

@@ -0,0 +1,4 @@
+export { VoidifyProgram } from "./program.js";
+export * from "./deposit.js";
+export * from "./withdraw.js";
+export * from "./relayer/index.js";

package/dist/voidify/index.js

@@ -0,0 +1,4 @@
+export { VoidifyProgram } from "./program.js";
+export * from "./deposit.js";
+export * from "./withdraw.js";
+export * from "./relayer/index.js";

package/dist/voidify/program.d.ts

@@ -0,0 +1,36 @@
+import { Program } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { Voidify } from "../idl/voidify/idl.js";
+export declare class VoidifyProgram {
+    private connection;
+    private _program;
+    private _programId;
+    static readonly SEEDS: {
+        readonly CORE_CONFIG: Buffer<ArrayBufferLike>;
+        readonly STAKE_CONFIG: Buffer<ArrayBufferLike>;
+        readonly TREASURY_CONFIG: Buffer<ArrayBufferLike>;
+        readonly ORACLE_CONFIG: Buffer<ArrayBufferLike>;
+        readonly POOL: Buffer<ArrayBufferLike>;
+        readonly TREASURY: Buffer<ArrayBufferLike>;
+        readonly COMMITMENT: Buffer<ArrayBufferLike>;
+        readonly NULLIFIER: Buffer<ArrayBufferLike>;
+        readonly RELAYER_CONFIG: Buffer<ArrayBufferLike>;
+        readonly RELAYER_EVENT_COUNTER: Buffer<ArrayBufferLike>;
+    };
+    static readonly BPF_LOADER_UPGRADEABLE_PROGRAM_ID: PublicKey;
+    constructor(connection: Connection, programId: PublicKey);
+    get program(): Program<Voidify>;
+    get programId(): PublicKey;
+    get rpcConnection(): Connection;
+    coreConfig(): PublicKey;
+    stakeConfig(): PublicKey;
+    treasuryConfig(): PublicKey;
+    oracleConfig(): PublicKey;
+    pool(denomination: number | bigint): PublicKey;
+    treasury(): PublicKey;
+    commitment(commitment: Uint8Array): PublicKey;
+    nullifier(nullifierHash: Uint8Array): PublicKey;
+    relayerConfig(relayerPubkey: PublicKey): PublicKey;
+    relayerEventCounter(): PublicKey;
+    programData(): PublicKey;
+}

package/dist/voidify/program.js

@@ -0,0 +1,87 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import idl from "../idl/voidify/idl.json" with { type: "json" };
+import { getConstSeed } from "../utils/idl-seed.js";
+export class VoidifyProgram {
+    connection;
+    _program = null;
+    _programId;
+    static SEEDS = {
+        CORE_CONFIG: getConstSeed(idl, "core_config"),
+        STAKE_CONFIG: getConstSeed(idl, "stake_config"),
+        TREASURY_CONFIG: getConstSeed(idl, "treasury_config"),
+        ORACLE_CONFIG: getConstSeed(idl, "oracle_config"),
+        POOL: getConstSeed(idl, "pool"),
+        TREASURY: getConstSeed(idl, "treasury"),
+        COMMITMENT: getConstSeed(idl, "commitment"),
+        NULLIFIER: getConstSeed(idl, "nullifier"),
+        RELAYER_CONFIG: getConstSeed(idl, "relayer_config"),
+        RELAYER_EVENT_COUNTER: getConstSeed(idl, "relayer_event_counter"),
+    };
+    static BPF_LOADER_UPGRADEABLE_PROGRAM_ID = new PublicKey("BPFLoaderUpgradeab1e11111111111111111111111");
+    constructor(connection, programId) {
+        this.connection = connection;
+        this._programId = programId;
+    }
+    get program() {
+        if (!this._program) {
+            idl["address"] = this._programId.toBase58();
+            this._program = new Program(idl, {
+                connection: this.connection,
+            });
+        }
+        return this._program;
+    }
+    get programId() {
+        return this._programId;
+    }
+    get rpcConnection() {
+        return this.connection;
+    }
+    coreConfig() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.CORE_CONFIG], this._programId);
+        return pda;
+    }
+    stakeConfig() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.STAKE_CONFIG], this._programId);
+        return pda;
+    }
+    treasuryConfig() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.TREASURY_CONFIG], this._programId);
+        return pda;
+    }
+    oracleConfig() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.ORACLE_CONFIG], this._programId);
+        return pda;
+    }
+    pool(denomination) {
+        const denominationBuffer = Buffer.alloc(8);
+        denominationBuffer.writeBigUInt64BE(BigInt(denomination));
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.POOL, denominationBuffer], this._programId);
+        return pda;
+    }
+    treasury() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.TREASURY], this._programId);
+        return pda;
+    }
+    commitment(commitment) {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.COMMITMENT, commitment], this._programId);
+        return pda;
+    }
+    nullifier(nullifierHash) {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.NULLIFIER, nullifierHash], this._programId);
+        return pda;
+    }
+    relayerConfig(relayerPubkey) {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.RELAYER_CONFIG, relayerPubkey.toBuffer()], this._programId);
+        return pda;
+    }
+    relayerEventCounter() {
+        const [pda] = PublicKey.findProgramAddressSync([VoidifyProgram.SEEDS.RELAYER_EVENT_COUNTER], this._programId);
+        return pda;
+    }
+    programData() {
+        const [pda] = PublicKey.findProgramAddressSync([this._programId.toBuffer()], VoidifyProgram.BPF_LOADER_UPGRADEABLE_PROGRAM_ID);
+        return pda;
+    }
+}

package/dist/voidify/relayer/index.d.ts

@@ -0,0 +1 @@
+export * from "./list.js";

package/dist/voidify/relayer/index.js

@@ -0,0 +1 @@
+export * from "./list.js";

package/dist/voidify/relayer/list.d.ts

@@ -0,0 +1,5 @@
+import { Context } from "../../context.js";
+import type { RelayerRecord } from "../../substream/types.js";
+export declare function listRelayers(ctx: Context, pubkey?: string, options?: {
+    output?: string;
+}): Promise<RelayerRecord[] | RelayerRecord | null>;

package/dist/voidify/relayer/list.js

@@ -0,0 +1,16 @@
+import { SubstreamCliClient } from "../../substream/client.js";
+export async function listRelayers(ctx, pubkey, options) {
+    const client = new SubstreamCliClient(ctx);
+    await client.init();
+    const relayerModule = client.module("relayer");
+    await relayerModule.sync();
+    const result = pubkey
+        ? await relayerModule.get(pubkey)
+        : await relayerModule.list();
+    if (options?.output) {
+        const fs = await import("fs/promises");
+        const data = JSON.stringify(result, null, 2);
+        await fs.writeFile(options.output, data, "utf-8");
+    }
+    return result;
+}

package/dist/voidify/withdraw.d.ts

@@ -0,0 +1,16 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { Context } from "../context.js";
+import { Note } from "../utils/note.js";
+export declare function directWithdrawIx(ctx: Context, proof: Uint8Array, root: Uint8Array, nullifierHash: Uint8Array, recipient: string, fee: bigint, treasury: bigint, denomination: bigint): Promise<TransactionInstruction[]>;
+export declare function withdrawIx(ctx: Context, proof: Uint8Array, root: Uint8Array, nullifierHash: Uint8Array, recipient: string, relayer: string, fee: bigint, treasury: bigint, switchboardQuote: PublicKey, denomination: bigint): Promise<TransactionInstruction[]>;
+export interface WithdrawArtifact {
+    withdrawData: string;
+    relayerUrl: string;
+}
+export declare function validateNote(ctx: Context, note_str: string): Promise<{
+    note: Note;
+}>;
+export declare function prepareWithdraw(ctx: Context, note_str: string, recipient: string, relayer: string): Promise<WithdrawArtifact>;
+export declare function submitWithdrawToRelayer(artifact: WithdrawArtifact): Promise<string>;
+export declare function withdraw(ctx: Context, note_str: string, recipient: string, relayer: string, _dryRun: boolean): Promise<string>;
+export declare function directWithdraw(ctx: Context, note_str: string, recipient: string): Promise<string>;

package/dist/voidify/withdraw.js

@@ -0,0 +1,188 @@
+import { ComputeBudgetProgram, PublicKey, } from "@solana/web3.js";
+import { bigIntToBytes } from "../utils/bytes.js";
+import { Note } from "../utils/note.js";
+import { generateProof, proofToBytes } from "../utils/proof.js";
+import { toBN } from "../utils/amount.js";
+import { signAndSend } from "../utils/tx.js";
+import { SubstreamCliClient } from "../substream/client.js";
+import { VoidifyProgram } from "./program.js";
+const WITHDRAW_COMPUTE_UNIT_LIMIT = 600_000;
+function withdrawComputeBudgetIx() {
+    return ComputeBudgetProgram.setComputeUnitLimit({
+        units: WITHDRAW_COMPUTE_UNIT_LIMIT,
+    });
+}
+export async function directWithdrawIx(ctx, proof, root, nullifierHash, recipient, fee, treasury, denomination) {
+    const recipientPubkey = new PublicKey(recipient);
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const treasuryConfig = await voidifyProgram.program.account.treasuryConfig.fetch(voidifyProgram.treasuryConfig());
+    const ix = await voidifyProgram.program.methods
+        .directWithdraw(Array.from(proof), Array.from(root), Array.from(nullifierHash), toBN(fee), toBN(treasury))
+        .accountsPartial({
+        sender: ctx.publicKey,
+        recipient: recipientPubkey,
+        pool: voidifyProgram.pool(denomination),
+        treasurySolDestination: treasuryConfig.treasurySolAddress,
+    })
+        .instruction();
+    return [withdrawComputeBudgetIx(), ix];
+}
+export async function withdrawIx(ctx, proof, root, nullifierHash, recipient, relayer, fee, treasury, switchboardQuote, denomination) {
+    const recipientPubkey = new PublicKey(recipient);
+    const relayerPubkey = new PublicKey(relayer);
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const [treasuryConfig, stakeConfig] = await Promise.all([
+        voidifyProgram.program.account.treasuryConfig.fetch(voidifyProgram.treasuryConfig()),
+        voidifyProgram.program.account.stakeConfig.fetch(voidifyProgram.stakeConfig()),
+    ]);
+    const ix = await voidifyProgram.program.methods
+        .withdraw(Array.from(proof), Array.from(root), Array.from(nullifierHash), toBN(fee), toBN(treasury))
+        .accountsPartial({
+        relayer: relayerPubkey,
+        recipient: recipientPubkey,
+        pool: voidifyProgram.pool(denomination),
+        switchboardQuote,
+        stakeTokenMint: stakeConfig.stakeTokenMint,
+        stakingRewardVault: treasuryConfig.stakingRewardVault,
+        treasuryTokenAccount: treasuryConfig.treasuryTokenAccount,
+    })
+        .instruction();
+    return [withdrawComputeBudgetIx(), ix];
+}
+export async function validateNote(ctx, note_str) {
+    const note = await Note.deserialize(note_str);
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const nullifierBytes = bigIntToBytes(BigInt(note.nullifierHash));
+    const nullifierPda = voidifyProgram.nullifier(nullifierBytes);
+    const nullifierAccount = await ctx.connection.getAccountInfo(nullifierPda);
+    if (nullifierAccount !== null) {
+        throw new Error("Note already used: this note has been withdrawn. Each deposit note can be used only once.");
+    }
+    const client = new SubstreamCliClient(ctx);
+    await client.init();
+    const depositModule = client.module("deposit");
+    await depositModule.sync(note.amountRaw);
+    const deposits = await depositModule.list(note.amountRaw);
+    const commitmentInPool = deposits.some((d) => d.commitment === note.commitment);
+    if (!commitmentInPool) {
+        throw new Error("Invalid note: deposit not found in the pool. Verify the note is correct and the deposit transaction has been confirmed.");
+    }
+    return { note };
+}
+export async function prepareWithdraw(ctx, note_str, recipient, relayer) {
+    const note = await Note.deserialize(note_str);
+    const recipientPubkey = new PublicKey(recipient);
+    const relayerPubkey = new PublicKey(relayer);
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const nullifierBytes = bigIntToBytes(BigInt(note.nullifierHash));
+    const nullifierPda = voidifyProgram.nullifier(nullifierBytes);
+    const nullifierAccount = await ctx.connection.getAccountInfo(nullifierPda);
+    if (nullifierAccount !== null) {
+        throw new Error("Note already used: this note has been withdrawn. Each deposit note can be used only once.");
+    }
+    const client = new SubstreamCliClient(ctx);
+    await client.init();
+    const depositModule = client.module("deposit");
+    await depositModule.sync(note.amountRaw);
+    const deposits = await depositModule.list(note.amountRaw);
+    const commitments = [...deposits]
+        .sort((a, b) => a.index - b.index)
+        .map((d) => d.commitment);
+    if (commitments.length === 0) {
+        throw new Error("Failed to get commitments.");
+    }
+    if (!commitments.includes(note.commitment)) {
+        throw new Error("Invalid note: deposit not found in the pool. Verify the note is correct and the deposit transaction has been confirmed.");
+    }
+    const relayerModule = client.module("relayer");
+    await relayerModule.sync();
+    const relayerInfo = await relayerModule.get(relayer);
+    if (!relayerInfo) {
+        throw new Error("Failed to get relayer info");
+    }
+    const treasuryConfig = await voidifyProgram.program.account.treasuryConfig.fetch(voidifyProgram.treasuryConfig());
+    const fee = (note.amountRaw * BigInt(relayerInfo.feeBps)) / BigInt(10000);
+    const treasury = (note.amountRaw * BigInt(treasuryConfig.treasuryBps)) / BigInt(10000);
+    const { root, proof } = await generateProof(note.nullifier, note.secret, note.amountRaw.toString(), note.commitment, note.nullifierHash, recipientPubkey, relayerPubkey, fee, treasury, commitments, ctx.wasmPath, ctx.zkeyPath);
+    const withdrawData = JSON.stringify({
+        proof: await proofToBytes(proof),
+        root: Array.from(bigIntToBytes(BigInt(root))),
+        nullifierHash: Array.from(bigIntToBytes(BigInt(note.nullifierHash))),
+        recipient,
+        amount: note.amountRaw.toString(),
+        fee: fee.toString(),
+        treasury: treasury.toString(),
+    });
+    return { withdrawData, relayerUrl: relayerInfo.url };
+}
+export async function submitWithdrawToRelayer(artifact) {
+    const response = await fetch(artifact.relayerUrl + "/api/relay/withdraw", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: artifact.withdrawData,
+    });
+    if (!response.ok) {
+        const errorBody = await response.text().catch(() => "<unreadable body>");
+        let formatted = errorBody;
+        try {
+            const parsed = JSON.parse(errorBody);
+            formatted =
+                typeof parsed?.error === "string"
+                    ? parsed.error
+                    : JSON.stringify(parsed, null, 2);
+        }
+        catch { }
+        throw new Error(`Failed to send withdraw data: ${response.status} ${response.statusText}\n${formatted}`);
+    }
+    const responseText = await response.text();
+    let result;
+    try {
+        result = JSON.parse(responseText);
+    }
+    catch {
+        throw new Error(`Relayer returned non-JSON response: ${responseText.slice(0, 200)}`);
+    }
+    if (!result?.success || !result?.signature) {
+        throw new Error(result?.error || "Relayer returned unsuccessful response");
+    }
+    return result.signature;
+}
+export async function withdraw(ctx, note_str, recipient, relayer, _dryRun) {
+    const artifact = await prepareWithdraw(ctx, note_str, recipient, relayer);
+    return submitWithdrawToRelayer(artifact);
+}
+export async function directWithdraw(ctx, note_str, recipient) {
+    const note = await Note.deserialize(note_str);
+    const recipientPubkey = new PublicKey(recipient);
+    const voidifyProgram = new VoidifyProgram(ctx.connection, ctx.programId);
+    const nullifierBytes = bigIntToBytes(BigInt(note.nullifierHash));
+    const nullifierPda = voidifyProgram.nullifier(nullifierBytes);
+    const nullifierAccount = await ctx.connection.getAccountInfo(nullifierPda);
+    if (nullifierAccount !== null) {
+        throw new Error("Note already used: this note has been withdrawn. Each deposit note can be used only once.");
+    }
+    const client = new SubstreamCliClient(ctx);
+    await client.init();
+    const depositModule = client.module("deposit");
+    await depositModule.sync(note.amountRaw);
+    const deposits = await depositModule.list(note.amountRaw);
+    const commitments = [...deposits]
+        .sort((a, b) => a.index - b.index)
+        .map((d) => d.commitment);
+    if (commitments.length === 0) {
+        throw new Error("Failed to get commitments.");
+    }
+    if (!commitments.includes(note.commitment)) {
+        throw new Error("Invalid note: deposit not found in the pool. Verify the note is correct and the deposit transaction has been confirmed.");
+    }
+    const treasuryConfig = await voidifyProgram.program.account.treasuryConfig.fetch(voidifyProgram.treasuryConfig());
+    const fee = 0n;
+    const treasury = (note.amountRaw * BigInt(treasuryConfig.directWithdrawBps)) / 10000n;
+    const senderAsRelayer = ctx.publicKey;
+    const { root, proof } = await generateProof(note.nullifier, note.secret, note.amountRaw.toString(), note.commitment, note.nullifierHash, recipientPubkey, senderAsRelayer, fee, treasury, commitments, ctx.wasmPath, ctx.zkeyPath);
+    const proofBytes = new Uint8Array(await proofToBytes(proof));
+    const rootBytes = bigIntToBytes(BigInt(root));
+    const nullifierHashBytes = bigIntToBytes(BigInt(note.nullifierHash));
+    const ixs = await directWithdrawIx(ctx, proofBytes, rootBytes, nullifierHashBytes, recipient, fee, treasury, note.amountRaw);
+    return signAndSend(ctx, ixs);
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@voidifydao/sdk",
+  "version": "1.0.0",
+  "description": "Voidify client SDK and CLI for interacting with the Anchor voidify program suite (browser + Node).",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "voidify": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "start": "npm run build && node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint src/**/*.ts"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.32.1",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "@switchboard-xyz/common": "^5.8.1",
+    "@switchboard-xyz/on-demand": "^3.10.1",
+    "better-sqlite3": "^12.9.0",
+    "bn.js": "^5.2.3",
+    "bs58": "^6.0.0",
+    "circomlibjs": "^0.1.7",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "cors": "^2.8.6",
+    "dexie": "^4.4.2",
+    "express": "^5.2.1",
+    "ffjavascript": "^0.3.1",
+    "fixed-merkle-tree": "^0.7.3",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "snarkjs": "^0.7.6",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bn.js": "^5.2.0",
+    "@types/circomlibjs": "^0.1.6",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^20.11.0",
+    "@types/snarkjs": "^0.7.9",
+    "esbuild": "^0.28.0",
+    "prettier": "^3.8.3",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.17",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "keywords": [
+    "solana",
+    "anchor",
+    "voidify",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VoidifyCommunity/voidify-sdk.git"
+  },
+  "author": "",
+  "license": "MIT"
+}