@voidifydao/sdk 1.0.0

package/dist/cli/substream.js

@@ -0,0 +1,35 @@
+import { startSubstream } from "../substream/server/index.js";
+import { contextFromConfig, expandHome, loadCliConfig, } from "../cli/helpers.js";
+export function registerSubstreamCommands(program) {
+    program
+        .command("substream")
+        .description("Start the Substream service")
+        .option("--port <number>", "Service port")
+        .option("--host <host>", "Service listen address")
+        .option("--db <path>", "Database path")
+        .action(async (options) => {
+        try {
+            const opts = program.opts();
+            const cfg = loadCliConfig(opts);
+            if (!cfg.substreamServer) {
+                throw new Error("substreamServer is not configured. Set substreamServer to {port, host, dbPath}, or rerun `voidify-cli config init --type substream`.");
+            }
+            const dbPath = options.db ?? cfg.substreamServer.dbPath;
+            if (!dbPath) {
+                throw new Error("substreamServer.dbPath is not configured, and --db was not provided. Choose one of them.");
+            }
+            const ctx = await contextFromConfig(cfg, opts.keypair);
+            await startSubstream(ctx, {
+                port: options.port
+                    ? parseInt(options.port)
+                    : cfg.substreamServer.port,
+                host: options.host ?? cfg.substreamServer.host,
+                dbPath: expandHome(dbPath),
+            });
+        }
+        catch (error) {
+            console.error("Substream service failed:", error);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/withdraw.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerWithdrawCommands(program: Command): void;

package/dist/cli/withdraw.js

@@ -0,0 +1,23 @@
+import { withdraw } from "../voidify/withdraw.js";
+import { createServiceContext } from "../cli/helpers.js";
+export function registerWithdrawCommands(program) {
+    program
+        .command("withdraw")
+        .description("Withdraw through a relayer")
+        .requiredOption("--note <string>", "Note generated when depositing")
+        .requiredOption("--recipient <pubkey>", "Recipient address")
+        .requiredOption("--relayer <pubkey>", "Relayer address")
+        .option("--dry", "Dry run: print withdraw information without generating a proof")
+        .action(async (options) => {
+        try {
+            const ctx = await createServiceContext(program.opts());
+            const result = await withdraw(ctx, options.note, options.recipient, options.relayer, options.dry ?? false);
+            console.log("Withdraw successful:", { txSignature: result });
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("Withdraw failed:", error);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerDepositCommands } from "./cli/deposit.js";
+import { registerNoteCommands } from "./cli/note.js";
+import { registerWithdrawCommands } from "./cli/withdraw.js";
+import { registerRelayerCommands } from "./cli/relayer.js";
+import { registerSubstreamCommands } from "./cli/substream.js";
+import { registerConfigCommand } from "./cli/config/command.js";
+const program = new Command();
+program
+    .enablePositionalOptions()
+    .option("-k, --keypair <path>", "Specify the keypair file path")
+    .option("--url <url>", "Specify the RPC URL")
+    .option("-c, --config <path>", "Specify the client config file path")
+    .description("Command-line tool for interacting with the Anchor voidify program");
+registerDepositCommands(program);
+registerNoteCommands(program);
+registerWithdrawCommands(program);
+registerConfigCommand(program);
+registerRelayerCommands(program);
+registerSubstreamCommands(program);
+process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason instanceof Error ? reason.message : reason);
+    process.exitCode = 1;
+});
+process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err instanceof Error ? err.message : err);
+    process.exit(1);
+});
+program.parse();

package/dist/context.d.ts

@@ -0,0 +1,45 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import type { SubstreamRepos } from "./substream/types.js";
+export type SubstreamMode = "remote" | "local" | "auto";
+export type SubstreamConfig = {
+    type: "remote";
+    url: string;
+    makeRepos?: () => SubstreamRepos;
+} | {
+    type: "local";
+    makeRepos?: () => SubstreamRepos;
+} | {
+    type: "auto";
+    url: string;
+    makeRepos?: () => SubstreamRepos;
+};
+export interface ContextOptions {
+    rpcUrl?: string;
+    programId?: PublicKey;
+    stakingProgramId?: PublicKey;
+    wallet?: anchor.Wallet | Keypair | null;
+    substream?: SubstreamConfig;
+    wasmPath?: string;
+    zkeyPath?: string;
+}
+export declare class Context {
+    private readonly _rpcUrl;
+    private readonly _connection;
+    private readonly _programId;
+    private readonly _stakingProgramId;
+    private readonly _substream;
+    private readonly _wasmPath;
+    private readonly _zkeyPath;
+    readonly wallet: anchor.Wallet | null;
+    constructor(opts?: ContextOptions);
+    get rpcUrl(): string;
+    get connection(): Connection;
+    get programId(): PublicKey;
+    get stakingProgramId(): PublicKey;
+    hasStakingProgramId(): boolean;
+    get substream(): SubstreamConfig;
+    get wasmPath(): string;
+    get zkeyPath(): string;
+    get publicKey(): PublicKey;
+}

package/dist/context.js

@@ -0,0 +1,77 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Connection, Keypair } from "@solana/web3.js";
+export class Context {
+    _rpcUrl;
+    _connection;
+    _programId;
+    _stakingProgramId;
+    _substream;
+    _wasmPath;
+    _zkeyPath;
+    wallet;
+    constructor(opts = {}) {
+        this._rpcUrl = opts.rpcUrl ?? null;
+        this._connection = opts.rpcUrl
+            ? new Connection(opts.rpcUrl, "confirmed")
+            : null;
+        this._programId = opts.programId ?? null;
+        this._stakingProgramId = opts.stakingProgramId ?? null;
+        this._substream = opts.substream ?? null;
+        this._wasmPath = opts.wasmPath ?? null;
+        this._zkeyPath = opts.zkeyPath ?? null;
+        const w = opts.wallet ?? null;
+        this.wallet =
+            w === null ? null : w instanceof Keypair ? new anchor.Wallet(w) : w;
+    }
+    get rpcUrl() {
+        if (!this._rpcUrl) {
+            throw new Error("rpcUrl is required for this operation");
+        }
+        return this._rpcUrl;
+    }
+    get connection() {
+        if (!this._connection) {
+            throw new Error("rpcUrl/connection is required for this operation");
+        }
+        return this._connection;
+    }
+    get programId() {
+        if (!this._programId) {
+            throw new Error("programId is required for this operation");
+        }
+        return this._programId;
+    }
+    get stakingProgramId() {
+        if (!this._stakingProgramId) {
+            throw new Error("stakingProgramId is required for this operation");
+        }
+        return this._stakingProgramId;
+    }
+    hasStakingProgramId() {
+        return this._stakingProgramId !== null;
+    }
+    get substream() {
+        if (!this._substream) {
+            throw new Error("substream config is required for this operation");
+        }
+        return this._substream;
+    }
+    get wasmPath() {
+        if (!this._wasmPath) {
+            throw new Error("wasmPath is required for this operation (proof generation)");
+        }
+        return this._wasmPath;
+    }
+    get zkeyPath() {
+        if (!this._zkeyPath) {
+            throw new Error("zkeyPath is required for this operation (proof generation)");
+        }
+        return this._zkeyPath;
+    }
+    get publicKey() {
+        if (!this.wallet) {
+            throw new Error("wallet is required for this operation");
+        }
+        return this.wallet.publicKey;
+    }
+}