@unlink-xyz/cli 0.1.0

package/dist/commands/multisig.js

@@ -0,0 +1,343 @@
+import { createMultisigWallet, runSigningListener, signMultisig, } from "@unlink-xyz/multisig";
+import { ethers } from "ethers";
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { listMultisigAccounts, loadMultisigAccount, saveMultisigAccount, } from "../lib/multisig-store.js";
+import { requireChainId, requireGatewayUrl, requirePoolAddress, requirePrivateKey, resolveOptions, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+async function loadAccountView(options, groupId) {
+    const account = await loadMultisigAccount(options.dataDir, groupId);
+    const msWallet = createMultisigWallet({
+        gatewayUrl: account.gatewayUrl,
+    });
+    return { account, accountView: msWallet.toAccountView(account) };
+}
+function parseOptionalParticipantIndex(cmdOpts) {
+    const participantIndexRaw = cmdOpts["participantIndex"];
+    if (participantIndexRaw === undefined)
+        return undefined;
+    const participantIndex = Number(participantIndexRaw);
+    if (!Number.isInteger(participantIndex) || participantIndex < 1) {
+        throw new Error("--participant-index must be a positive integer");
+    }
+    return participantIndex;
+}
+export function registerMultisigCommands(program) {
+    const multisig = program
+        .command("multisig")
+        .description("Multisig wallet management (FROST threshold signatures)");
+    multisig
+        .command("create")
+        .description("Create a new multisig wallet (starts DKG ceremony)")
+        .requiredOption("-t, --threshold <n>", "Minimum signers required")
+        .requiredOption("-n, --participants <n>", "Total number of participants")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        const threshold = Number(cmdOpts["threshold"]);
+        const totalShares = Number(cmdOpts["participants"]);
+        const wallet = createMultisigWallet({
+            gatewayUrl: options.gatewayUrl,
+        });
+        const viewingKeyPair = {
+            privateKey: globalThis.crypto.getRandomValues(new Uint8Array(32)),
+            pubkey: globalThis.crypto.getRandomValues(new Uint8Array(32)),
+        };
+        log("Creating DKG session...", options);
+        const { groupId, complete } = await wallet.create({
+            threshold,
+            totalShares,
+            viewingKeyPair,
+        });
+        log(`Group ID (share with participants): ${groupId}`, options);
+        log("Waiting for all participants to join...", options);
+        const cliName = cmd.parent?.parent?.name() ?? "unlink-cli";
+        log(`Share this with participants:\n  ${cliName} multisig join --code ${groupId} --gateway-url ${options.gatewayUrl}`, options);
+        const account = await complete();
+        await saveMultisigAccount(options.dataDir, account);
+        output({
+            groupId: account.groupId,
+            address: account.address,
+            participantIndex: account.participantIndex,
+            threshold: account.config.threshold,
+            totalShares: account.config.totalShares,
+        }, options);
+    }));
+    multisig
+        .command("join")
+        .description("Join an existing multisig wallet (DKG ceremony)")
+        .requiredOption("-c, --code <group-id>", "Group ID from the creator")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        const code = cmdOpts["code"];
+        const wallet = createMultisigWallet({
+            gatewayUrl: options.gatewayUrl,
+        });
+        log("Joining DKG session...", options);
+        const account = await wallet.join({ code });
+        await saveMultisigAccount(options.dataDir, account);
+        output({
+            groupId: account.groupId,
+            address: account.address,
+            participantIndex: account.participantIndex,
+            threshold: account.config.threshold,
+            totalShares: account.config.totalShares,
+        }, options);
+    }));
+    multisig
+        .command("create-session")
+        .description("Create a signing session for threshold signing")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .option("-p, --participant-index <n>", "Participant index override when multiple local participants exist for a group")
+        .requiredOption("-P, --participants <indices>", "Comma-separated participant indices")
+        .requiredOption("-m, --message <value>", "Message to sign (bigint)")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const groupId = cmdOpts["groupId"];
+        const message = BigInt(cmdOpts["message"]);
+        const participants = cmdOpts["participants"]
+            .split(",")
+            .map(Number);
+        const participantIndex = parseOptionalParticipantIndex(cmdOpts);
+        const account = await loadMultisigAccount(options.dataDir, groupId, participantIndex);
+        const wallet = createMultisigWallet({
+            gatewayUrl: account.gatewayUrl,
+        });
+        log("Creating signing session...", options);
+        const { code } = await wallet.createSigningSession({
+            participants,
+            message,
+            groupId: account.groupId,
+        });
+        const cliName = cmd.parent?.parent?.name() ?? "unlink-cli";
+        const signCmdBase = `${cliName} multisig sign -g ${account.groupId} ` +
+            `-s ${code} -m ${message.toString()}`;
+        const nextSteps = {
+            shareWithParticipants: `${signCmdBase} -p <participant-index>`,
+            signAsCurrentParticipant: `${signCmdBase} -p ${account.participantIndex}`,
+        };
+        log(`Share this with participants:\n  ${nextSteps.shareWithParticipants}`, options);
+        log(`Run this to sign as this participant:\n  ${nextSteps.signAsCurrentParticipant}`, options);
+        output({
+            sessionCode: code,
+            participants,
+            message: String(message),
+            nextSteps,
+        }, options);
+    }));
+    multisig
+        .command("sign")
+        .description("Sign a message using a multisig account")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .option("-p, --participant-index <n>", "Participant index override when multiple local participants exist for a group")
+        .requiredOption("-s, --session-code <code>", "Signing session code")
+        .requiredOption("-m, --message <value>", "Message to sign (bigint)")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const groupId = cmdOpts["groupId"];
+        const participantIndex = parseOptionalParticipantIndex(cmdOpts);
+        const signingSessionCode = cmdOpts["sessionCode"];
+        const message = BigInt(cmdOpts["message"]);
+        const account = await loadMultisigAccount(options.dataDir, groupId, participantIndex);
+        log("Participating in signing session...", options);
+        const signature = await signMultisig({
+            account,
+            message,
+            signingSessionCode,
+        });
+        output(signature, options);
+    }));
+    multisig
+        .command("list")
+        .description("List saved multisig accounts")
+        .action(withErrorHandler(async (_cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const refs = await listMultisigAccounts(options.dataDir);
+        if (refs.length === 0) {
+            output(options.json ? [] : "No multisig accounts found.", options);
+            return;
+        }
+        const accounts = await Promise.all(refs.map(async (ref) => {
+            const account = await loadMultisigAccount(options.dataDir, ref.groupId, ref.participantIndex);
+            return {
+                groupId: account.groupId,
+                address: account.address,
+                participantIndex: account.participantIndex,
+                threshold: account.config.threshold,
+                totalShares: account.config.totalShares,
+            };
+        }));
+        output(accounts, options);
+    }));
+    multisig
+        .command("listen")
+        .description("Listen for signing sessions and auto-sign (co-signer mode)")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .option("-p, --participant-index <n>", "Participant index override when multiple local participants exist for a group")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const groupId = cmdOpts["groupId"];
+        const participantIndex = parseOptionalParticipantIndex(cmdOpts);
+        const account = await loadMultisigAccount(options.dataDir, groupId, participantIndex);
+        log(`Listening for signing sessions on group ${groupId} (participant ${account.participantIndex})...`, options);
+        log("Press Ctrl+C to stop.", options);
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        await runSigningListener({
+            account,
+            signal: controller.signal,
+            onSession: (session) => {
+                log(`Joining session ${session.code} (message: ${session.message})`, options);
+            },
+        });
+        log("Listener stopped.", options);
+    }));
+    // --- Pool operations (require createContext for UnlinkWallet) ---
+    multisig
+        .command("deposit")
+        .description("Deposit tokens into the privacy pool for a multisig account")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .requiredOption("-t, --token <address>", "Token contract address")
+        .requiredOption("-a, --amount <value>", "Amount (raw atomic units)")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        requirePrivateKey(options);
+        const groupId = cmdOpts["groupId"];
+        const token = cmdOpts["token"];
+        const amount = BigInt(cmdOpts["amount"]);
+        const { accountView } = await loadAccountView(options, groupId);
+        const ctx = await createContext(options);
+        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 }],
+            account: accountView,
+        });
+        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);
+    }));
+    multisig
+        .command("sync")
+        .description("Sync local state with blockchain for a multisig account")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const groupId = cmdOpts["groupId"];
+        const { accountView } = await loadAccountView(options, groupId);
+        const ctx = await createContext(options);
+        log("Syncing...", options);
+        await ctx.wallet.sync({}, { account: accountView });
+        output(options.json
+            ? { synced: true, chainId: ctx.wallet.chainId }
+            : "Sync complete.", options);
+    }));
+    multisig
+        .command("balance")
+        .argument("[token]", "Token address (omit for all)")
+        .description("Show token balances for a multisig account")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .action(withErrorHandler(async (token, cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const groupId = cmdOpts["groupId"];
+        const { accountView } = await loadAccountView(options, groupId);
+        const ctx = await createContext(options);
+        if (token) {
+            const bal = await ctx.wallet.getBalance(token, {
+                account: accountView,
+            });
+            output(options.json
+                ? { token, balance: bal.toString() }
+                : `${token}: ${bal.toString()}`, options);
+        }
+        else {
+            const balances = await ctx.wallet.getBalances({
+                account: accountView,
+            });
+            const balMap = balances;
+            const entries = Object.entries(balMap).map(([t, b]) => ({
+                token: t,
+                balance: b.toString(),
+            }));
+            if (options.json) {
+                output({ balances: entries }, options);
+            }
+            else if (entries.length === 0) {
+                process.stdout.write("No balances. Run 'unlink multisig sync --group-id ...' first.\n");
+            }
+            else {
+                for (const { token: t, balance: b } of entries) {
+                    process.stdout.write(`${t}: ${b}\n`);
+                }
+            }
+        }
+    }));
+    multisig
+        .command("transfer")
+        .description("Private transfer from a multisig account (FROST signing)")
+        .requiredOption("-g, --group-id <id>", "Multisig group ID")
+        .requiredOption("-r, --to <address>", "Recipient Unlink address (0zk1...)")
+        .requiredOption("-t, --token <address>", "Token contract address")
+        .requiredOption("-a, --amount <value>", "Amount (raw atomic units)")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        const groupId = cmdOpts["groupId"];
+        const { account, accountView } = await loadAccountView(options, groupId);
+        const ctx = await createContext(options);
+        const participants = Array.from({ length: account.config.totalShares }, (_, i) => i + 1);
+        const msWallet = createMultisigWallet({
+            gatewayUrl: account.gatewayUrl,
+        });
+        const signer = msWallet.createSigner({ account, participants });
+        log("Planning and submitting transfer...", options);
+        const result = await ctx.wallet.transfer({
+            transfers: [
+                {
+                    token: cmdOpts["token"],
+                    recipient: cmdOpts["to"],
+                    amount: BigInt(cmdOpts["amount"]),
+                },
+            ],
+        }, { signer, account: accountView });
+        output({ relayId: result.relayId, status: "submitted" }, options);
+    }));
+}

package/dist/commands/notes.d.ts

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

package/dist/commands/notes.js

@@ -0,0 +1,28 @@
+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 registerNotesCommands(program) {
+    program
+        .command("notes")
+        .description("List all notes (UTXO set)")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const ctx = await createContext(options);
+        const notes = await ctx.wallet.getNotes();
+        if (options.json) {
+            output({ notes }, options);
+        }
+        else if (notes.length === 0) {
+            process.stdout.write("No notes. Run 'unlink sync' first.\n");
+        }
+        else {
+            for (const n of notes) {
+                const status = n.spentAt != null ? "spent" : "unspent";
+                process.stdout.write(`#${String(n.index).padStart(4)}  ${status.padEnd(7)}  ${n.token}  ${n.value}\n`);
+            }
+        }
+    }));
+}

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,51 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireChainId, requireGatewayUrl, resolveOptions, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+export function registerSyncCommands(program) {
+    program
+        .command("sync")
+        .option("--all", "Sync all accounts (not just active)")
+        .description("Sync local state with blockchain")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        const ctx = await createContext(options);
+        const syncAll = Boolean(cmdOpts["all"]);
+        if (syncAll) {
+            const accounts = await ctx.wallet.accounts.list();
+            if (accounts.length === 0) {
+                throw new Error("No accounts found. Create an account first.");
+            }
+            const originalActive = await ctx.wallet.accounts.getActiveIndex();
+            try {
+                for (const acct of accounts) {
+                    await ctx.wallet.accounts.setActive(acct.index);
+                    log(`Syncing account #${acct.index}...`, options);
+                    await ctx.wallet.sync();
+                }
+            }
+            finally {
+                // Always restore original active account, even if sync fails.
+                if (originalActive !== null) {
+                    await ctx.wallet.accounts.setActive(originalActive);
+                }
+            }
+            output(options.json
+                ? {
+                    synced: true,
+                    chainId: ctx.wallet.chainId,
+                    accounts: accounts.length,
+                }
+                : `Sync complete (${accounts.length} accounts).`, options);
+        }
+        else {
+            log("Syncing...", options);
+            await ctx.wallet.sync();
+            output(options.json
+                ? { synced: true, chainId: ctx.wallet.chainId }
+                : "Sync complete.", options);
+        }
+    }));
+}

package/dist/commands/transfer.d.ts

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

package/dist/commands/transfer.js

@@ -0,0 +1,47 @@
+import { Option } from "commander";
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireChainId, requireGatewayUrl, requirePoolAddress, resolveOptions, } from "../lib/options.js";
+import { log, output } from "../lib/output.js";
+import { isRelaySuccess, pollRelayStatus } from "../lib/relay.js";
+export function registerTransferCommands(program) {
+    program
+        .command("transfer")
+        .requiredOption("--to <address>", "Recipient Unlink address (0zk1...)")
+        .requiredOption("--token <address>", "Token contract address")
+        .requiredOption("--amount <value>", "Amount (raw atomic units)")
+        .addOption(new Option("--wait", "Wait for relay confirmation").default(true))
+        .addOption(new Option("--no-wait", "Fire-and-forget (do not wait for confirmation)"))
+        .description("Private transfer to another Unlink address")
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        requireChainId(options);
+        requirePoolAddress(options);
+        const ctx = await createContext(options);
+        const activeIdx = await ctx.wallet.accounts.getActiveIndex();
+        log(`Using account #${activeIdx}`, options);
+        log("Planning and submitting transfer...", options);
+        const result = await ctx.wallet.transfer({
+            transfers: [
+                {
+                    token: cmdOpts["token"],
+                    recipient: cmdOpts["to"],
+                    amount: BigInt(cmdOpts["amount"]),
+                },
+            ],
+        });
+        log(`Relay ID: ${result.relayId}`, options);
+        const shouldWait = cmdOpts["wait"];
+        if (shouldWait) {
+            const final = await pollRelayStatus(ctx.wallet, result.relayId, options);
+            if (!isRelaySuccess(final)) {
+                throw new Error(`Transfer relay ${final.relayId} ended with status "${final.status}"${final.error ? `: ${final.error}` : ""}`);
+            }
+            output(final, options);
+        }
+        else {
+            output({ relayId: result.relayId, status: "submitted" }, options);
+        }
+    }));
+}

package/dist/commands/tx-status.d.ts

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

package/dist/commands/tx-status.js

@@ -0,0 +1,31 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { mergeConfigDefaults, requireGatewayUrl, resolveOptions, } from "../lib/options.js";
+import { output } from "../lib/output.js";
+export function registerTxStatusCommands(program) {
+    program
+        .command("tx-status")
+        .argument("<id>", "Transaction/relay ID")
+        .description("Check transaction status")
+        .action(withErrorHandler(async (txId, _opts, cmd) => {
+        const options = mergeConfigDefaults(resolveOptions(cmd.optsWithGlobals()));
+        requireGatewayUrl(options);
+        const ctx = await createContext(options, { local: true });
+        const status = await ctx.wallet.getTxStatus(txId);
+        if (options.json) {
+            output(status, options);
+        }
+        else {
+            process.stdout.write(`State:  ${status.state}\n`);
+            if (status.txHash) {
+                process.stdout.write(`TxHash: ${status.txHash}\n`);
+            }
+            if (status.error) {
+                process.stdout.write(`Error:  ${status.error}\n`);
+            }
+            if (status.receipt?.blockNumber != null) {
+                process.stdout.write(`Block:  ${status.receipt.blockNumber}\n`);
+            }
+        }
+    }));
+}

package/dist/commands/wallet.d.ts

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

package/dist/commands/wallet.js

@@ -0,0 +1,98 @@
+import { createContext } from "../lib/context.js";
+import { withErrorHandler } from "../lib/errors.js";
+import { resolveOptions } from "../lib/options.js";
+import { output } from "../lib/output.js";
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        if (process.stdin.isTTY) {
+            resolve("");
+            return;
+        }
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data.trim()));
+        process.stdin.on("error", reject);
+    });
+}
+export function registerWalletCommands(program) {
+    const wallet = program.command("wallet").description("Wallet management");
+    wallet
+        .command("create")
+        .description("Create new wallet and display recovery mnemonic")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const { mnemonic } = await ctx.wallet.seed.create();
+        await ctx.wallet.accounts.create();
+        if (options.json) {
+            output({ mnemonic, accountIndex: 0 }, options);
+        }
+        else {
+            process.stdout.write("Wallet created successfully!\n");
+            process.stdout.write("\nRecovery mnemonic (write this down and store safely):\n\n");
+            process.stdout.write(`  ${mnemonic}\n\n`);
+            process.stdout.write("First account (index 0) created and set as active.\n");
+        }
+    }));
+    wallet
+        .command("import")
+        .description("Import wallet from BIP-39 mnemonic")
+        .option("--mnemonic <words>", "Mnemonic phrase (or pipe via stdin)")
+        .option("--overwrite", "Overwrite existing wallet", false)
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        let mnemonic = cmdOpts["mnemonic"];
+        if (!mnemonic) {
+            mnemonic = await readStdin();
+        }
+        if (!mnemonic?.trim()) {
+            throw new Error("Mnemonic required. Use --mnemonic or pipe via stdin.");
+        }
+        const ctx = await createContext(options, { local: true });
+        await ctx.wallet.seed.importMnemonic(mnemonic.trim(), {
+            overwrite: Boolean(cmdOpts["overwrite"]),
+        });
+        await ctx.wallet.accounts.create();
+        output(options.json
+            ? { imported: true, accountIndex: 0 }
+            : "Wallet imported successfully. Account 0 created.", options);
+    }));
+    wallet
+        .command("export")
+        .description("Export wallet recovery mnemonic")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const mnemonic = await ctx.wallet.seed.exportMnemonic();
+        output(options.json ? { mnemonic } : mnemonic, options);
+    }));
+    wallet
+        .command("delete")
+        .description("Delete wallet (irreversible)")
+        .option("--yes", "Skip confirmation", false)
+        .action(withErrorHandler(async (cmdOpts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        if (!cmdOpts["yes"]) {
+            throw new Error("Delete wallet? This cannot be undone. Use --yes to confirm.");
+        }
+        const ctx = await createContext(options, { local: true });
+        await ctx.wallet.seed.delete();
+        output(options.json ? { deleted: true } : "Wallet deleted.", options);
+    }));
+    wallet
+        .command("status")
+        .description("Check if wallet exists")
+        .action(withErrorHandler(async (_opts, cmd) => {
+        const options = resolveOptions(cmd.optsWithGlobals());
+        const ctx = await createContext(options, { local: true });
+        const exists = await ctx.wallet.seed.exists();
+        output(options.json
+            ? { exists }
+            : exists
+                ? "Wallet exists"
+                : "No wallet found", options);
+    }));
+}

package/dist/commands/withdraw.d.ts

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