@veil-cash/sdk 0.4.0 → 0.6.0

package/src/cli/commands/balance.ts

@@ -6,9 +6,13 @@ import { Command } from 'commander';
 import { getQueueBalance, getPrivateBalance } from '../../balance.js';
 import { POOL_CONFIG } from '../../addresses.js';
 import { Keypair } from '../../keypair.js';
-import { getAddress } from '../wallet.js';
+import { getWalletBalances } from '../wallet.js';
+import { resolveAddress } from '../config.js';
 import { formatUnits } from 'viem';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import { clearProgress, createProgressReporter, maskValue, printFields, printHeader, printJson, printLine, printList, printSection } from '../output.js';
+import { createPrivateBalanceCommand } from './private-balance.js';
+import { createQueueBalanceCommand } from './queue-balance.js';
 import type { RelayPool } from '../../types.js';
 
 const SUPPORTED_POOLS: RelayPool[] = ['eth', 'usdc'];
@@ -89,11 +93,15 @@ export function createBalanceCommand(): Command {
   const balance = new Command('balance')
     .description('Show queue and private balances (all pools by default)')
     .option('--pool <pool>', 'Pool to check (eth, usdc, or all)', 'all')
-    .option('--wallet-key <key>', 'Ethereum wallet key (or set WALLET_KEY env)')
-    .option('--address <address>', 'Address to check (or derived from wallet key)')
-    .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')
+    .option('--address <address>', 'Address to check (or derived from WALLET_KEY / SIGNER_ADDRESS)')
+    .option('--json', 'Output as JSON')
+    .addHelpText('after', `
+Examples:
+  veil balance
+  veil balance --pool eth
+  veil balance queue --pool usdc
+  veil balance --json
+`)
     .action(async (options) => {
       try {
         const poolArg = (options.pool || 'all').toLowerCase();
@@ -106,73 +114,153 @@ export function createBalanceCommand(): Command {
         const poolsToQuery: RelayPool[] = poolArg === 'all' ? [...SUPPORTED_POOLS] : [poolArg as RelayPool];
 
         // Get address
-        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 (or set WALLET_KEY env)');
-          }
-          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;
 
         // Get keypair for private balance
-        const veilKey = options.veilKey || process.env.VEIL_KEY;
+        const veilKey = process.env.VEIL_KEY;
         const keypair = veilKey ? new Keypair(veilKey) : null;
 
-        const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+        const rpcUrl = process.env.RPC_URL;
 
-        // Progress callback
-        const onProgress = options.quiet 
-          ? undefined 
-          : (stage: string, detail?: string) => {
-              const msg = detail ? `${stage}: ${detail}` : stage;
-              process.stderr.write(`\r\x1b[K${msg}`);
-            };
+        const onProgress = createProgressReporter();
 
         // Get deposit key if available
         const depositKey = process.env.DEPOSIT_KEY || (keypair ? keypair.depositKey() : null);
 
         // Single pool mode -- flat output (backwards compatible)
         if (poolsToQuery.length === 1) {
-          const poolResult = await fetchPoolBalance(poolsToQuery[0], address, keypair, rpcUrl, onProgress);
+          const [poolResult, walletBalances] = await Promise.all([
+            fetchPoolBalance(poolsToQuery[0], address, keypair, rpcUrl, onProgress),
+            getWalletBalances(address, rpcUrl),
+          ]);
 
-          // Clear progress line
-          if (!options.quiet) process.stderr.write('\r\x1b[K');
+          clearProgress();
 
           const output = {
             address,
             depositKey: depositKey || null,
+            wallet: walletBalances,
             ...poolResult,
           };
 
-          console.log(JSON.stringify(output, null, 2));
+          if (options.json) {
+            printJson(output);
+            return;
+          }
+
+          printCombinedBalanceHuman(output);
           return;
         }
 
         // All pools mode -- nested output
-        const pools: Record<string, unknown>[] = [];
-        for (const pool of poolsToQuery) {
-          const poolResult = await fetchPoolBalance(pool, address, keypair, rpcUrl, onProgress);
-          pools.push(poolResult);
-        }
+        const poolPromises = poolsToQuery.map(pool =>
+          fetchPoolBalance(pool, address, keypair, rpcUrl, onProgress),
+        );
+        const [walletBalances, ...poolResults] = await Promise.all([
+          getWalletBalances(address, rpcUrl),
+          ...poolPromises,
+        ]);
 
-        // Clear progress line
-        if (!options.quiet) process.stderr.write('\r\x1b[K');
+        clearProgress();
 
         const output = {
           address,
           depositKey: depositKey || null,
-          pools,
+          wallet: walletBalances,
+          pools: poolResults,
         };
 
-        console.log(JSON.stringify(output, null, 2));
+        if (options.json) {
+          printJson(output);
+          return;
+        }
+
+        printMultiPoolBalanceHuman(output);
       } catch (error) {
-        process.stderr.write('\r\x1b[K');
+        clearProgress();
         handleCLIError(error);
       }
     });
 
+  balance.addCommand(createQueueBalanceCommand('queue'));
+  balance.addCommand(createPrivateBalanceCommand('private'));
+
   return balance;
 }
+
+function printPoolHuman(output: Record<string, unknown>): void {
+  const symbol = output.symbol as string;
+
+  printSection(`${output.pool}`);
+  printFields([
+    { label: 'Total', value: `${output.totalBalance} ${symbol}` },
+  ]);
+
+  const privateData = output.private as { balance?: string | null; balanceWei?: string; utxoCount?: number; note?: string; utxos?: Array<{ index: number; amount: string }> };
+  if (privateData.note) {
+    printFields([
+      { label: 'Private', value: privateData.note },
+    ]);
+  } else {
+    printFields([
+      { label: 'Private', value: `${privateData.balance} ${symbol}` },
+    ]);
+  }
+
+  const queueData = output.queue as { balance: string; balanceWei: string; count: number; deposits: Array<{ nonce: string | number; amount: string; status: string }> };
+  printFields([
+    { label: 'Queue', value: `${queueData.balance} ${symbol}` },
+    { label: 'Pending', value: queueData.count },
+  ]);
+  if (queueData.deposits.length > 0) {
+    printList(
+      queueData.deposits.map((d) => `nonce ${d.nonce}: ${d.amount} (${d.status})`)
+    );
+  }
+}
+
+function printCombinedBalanceHuman(output: Record<string, unknown>): void {
+  const wallet = output.wallet as { eth: string; usdc: string };
+
+  printHeader(`${output.pool} Balance`);
+  printFields([
+    { label: 'Address', value: output.address },
+    { label: 'Deposit key', value: typeof output.depositKey === 'string' ? maskValue(output.depositKey) : 'not set' },
+  ]);
+
+  printSection('Wallet (public)');
+  printFields([
+    { label: 'ETH', value: `${wallet.eth} ETH` },
+    { label: 'USDC', value: `${wallet.usdc} USDC` },
+  ]);
+
+  printPoolHuman(output);
+  printLine();
+}
+
+function printMultiPoolBalanceHuman(output: { address: string; depositKey: string | null; wallet: { eth: string; usdc: string }; pools: Record<string, unknown>[] }): void {
+  printHeader('Balances');
+  printFields([
+    { label: 'Address', value: output.address },
+    { label: 'Deposit key', value: output.depositKey ? maskValue(output.depositKey) : 'not set' },
+  ]);
+
+  printSection('Wallet (public)');
+  printFields([
+    { label: 'ETH', value: `${output.wallet.eth} ETH` },
+    { label: 'USDC', value: `${output.wallet.usdc} USDC` },
+  ]);
+
+  for (const poolResult of output.pools) {
+    printPoolHuman(poolResult);
+  }
+
+  printLine();
+}

package/src/cli/commands/deposit.ts

@@ -6,88 +6,118 @@ import { Command } from 'commander';
 import { buildDepositETHTx, buildDepositUSDCTx, buildApproveUSDCTx } from '../../deposit.js';
 import { sendTransaction, getAddress, getBalance } from '../wallet.js';
 import { getConfig } from '../config.js';
-import { parseEther, formatEther } from 'viem';
+import { createPublicClient, http, parseEther, parseUnits, formatEther, formatUnits } from 'viem';
+import { base } from 'viem/chains';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import { clearProgress, createProgressReporter, printFields, printHeader, printJson, printLine, txUrl } from '../output.js';
+import { POOL_CONFIG, getAddresses } from '../../addresses.js';
+import { ENTRY_ABI, ERC20_ABI } from '../../abi.js';
 import type { TransactionData } from '../../types.js';
 
-// Minimum deposits per asset (net after 0.3% fee)
-const DEPOSIT_FEE_PERCENT = 0.3;
-const MINIMUM_DEPOSITS: Record<string, number> = {
+const MINIMUM_NET: Record<string, number> = {
   ETH: 0.01,
   USDC: 10,
 };
 
-function getMinimumWithFee(asset: string): number {
-  const min = MINIMUM_DEPOSITS[asset] || 0;
-  return min / (1 - DEPOSIT_FEE_PERCENT / 100);
+/**
+ * Query the Entry contract for the exact gross amount (net + fee).
+ * This matches the contract's own fee math and avoids rounding mismatches.
+ */
+async function getGrossAmount(
+  netWei: bigint,
+  rpcUrl: string | undefined,
+): Promise<{ grossWei: bigint; feeWei: bigint }> {
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl),
+  });
+
+  const grossWei = await publicClient.readContract({
+    address: getAddresses().entry,
+    abi: ENTRY_ABI,
+    functionName: 'getDepositAmountWithFee',
+    args: [netWei],
+  }) as bigint;
+
+  return { grossWei, feeWei: grossWei - netWei };
 }
 
 const SUPPORTED_ASSETS = ['ETH', 'USDC'];
 
-// Progress helper - writes to stderr so JSON output stays clean
-function progress(msg: string, quiet?: boolean) {
-  if (!quiet) {
-    process.stderr.write(`\r\x1b[K${msg}`);
-  }
-}
-
 export function createDepositCommand(): Command {
   const deposit = new Command('deposit')
     .description('Deposit ETH or USDC into Veil')
     .argument('<asset>', 'Asset to deposit (ETH or USDC)')
-    .argument('<amount>', 'Amount to deposit (e.g., 0.1)')
-    .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('--rpc-url <url>', 'RPC URL (or set RPC_URL env)')
-    .option('--unsigned', 'Output unsigned transaction payload (Bankr-compatible format)')
-    .option('--quiet', 'Suppress progress output')
+    .argument('<amount>', 'Amount to deposit — this is what arrives in your Veil balance')
+    .option('--unsigned', 'Output unsigned transaction payload instead of sending')
+    .option('--json', 'Output as JSON')
+    .addHelpText('after', `
+The amount you specify is the net amount that lands in your Veil balance.
+The 0.3% protocol fee is automatically added on top.
+
+Examples:
+  veil deposit ETH 0.1          # deposits 0.1 ETH (sends ~0.1003 ETH)
+  veil deposit USDC 100         # deposits 100 USDC (sends ~100.30 USDC)
+  veil deposit ETH 0.1 --unsigned
+  veil deposit ETH 0.1 --json
+`)
     .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(', ')}`);
         }
 
         const amountNum = parseFloat(amount);
-        const minimumWithFee = getMinimumWithFee(assetUpper);
-        const minimumNet = MINIMUM_DEPOSITS[assetUpper];
-        
-        // Check minimum deposit
-        if (amountNum < minimumWithFee) {
+        const minimumNet = MINIMUM_NET[assetUpper];
+
+        if (amountNum < minimumNet) {
           throw new CLIError(
             ErrorCode.INVALID_AMOUNT,
-            `Minimum deposit is ${minimumNet} ${assetUpper} (net). ` +
-            `With ${DEPOSIT_FEE_PERCENT}% fee, send at least ${minimumWithFee.toFixed(assetUpper === 'ETH' ? 5 : 8)} ${assetUpper}.`
+            `Minimum deposit is ${minimumNet} ${assetUpper}.`
           );
         }
 
-        // Get deposit key from option or env
-        const depositKey = options.depositKey || process.env.DEPOSIT_KEY;
+        const rpcUrl = process.env.RPC_URL;
+        const poolConfig = POOL_CONFIG[assetUpper.toLowerCase() as 'eth' | 'usdc'];
+        const netWei = assetUpper === 'ETH'
+          ? parseEther(amount)
+          : parseUnits(amount, poolConfig.decimals);
+
+        const progress = createProgressReporter();
+        progress('Calculating fee...');
+
+        const { grossWei, feeWei } = await getGrossAmount(netWei, rpcUrl);
+        const grossStr = assetUpper === 'ETH'
+          ? formatEther(grossWei)
+          : formatUnits(grossWei, poolConfig.decimals);
+        const feeStr = assetUpper === 'ETH'
+          ? formatEther(feeWei)
+          : formatUnits(feeWei, poolConfig.decimals);
+
+        const depositKey = process.env.DEPOSIT_KEY;
         if (!depositKey) {
-          throw new CLIError(ErrorCode.DEPOSIT_KEY_MISSING, 'Deposit key required. Use --deposit-key or set DEPOSIT_KEY in .env (run: veil init)');
+          throw new CLIError(ErrorCode.DEPOSIT_KEY_MISSING, 'DEPOSIT_KEY not set. Run "veil init" first.');
         }
 
-        progress('Building transaction...', options.quiet);
+        progress('Building transaction...');
 
-        // Build the deposit transaction
         let tx: TransactionData;
         let approveTx: TransactionData | null = null;
 
         if (assetUpper === 'USDC') {
-          approveTx = buildApproveUSDCTx({ amount });
-          tx = buildDepositUSDCTx({ depositKey, amount });
+          approveTx = buildApproveUSDCTx({ amount: grossStr });
+          tx = buildDepositUSDCTx({ depositKey, amount: grossStr });
         } else {
-          tx = buildDepositETHTx({ depositKey, amount });
+          tx = buildDepositETHTx({ depositKey, amount: grossStr });
         }
 
-        // Handle --unsigned mode (no wallet required, just build payload)
+        // --unsigned mode
         if (options.unsigned) {
-          progress('', options.quiet); // Clear line
+          clearProgress();
           const payloads: Record<string, unknown>[] = [];
 
-          // Include approval tx for ERC20 tokens
           if (approveTx) {
             payloads.push({
               step: 'approve',
@@ -106,52 +136,95 @@ export function createDepositCommand(): Command {
             chainId: 8453,
           });
 
-          console.log(JSON.stringify(payloads.length === 1 ? payloads[0] : payloads, null, 2));
+          printJson(payloads.length === 1 ? payloads[0] : payloads);
           return;
         }
 
-        // Regular mode: sign and send
         const config = getConfig(options);
         const address = getAddress(config.privateKey);
 
-        // For ETH deposits, check ETH balance
         if (assetUpper === 'ETH') {
-          progress('Checking balance...', options.quiet);
+          progress('Checking balance...');
           const balance = await getBalance(address, config.rpcUrl);
-          const amountWei = parseEther(amount);
-          
-          if (balance < amountWei) {
-            progress('', options.quiet);
-            throw new CLIError(ErrorCode.INSUFFICIENT_BALANCE, `Insufficient ETH balance. Have: ${formatEther(balance)} ETH, Need: ${amount} ETH`);
+
+          if (balance < grossWei) {
+            clearProgress();
+            throw new CLIError(
+              ErrorCode.INSUFFICIENT_BALANCE,
+              `Insufficient ETH balance. Have: ${formatEther(balance)} ETH, Need: ${grossStr} ETH (${amount} + fee)`
+            );
           }
         }
 
-        // Send approval transaction for ERC20 tokens
         if (approveTx) {
-          progress(`Approving ${assetUpper}...`, options.quiet);
-          await sendTransaction(config, approveTx);
+          progress(`Approving ${assetUpper}...`);
+          const approvalResult = await sendTransaction(config, approveTx);
+          if (assetUpper === 'USDC') {
+            const publicClient = createPublicClient({
+              chain: base,
+              transport: http(config.rpcUrl),
+            });
+            const addresses = getAddresses();
+            let allowance = await publicClient.readContract({
+              address: getAddresses().usdcToken,
+              abi: ERC20_ABI,
+              functionName: 'allowance',
+              args: [address, addresses.entry],
+            }) as bigint;
+            for (let confirmations = 2; allowance < grossWei && confirmations <= 3; confirmations++) {
+              await publicClient.waitForTransactionReceipt({
+                hash: approvalResult.hash,
+                confirmations,
+              });
+              allowance = await publicClient.readContract({
+                address: addresses.usdcToken,
+                abi: ERC20_ABI,
+                functionName: 'allowance',
+                args: [address, addresses.entry],
+              }) as bigint;
+            }
+            if (allowance < grossWei) {
+              throw new CLIError(
+                ErrorCode.CONTRACT_ERROR,
+                `USDC approval is not yet visible on RPC after confirmation. Allowance ${allowance.toString()} < required ${grossWei.toString()}.`
+              );
+            }
+          }
         }
 
-        progress('Sending deposit transaction...', options.quiet);
-
-        // Send the deposit transaction
+        progress('Sending deposit transaction...');
         const result = await sendTransaction(config, tx);
+        progress('Confirming...');
+        clearProgress();
 
-        progress('Confirming...', options.quiet);
-
-        // Clear progress line
-        progress('', options.quiet);
-
-        console.log(JSON.stringify({
+        const output = {
           success: result.receipt.status === 'success',
           hash: result.hash,
           asset: assetUpper,
           amount,
+          fee: feeStr,
+          totalSent: grossStr,
           blockNumber: result.receipt.blockNumber.toString(),
-          gasUsed: result.receipt.gasUsed.toString(),
-        }, null, 2));
+        };
+
+        if (options.json) {
+          printJson(output);
+          return;
+        }
+
+        printHeader('Deposit Submitted');
+        printFields([
+          { label: 'Asset', value: assetUpper },
+          { label: 'Amount', value: `${amount} ${assetUpper}` },
+          { label: 'Fee', value: `${feeStr} ${assetUpper} (0.3%)` },
+          { label: 'Total sent', value: `${grossStr} ${assetUpper}` },
+          { label: 'From', value: address },
+          { label: 'Transaction', value: txUrl(result.hash) },
+          { label: 'Block', value: result.receipt.blockNumber },
+        ]);
+        printLine();
       } catch (error) {
-        progress('', options.quiet); // Clear progress line
+        clearProgress();
         handleCLIError(error);
       }
     });