@veil-cash/sdk 0.4.0 → 0.6.0

package/src/cli/commands/register.ts

@@ -5,57 +5,63 @@
 import { Command } from 'commander';
 import { buildRegisterTx, buildChangeDepositKeyTx } from '../../deposit.js';
 import { sendTransaction, getAddress, isRegistered } from '../wallet.js';
-import { getConfig } from '../config.js';
+import { getConfig, resolveAddress } from '../config.js';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import { maskValue, printFields, printHeader, printJson, printLine, txUrl } from '../output.js';
 
 export function createRegisterCommand(): Command {
   const register = new Command('register')
     .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')
+    .option('--address <address>', 'Signer address (optional if SIGNER_ADDRESS or WALLET_KEY is set in --unsigned mode)')
+    .option('--unsigned', 'Output unsigned transaction payload instead of sending')
+     .option('--force', 'Change deposit key even if already registered')
+     .option('--json', 'Output as JSON')
+     .addHelpText('after', `
+ Examples:
+   veil register
+   veil register --force
+   veil register --unsigned --address 0x...
+   SIGNER_ADDRESS=0x... veil register --unsigned
+   veil register --json
+ `)
     .action(async (options) => {
       const jsonOutput = options.json;
 
       try {
         // Get deposit key from option or env
-        const depositKey = options.depositKey || process.env.DEPOSIT_KEY;
+        const depositKey = process.env.DEPOSIT_KEY;
         if (!depositKey) {
-          throw new CLIError(ErrorCode.DEPOSIT_KEY_MISSING, 'Deposit key required. Run "veil init" first or use --deposit-key');
+          throw new CLIError(ErrorCode.DEPOSIT_KEY_MISSING, 'DEPOSIT_KEY not set. Run "veil init" first.');
         }
 
         // Handle --unsigned mode (no wallet required, just build payload)
         if (options.unsigned) {
-          let address: `0x${string}`;
-          if (options.address) {
-            address = options.address as `0x${string}`;
-          } else {
-            const walletKey = options.walletKey || process.env.WALLET_KEY;
-            if (!walletKey) {
-              throw new CLIError(ErrorCode.WALLET_KEY_MISSING, 'Must provide --address or --wallet-key for --unsigned mode');
-            }
-            address = getAddress(walletKey as `0x${string}`);
+          const resolvedAddress = resolveAddress({ address: options.address }, { required: true });
+          if (!resolvedAddress) {
+            throw new CLIError(
+              ErrorCode.WALLET_KEY_MISSING,
+              'Must provide --address, set SIGNER_ADDRESS, or set WALLET_KEY env.',
+            );
           }
+          const address = resolvedAddress.address;
 
-          // Use changeDepositKey if --force is set, otherwise register
-          const tx = options.force
+          const rpcUrl = process.env.RPC_URL;
+          const isChange = options.force
+            ? (await isRegistered(address, rpcUrl)).registered
+            : false;
+          const tx = isChange
             ? buildChangeDepositKeyTx(depositKey, address)
             : buildRegisterTx(depositKey, address);
 
           const payload = {
-            action: options.force ? 'changeDepositKey' : 'register',
+            action: isChange ? 'changeDepositKey' : 'register',
             to: tx.to,
             data: tx.data,
             value: '0',
             chainId: 8453,
           };
 
-          console.log(JSON.stringify(payload, null, 2));
-          process.exit(0);
+          printJson(payload);
           return;
         }
 
@@ -64,35 +70,35 @@ export function createRegisterCommand(): Command {
         const address = getAddress(config.privateKey);
 
         // Check if already registered
-        if (!jsonOutput) console.log('\nChecking registration status...');
+        if (!jsonOutput) printLine('Checking registration status...');
         const { registered, depositKey: existingKey } = await isRegistered(address, config.rpcUrl);
         
         // 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 (registered && keysMatch && !options.force) {
           if (jsonOutput) {
-            console.log(JSON.stringify({
+            printJson({
               success: true,
               alreadyRegistered: true,
               keysMatch: true,
               address,
               depositKey: existingKey,
-            }, null, 2));
+            });
           } else {
-            console.log(`\nAddress ${address} is already registered with this deposit key.`);
-            console.log(`\nDeposit key: ${existingKey!.slice(0, 40)}...`);
+            printHeader('Already Registered');
+            printFields([
+              { label: 'Address', value: address },
+              { label: 'Deposit key', value: maskValue(existingKey!) },
+            ]);
+            printLine();
           }
-          process.exit(0);
           return;
         }
 
-        if (isChange && !options.force) {
-          // Registered with a different key but --force not provided
+        if (registered && !keysMatch && !options.force) {
           if (jsonOutput) {
-            console.log(JSON.stringify({
+            printJson({
               success: false,
               alreadyRegistered: true,
               keysMatch: false,
@@ -100,23 +106,31 @@ export function createRegisterCommand(): Command {
               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.`);
+            printLine('A different deposit key is already registered');
+            printFields([
+              { label: 'Address', value: address },
+              { label: 'On-chain key', value: maskValue(existingKey!) },
+              { label: 'Local key', value: maskValue(depositKey) },
+            ]);
+            printLine('');
+            printLine('Use `veil register --force` to change your deposit key on-chain.');
           }
           process.exit(1);
           return;
         }
 
+        const isChange = registered && options.force;
+
         // Build the appropriate transaction
         const action = isChange ? 'Changing deposit key' : 'Registering deposit key';
         if (!jsonOutput) {
-          console.log(`${action}...`);
-          console.log(`  Address: ${address}`);
-          console.log(`  Deposit Key: ${depositKey.slice(0, 40)}...`);
+          printLine(`${action}...`);
+          printFields([
+            { label: 'Address', value: address },
+            { label: 'Deposit key', value: maskValue(depositKey) },
+          ]);
         }
 
         const tx = isChange
@@ -126,22 +140,22 @@ export function createRegisterCommand(): Command {
 
         if (result.receipt.status === 'success') {
           if (jsonOutput) {
-            console.log(JSON.stringify({
+            printJson({
               success: true,
               action: isChange ? 'changed' : 'registered',
               address,
               transactionHash: result.hash,
               blockNumber: result.receipt.blockNumber.toString(),
-              gasUsed: result.receipt.gasUsed.toString(),
-            }, null, 2));
+            });
           } else {
-            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}`);
-            console.log('\nNext step: veil deposit <amount>');
+            printLine(isChange ? 'Deposit key changed successfully' : 'Registration successful');
+            printFields([
+              { label: 'Transaction', value: txUrl(result.hash) },
+              { label: 'Block', value: result.receipt.blockNumber },
+            ]);
+            printLine('');
+            printLine('Next step: veil deposit <asset> <amount>');
           }
-          process.exit(0);
         } else {
           throw new CLIError(ErrorCode.CONTRACT_ERROR, `Transaction reverted: ${result.hash}`);
         }

package/src/cli/commands/status.ts

@@ -3,13 +3,28 @@
  */
 
 import { Command } from 'commander';
-import { isRegistered, getAddress } from '../wallet.js';
+import { isRegistered, getAddress, getWalletBalances } from '../wallet.js';
+import { resolveAddress } from '../config.js';
 import { checkRelayHealth } from '../../relay.js';
+import { handleCLIError } from '../errors.js';
+import { maskValue, printFields, printHeader, printJson, printSection } from '../output.js';
 
 interface StatusResult {
   walletKey: {
     found: boolean;
     address?: string;
+    valid?: boolean;
+    ethBalance?: string;
+    error?: string;
+  };
+  signerAddress: {
+    found: boolean;
+    address?: string;
+    valid?: boolean;
+  };
+  resolvedAddress: {
+    address?: string;
+    source?: string;
   };
   veilKey: {
     found: boolean;
@@ -41,89 +56,200 @@ interface StatusResult {
 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)')
+    .option('--json', 'Output as JSON')
+    .addHelpText('after', `
+Examples:
+  veil status
+  veil status --json
+`)
     .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
+      try {
+        const result: StatusResult = {
+          walletKey: { found: false },
+          signerAddress: { found: false },
+          resolvedAddress: {},
+          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}`);
+            result.walletKey.valid = true;
+          } catch {
+            result.walletKey.valid = false;
+            result.walletKey.error = 'invalid format';
+          }
         }
-      }
 
-      // Check VEIL_KEY
-      const veilKey = process.env.VEIL_KEY;
-      if (veilKey) {
-        result.veilKey.found = true;
-      }
+        // Check SIGNER_ADDRESS
+        const signerAddress = process.env.SIGNER_ADDRESS;
+        if (signerAddress) {
+          result.signerAddress.found = true;
+          if (/^0x[a-fA-F0-9]{40}$/.test(signerAddress.trim())) {
+            result.signerAddress.valid = true;
+            result.signerAddress.address = signerAddress.trim();
+          } else {
+            result.signerAddress.valid = false;
+          }
+        }
 
-      // 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 VEIL_KEY
+        const veilKey = process.env.VEIL_KEY;
+        if (veilKey) {
+          result.veilKey.found = true;
         }
-      }
 
-      // 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 DEPOSIT_KEY
+        const depositKey = process.env.DEPOSIT_KEY;
+        if (depositKey) {
+          result.depositKey.found = true;
+          if (depositKey.length > 20) {
+            result.depositKey.key = `${depositKey.slice(0, 10)}...${depositKey.slice(-8)}`;
+          } else {
+            result.depositKey.key = depositKey;
+          }
+        }
 
-      // 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();
+        // Check RPC_URL
+        const rpcUrl = process.env.RPC_URL;
+        if (rpcUrl) {
+          result.rpcUrl.found = true;
+          result.rpcUrl.url = rpcUrl;
+        }
+        const effectiveRpcUrl = rpcUrl || 'https://mainnet.base.org';
+
+        const resolvedAddress = resolveAddress({}, { required: false, allowInvalidWalletKey: true });
+        if (resolvedAddress) {
+          result.resolvedAddress.address = resolvedAddress.address;
+          result.resolvedAddress.source =
+            resolvedAddress.source === 'wallet-key'
+              ? 'WALLET_KEY'
+              : resolvedAddress.source === 'signer-address'
+                ? 'SIGNER_ADDRESS'
+                : '--address';
+
+          try {
+            const walletBalances = await getWalletBalances(
+              resolvedAddress.address,
+              effectiveRpcUrl
+            );
+            result.walletKey.ethBalance = walletBalances.eth;
+          } catch {
+            // Ignore wallet balance lookup errors so status can still report config/registration
+          }
+
+          result.registration.checked = true;
+          try {
+            const regStatus = await isRegistered(
+              resolvedAddress.address,
+              effectiveRpcUrl
+            );
+            result.registration.registered = regStatus.registered;
+            result.registration.onChainKey = regStatus.depositKey;
+
+            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
+        const relayUrl = process.env.RELAY_URL;
+        result.relay.checked = true;
+        try {
+          const health = await checkRelayHealth(relayUrl);
+          result.relay.healthy = health.status === 'ok';
+          result.relay.status = health.status;
+          result.relay.network = health.network;
         } catch (error) {
-          result.registration.error = error instanceof Error ? error.message : 'Unknown error';
+          result.relay.healthy = false;
+          result.relay.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;
+        if (options.json) {
+          printJson(result);
+          return;
+        }
+
+        const signingValue = result.signerAddress.found
+          ? result.signerAddress.valid === false
+            ? 'external (SIGNER_ADDRESS invalid)'
+            : 'external (SIGNER_ADDRESS)'
+          : result.walletKey.found
+            ? result.walletKey.valid === false
+              ? 'local (WALLET_KEY invalid)'
+              : 'local (WALLET_KEY)'
+            : 'not configured';
+
+        printHeader('Veil CLI Status');
+        printSection('Configuration');
+        printFields([
+          { label: 'Signing', value: signingValue },
+          { label: 'Address', value: result.resolvedAddress.address || 'n/a' },
+          { label: 'ETH balance', value: result.walletKey.ethBalance ? `${result.walletKey.ethBalance} ETH` : 'n/a' },
+          { label: 'Veil key', value: result.veilKey.found ? 'configured' : 'missing' },
+          { label: 'Deposit key', value: result.depositKey.found ? maskValue(result.depositKey.key || '') : 'missing' },
+          { label: 'RPC URL', value: maskUrl(result.rpcUrl.url) },
+        ]);
+
+        printSection('Registration');
+        if (!result.registration.checked) {
+          printFields([
+            {
+              label: 'Status',
+              value: result.walletKey.found && result.walletKey.valid === false
+                ? 'skipped (invalid WALLET_KEY)'
+                : 'skipped (no WALLET_KEY or SIGNER_ADDRESS)'
+            },
+          ]);
+        } else if (result.registration.error) {
+          printFields([
+            { label: 'Error', value: result.registration.error },
+          ]);
+        } else {
+          printFields([
+            { label: 'Registered', value: result.registration.registered },
+            { label: 'Keys match', value: result.registration.matches ?? 'n/a' },
+            { label: 'On-chain key', value: result.registration.onChainKey ? maskValue(result.registration.onChainKey) : 'n/a' },
+          ]);
+        }
+
+        printSection('Relay');
+        if (result.relay.error) {
+          printFields([
+            { label: 'Healthy', value: false },
+            { label: 'Error', value: result.relay.error },
+          ]);
+        } else {
+          printFields([
+            { label: 'Healthy', value: result.relay.healthy },
+            { label: 'Status', value: result.relay.status || 'n/a' },
+            { label: 'Network', value: result.relay.network || 'n/a' },
+          ]);
+        }
       } catch (error) {
-        result.relay.healthy = false;
-        result.relay.error = error instanceof Error ? error.message : 'Unknown error';
+        handleCLIError(error);
       }
-
-      console.log(JSON.stringify(result, null, 2));
     });
 
   return status;
 }
+
+function maskUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return parsed.origin;
+  } catch {
+    return maskValue(url);
+  }
+}