@veil-cash/sdk 0.1.1 → 0.3.0

package/src/cli/commands/init.ts

@@ -82,19 +82,56 @@ function saveVeilKeypair(veilKey: string, depositKey: string, envPath: string):
   writeFileSync(envPath, content);
 }
 
+/**
+ * Resolve wallet key from CLI flag or WALLET_KEY env var
+ */
+function resolveWalletKey(options: { walletKey?: string }): `0x${string}` {
+  const raw = options.walletKey || process.env.WALLET_KEY;
+  if (!raw) {
+    throw new Error('Wallet key required for --sign-message. Use --wallet-key <key> or set WALLET_KEY env var.');
+  }
+  const key = raw.startsWith('0x') ? raw : `0x${raw}`;
+  if (key.length !== 66) {
+    throw new Error('Invalid wallet key format. Must be a 0x-prefixed 64-character hex string.');
+  }
+  return key as `0x${string}`;
+}
+
 export function createInitCommand(): Command {
   const init = new Command('init')
     .description('Generate a new Veil keypair')
     .option('--force', 'Overwrite existing keypair without prompting')
     .option('--json', 'Output as JSON (no prompts, no file save)')
-    .option('--out <path>', 'Save to custom path instead of .env.veil')
     .option('--no-save', 'Print keypair without saving to file')
+    .option('--sign-message', 'Derive keypair from wallet signature (same as frontend login)')
+    .option('--wallet-key <key>', 'Ethereum wallet private key (or set WALLET_KEY env var)')
+    .option('--signature <sig>', 'Derive keypair from a pre-computed EIP-191 personal_sign signature')
     .action(async (options) => {
-      const envPath = options.out || getDefaultEnvPath();
+      const envPath = getDefaultEnvPath();
       
+      /**
+       * Create keypair: derived from wallet, from signature, or random
+       */
+      async function createKp(): Promise<Keypair> {
+        if (options.signMessage) {
+          const walletKey = resolveWalletKey(options);
+          return Keypair.fromWalletKey(walletKey);
+        }
+        if (options.signature) {
+          return Keypair.fromSignature(options.signature);
+        }
+        return new Keypair();
+      }
+
+      const derivationLabel = options.signMessage
+        ? 'Derived Veil keypair from wallet signature'
+        : options.signature
+          ? 'Derived Veil keypair from provided signature'
+          : 'Generated new Veil keypair';
+
       // JSON mode: no prompts, no save, just output JSON
       if (options.json) {
-        const kp = new Keypair();
+        const kp = await createKp();
         console.log(JSON.stringify({
           veilKey: kp.privkey,
           depositKey: kp.depositKey(),
@@ -105,13 +142,13 @@ export function createInitCommand(): Command {
 
       // No-save mode: print but don't save
       if (!options.save) {
-        const kp = new Keypair();
-        console.log('\nGenerated new Veil keypair:\n');
+        const kp = await createKp();
+        console.log(`\n${derivationLabel}:\n`);
         console.log('Veil Private Key:');
         console.log(`  ${kp.privkey}\n`);
         console.log('Deposit Key (register this on-chain):');
         console.log(`  ${kp.depositKey()}\n`);
-        console.log('(Not saved - use --out <path> to save to a file)');
+        console.log('(Not saved - run without --no-save to save to .env.veil)');
         process.exit(0);
         return;
       }
@@ -129,9 +166,9 @@ export function createInitCommand(): Command {
         }
       }
       
-      const kp = new Keypair();
+      const kp = await createKp();
       
-      console.log('\nGenerated new Veil keypair:\n');
+      console.log(`\n${derivationLabel}:\n`);
       console.log('Veil Private Key:');
       console.log(`  ${kp.privkey}\n`);
       console.log('Deposit Key (register this on-chain):');

package/src/cli/commands/private-balance.ts

@@ -5,16 +5,20 @@
 import { Command } from 'commander';
 import { getPrivateBalance } from '../../balance.js';
 import { Keypair } from '../../keypair.js';
+import type { RelayPool } from '../../types.js';
 
 export function createPrivateBalanceCommand(): Command {
   const privateBalance = new Command('private-balance')
     .description('Show private balance (requires VEIL_KEY)')
+    .option('--pool <pool>', 'Pool to check (eth, usdc, or cbbtc)', 'eth')
     .option('--veil-key <key>', 'Veil private key (or set VEIL_KEY env)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--show-utxos', 'Show individual UTXO details')
     .option('--quiet', 'Suppress progress output')
     .action(async (options) => {
       try {
+        const pool = (options.pool || 'eth').toLowerCase() as RelayPool;
+
         // Get keypair
         const veilKey = options.veilKey || process.env.VEIL_KEY;
         if (!veilKey) {
@@ -33,7 +37,7 @@ export function createPrivateBalanceCommand(): Command {
             };
 
         // Get private balance from SDK
-        const result = await getPrivateBalance({ keypair, rpcUrl, onProgress });
+        const result = await getPrivateBalance({ keypair, pool, rpcUrl, onProgress });
 
         // Clear progress line
         if (!options.quiet) {
@@ -42,6 +46,7 @@ export function createPrivateBalanceCommand(): Command {
 
         // Format output
         const output: Record<string, unknown> = {
+          pool: pool.toUpperCase(),
           privateBalance: result.privateBalance,
           privateBalanceWei: result.privateBalanceWei,
           utxoCount: result.utxoCount,

package/src/cli/commands/queue-balance.ts

@@ -5,16 +5,20 @@
 import { Command } from 'commander';
 import { getQueueBalance } from '../../balance.js';
 import { getAddress } from '../wallet.js';
+import type { RelayPool } from '../../types.js';
 
 export function createQueueBalanceCommand(): Command {
   const balance = new Command('queue-balance')
     .description('Show queue balance and pending deposits')
+    .option('--pool <pool>', 'Pool to check (eth, usdc, or cbbtc)', 'eth')
     .option('--wallet-key <key>', 'Ethereum wallet key (or set WALLET_KEY env)')
     .option('--address <address>', 'Address to check (or derived from wallet key)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--quiet', 'Suppress progress output')
     .action(async (options) => {
       try {
+        const pool = (options.pool || 'eth').toLowerCase() as RelayPool;
+
         // Get address
         let address: `0x${string}`;
         if (options.address) {
@@ -37,7 +41,7 @@ export function createQueueBalanceCommand(): Command {
 
         // Get queue balance from SDK
         const rpcUrl = options.rpcUrl || process.env.RPC_URL;
-        const result = await getQueueBalance({ address, rpcUrl, onProgress });
+        const result = await getQueueBalance({ address, pool, rpcUrl, onProgress });
 
         // Clear progress line
         if (!options.quiet) {

package/src/cli/commands/register.ts

@@ -3,19 +3,20 @@
  */
 
 import { Command } from 'commander';
-import { buildRegisterTx } from '../../deposit.js';
+import { buildRegisterTx, buildChangeDepositKeyTx } from '../../deposit.js';
 import { sendTransaction, getAddress, isRegistered } from '../wallet.js';
 import { getConfig } from '../config.js';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
 
 export function createRegisterCommand(): Command {
   const register = new Command('register')
-    .description('Register your deposit key on-chain (one-time)')
+    .description('Register or update your deposit key on-chain')
     .option('--deposit-key <key>', 'Your Veil deposit key (or set DEPOSIT_KEY env)')
     .option('--wallet-key <key>', 'Ethereum wallet key for signing (or set WALLET_KEY env)')
     .option('--address <address>', 'Owner address (required with --unsigned)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--unsigned', 'Output unsigned transaction payload (Bankr-compatible format)')
+    .option('--force', 'Change deposit key even if already registered')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       const jsonOutput = options.json;
@@ -40,9 +41,13 @@ export function createRegisterCommand(): Command {
             address = getAddress(walletKey as `0x${string}`);
           }
 
-          const tx = buildRegisterTx(depositKey, address);
+          // Use changeDepositKey if --force is set, otherwise register
+          const tx = options.force
+            ? buildChangeDepositKeyTx(depositKey, address)
+            : buildRegisterTx(depositKey, address);
 
           const payload = {
+            action: options.force ? 'changeDepositKey' : 'register',
             to: tx.to,
             data: tx.data,
             value: '0',
@@ -62,45 +67,75 @@ export function createRegisterCommand(): Command {
         if (!jsonOutput) console.log('\nChecking registration status...');
         const { registered, depositKey: existingKey } = await isRegistered(address, config.rpcUrl);
         
-        if (registered) {
+        // Determine if this is a new registration or a key change
+        const keysMatch = registered && existingKey === depositKey;
+        const isChange = registered && !keysMatch;
+
+        if (registered && keysMatch) {
+          // Already registered with the same key -- nothing to do
           if (jsonOutput) {
             console.log(JSON.stringify({
               success: true,
               alreadyRegistered: true,
+              keysMatch: true,
               address,
               depositKey: existingKey,
             }, null, 2));
           } else {
-            console.log(`\nAddress ${address} is already registered.`);
-            console.log(`\nExisting deposit key:`);
-            console.log(`  ${existingKey}`);
+            console.log(`\nAddress ${address} is already registered with this deposit key.`);
+            console.log(`\nDeposit key: ${existingKey!.slice(0, 40)}...`);
           }
           process.exit(0);
           return;
         }
 
+        if (isChange && !options.force) {
+          // Registered with a different key but --force not provided
+          if (jsonOutput) {
+            console.log(JSON.stringify({
+              success: false,
+              alreadyRegistered: true,
+              keysMatch: false,
+              address,
+              onChainKey: existingKey,
+              localKey: depositKey.slice(0, 40) + '...',
+              hint: 'Use --force to change deposit key',
+            }, null, 2));
+          } else {
+            console.log(`\nAddress ${address} is already registered with a different deposit key.`);
+            console.log(`\n  On-chain key: ${existingKey!.slice(0, 40)}...`);
+            console.log(`  Local key:    ${depositKey.slice(0, 40)}...`);
+            console.log(`\nUse --force to change your deposit key on-chain.`);
+          }
+          process.exit(1);
+          return;
+        }
+
+        // Build the appropriate transaction
+        const action = isChange ? 'Changing deposit key' : 'Registering deposit key';
         if (!jsonOutput) {
-          console.log('Registering deposit key...');
+          console.log(`${action}...`);
           console.log(`  Address: ${address}`);
           console.log(`  Deposit Key: ${depositKey.slice(0, 40)}...`);
         }
 
-        // Build and send
-        const tx = buildRegisterTx(depositKey, address);
+        const tx = isChange
+          ? buildChangeDepositKeyTx(depositKey, address)
+          : buildRegisterTx(depositKey, address);
         const result = await sendTransaction(config, tx);
 
         if (result.receipt.status === 'success') {
           if (jsonOutput) {
             console.log(JSON.stringify({
               success: true,
-              alreadyRegistered: false,
+              action: isChange ? 'changed' : 'registered',
               address,
               transactionHash: result.hash,
               blockNumber: result.receipt.blockNumber.toString(),
               gasUsed: result.receipt.gasUsed.toString(),
             }, null, 2));
           } else {
-            console.log('\nRegistration successful!');
+            console.log(isChange ? '\nDeposit key changed successfully!' : '\nRegistration successful!');
             console.log(`  Transaction: ${result.hash}`);
             console.log(`  Block: ${result.receipt.blockNumber}`);
             console.log(`  Gas used: ${result.receipt.gasUsed}`);

package/src/cli/commands/status.ts

@@ -0,0 +1,129 @@
+/**
+ * Status CLI command - Check configuration and service status
+ */
+
+import { Command } from 'commander';
+import { isRegistered, getAddress } from '../wallet.js';
+import { checkRelayHealth } from '../../relay.js';
+
+interface StatusResult {
+  walletKey: {
+    found: boolean;
+    address?: string;
+  };
+  veilKey: {
+    found: boolean;
+  };
+  depositKey: {
+    found: boolean;
+    key?: string;
+  };
+  rpcUrl: {
+    found: boolean;
+    url: string;
+  };
+  registration: {
+    checked: boolean;
+    registered?: boolean;
+    matches?: boolean;
+    onChainKey?: string | null;
+    error?: string;
+  };
+  relay: {
+    checked: boolean;
+    healthy?: boolean;
+    status?: string;
+    network?: string;
+    error?: string;
+  };
+}
+
+export function createStatusCommand(): Command {
+  const status = new Command('status')
+    .description('Check configuration and service status')
+    .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
+    .action(async (options) => {
+      const result: StatusResult = {
+        walletKey: { found: false },
+        veilKey: { found: false },
+        depositKey: { found: false },
+        rpcUrl: { found: false, url: 'https://mainnet.base.org' },
+        registration: { checked: false },
+        relay: { checked: false },
+      };
+
+      // Check WALLET_KEY
+      const walletKey = process.env.WALLET_KEY;
+      if (walletKey) {
+        result.walletKey.found = true;
+        try {
+          result.walletKey.address = getAddress(walletKey as `0x${string}`);
+        } catch {
+          // Invalid key format, but it was found
+        }
+      }
+
+      // Check VEIL_KEY
+      const veilKey = process.env.VEIL_KEY;
+      if (veilKey) {
+        result.veilKey.found = true;
+      }
+
+      // Check DEPOSIT_KEY
+      const depositKey = process.env.DEPOSIT_KEY;
+      if (depositKey) {
+        result.depositKey.found = true;
+        // Show truncated key
+        if (depositKey.length > 20) {
+          result.depositKey.key = `${depositKey.slice(0, 10)}...${depositKey.slice(-8)}`;
+        } else {
+          result.depositKey.key = depositKey;
+        }
+      }
+
+      // Check RPC_URL
+      const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+      if (rpcUrl) {
+        result.rpcUrl.found = true;
+        result.rpcUrl.url = rpcUrl;
+      }
+      const effectiveRpcUrl = rpcUrl || 'https://mainnet.base.org';
+
+      // Check registration status (requires wallet address)
+      if (result.walletKey.found && result.walletKey.address) {
+        result.registration.checked = true;
+        try {
+          const regStatus = await isRegistered(
+            result.walletKey.address as `0x${string}`,
+            effectiveRpcUrl
+          );
+          result.registration.registered = regStatus.registered;
+          result.registration.onChainKey = regStatus.depositKey;
+
+          // Check if on-chain key matches env DEPOSIT_KEY
+          if (regStatus.registered && depositKey && regStatus.depositKey) {
+            result.registration.matches = 
+              regStatus.depositKey.toLowerCase() === depositKey.toLowerCase();
+          }
+        } catch (error) {
+          result.registration.error = error instanceof Error ? error.message : 'Unknown error';
+        }
+      }
+
+      // Check relay health
+      result.relay.checked = true;
+      try {
+        const health = await checkRelayHealth();
+        result.relay.healthy = health.status === 'ok';
+        result.relay.status = health.status;
+        result.relay.network = health.network;
+      } catch (error) {
+        result.relay.healthy = false;
+        result.relay.error = error instanceof Error ? error.message : 'Unknown error';
+      }
+
+      console.log(JSON.stringify(result, null, 2));
+    });
+
+  return status;
+}

package/src/cli/commands/transfer.ts

@@ -6,6 +6,9 @@ import { Command } from 'commander';
 import { Keypair } from '../../keypair.js';
 import { transfer, mergeUtxos } from '../../transfer.js';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import type { RelayPool } from '../../types.js';
+
+const SUPPORTED_ASSETS = ['ETH', 'USDC', 'CBBTC'];
 
 // Progress helper - writes to stderr so JSON output stays clean
 function progress(msg: string, quiet?: boolean) {
@@ -17,13 +20,21 @@ function progress(msg: string, quiet?: boolean) {
 export function createTransferCommand(): Command {
   const transferCmd = new Command('transfer')
     .description('Transfer privately within the pool to another registered address')
+    .argument('<asset>', 'Asset to transfer (ETH, USDC, or CBBTC)')
     .argument('<amount>', 'Amount to transfer (e.g., 0.1)')
     .argument('<recipient>', 'Recipient address (must be registered)')
     .option('--veil-key <key>', 'Veil private key (or set VEIL_KEY env)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--quiet', 'Suppress progress output')
-    .action(async (amount: string, recipient: string, options) => {
+    .action(async (asset: string, amount: string, recipient: string, options) => {
       try {
+        const assetUpper = asset.toUpperCase();
+
+        // Validate asset
+        if (!SUPPORTED_ASSETS.includes(assetUpper)) {
+          throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS.join(', ')}`);
+        }
+
         // Validate recipient
         if (!/^0x[a-fA-F0-9]{40}$/.test(recipient)) {
           throw new CLIError(ErrorCode.INVALID_ADDRESS, 'Invalid recipient address format');
@@ -37,6 +48,7 @@ export function createTransferCommand(): Command {
 
         const senderKeypair = new Keypair(veilKey);
         const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+        const pool = assetUpper.toLowerCase() as RelayPool;
 
         // Progress callback
         const onProgress = options.quiet
@@ -46,13 +58,14 @@ export function createTransferCommand(): Command {
               progress(msg, options.quiet);
             };
 
-        progress('Starting transfer...', options.quiet);
+        progress(`Starting ${assetUpper} transfer...`, options.quiet);
 
         // Execute transfer
         const result = await transfer({
           amount,
           recipientAddress: recipient as `0x${string}`,
           senderKeypair,
+          pool,
           rpcUrl,
           onProgress,
         });
@@ -65,6 +78,7 @@ export function createTransferCommand(): Command {
           success: result.success,
           transactionHash: result.transactionHash,
           blockNumber: result.blockNumber,
+          asset: assetUpper,
           amount: result.amount,
           recipient: result.recipient,
           type: 'transfer',
@@ -82,12 +96,20 @@ export function createTransferCommand(): Command {
 export function createMergeCommand(): Command {
   const mergeCmd = new Command('merge')
     .description('Merge UTXOs by self-transfer (consolidate small UTXOs)')
+    .argument('<asset>', 'Asset to merge (ETH, USDC, or CBBTC)')
     .argument('<amount>', 'Amount to merge (e.g., 0.5)')
     .option('--veil-key <key>', 'Veil private key (or set VEIL_KEY env)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--quiet', 'Suppress progress output')
-    .action(async (amount: string, options) => {
+    .action(async (asset: string, amount: string, options) => {
       try {
+        const assetUpper = asset.toUpperCase();
+
+        // Validate asset
+        if (!SUPPORTED_ASSETS.includes(assetUpper)) {
+          throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS.join(', ')}`);
+        }
+
         // Get keypair
         const veilKey = options.veilKey || process.env.VEIL_KEY;
         if (!veilKey) {
@@ -96,6 +118,7 @@ export function createMergeCommand(): Command {
 
         const keypair = new Keypair(veilKey);
         const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+        const pool = assetUpper.toLowerCase() as RelayPool;
 
         // Progress callback
         const onProgress = options.quiet
@@ -105,12 +128,13 @@ export function createMergeCommand(): Command {
               progress(msg, options.quiet);
             };
 
-        progress('Starting merge (self-transfer)...', options.quiet);
+        progress(`Starting ${assetUpper} merge (self-transfer)...`, options.quiet);
 
         // Execute merge
         const result = await mergeUtxos({
           amount,
           keypair,
+          pool,
           rpcUrl,
           onProgress,
         });
@@ -123,6 +147,7 @@ export function createMergeCommand(): Command {
           success: result.success,
           transactionHash: result.transactionHash,
           blockNumber: result.blockNumber,
+          asset: assetUpper,
           amount: result.amount,
           type: 'merge',
         }, null, 2));

package/src/cli/commands/withdraw.ts

@@ -6,6 +6,9 @@ import { Command } from 'commander';
 import { Keypair } from '../../keypair.js';
 import { withdraw } from '../../withdraw.js';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import type { RelayPool } from '../../types.js';
+
+const SUPPORTED_ASSETS = ['ETH', 'USDC', 'CBBTC'];
 
 // Progress helper - writes to stderr so JSON output stays clean
 function progress(msg: string, quiet?: boolean) {
@@ -17,13 +20,21 @@ function progress(msg: string, quiet?: boolean) {
 export function createWithdrawCommand(): Command {
   const withdrawCmd = new Command('withdraw')
     .description('Withdraw from private pool to a public address')
+    .argument('<asset>', 'Asset to withdraw (ETH, USDC, or CBBTC)')
     .argument('<amount>', 'Amount to withdraw (e.g., 0.1)')
     .argument('<recipient>', 'Recipient address (e.g., 0x...)')
     .option('--veil-key <key>', 'Veil private key (or set VEIL_KEY env)')
     .option('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
     .option('--quiet', 'Suppress progress output')
-    .action(async (amount: string, recipient: string, options) => {
+    .action(async (asset: string, amount: string, recipient: string, options) => {
       try {
+        const assetUpper = asset.toUpperCase();
+
+        // Validate asset
+        if (!SUPPORTED_ASSETS.includes(assetUpper)) {
+          throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS.join(', ')}`);
+        }
+
         // Validate recipient
         if (!/^0x[a-fA-F0-9]{40}$/.test(recipient)) {
           throw new CLIError(ErrorCode.INVALID_ADDRESS, 'Invalid recipient address format');
@@ -37,6 +48,7 @@ export function createWithdrawCommand(): Command {
 
         const keypair = new Keypair(veilKey);
         const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+        const pool = assetUpper.toLowerCase() as RelayPool;
 
         // Progress callback
         const onProgress = options.quiet
@@ -46,13 +58,14 @@ export function createWithdrawCommand(): Command {
               progress(msg, options.quiet);
             };
 
-        progress('Starting withdrawal...', options.quiet);
+        progress(`Starting ${assetUpper} withdrawal...`, options.quiet);
 
         // Execute withdrawal
         const result = await withdraw({
           amount,
           recipient: recipient as `0x${string}`,
           keypair,
+          pool,
           rpcUrl,
           onProgress,
         });
@@ -65,6 +78,7 @@ export function createWithdrawCommand(): Command {
           success: result.success,
           transactionHash: result.transactionHash,
           blockNumber: result.blockNumber,
+          asset: assetUpper,
           amount: result.amount,
           recipient: result.recipient,
         }, null, 2));

package/src/cli/index.ts

@@ -2,16 +2,17 @@
  * Veil CLI - Command-line interface for Veil Cash
  * 
  * Usage:
- *   veil init              # Generate keypair
- *   veil keypair           # Show keypair (JSON)
- *   veil register          # Register on-chain
- *   veil deposit 0.1       # Deposit ETH
- *   veil balance           # Show all balances
- *   veil queue-balance     # Show pending queue deposits
- *   veil private-balance   # Show private balance
- *   veil withdraw 0.1 --recipient 0x...  # Withdraw to public address
- *   veil transfer 0.1 --to 0x...         # Transfer privately
- *   veil merge 0.5         # Merge UTXOs (self-transfer)
+ *   veil init                        # Generate keypair
+ *   veil keypair                     # Show keypair (JSON)
+ *   veil status                      # Check config and service status
+ *   veil register                    # Register on-chain
+ *   veil deposit ETH 0.1             # Deposit ETH
+ *   veil balance                     # Show all balances
+ *   veil queue-balance               # Show pending queue deposits
+ *   veil private-balance             # Show private balance
+ *   veil withdraw ETH 0.1 0x...      # Withdraw to public address
+ *   veil transfer ETH 0.1 0x...      # Transfer privately
+ *   veil merge ETH 0.5               # Merge UTXOs (self-transfer)
  */
 
 import { Command } from 'commander';
@@ -25,6 +26,7 @@ import { createQueueBalanceCommand } from './commands/queue-balance.js';
 import { createPrivateBalanceCommand } from './commands/private-balance.js';
 import { createWithdrawCommand } from './commands/withdraw.js';
 import { createTransferCommand, createMergeCommand } from './commands/transfer.js';
+import { createStatusCommand } from './commands/status.js';
 
 // Load environment variables
 loadEnv();
@@ -34,7 +36,7 @@ const program = new Command();
 program
   .name('veil')
   .description('CLI for Veil Cash privacy pools on Base')
-  .version('0.1.0');
+  .version('0.3.0');
 
 // Add commands
 program.addCommand(createInitCommand());
@@ -47,6 +49,7 @@ program.addCommand(createPrivateBalanceCommand());
 program.addCommand(createWithdrawCommand());
 program.addCommand(createTransferCommand());
 program.addCommand(createMergeCommand());
+program.addCommand(createStatusCommand());
 
 // Parse and execute
 program.parse();