@veil-cash/sdk 0.3.0 → 0.5.0

package/src/cli/commands/deposit.ts

@@ -3,95 +3,121 @@
  */
 
 import { Command } from 'commander';
-import { buildDepositETHTx, buildDepositUSDCTx, buildApproveUSDCTx, buildDepositCBBTCTx, buildApproveCBBTCTx } from '../../deposit.js';
+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,
-  CBBTC: 0.0001,
 };
 
-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', 'CBBTC'];
-
-// 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}`);
-  }
-}
+const SUPPORTED_ASSETS = ['ETH', 'USDC'];
 
 export function createDepositCommand(): Command {
   const deposit = new Command('deposit')
-    .description('Deposit ETH, USDC, or cbBTC into Veil')
-    .argument('<asset>', 'Asset to deposit (ETH, USDC, or CBBTC)')
-    .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')
+    .description('Deposit ETH or USDC into Veil')
+    .argument('<asset>', 'Asset to deposit (ETH or USDC)')
+    .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 });
-        } else if (assetUpper === 'CBBTC') {
-          approveTx = buildApproveCBBTCTx({ amount });
-          tx = buildDepositCBBTCTx({ 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',
@@ -110,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);
       }
     });

package/src/cli/commands/init.ts

@@ -8,6 +8,8 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { mkdirSync } from 'fs';
 import { Keypair } from '../../keypair.js';
+import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import { printFields, printHeader, printJson, printLine } from '../output.js';
 
 /**
  * Prompt user for yes/no confirmation
@@ -33,6 +35,18 @@ function getDefaultEnvPath(): string {
   return '.env.veil';
 }
 
+/**
+ * Enforce mutually exclusive wallet env modes.
+ */
+function ensureAddressEnvConsistency(): void {
+  if (process.env.WALLET_KEY && process.env.SIGNER_ADDRESS) {
+    throw new CLIError(
+      ErrorCode.CONFIG_CONFLICT,
+      'WALLET_KEY and SIGNER_ADDRESS are mutually exclusive. Set only one.',
+    );
+  }
+}
+
 /**
  * Check if VEIL_KEY exists in an env file
  */
@@ -62,7 +76,6 @@ function updateEnvVar(content: string, key: string, value: string): string {
  * Save Veil keypair to a file
  */
 function saveVeilKeypair(veilKey: string, depositKey: string, envPath: string): void {
-  // Ensure directory exists
   const dir = dirname(envPath);
   if (dir && dir !== '.' && !existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -85,99 +98,116 @@ function saveVeilKeypair(veilKey: string, depositKey: string, envPath: string):
 /**
  * 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;
+function resolveWalletKey(): `0x${string}` {
+  const raw = 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 hasExternalSigner = Boolean(process.env.SIGNER_ADDRESS);
+    throw new CLIError(
+      ErrorCode.WALLET_KEY_MISSING,
+      hasExternalSigner
+        ? 'WALLET_KEY env var required for wallet-derived init. If you are using an external signer, use "veil init --signature 0x..." or use --generate for a random keypair.'
+        : 'WALLET_KEY env var required. Set it or use --generate for a random keypair.',
+    );
   }
   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.');
+    throw new CLIError(ErrorCode.WALLET_KEY_MISSING, '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')
+    .description('Derive a Veil keypair from your wallet (or generate a random one)')
+    .option('--generate', 'Generate a random keypair instead of deriving from wallet')
+    .option('--signature <sig>', 'Derive keypair from a pre-computed EIP-191 personal_sign signature')
     .option('--force', 'Overwrite existing keypair without prompting')
     .option('--json', 'Output as JSON (no prompts, no file save)')
     .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')
+    .addHelpText('after', `
+Examples:
+  veil init                           Derive from WALLET_KEY (default)
+  veil init --generate                Generate a random keypair
+  veil init --signature 0x...         Derive from a pre-computed signature
+  veil init --json                    Output keypair as JSON
+`)
     .action(async (options) => {
-      const envPath = getDefaultEnvPath();
-      
-      /**
-       * Create keypair: derived from wallet, from signature, or random
-       */
-      async function createKp(): Promise<Keypair> {
-        if (options.signMessage) {
-          const walletKey = resolveWalletKey(options);
+      try {
+        ensureAddressEnvConsistency();
+        const envPath = getDefaultEnvPath();
+        const useRandom = options.generate;
+        const useSignature = options.signature;
+
+        async function createKp(): Promise<Keypair> {
+          if (useSignature) {
+            return Keypair.fromSignature(options.signature);
+          }
+          if (useRandom) {
+            return new Keypair();
+          }
+          const walletKey = resolveWalletKey();
           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';
+        const derivation: 'wallet-signature' | 'provided-signature' | 'random' =
+          useSignature ? 'provided-signature'
+          : useRandom ? 'random'
+          : 'wallet-signature';
+
+        const derivationLabel =
+          useSignature ? 'Derived keypair from provided signature'
+          : useRandom ? 'Generated random keypair'
+          : 'Derived keypair from wallet signature';
 
-      // JSON mode: no prompts, no save, just output JSON
-      if (options.json) {
         const kp = await createKp();
-        console.log(JSON.stringify({
+        const result = {
           veilKey: kp.privkey,
+          veilPrivateKey: kp.privkey,
           depositKey: kp.depositKey(),
-        }, null, 2));
-        process.exit(0);
-        return;
-      }
+          derivation,
+        };
 
-      // No-save mode: print but don't save
-      if (!options.save) {
-        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 - run without --no-save to save to .env.veil)');
-        process.exit(0);
-        return;
-      }
+        if (options.json) {
+          printJson(result);
+          return;
+        }
 
-      // Check if VEIL_KEY already exists (unless --force)
-      const keyExists = veilKeyExistsAt(envPath);
-      
-      if (keyExists && !options.force) {
-        console.log(`\nWARNING: A Veil key already exists in ${envPath}`);
-        const proceed = await confirm('Create a new key? This will overwrite the existing one');
-        if (!proceed) {
-          console.log('Aborted. Existing key preserved.');
-          process.exit(0);
+        if (!options.save) {
+          printHeader(derivationLabel);
+          printFields([
+            { label: 'Veil private key', value: kp.privkey },
+            { label: 'Deposit key', value: kp.depositKey() },
+            { label: 'Saved', value: 'no' },
+          ]);
+          printLine();
+          printLine('Run `veil init` without `--no-save` to persist these keys to .env.veil.');
+          printLine();
           return;
         }
+
+        const keyExists = veilKeyExistsAt(envPath);
+        if (keyExists && !options.force) {
+          printLine(`WARNING: A Veil key already exists in ${envPath}`);
+          const proceed = await confirm('Create a new key? This will overwrite the existing one');
+          if (!proceed) {
+            printLine('Aborted. Existing key preserved.');
+            return;
+          }
+        }
+
+        saveVeilKeypair(kp.privkey!, kp.depositKey(), envPath);
+        printHeader(derivationLabel);
+        printFields([
+          { label: 'Veil private key', value: kp.privkey },
+          { label: 'Deposit key', value: kp.depositKey() },
+          { label: 'Saved to', value: envPath },
+        ]);
+        printLine();
+        printLine('Next step: veil register');
+        printLine();
+      } catch (error) {
+        handleCLIError(error);
       }
-      
-      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`);
-      
-      saveVeilKeypair(kp.privkey!, kp.depositKey(), envPath);
-      console.log(`Saved to ${envPath}`);
-      console.log('\nNext step: veil register');
-      process.exit(0);
     });
 
   return init;

package/src/cli/commands/keypair.ts

@@ -4,27 +4,45 @@
 
 import { Command } from 'commander';
 import { Keypair } from '../../keypair.js';
+import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import { printFields, printJson, printLine } from '../output.js';
 
 export function createKeypairCommand(): Command {
   const keypair = new Command('keypair')
-    .description('Show current Veil keypair as JSON')
+    .description('Show your current Veil keypair')
+    .option('--json', 'Output as JSON')
+    .addHelpText('after', `
+Examples:
+  veil keypair
+  veil keypair --json
+`)
     .action(() => {
-      const veilKey = process.env.VEIL_KEY;
-      
-      if (!veilKey) {
-        console.log(JSON.stringify({ 
-          success: false, 
-          error: 'No keypair found. Run "veil init" first.' 
-        }, null, 2));
-        process.exit(1);
+      try {
+        const veilKey = process.env.VEIL_KEY;
+
+        if (!veilKey) {
+          throw new CLIError(ErrorCode.VEIL_KEY_MISSING, 'No keypair found. Run "veil init" first.');
+        }
+
+        const kp = new Keypair(veilKey);
+        const result = {
+          veilPrivateKey: kp.privkey,
+          depositKey: kp.depositKey(),
+        };
+
+        if ((keypair.opts() as { json?: boolean }).json) {
+          printJson(result);
+          return;
+        }
+
+        printLine('Veil keypair');
+        printFields([
+          { label: 'Veil private key', value: result.veilPrivateKey },
+          { label: 'Deposit key', value: result.depositKey },
+        ]);
+      } catch (error) {
+        handleCLIError(error);
       }
-      
-      const kp = new Keypair(veilKey);
-      
-      console.log(JSON.stringify({
-        veilPrivateKey: kp.privkey,
-        depositKey: kp.depositKey(),
-      }, null, 2));
     });
 
   return keypair;