@voidifydao/sdk 1.0.0

package/dist/cli/config/command.d.ts

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

package/dist/cli/config/command.js

@@ -0,0 +1,91 @@
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { defaultUserConfigPath, getStore, getStorePath, isValidConfigKey, } from "./loader.js";
+import { buildTemplate, postInitHint } from "./init.js";
+function requireConfigPath(cmd) {
+    const root = cmd.parent?.parent ?? cmd.parent ?? cmd;
+    const cfgPath = root.opts().config;
+    return cfgPath ?? defaultUserConfigPath();
+}
+const VALID_INIT_TYPES = [
+    "default",
+    "relayer",
+    "substream",
+    "full",
+];
+function parseInitType(raw) {
+    if (VALID_INIT_TYPES.includes(raw)) {
+        return raw;
+    }
+    console.error(`Unknown --type: ${raw}. Available values: ${VALID_INIT_TYPES.join(", ")}`);
+    process.exit(1);
+}
+function resolveInitPath(cmd, initPath) {
+    if (initPath)
+        return initPath;
+    const root = cmd.parent?.parent ?? cmd.parent ?? cmd;
+    const fromGlobal = root.opts().config;
+    if (fromGlobal)
+        return fromGlobal;
+    return defaultUserConfigPath();
+}
+export function registerConfigCommand(program) {
+    const configCommand = new Command("config")
+        .enablePositionalOptions()
+        .description("Client config file management; does not affect on-chain program state");
+    configCommand
+        .command("path")
+        .description("Print the config file path; requires -c <path>")
+        .action(function () {
+        console.log(getStorePath(requireConfigPath(this)));
+    });
+    configCommand
+        .command("init")
+        .description("Write the initial config only if the file does not exist. --type selects the template and default filename; --path or global -c overrides the location.")
+        .option("-t, --type <type>", `Template type: ${VALID_INIT_TYPES.join(" | ")}`, "default")
+        .option("--path <path>", "Config file path; defaults to ~/.config/voidify/config.json, or %APPDATA%\\voidify\\config.json on Windows; can also be specified with global -c")
+        .action(function (opts) {
+        const type = parseInitType(opts.type);
+        const filePath = getStorePath(resolveInitPath(this, opts.path));
+        if (fs.existsSync(filePath)) {
+            console.log(`Config file already exists: ${filePath}`);
+            return;
+        }
+        const template = buildTemplate(type);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(template, null, 2) + "\n");
+        console.log(`Wrote [${type}] template: ${filePath}`);
+        console.log("");
+        console.log(postInitHint(type));
+    });
+    configCommand
+        .command("get <key>")
+        .description("Read one config item; supports dot notation such as substream.url")
+        .action(function (key) {
+        const store = getStore(requireConfigPath(this));
+        const value = store.get(key);
+        console.log(JSON.stringify(value, null, 2));
+    });
+    configCommand
+        .command("set <key> <value>")
+        .description("Set one config item; supports dot notation, and falls back to string when JSON parsing fails")
+        .action(function (key, raw) {
+        if (!isValidConfigKey(key)) {
+            console.error(`Unknown config key: ${key}`);
+            process.exit(1);
+        }
+        const store = getStore(requireConfigPath(this));
+        let value;
+        try {
+            value = JSON.parse(raw);
+        }
+        catch {
+            value = raw;
+        }
+        store.set(key, value);
+        console.log(`Wrote: ${key} = ${JSON.stringify(value)}`);
+        console.log(`File: ${store.path}`);
+    });
+    program.addCommand(configCommand);
+}

package/dist/cli/config/init.d.ts

@@ -0,0 +1,3 @@
+export type InitType = "default" | "relayer" | "substream" | "full";
+export declare function buildTemplate(type: InitType): Record<string, unknown>;
+export declare function postInitHint(type: InitType): string;

package/dist/cli/config/init.js

@@ -0,0 +1,88 @@
+import { defaults } from "./types.js";
+const REQUIRED = (desc) => `<TODO: ${desc}>`;
+const FILE_KEYPAIR_PATH_HINT = "absolute path to your solana-keygen JSON file";
+function fileKeypairPlaceholder(role) {
+    return {
+        type: "file",
+        path: REQUIRED(`${role} - ${FILE_KEYPAIR_PATH_HINT}`),
+    };
+}
+export function buildTemplate(type) {
+    switch (type) {
+        case "default":
+            return {
+                rpcUrl: defaults.rpcUrl,
+                programId: REQUIRED("voidify program ID"),
+                stakingProgramId: null,
+                keypair: fileKeypairPlaceholder("user keypair"),
+                substream: { ...defaults.substream },
+                proof: { ...defaults.proof },
+            };
+        case "relayer":
+            return {
+                rpcUrl: defaults.rpcUrl,
+                programId: REQUIRED("voidify program ID"),
+                stakingProgramId: null,
+                keypair: fileKeypairPlaceholder("relayer keypair"),
+                relayerServer: { ...defaults.relayerServer },
+            };
+        case "substream":
+            return {
+                rpcUrl: defaults.rpcUrl,
+                programId: REQUIRED("voidify program ID"),
+                keypair: null,
+                substreamServer: { ...defaults.substreamServer },
+            };
+        case "full":
+            return {
+                rpcUrl: defaults.rpcUrl,
+                programId: REQUIRED("voidify program ID"),
+                stakingProgramId: null,
+                keypair: fileKeypairPlaceholder("keypair for this config"),
+                substream: { ...defaults.substream },
+                proof: { ...defaults.proof },
+                substreamServer: { ...defaults.substreamServer },
+                relayerServer: { ...defaults.relayerServer },
+            };
+    }
+}
+export function postInitHint(type) {
+    switch (type) {
+        case "default":
+            return [
+                "Next steps:",
+                "  - programId      <- voidify main program",
+                "  - keypair.path   <- your keypair JSON file path",
+                "  - stakingProgramId <- optional staking program ID",
+                "  (substream / proof already use defaults; no changes needed)",
+                "",
+                "Applicable commands: deposit / withdraw / note.",
+            ].join("\n");
+        case "relayer":
+            return [
+                "Next steps:",
+                "  - programId                  <- voidify main program",
+                "  - keypair.path               <- keypair for the relayer service itself",
+                "  - relayerServer.feedId       <- Switchboard on-demand feed ID",
+                "  - stakingProgramId           <- optional staking program ID",
+                "",
+                "Applicable commands: relayer start / relayer list.",
+            ].join("\n");
+        case "substream":
+            return [
+                "Next steps:",
+                "  - programId               <- voidify main program (used to filter on-chain events)",
+                "  - substreamServer.dbPath  <- server's local SQLite DB file path",
+                "",
+                "Applicable command: substream.",
+            ].join("\n");
+        case "full":
+            return [
+                "Next steps: full template; fill in values as needed.",
+                "  required: programId, keypair.path, relayerServer.feedId",
+                "  optional: stakingProgramId",
+                "",
+                "Reminder: one config should use one keypair. Create separate config files and switch with -c when roles differ.",
+            ].join("\n");
+    }
+}

package/dist/cli/config/keypair.d.ts

@@ -0,0 +1,4 @@
+import { Keypair } from "@solana/web3.js";
+import type { KeypairSource, VoidifyConfig } from "./types.js";
+export declare function loadKeypairSource(src: KeypairSource | null | undefined): Keypair | null;
+export declare function resolveKeypair(cfg: VoidifyConfig, cliKeypairPath: string | undefined): Keypair | null;

package/dist/cli/config/keypair.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import bs58 from "bs58";
+import { Keypair } from "@solana/web3.js";
+function expandHome(p) {
+    if (p === "~")
+        return os.homedir();
+    if (p.startsWith("~/"))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+export function loadKeypairSource(src) {
+    if (!src)
+        return null;
+    switch (src.type) {
+        case "file": {
+            const data = JSON.parse(fs.readFileSync(expandHome(src.path), "utf-8"));
+            return Keypair.fromSecretKey(Uint8Array.from(data));
+        }
+        case "base58": {
+            const decoded = bs58.decode(src.key);
+            if (decoded.length !== 64) {
+                throw new Error(`Decoded keypair base58 value is ${decoded.length} bytes; expected 64 bytes for a standard Solana secret key`);
+            }
+            return Keypair.fromSecretKey(decoded);
+        }
+    }
+}
+export function resolveKeypair(cfg, cliKeypairPath) {
+    if (cliKeypairPath) {
+        return loadKeypairSource({ type: "file", path: cliKeypairPath });
+    }
+    return loadKeypairSource(cfg.keypair);
+}

package/dist/cli/config/loader.d.ts

@@ -0,0 +1,11 @@
+import Conf from "conf";
+import { type VoidifyConfig } from "./types.js";
+export declare function defaultUserConfigPath(): string;
+export declare function isValidConfigKey(key: string): boolean;
+export interface LoadOptions {
+    configPath: string;
+    rpcUrl?: string;
+}
+export declare function getStore(configPath: string): Conf<VoidifyConfig>;
+export declare function getStorePath(configPath: string): string;
+export declare function loadConfig(opts: LoadOptions): VoidifyConfig;

package/dist/cli/config/loader.js

@@ -0,0 +1,65 @@
+import Conf from "conf";
+import fs from "node:fs";
+import path from "node:path";
+import { defaultUserConfigDir, defaults } from "./types.js";
+export function defaultUserConfigPath() {
+    return path.join(defaultUserConfigDir(), "config.json");
+}
+const OPTIONAL_KEYS = [
+    "stakingProgramId",
+    "keypair",
+    "keypair.type",
+    "keypair.path",
+    "keypair.key",
+    "substream",
+    "substream.type",
+    "substream.url",
+    "substream.dbPath",
+];
+function collectPaths(obj, prefix = "") {
+    if (obj === null || typeof obj !== "object" || Array.isArray(obj))
+        return [];
+    const paths = [];
+    for (const [k, v] of Object.entries(obj)) {
+        const next = prefix ? `${prefix}.${k}` : k;
+        paths.push(next);
+        paths.push(...collectPaths(v, next));
+    }
+    return paths;
+}
+const VALID_KEYS = new Set([
+    ...collectPaths(defaults),
+    ...OPTIONAL_KEYS,
+]);
+export function isValidConfigKey(key) {
+    return VALID_KEYS.has(key);
+}
+function buildStore(configPath) {
+    const resolved = path.resolve(configPath);
+    return new Conf({
+        projectName: "voidify",
+        cwd: path.dirname(resolved),
+        configName: path.basename(resolved, path.extname(resolved)),
+    });
+}
+export function getStore(configPath) {
+    const resolved = path.resolve(configPath);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Config file does not exist: ${resolved}. Run \`voidify config init [--type ...]\` first to generate a template.`);
+    }
+    return buildStore(configPath);
+}
+export function getStorePath(configPath) {
+    return path.resolve(configPath);
+}
+export function loadConfig(opts) {
+    const resolved = path.resolve(opts.configPath);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Config file does not exist: ${resolved}. Run \`voidify config init [--type ...]\` first to generate a template.`);
+    }
+    const store = buildStore(opts.configPath);
+    const cfg = { ...store.store };
+    if (opts.rpcUrl)
+        cfg.rpcUrl = opts.rpcUrl;
+    return cfg;
+}

package/dist/cli/config/types.d.ts

@@ -0,0 +1,50 @@
+export type KeypairSource = {
+    type: "file";
+    path: string;
+} | {
+    type: "base58";
+    key: string;
+};
+export type SubstreamSource = {
+    type: "remote";
+    url: string;
+    dbPath: string;
+} | {
+    type: "local";
+    dbPath: string;
+} | {
+    type: "auto";
+    url: string;
+    dbPath: string;
+};
+export interface VoidifyConfig {
+    rpcUrl: string;
+    programId: string;
+    stakingProgramId?: string | null;
+    keypair?: KeypairSource | null;
+    substream?: SubstreamSource | null;
+    proof?: {
+        wasmPath: string;
+        zkeyPath: string;
+    } | null;
+    substreamServer?: {
+        port: number;
+        host: string;
+        dbPath: string;
+    } | null;
+    relayerServer?: {
+        port: number;
+        host: string;
+        feedId: string;
+    } | null;
+}
+interface VoidifyDefaults {
+    rpcUrl: string;
+    substream: NonNullable<VoidifyConfig["substream"]>;
+    proof: NonNullable<VoidifyConfig["proof"]>;
+    substreamServer: NonNullable<VoidifyConfig["substreamServer"]>;
+    relayerServer: NonNullable<VoidifyConfig["relayerServer"]>;
+}
+export declare function defaultUserConfigDir(): string;
+export declare const defaults: VoidifyDefaults;
+export {};

package/dist/cli/config/types.js

@@ -0,0 +1,33 @@
+import os from "node:os";
+import path from "node:path";
+export function defaultUserConfigDir() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "voidify");
+    }
+    const xdgHome = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+    return path.join(xdgHome, "voidify");
+}
+const defaultConfigPath = (...parts) => path.join(defaultUserConfigDir(), ...parts);
+export const defaults = {
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    substream: {
+        type: "auto",
+        url: "https://substream.voidifycto.com",
+        dbPath: defaultConfigPath("substream.db"),
+    },
+    proof: {
+        wasmPath: defaultConfigPath("assets", "withdraw.wasm"),
+        zkeyPath: defaultConfigPath("assets", "withdraw.zkey"),
+    },
+    substreamServer: {
+        port: 3003,
+        host: "0.0.0.0",
+        dbPath: defaultConfigPath("substream-server.db"),
+    },
+    relayerServer: {
+        port: 3002,
+        host: "0.0.0.0",
+        feedId: "0xc5844a98ff37b7ea928409eb08507e1bfe54f5493c3d7f6012ef9c5e457ec031",
+    },
+};

package/dist/cli/deposit.d.ts

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

package/dist/cli/deposit.js

@@ -0,0 +1,58 @@
+import { Command } from "commander";
+import { deposit, listDeposits } from "../voidify/deposit.js";
+import { parseUnits } from "../utils/amount.js";
+import { Note } from "../utils/note.js";
+import { createServiceContext, SOL_DECIMALS, } from "../cli/helpers.js";
+export function registerDepositCommands(program) {
+    const depositCommand = new Command("deposit")
+        .enablePositionalOptions()
+        .description("Deposit commands");
+    depositCommand
+        .command("submit")
+        .option("-c, --commitment <string>", "Commitment generated by the note gen command; if omitted, a new one is generated and printed")
+        .requiredOption("-a, --amount <amount>", "Deposit amount in UI units, such as 1 for 1 SOL")
+        .action(async (options) => {
+        try {
+            const ctx = await createServiceContext(program.opts());
+            let commitment = options.commitment;
+            if (!commitment) {
+                const note = await Note.generate(options.amount);
+                commitment = note.commitment;
+                console.log("Note generated:", {
+                    note: note.serialize(),
+                    commitment: note.commitment,
+                });
+            }
+            const txSignature = await deposit(ctx, commitment, parseUnits(options.amount, SOL_DECIMALS));
+            console.log("Transaction successful:", { txSignature });
+        }
+        catch (error) {
+            console.error("Deposit failed:", error);
+            process.exit(1);
+        }
+    });
+    depositCommand
+        .command("list <amount>")
+        .description("List records for a denomination pool, using UI units such as 1 for 1 SOL")
+        .option("--offset <number>", "Pagination offset")
+        .option("--limit <number>", "Page size")
+        .option("-o, --output <file>", "Write output to a file")
+        .action(async (amount, options) => {
+        try {
+            const ctx = await createServiceContext(program.opts());
+            const deposits = await listDeposits(ctx, parseUnits(amount, SOL_DECIMALS), {
+                offset: options.offset !== undefined
+                    ? parseInt(options.offset)
+                    : undefined,
+                limit: options.limit !== undefined ? parseInt(options.limit) : undefined,
+                output: options.output,
+            });
+            console.log("Deposit records:", deposits);
+        }
+        catch (error) {
+            console.error("List deposits failed:", error);
+            process.exit(1);
+        }
+    });
+    program.addCommand(depositCommand);
+}

package/dist/cli/helpers.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../context.js";
+import type { VoidifyConfig } from "../cli/config/types.js";
+export declare const SOL_DECIMALS = 9;
+export interface GlobalOptions {
+    config?: string;
+    keypair?: string;
+    url?: string;
+}
+export declare function expandHome(p: string): string;
+export declare function loadCliConfig(opts: GlobalOptions): VoidifyConfig;
+export declare function contextFromConfig(cfg: VoidifyConfig, cliKeypairPath?: string): Promise<Context>;
+export declare function createServiceContext(opts: GlobalOptions): Promise<Context>;

package/dist/cli/helpers.js

@@ -0,0 +1,53 @@
+import os from "node:os";
+import path from "node:path";
+import { PublicKey } from "@solana/web3.js";
+import { Context } from "../context.js";
+import { defaultUserConfigPath, loadConfig } from "../cli/config/loader.js";
+import { resolveKeypair } from "../cli/config/keypair.js";
+import { makeSQLiteStores } from "../substream/database/sqlite.js";
+export const SOL_DECIMALS = 9;
+export function expandHome(p) {
+    if (p === "~")
+        return os.homedir();
+    if (p.startsWith("~/"))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+export function loadCliConfig(opts) {
+    return loadConfig({
+        configPath: opts.config ?? defaultUserConfigPath(),
+        rpcUrl: opts.url,
+    });
+}
+export async function contextFromConfig(cfg, cliKeypairPath) {
+    const keypair = resolveKeypair(cfg, cliKeypairPath);
+    const substream = (() => {
+        const cs = cfg.substream;
+        if (!cs)
+            return undefined;
+        const dbPath = expandHome(cs.dbPath);
+        const makeRepos = () => makeSQLiteStores(dbPath, cfg.programId);
+        switch (cs.type) {
+            case "remote":
+                return { type: "remote", url: cs.url, makeRepos };
+            case "local":
+                return { type: "local", makeRepos };
+            case "auto":
+                return { type: "auto", url: cs.url, makeRepos };
+        }
+    })();
+    return new Context({
+        rpcUrl: cfg.rpcUrl,
+        programId: cfg.programId ? new PublicKey(cfg.programId) : undefined,
+        stakingProgramId: cfg.stakingProgramId
+            ? new PublicKey(cfg.stakingProgramId)
+            : undefined,
+        wallet: keypair,
+        substream,
+        wasmPath: cfg.proof ? expandHome(cfg.proof.wasmPath) : undefined,
+        zkeyPath: cfg.proof ? expandHome(cfg.proof.zkeyPath) : undefined,
+    });
+}
+export async function createServiceContext(opts) {
+    return contextFromConfig(loadCliConfig(opts), opts.keypair);
+}

package/dist/cli/note.d.ts

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

package/dist/cli/note.js

@@ -0,0 +1,50 @@
+import { Command } from "commander";
+import { Note } from "../utils/note.js";
+import { formatUnits } from "../utils/amount.js";
+import { SOL_DECIMALS } from "../cli/helpers.js";
+export function registerNoteCommands(program) {
+    const noteCommand = new Command("note")
+        .enablePositionalOptions()
+        .description("Generate notes");
+    noteCommand
+        .command("gen <amount>")
+        .description("Generate a note; amount uses UI units such as 1 for 1 SOL")
+        .action(async (amount) => {
+        try {
+            const note = await Note.generate(amount);
+            console.log("Note generated:", {
+                note: note.serialize(),
+                commitment: note.commitment,
+            });
+        }
+        catch (error) {
+            console.error("Generate note failed:", error);
+            process.exit(1);
+        }
+    });
+    noteCommand
+        .command("verify <note> <commitment>")
+        .description("Verify a note")
+        .action(async (note_str, commitment) => {
+        try {
+            const note = await Note.deserialize(note_str);
+            const valid = await note.verify(commitment);
+            if (!valid) {
+                console.error("Note is invalid");
+                process.exit(1);
+            }
+            console.log("Note verification passed");
+            console.log("Note details:", {
+                amount: note.amount,
+                amountInSol: formatUnits(note.amountRaw, SOL_DECIMALS),
+                commitment: note.commitment,
+                nullifierHash: note.nullifierHash,
+            });
+        }
+        catch (error) {
+            console.error("Note verify failed:", error);
+            process.exit(1);
+        }
+    });
+    program.addCommand(noteCommand);
+}

package/dist/cli/relayer.d.ts

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

package/dist/cli/relayer.js

@@ -0,0 +1,60 @@
+import { Command } from "commander";
+import { startRelayer } from "../relayer/server/index.js";
+import { listRelayers } from "../voidify/relayer/list.js";
+import { createServiceContext, contextFromConfig, loadCliConfig, } from "../cli/helpers.js";
+export function registerRelayerCommands(program) {
+    const relayerCommand = new Command("relayer")
+        .enablePositionalOptions()
+        .description("Relayer commands");
+    relayerCommand
+        .command("list")
+        .description("List relayer information; with --pubkey, returns only that relayer")
+        .option("--pubkey <pubkey>", "Specific relayer public key")
+        .option("-o, --output <file>", "Write output to a file")
+        .action(async (options) => {
+        try {
+            const ctx = await createServiceContext(program.opts());
+            const relayers = await listRelayers(ctx, options.pubkey, {
+                output: options.output,
+            });
+            console.log("Relayer records:", relayers);
+        }
+        catch (error) {
+            console.error("List relayers failed:", error);
+            process.exit(1);
+        }
+    });
+    relayerCommand
+        .command("start")
+        .description("Start the relayer HTTP service")
+        .option("--port <number>", "Service port")
+        .option("--host <host>", "Service listen address")
+        .action(async (options) => {
+        try {
+            const opts = program.opts();
+            const cfg = loadCliConfig(opts);
+            if (!cfg.relayerServer) {
+                throw new Error("relayerServer is not configured. Set relayerServer to {port, host, feedId}, or rerun `voidify-cli config init --type relayer`.");
+            }
+            const feedId = cfg.relayerServer.feedId;
+            if (!feedId) {
+                throw new Error("relayerServer.feedId is not configured. Run `voidify-cli config set relayerServer.feedId <0x...>`.");
+            }
+            const ctx = await contextFromConfig(cfg, opts.keypair);
+            const port = options.port
+                ? parseInt(options.port)
+                : cfg.relayerServer.port;
+            const host = options.host ?? cfg.relayerServer.host;
+            await startRelayer(ctx, {
+                port,
+                host,
+                feedId,
+            });
+        }
+        catch (error) {
+            console.error("Start relayer failed:", error);
+            process.exit(1);
+        }
+    });
+    program.addCommand(relayerCommand);
+}

package/dist/cli/substream.d.ts

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