@unlink-xyz/cli 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# @unlink-xyz/cli
+
+Command-line interface for the Unlink privacy protocol.
+
+## Overview
+
+CLI tool for managing wallets, accounts, and performing private deposits, transfers, and withdrawals on EVM blockchains. Uses `@unlink-xyz/core` under the hood with SQLite for local state storage.
+
+> **Documentation:** [CLI guide](../../docs/sdk/cli.mdx)

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,46 @@
+import os from "node:os";
+import path from "node:path";
+import { Command, Option } from "commander";
+import { registerAccountCommands } from "./commands/account.js";
+import { registerBalanceCommands } from "./commands/balance.js";
+import { registerBurnerCommands } from "./commands/burner.js";
+import { registerConfigCommands } from "./commands/config.js";
+import { registerDepositCommands } from "./commands/deposit.js";
+import { registerHistoryCommands } from "./commands/history.js";
+import { registerMultisigCommands } from "./commands/multisig.js";
+import { registerNotesCommands } from "./commands/notes.js";
+import { registerSyncCommands } from "./commands/sync.js";
+import { registerTransferCommands } from "./commands/transfer.js";
+import { registerTxStatusCommands } from "./commands/tx-status.js";
+import { registerWalletCommands } from "./commands/wallet.js";
+import { registerWithdrawCommands } from "./commands/withdraw.js";
+export function createProgram() {
+    const program = new Command("unlink")
+        .description("Unlink Protocol CLI — privacy-as-a-service for EVM blockchains")
+        .version("0.1.0");
+    program
+        .addOption(new Option("--gateway-url <url>", "Gateway endpoint URL").env("UNLINK_GATEWAY_URL"))
+        .addOption(new Option("--chain-id <id>", "Chain ID").env("UNLINK_CHAIN_ID"))
+        .addOption(new Option("--pool-address <addr>", "Pool contract address").env("UNLINK_POOL_ADDRESS"))
+        .addOption(new Option("--data-dir <path>", "Data directory")
+        .env("UNLINK_DATA_DIR")
+        .default(path.join(os.homedir(), ".unlink")))
+        .addOption(new Option("--node-url <url>", "Ethereum JSON-RPC URL for on-chain transactions (defaults to --gateway-url)").env("UNLINK_RPC_HTTP_URL"))
+        .addOption(new Option("--json", "Output JSON").default(false))
+        .addOption(new Option("--private-key <key>", "Private key for signing").env("UNLINK_PRIVATE_KEY"))
+        .addOption(new Option("--artifact-version <version>", "ZK artifact version for proof generation").env("UNLINK_ARTIFACT_VERSION"));
+    registerWalletCommands(program);
+    registerAccountCommands(program);
+    registerBalanceCommands(program);
+    registerBurnerCommands(program);
+    registerDepositCommands(program);
+    registerTransferCommands(program);
+    registerWithdrawCommands(program);
+    registerSyncCommands(program);
+    registerTxStatusCommands(program);
+    registerHistoryCommands(program);
+    registerNotesCommands(program);
+    registerConfigCommands(program);
+    registerMultisigCommands(program);
+    return program;
+}

package/dist/commands/account.d.ts

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

package/dist/commands/account.js

@@ -0,0 +1,83 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { parseIndex, resolveOptions } from "../lib/options.js";
+import { output } from "../lib/output.js";
+export function registerAccountCommands(program) {
+    const account = program.command("account").description("Account management");
+    account
+        .command("list")
+        .description("List all derived accounts")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const accounts = await ctx.wallet.accounts.list();
+        const activeIndex = await ctx.wallet.accounts.getActiveIndex();
+        if (options.json) {
+            output({
+                accounts: accounts.map((a) => ({
+                    index: a.index,
+                    address: a.address,
+                    masterPublicKey: a.masterPublicKey.toString(),
+                })),
+                activeIndex,
+            }, options);
+        }
+        else {
+            if (accounts.length === 0) {
+                process.stdout.write("No accounts. Create one with: unlink account create\n");
+                return;
+            }
+            for (const a of accounts) {
+                const marker = a.index === activeIndex ? " (active)" : "";
+                process.stdout.write(`#${a.index}${marker}  ${a.address}\n`);
+            }
+        }
+    }));
+    account
+        .command("create")
+        .description("Derive and persist a new account")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const acct = await ctx.wallet.accounts.create();
+        const list = await ctx.wallet.accounts.list();
+        const info = list.find((a) => a.masterPublicKey === acct.masterPublicKey);
+        output(options.json
+            ? {
+                index: info?.index,
+                address: acct.address,
+                masterPublicKey: acct.masterPublicKey.toString(),
+            }
+            : `Account #${info?.index} created: ${acct.address}`, options);
+    }));
+    account
+        .command("active")
+        .description("Show active account")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const idx = await ctx.wallet.accounts.getActiveIndex();
+        if (idx === null) {
+            output(options.json ? { active: null } : "No active account", options);
+            return;
+        }
+        const list = await ctx.wallet.accounts.list();
+        const active = list.find((a) => a.index === idx);
+        output(options.json
+            ? { index: idx, address: active?.address }
+            : `#${idx}  ${active?.address}`, options);
+    }));
+    account
+        .command("switch")
+        .argument("<index>", "Account index")
+        .description("Switch active account")
+        .action(withErrorHandler(async (indexStr, _opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const index = parseIndex(indexStr);
+        const ctx = await createContext(options, { local: true });
+        await ctx.wallet.accounts.setActive(index);
+        output(options.json
+            ? { switched: true, index }
+            : `Switched to account #${index}`, options);
+    }));
+}

package/dist/commands/balance.d.ts

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

package/dist/commands/balance.js

@@ -0,0 +1,75 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireChainId, requireGatewayUrl, resolveOptions, } from "../lib/options.js";
+import { output } from "../lib/output.js";
+import { formatTokenAmount, resolveTokenDecimals, resolveTokenSymbol, } from "../lib/tokens.js";
+export function registerBalanceCommands(program) {
+    program
+        .command("balance")
+        .argument("[token]", "Token address (omit for all)")
+        .description("Show token balances")
+        .action(withErrorHandler(async (token, _opts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const ctx = await createContext(options);
+        // Show active account header in human-readable mode
+        const activeIdx = await ctx.wallet.accounts.getActiveIndex();
+        const activeAcct = await ctx.wallet.accounts.getActive();
+        const addressTag = activeAcct
+            ? ` (${truncateZkAddress(activeAcct.address)})`
+            : "";
+        if (token) {
+            const bal = await ctx.wallet.getBalance(token);
+            if (options.json) {
+                output({ token, balance: bal.toString() }, options);
+            }
+            else {
+                const label = options.nodeUrl
+                    ? await resolveTokenSymbol(options.nodeUrl, token)
+                    : token;
+                const decimals = options.nodeUrl
+                    ? await resolveTokenDecimals(options.nodeUrl, token)
+                    : undefined;
+                process.stdout.write(`Account #${activeIdx}${addressTag}\n`);
+                process.stdout.write(`${label}: ${formatTokenAmount(bal, decimals)}\n`);
+            }
+        }
+        else {
+            const balances = await ctx.wallet.getBalances();
+            const balMap = balances;
+            const entries = Object.entries(balMap).map(([t, b]) => ({
+                token: t,
+                balance: b,
+            }));
+            if (options.json) {
+                output({
+                    balances: entries.map((e) => ({
+                        token: e.token,
+                        balance: e.balance.toString(),
+                    })),
+                }, options);
+            }
+            else if (entries.length === 0) {
+                process.stdout.write("No balances. Run 'unlink sync' first.\n");
+            }
+            else {
+                process.stdout.write(`Account #${activeIdx}${addressTag}\n`);
+                for (const { token: t, balance: b } of entries) {
+                    const label = options.nodeUrl
+                        ? await resolveTokenSymbol(options.nodeUrl, t)
+                        : t;
+                    const decimals = options.nodeUrl
+                        ? await resolveTokenDecimals(options.nodeUrl, t)
+                        : undefined;
+                    process.stdout.write(`${label}: ${formatTokenAmount(b, decimals)}\n`);
+                }
+            }
+        }
+    }));
+}
+function truncateZkAddress(addr) {
+    if (addr.length <= 16)
+        return addr;
+    return `${addr.slice(0, 8)}...${addr.slice(-4)}`;
+}

package/dist/commands/burner.d.ts

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

package/dist/commands/burner.js

@@ -0,0 +1,114 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, parseIndex, requireChainId, requireGatewayUrl, requirePoolAddress, resolveOptions, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+export function registerBurnerCommands(program) {
+    const burner = program
+        .command("burner")
+        .description("Manage burner accounts for DeFi interactions");
+    burner
+        .command("address")
+        .argument("<index>", "BIP-44 derivation index")
+        .description("Derive burner address at a given index")
+        .action(withErrorHandler(async (indexArg, _opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const index = parseIndex(indexArg);
+        const account = await ctx.wallet.burner.addressOf(index);
+        output(account, options);
+    }));
+    burner
+        .command("fund")
+        .argument("<index>", "BIP-44 derivation index")
+        .requiredOption("--token <address>", "Token contract address")
+        .requiredOption("--amount <value>", "Amount (raw atomic units)")
+        .description("Withdraw from shielded pool to fund a burner")
+        .action(withErrorHandler(async (indexArg, cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        const ctx = await createContext(options);
+        const index = parseIndex(indexArg);
+        log("Funding burner from shielded pool...", options);
+        const result = await ctx.wallet.burner.fund(index, {
+            token: cmdOpts["token"],
+            amount: BigInt(cmdOpts["amount"]),
+        });
+        output({ relayId: result.relayId, status: "submitted" }, options);
+    }));
+    burner
+        .command("send")
+        .argument("<index>", "BIP-44 derivation index")
+        .requiredOption("--to <address>", "Destination address")
+        .option("--data <hex>", "Transaction calldata (hex)")
+        .option("--value <amount>", "ETH value in wei")
+        .option("--gas-limit <limit>", "Gas limit")
+        .description("Send a transaction from a burner account")
+        .action(withErrorHandler(async (indexArg, cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const index = parseIndex(indexArg);
+        log("Sending transaction from burner...", options);
+        const result = await ctx.wallet.burner.send(index, {
+            to: cmdOpts["to"],
+            data: cmdOpts["data"] ?? undefined,
+            value: cmdOpts["value"]
+                ? BigInt(cmdOpts["value"])
+                : undefined,
+            gasLimit: cmdOpts["gasLimit"]
+                ? BigInt(cmdOpts["gasLimit"])
+                : undefined,
+        });
+        output(result, options);
+    }));
+    burner
+        .command("sweep")
+        .argument("<index>", "BIP-44 derivation index")
+        .requiredOption("--token <address>", "Token contract address")
+        .option("--amount <value>", "Amount to sweep (omit to sweep full balance)")
+        .description("Sweep burner balance back to shielded pool")
+        .action(withErrorHandler(async (indexArg, cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        const ctx = await createContext(options);
+        const index = parseIndex(indexArg);
+        log("Sweeping burner balance to pool...", options);
+        const result = await ctx.wallet.burner.sweepToPool(index, {
+            token: cmdOpts["token"],
+            amount: cmdOpts["amount"]
+                ? BigInt(cmdOpts["amount"])
+                : undefined,
+        });
+        output(result, options);
+    }));
+    burner
+        .command("export-key")
+        .argument("<index>", "BIP-44 derivation index")
+        .description("Export burner private key for wallet import")
+        .action(withErrorHandler(async (indexArg, _opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const index = parseIndex(indexArg);
+        const key = await ctx.wallet.burner.exportKey(index);
+        output(options.json ? { privateKey: key } : key, options);
+    }));
+    burner
+        .command("balance")
+        .argument("<address>", "Burner or EOA address")
+        .option("--token <address>", "ERC-20 token address (omit for native ETH)")
+        .description("Check burner ETH or token balance")
+        .action(withErrorHandler(async (address, cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const token = cmdOpts["token"];
+        const balance = token
+            ? await ctx.wallet.burner.getTokenBalance(address, token)
+            : await ctx.wallet.burner.getBalance(address);
+        output(options.json
+            ? { address, token: token ?? "ETH", balance: balance.toString() }
+            : `${token ?? "ETH"}: ${balance.toString()}`, options);
+    }));
+}

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,140 @@
+import readline from "node:readline/promises";
+import { withErrorHandler } from "../lib/errors.js";
+import { loadConfigFile, mergeConfigDefaults, resolveOptions, saveConfigFile, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+const VALID_CONFIG_KEYS = [
+    "gatewayUrl",
+    "chainId",
+    "poolAddress",
+    "nodeUrl",
+    "artifactVersion",
+];
+export function registerConfigCommands(program) {
+    const config = program.command("config").description("Configuration");
+    config
+        .command("show")
+        .description("Show current configuration (with value sources)")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const fileConfig = loadConfigFile(options.dataDir);
+        const merged = mergeConfigDefaults(options);
+        function source(key, cliValue) {
+            if (cliValue !== undefined)
+                return "flag/env";
+            if (fileConfig[key] !== undefined)
+                return "config";
+            return "";
+        }
+        const rows = [
+            {
+                key: "Gateway URL",
+                value: merged.gatewayUrl ?? "(not set)",
+                src: source("gatewayUrl", options.gatewayUrl),
+            },
+            {
+                key: "Chain ID",
+                value: merged.chainId ?? "(not set)",
+                src: source("chainId", options.chainId),
+            },
+            {
+                key: "Pool Address",
+                value: merged.poolAddress ?? "(not set)",
+                src: source("poolAddress", options.poolAddress),
+            },
+            {
+                key: "Node URL",
+                value: merged.nodeUrl ?? "(not set)",
+                src: source("nodeUrl", options.nodeUrl),
+            },
+            {
+                key: "Artifact Ver",
+                value: merged.artifactVersion ?? "(not set)",
+                src: source("artifactVersion", options.artifactVersion),
+            },
+            { key: "Data Dir", value: merged.dataDir, src: "" },
+        ];
+        if (options.json) {
+            output({
+                gatewayUrl: merged.gatewayUrl ?? null,
+                chainId: merged.chainId ?? null,
+                poolAddress: merged.poolAddress ?? null,
+                nodeUrl: merged.nodeUrl ?? null,
+                artifactVersion: merged.artifactVersion ?? null,
+                dataDir: merged.dataDir,
+            }, options);
+        }
+        else {
+            for (const row of rows) {
+                const srcTag = row.src ? ` [${row.src}]` : "";
+                process.stdout.write(`${row.key.padEnd(14)} ${row.value}${srcTag}\n`);
+            }
+        }
+    }));
+    config
+        .command("init")
+        .description("Initialize connection config (interactive)")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const existing = loadConfigFile(options.dataDir);
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stderr,
+        });
+        try {
+            const gatewayUrl = (await rl.question(`Gateway URL [${existing.gatewayUrl ?? ""}]: `)) || existing.gatewayUrl;
+            const chainIdStr = (await rl.question(`Chain ID [${existing.chainId ?? ""}]: `)) ||
+                String(existing.chainId ?? "");
+            const poolAddress = (await rl.question(`Pool Address [${existing.poolAddress ?? ""}]: `)) || existing.poolAddress;
+            const nodeUrl = (await rl.question(`Node URL [${existing.nodeUrl ?? ""}]: `)) ||
+                existing.nodeUrl;
+            const artifactVersion = (await rl.question(`Artifact Version [${existing.artifactVersion ?? ""}]: `)) || existing.artifactVersion;
+            const newConfig = {};
+            if (gatewayUrl)
+                newConfig.gatewayUrl = gatewayUrl;
+            if (chainIdStr)
+                newConfig.chainId = Number(chainIdStr);
+            if (poolAddress)
+                newConfig.poolAddress = poolAddress;
+            if (nodeUrl)
+                newConfig.nodeUrl = nodeUrl;
+            if (artifactVersion)
+                newConfig.artifactVersion = artifactVersion;
+            saveConfigFile(options.dataDir, newConfig);
+            log(`Config saved to ${options.dataDir}/config.json`, options);
+            if (options.json) {
+                output(newConfig, options);
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }));
+    config
+        .command("set")
+        .argument("<key>", `Config key (${VALID_CONFIG_KEYS.join(", ")})`)
+        .argument("<value>", "Config value")
+        .description("Set a single config value")
+        .action(withErrorHandler(async (key, value, _opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        if (!VALID_CONFIG_KEYS.includes(key)) {
+            throw new Error(`Invalid config key "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`);
+        }
+        const existing = loadConfigFile(options.dataDir);
+        const updated = { ...existing };
+        if (key === "chainId") {
+            const num = Number(value);
+            if (Number.isNaN(num) || !Number.isInteger(num) || num < 0) {
+                throw new Error("chainId must be a non-negative integer");
+            }
+            updated.chainId = num;
+        }
+        else {
+            updated[key] = value;
+        }
+        saveConfigFile(options.dataDir, updated);
+        log(`Set ${key} = ${value}`, options);
+        if (options.json) {
+            output(updated, options);
+        }
+    }));
+}

package/dist/commands/deposit.d.ts

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

package/dist/commands/deposit.js

@@ -0,0 +1,58 @@
+import { ethers } from "ethers";
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireChainId, requireGatewayUrl, requirePoolAddress, requirePrivateKey, resolveOptions, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+export function registerDepositCommands(program) {
+    program
+        .command("deposit")
+        .requiredOption("--token <address>", "Token contract address")
+        .requiredOption("--amount <value>", "Amount (raw atomic units)")
+        .description("Deposit tokens into the privacy pool")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        requirePrivateKey(options);
+        const ctx = await createContext(options);
+        const amount = BigInt(cmdOpts["amount"]);
+        const token = cmdOpts["token"];
+        const ethRpcUrl = options.nodeUrl ?? ctx.gatewayUrl;
+        const provider = new ethers.JsonRpcProvider(ethRpcUrl, ctx.wallet.chainId, { staticNetwork: true });
+        const signer = new ethers.Wallet(options.privateKey, provider);
+        const depositor = await signer.getAddress();
+        const erc20 = new ethers.Contract(token, [
+            "function allowance(address,address) view returns (uint256)",
+            "function approve(address,uint256) returns (bool)",
+        ], signer);
+        const allowance = (await erc20.getFunction("allowance")(depositor, options.poolAddress));
+        if (allowance < amount) {
+            log("Approving token spend...", options);
+            const approveTx = (await erc20.getFunction("approve")(options.poolAddress, amount));
+            await approveTx.wait();
+        }
+        log("Preparing deposit...", options);
+        const relay = await ctx.wallet.deposit({
+            depositor,
+            deposits: [{ token, amount }],
+        });
+        log(`Relay ID: ${relay.relayId}\nSubmitting transaction...`, options);
+        const nonce = await provider.getTransactionCount(depositor, "pending");
+        const tx = await signer.sendTransaction({
+            to: relay.to,
+            data: relay.calldata,
+            nonce,
+        });
+        log(`Tx hash: ${tx.hash}\nWaiting for confirmation...`, options);
+        await tx.wait();
+        log("Reconciling deposit...", options);
+        const result = await ctx.wallet.confirmDeposit(relay.relayId);
+        output({
+            relayId: relay.relayId,
+            txHash: tx.hash,
+            status: "confirmed",
+            commitments: result.commitments,
+        }, options);
+    }));
+}

package/dist/commands/history.d.ts

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

package/dist/commands/history.js

@@ -0,0 +1,30 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireChainId, requireGatewayUrl, resolveOptions, } from "../lib/options.js";
+import { output } from "../lib/output.js";
+export function registerHistoryCommands(program) {
+    program
+        .command("history")
+        .description("Show transaction history")
+        .option("--include-self-sends", "Include self-sends", false)
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const ctx = await createContext(options);
+        const entries = await ctx.wallet.getHistory({
+            includeSelfSends: Boolean(cmdOpts["includeSelfSends"]),
+        });
+        if (options.json) {
+            output({ entries }, options);
+        }
+        else if (entries.length === 0) {
+            process.stdout.write("No transaction history.\n");
+        }
+        else {
+            for (const e of entries) {
+                process.stdout.write(`${e.kind}  ${e.txHash ?? "pending"}\n`);
+            }
+        }
+    }));
+}

package/dist/commands/multisig.d.ts

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