@veil-cash/sdk 0.2.0 → 0.4.0

package/dist/cli/index.cjs

@@ -5,9 +5,9 @@ var readline = require('readline');
 var fs = require('fs');
 var path = require('path');
 var ethers = require('ethers');
+var accounts = require('viem/accounts');
 var crypto = require('crypto');
 var viem = require('viem');
-var accounts = require('viem/accounts');
 var chains = require('viem/chains');
 var MerkleTree = require('fixed-merkle-tree-legacy');
 var snarkjs = require('snarkjs');
@@ -3996,6 +3996,7 @@ function shuffle(array) {
 }
 
 // src/keypair.ts
+var VEIL_SIGNED_MESSAGE = "Sign this message to create your Veil Wallet private key. This will be used to decrypt your balances. Ensure you are signing this message on the Veil Cash website.";
 var ethSigUtil = __require("eth-sig-util");
 function packEncryptedMessage(encryptedMessage) {
   const nonceBuf = Buffer.from(encryptedMessage.nonce, "base64");
@@ -4075,6 +4076,69 @@ var Keypair = class _Keypair {
       encryptionKey: Buffer.from(str.slice(64, 128), "hex").toString("base64")
     });
   }
+  /**
+   * Derive a Keypair from an EIP-191 personal_sign signature.
+   * The private key is keccak256(signature) -- matching the frontend derivation.
+   * 
+   * @param signature - Raw ECDSA signature (0x-prefixed, 132 hex chars)
+   * @returns Keypair derived from the signature
+   * 
+   * @example
+   * ```typescript
+   * const keypair = Keypair.fromSignature(signature);
+   * ```
+   */
+  static fromSignature(signature) {
+    const privkey = ethers.ethers.keccak256(signature);
+    return new _Keypair(privkey);
+  }
+  /**
+   * Derive a Keypair from an Ethereum wallet private key.
+   * Signs VEIL_SIGNED_MESSAGE with the wallet, then derives via keccak256(signature).
+   * Produces the same keypair as the frontend for the same wallet.
+   * 
+   * @param walletPrivateKey - Ethereum EOA private key (0x-prefixed)
+   * @returns Promise resolving to the derived Keypair
+   * 
+   * @example
+   * ```typescript
+   * const keypair = await Keypair.fromWalletKey('0xYOUR_WALLET_PRIVATE_KEY');
+   * console.log(keypair.depositKey()); // Same as frontend login with this wallet
+   * ```
+   */
+  static async fromWalletKey(walletPrivateKey) {
+    const account = accounts.privateKeyToAccount(walletPrivateKey);
+    const signature = await account.signMessage({ message: VEIL_SIGNED_MESSAGE });
+    return _Keypair.fromSignature(signature);
+  }
+  /**
+   * Derive a Keypair using any external signer that supports personal_sign (EIP-191).
+   * The signer function receives VEIL_SIGNED_MESSAGE and must return a 0x-prefixed signature.
+   * Works with any signing backend: Bankr, MPC wallets, custodial services, hardware wallets, etc.
+   * 
+   * @param signer - Async function that signs a message and returns a 0x-prefixed signature
+   * @returns Promise resolving to the derived Keypair
+   * 
+   * @example
+   * ```typescript
+   * // With Bankr
+   * const keypair = await Keypair.fromSigner(async (message) => {
+   *   const res = await fetch('https://api.bankr.bot/agent/sign', {
+   *     method: 'POST',
+   *     headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
+   *     body: JSON.stringify({ signatureType: 'personal_sign', message }),
+   *   });
+   *   return (await res.json()).signature;
+   * });
+   * 
+   * // With any custom signer
+   * const keypair = await Keypair.fromSigner(async (msg) => myService.personalSign(msg));
+   * ```
+   */
+  static async fromSigner(signer) {
+    const signature = await signer(VEIL_SIGNED_MESSAGE);
+    return _Keypair.fromSignature(signature);
+  }
   /**
    * Sign a message using the private key
    * @param commitment - Commitment hash
@@ -4165,28 +4229,55 @@ function saveVeilKeypair(veilKey, depositKey, envPath) {
   content = updateEnvVar(content, "DEPOSIT_KEY", depositKey);
   fs.writeFileSync(envPath, content);
 }
+function resolveWalletKey(options) {
+  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;
+}
 function createInitCommand() {
-  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").action(async (options) => {
-    const envPath = options.out || getDefaultEnvPath();
+  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("--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 = getDefaultEnvPath();
+    async function createKp() {
+      if (options.signMessage) {
+        const walletKey = resolveWalletKey(options);
+        return Keypair.fromWalletKey(walletKey);
+      }
+      if (options.signature) {
+        return Keypair.fromSignature(options.signature);
+      }
+      return new Keypair();
+    }
+    const derivation = options.signMessage ? "wallet-signature" : options.signature ? "provided-signature" : "random";
+    const derivationLabel = options.signMessage ? "Derived Veil keypair from wallet signature" : options.signature ? "Derived Veil keypair from provided signature" : "Generated new Veil keypair";
     if (options.json) {
-      const kp2 = new Keypair();
+      const kp2 = await createKp();
       console.log(JSON.stringify({
         veilKey: kp2.privkey,
-        depositKey: kp2.depositKey()
+        veilPrivateKey: kp2.privkey,
+        depositKey: kp2.depositKey(),
+        derivation
       }, null, 2));
       process.exit(0);
       return;
     }
     if (!options.save) {
-      const kp2 = new Keypair();
-      console.log("\nGenerated new Veil keypair:\n");
+      const kp2 = await createKp();
+      console.log(`
+${derivationLabel}:
+`);
       console.log("Veil Private Key:");
       console.log(`  ${kp2.privkey}
 `);
       console.log("Deposit Key (register this on-chain):");
       console.log(`  ${kp2.depositKey()}
 `);
-      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;
     }
@@ -4201,8 +4292,10 @@ WARNING: A Veil key already exists in ${envPath}`);
         return;
       }
     }
-    const kp = new Keypair();
-    console.log("\nGenerated new Veil keypair:\n");
+    const kp = await createKp();
+    console.log(`
+${derivationLabel}:
+`);
     console.log("Veil Private Key:");
     console.log(`  ${kp.privkey}
 `);
@@ -4250,10 +4343,43 @@ var ADDRESSES = {
 };
 var POOL_CONFIG = {
   eth: {
-    decimals: 18}};
+    decimals: 18,
+    displayDecimals: 4,
+    symbol: "ETH",
+    name: "Ethereum"
+  },
+  usdc: {
+    decimals: 6,
+    displayDecimals: 2,
+    symbol: "USDC",
+    name: "USD Coin"
+  }
+};
 function getAddresses() {
   return ADDRESSES;
 }
+function getPoolAddress(pool) {
+  const addresses = getAddresses();
+  switch (pool) {
+    case "eth":
+      return addresses.ethPool;
+    case "usdc":
+      return addresses.usdcPool;
+    default:
+      throw new Error(`Unknown pool: ${pool}`);
+  }
+}
+function getQueueAddress(pool) {
+  const addresses = getAddresses();
+  switch (pool) {
+    case "eth":
+      return addresses.ethQueue;
+    case "usdc":
+      return addresses.usdcQueue;
+    default:
+      throw new Error(`Unknown pool: ${pool}`);
+  }
+}
 function getRelayUrl() {
   return ADDRESSES.relayUrl;
 }
@@ -4315,6 +4441,23 @@ var ENTRY_ABI = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  // Change deposit key (must already be registered)
+  {
+    inputs: [
+      {
+        components: [
+          { name: "owner", type: "address" },
+          { name: "depositKey", type: "bytes" }
+        ],
+        name: "_account",
+        type: "tuple"
+      }
+    ],
+    name: "changeDepositKey",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   // Queue ETH deposit
   {
     inputs: [{ name: "_depositKey", type: "bytes" }],
@@ -4828,6 +4971,35 @@ var POOL_ABI = [
   // ============ RECEIVE ============
   { stateMutability: "payable", type: "receive" }
 ];
+var ERC20_ABI = [
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
 
 // src/deposit.ts
 function buildRegisterTx(depositKey, ownerAddress) {
@@ -4845,6 +5017,21 @@ function buildRegisterTx(depositKey, ownerAddress) {
     data
   };
 }
+function buildChangeDepositKeyTx(depositKey, ownerAddress) {
+  const addresses = getAddresses();
+  const data = viem.encodeFunctionData({
+    abi: ENTRY_ABI,
+    functionName: "changeDepositKey",
+    args: [{
+      owner: ownerAddress,
+      depositKey
+    }]
+  });
+  return {
+    to: addresses.entry,
+    data
+  };
+}
 function buildDepositETHTx(options) {
   const { depositKey, amount } = options;
   const addresses = getAddresses();
@@ -4860,6 +5047,34 @@ function buildDepositETHTx(options) {
     value
   };
 }
+function buildApproveUSDCTx(options) {
+  const { amount } = options;
+  const addresses = getAddresses();
+  const amountWei = viem.parseUnits(amount, POOL_CONFIG.usdc.decimals);
+  const data = viem.encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [addresses.entry, amountWei]
+  });
+  return {
+    to: addresses.usdcToken,
+    data
+  };
+}
+function buildDepositUSDCTx(options) {
+  const { depositKey, amount } = options;
+  const addresses = getAddresses();
+  const amountWei = viem.parseUnits(amount, POOL_CONFIG.usdc.decimals);
+  const data = viem.encodeFunctionData({
+    abi: ENTRY_ABI,
+    functionName: "queueUSDC",
+    args: [amountWei, depositKey]
+  });
+  return {
+    to: addresses.entry,
+    data
+  };
+}
 function createWallet(config) {
   const { privateKey, rpcUrl } = config;
   const account = accounts.privateKeyToAccount(privateKey);
@@ -5076,7 +5291,7 @@ function handleCLIError(error) {
 
 // src/cli/commands/register.ts
 function createRegisterCommand() {
-  const register = new Command("register").description("Register your deposit key on-chain (one-time)").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("--json", "Output as JSON").action(async (options) => {
+  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").action(async (options) => {
     const jsonOutput = options.json;
     try {
       const depositKey = options.depositKey || process.env.DEPOSIT_KEY;
@@ -5094,8 +5309,9 @@ function createRegisterCommand() {
           }
           address2 = getAddress(walletKey);
         }
-        const tx2 = buildRegisterTx(depositKey, address2);
+        const tx2 = options.force ? buildChangeDepositKeyTx(depositKey, address2) : buildRegisterTx(depositKey, address2);
         const payload = {
+          action: options.force ? "changeDepositKey" : "register",
           to: tx2.to,
           data: tx2.data,
           value: "0",
@@ -5109,43 +5325,69 @@ function createRegisterCommand() {
       const address = getAddress(config.privateKey);
       if (!jsonOutput) console.log("\nChecking registration status...");
       const { registered, depositKey: existingKey } = await isRegistered(address, config.rpcUrl);
-      if (registered) {
+      const keysMatch = registered && existingKey === depositKey;
+      const isChange = registered && !keysMatch;
+      if (registered && keysMatch) {
         if (jsonOutput) {
           console.log(JSON.stringify({
             success: true,
             alreadyRegistered: true,
+            keysMatch: true,
             address,
             depositKey: existingKey
           }, null, 2));
         } else {
           console.log(`
-Address ${address} is already registered.`);
+Address ${address} is already registered with this deposit key.`);
           console.log(`
-Existing deposit key:`);
-          console.log(`  ${existingKey}`);
+Deposit key: ${existingKey.slice(0, 40)}...`);
         }
         process.exit(0);
         return;
       }
+      if (isChange && !options.force) {
+        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(`
+Address ${address} is already registered with a different deposit key.`);
+          console.log(`
+  On-chain key: ${existingKey.slice(0, 40)}...`);
+          console.log(`  Local key:    ${depositKey.slice(0, 40)}...`);
+          console.log(`
+Use --force to change your deposit key on-chain.`);
+        }
+        process.exit(1);
+        return;
+      }
+      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)}...`);
       }
-      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}`);
@@ -5161,25 +5403,35 @@ Existing deposit key:`);
   });
   return register;
 }
-var MINIMUM_DEPOSIT_ETH = 0.01;
 var DEPOSIT_FEE_PERCENT = 0.3;
-var MINIMUM_DEPOSIT_WITH_FEE = MINIMUM_DEPOSIT_ETH / (1 - DEPOSIT_FEE_PERCENT / 100);
+var MINIMUM_DEPOSITS = {
+  ETH: 0.01,
+  USDC: 10
+};
+function getMinimumWithFee(asset) {
+  const min = MINIMUM_DEPOSITS[asset] || 0;
+  return min / (1 - DEPOSIT_FEE_PERCENT / 100);
+}
+var SUPPORTED_ASSETS = ["ETH", "USDC"];
 function progress(msg, quiet) {
   if (!quiet) {
     process.stderr.write(`\r\x1B[K${msg}`);
   }
 }
 function createDepositCommand() {
-  const deposit = new Command("deposit").description("Deposit ETH into Veil").argument("<asset>", "Asset to deposit (ETH)").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").action(async (asset, amount, options) => {
+  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").action(async (asset, amount, options) => {
     try {
-      if (asset.toUpperCase() !== "ETH") {
-        throw new CLIError(ErrorCode.INVALID_AMOUNT, "Only ETH is supported");
+      const assetUpper = asset.toUpperCase();
+      if (!SUPPORTED_ASSETS.includes(assetUpper)) {
+        throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS.join(", ")}`);
       }
       const amountNum = parseFloat(amount);
-      if (amountNum < MINIMUM_DEPOSIT_WITH_FEE) {
+      const minimumWithFee = getMinimumWithFee(assetUpper);
+      const minimumNet = MINIMUM_DEPOSITS[assetUpper];
+      if (amountNum < minimumWithFee) {
         throw new CLIError(
           ErrorCode.INVALID_AMOUNT,
-          `Minimum deposit is ${MINIMUM_DEPOSIT_ETH} ETH (net). With ${DEPOSIT_FEE_PERCENT}% fee, send at least ${MINIMUM_DEPOSIT_WITH_FEE.toFixed(5)} ETH.`
+          `Minimum deposit is ${minimumNet} ${assetUpper} (net). With ${DEPOSIT_FEE_PERCENT}% fee, send at least ${minimumWithFee.toFixed(assetUpper === "ETH" ? 5 : 8)} ${assetUpper}.`
         );
       }
       const depositKey = options.depositKey || process.env.DEPOSIT_KEY;
@@ -5187,38 +5439,59 @@ function createDepositCommand() {
         throw new CLIError(ErrorCode.DEPOSIT_KEY_MISSING, "Deposit key required. Use --deposit-key or set DEPOSIT_KEY in .env (run: veil init)");
       }
       progress("Building transaction...", options.quiet);
-      const tx = buildDepositETHTx({
-        depositKey,
-        amount
-      });
+      let tx;
+      let approveTx = null;
+      if (assetUpper === "USDC") {
+        approveTx = buildApproveUSDCTx({ amount });
+        tx = buildDepositUSDCTx({ depositKey, amount });
+      } else {
+        tx = buildDepositETHTx({ depositKey, amount });
+      }
       if (options.unsigned) {
         progress("", options.quiet);
-        const payload = {
+        const payloads = [];
+        if (approveTx) {
+          payloads.push({
+            step: "approve",
+            to: approveTx.to,
+            data: approveTx.data,
+            value: "0",
+            chainId: 8453
+          });
+        }
+        payloads.push({
+          step: "deposit",
           to: tx.to,
           data: tx.data,
           value: tx.value ? tx.value.toString() : "0",
           chainId: 8453
-          // Base mainnet
-        };
-        console.log(JSON.stringify(payload, null, 2));
+        });
+        console.log(JSON.stringify(payloads.length === 1 ? payloads[0] : payloads, null, 2));
         return;
       }
       const config = getConfig(options);
       const address = getAddress(config.privateKey);
-      progress("Checking balance...", options.quiet);
-      const balance = await getBalance(address, config.rpcUrl);
-      const amountWei = viem.parseEther(amount);
-      if (balance < amountWei) {
-        progress("", options.quiet);
-        throw new CLIError(ErrorCode.INSUFFICIENT_BALANCE, `Insufficient ETH balance. Have: ${viem.formatEther(balance)} ETH, Need: ${amount} ETH`);
+      if (assetUpper === "ETH") {
+        progress("Checking balance...", options.quiet);
+        const balance = await getBalance(address, config.rpcUrl);
+        const amountWei = viem.parseEther(amount);
+        if (balance < amountWei) {
+          progress("", options.quiet);
+          throw new CLIError(ErrorCode.INSUFFICIENT_BALANCE, `Insufficient ETH balance. Have: ${viem.formatEther(balance)} ETH, Need: ${amount} ETH`);
+        }
+      }
+      if (approveTx) {
+        progress(`Approving ${assetUpper}...`, options.quiet);
+        await sendTransaction(config, approveTx);
       }
-      progress("Sending transaction...", options.quiet);
+      progress("Sending deposit transaction...", options.quiet);
       const result = await sendTransaction(config, tx);
       progress("Confirming...", options.quiet);
       progress("", options.quiet);
       console.log(JSON.stringify({
         success: result.receipt.status === "success",
         hash: result.hash,
+        asset: assetUpper,
         amount,
         blockNumber: result.receipt.blockNumber.toString(),
         gasUsed: result.receipt.gasUsed.toString()
@@ -5315,15 +5588,16 @@ var DEPOSIT_STATUS_MAP = {
   3: "refunded"
 };
 async function getQueueBalance(options) {
-  const { address, rpcUrl, onProgress } = options;
-  const addresses = getAddresses();
+  const { address, pool = "eth", rpcUrl, onProgress } = options;
+  const queueAddress = getQueueAddress(pool);
+  const poolConfig = POOL_CONFIG[pool];
   const publicClient = viem.createPublicClient({
     chain: chains.base,
     transport: viem.http(rpcUrl)
   });
   onProgress?.("Fetching pending deposits...");
   const pendingNonces = await publicClient.readContract({
-    address: addresses.ethQueue,
+    address: queueAddress,
     abi: QUEUE_ABI,
     functionName: "getPendingDeposits"
   });
@@ -5334,7 +5608,7 @@ async function getQueueBalance(options) {
     const nonce = pendingNonces[i];
     onProgress?.("Checking deposit", `${i + 1}/${pendingNonces.length}`);
     const deposit = await publicClient.readContract({
-      address: addresses.ethQueue,
+      address: queueAddress,
       abi: QUEUE_ABI,
       functionName: "getDeposit",
       args: [nonce]
@@ -5344,7 +5618,7 @@ async function getQueueBalance(options) {
       pendingDeposits.push({
         nonce: nonce.toString(),
         status: DEPOSIT_STATUS_MAP[deposit.status] || "pending",
-        amount: viem.formatEther(deposit.amountIn),
+        amount: viem.formatUnits(deposit.amountIn, poolConfig.decimals),
         amountWei: deposit.amountIn.toString(),
         timestamp: new Date(Number(deposit.timestamp) * 1e3).toISOString()
       });
@@ -5355,15 +5629,16 @@ async function getQueueBalance(options) {
   }
   return {
     address,
-    queueBalance: viem.formatEther(totalQueueBalance),
+    queueBalance: viem.formatUnits(totalQueueBalance, poolConfig.decimals),
     queueBalanceWei: totalQueueBalance.toString(),
     pendingDeposits,
     pendingCount: pendingDeposits.length
   };
 }
 async function getPrivateBalance(options) {
-  const { keypair, rpcUrl, onProgress } = options;
-  const addresses = getAddresses();
+  const { keypair, pool = "eth", rpcUrl, onProgress } = options;
+  const poolAddress = getPoolAddress(pool);
+  const poolConfig = POOL_CONFIG[pool];
   if (!keypair.privkey) {
     throw new Error("Keypair must have a private key to calculate private balance");
   }
@@ -5373,7 +5648,7 @@ async function getPrivateBalance(options) {
   });
   onProgress?.("Fetching pool index...");
   const nextIndex = await publicClient.readContract({
-    address: addresses.ethPool,
+    address: poolAddress,
     abi: POOL_ABI,
     functionName: "nextIndex"
   });
@@ -5396,7 +5671,7 @@ async function getPrivateBalance(options) {
     const batchNum = Math.floor(start / BATCH_SIZE) + 1;
     onProgress?.("Fetching encrypted outputs", `batch ${batchNum}/${totalBatches} (${start}-${end})`);
     const batch = await publicClient.readContract({
-      address: addresses.ethPool,
+      address: poolAddress,
       abi: POOL_ABI,
       functionName: "getEncryptedOutputs",
       args: [BigInt(start), BigInt(end)]
@@ -5426,14 +5701,14 @@ async function getPrivateBalance(options) {
     const nullifier = utxo.getNullifier();
     const nullifierHex = toFixedHex(nullifier);
     const isSpent = await publicClient.readContract({
-      address: addresses.ethPool,
+      address: poolAddress,
       abi: POOL_ABI,
       functionName: "isSpent",
       args: [nullifierHex]
     });
     utxoInfos.push({
       index,
-      amount: viem.formatEther(utxo.amount),
+      amount: viem.formatUnits(utxo.amount, poolConfig.decimals),
       amountWei: utxo.amount.toString(),
       isSpent
     });
@@ -5445,7 +5720,7 @@ async function getPrivateBalance(options) {
     }
   }
   return {
-    privateBalance: viem.formatEther(totalBalance),
+    privateBalance: viem.formatUnits(totalBalance, poolConfig.decimals),
     privateBalanceWei: totalBalance.toString(),
     utxoCount: decryptedUtxos.length,
     spentCount,
@@ -5453,9 +5728,62 @@ async function getPrivateBalance(options) {
     utxos: utxoInfos
   };
 }
+var SUPPORTED_POOLS = ["eth", "usdc"];
+async function fetchPoolBalance(pool, address, keypair, rpcUrl, onProgress) {
+  const poolConfig = POOL_CONFIG[pool];
+  const poolProgress = onProgress ? (stage, detail) => onProgress(`[${pool.toUpperCase()}] ${stage}`, detail) : void 0;
+  const queueResult = await getQueueBalance({ address, pool, rpcUrl, onProgress: poolProgress });
+  let privateResult = null;
+  if (keypair) {
+    privateResult = await getPrivateBalance({ keypair, pool, rpcUrl, onProgress: poolProgress });
+  }
+  const queueBalanceWei = BigInt(queueResult.queueBalanceWei);
+  const privateBalanceWei = privateResult ? BigInt(privateResult.privateBalanceWei) : 0n;
+  const totalBalanceWei = queueBalanceWei + privateBalanceWei;
+  const result = {
+    pool: pool.toUpperCase(),
+    symbol: poolConfig.symbol,
+    totalBalance: viem.formatUnits(totalBalanceWei, poolConfig.decimals),
+    totalBalanceWei: totalBalanceWei.toString()
+  };
+  if (privateResult) {
+    const unspentUtxos = privateResult.utxos.filter((u) => !u.isSpent);
+    result.private = {
+      balance: privateResult.privateBalance,
+      balanceWei: privateResult.privateBalanceWei,
+      utxoCount: privateResult.unspentCount,
+      utxos: unspentUtxos.map((u) => ({
+        index: u.index,
+        amount: u.amount
+      }))
+    };
+  } else {
+    result.private = {
+      balance: null,
+      note: "Set VEIL_KEY to see private balance"
+    };
+  }
+  result.queue = {
+    balance: queueResult.queueBalance,
+    balanceWei: queueResult.queueBalanceWei,
+    count: queueResult.pendingCount,
+    deposits: queueResult.pendingDeposits.map((d) => ({
+      nonce: d.nonce,
+      amount: d.amount,
+      status: d.status,
+      timestamp: d.timestamp
+    }))
+  };
+  return result;
+}
 function createBalanceCommand() {
-  const balance = new Command("balance").description("Show queue and private balances").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").action(async (options) => {
+  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").action(async (options) => {
     try {
+      const poolArg = (options.pool || "all").toLowerCase();
+      if (poolArg !== "all" && !SUPPORTED_POOLS.includes(poolArg)) {
+        throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported pool: ${options.pool}. Supported: ${SUPPORTED_POOLS.join(", ")}, all`);
+      }
+      const poolsToQuery = poolArg === "all" ? [...SUPPORTED_POOLS] : [poolArg];
       let address;
       if (options.address) {
         address = options.address;
@@ -5473,51 +5801,28 @@ function createBalanceCommand() {
         const msg = detail ? `${stage}: ${detail}` : stage;
         process.stderr.write(`\r\x1B[K${msg}`);
       };
-      const queueResult = await getQueueBalance({ address, rpcUrl, onProgress });
-      let privateResult = null;
-      if (keypair) {
-        privateResult = await getPrivateBalance({ keypair, rpcUrl, onProgress });
+      const depositKey = process.env.DEPOSIT_KEY || (keypair ? keypair.depositKey() : null);
+      if (poolsToQuery.length === 1) {
+        const poolResult = await fetchPoolBalance(poolsToQuery[0], address, keypair, rpcUrl, onProgress);
+        if (!options.quiet) process.stderr.write("\r\x1B[K");
+        const output2 = {
+          address,
+          depositKey: depositKey || null,
+          ...poolResult
+        };
+        console.log(JSON.stringify(output2, null, 2));
+        return;
       }
-      if (!options.quiet) {
-        process.stderr.write("\r\x1B[K");
+      const pools = [];
+      for (const pool of poolsToQuery) {
+        const poolResult = await fetchPoolBalance(pool, address, keypair, rpcUrl, onProgress);
+        pools.push(poolResult);
       }
-      const queueBalanceWei = BigInt(queueResult.queueBalanceWei);
-      const privateBalanceWei = privateResult ? BigInt(privateResult.privateBalanceWei) : 0n;
-      const totalBalanceWei = queueBalanceWei + privateBalanceWei;
-      const depositKey = process.env.DEPOSIT_KEY || (keypair ? keypair.depositKey() : null);
+      if (!options.quiet) process.stderr.write("\r\x1B[K");
       const output = {
         address,
         depositKey: depositKey || null,
-        totalBalance: viem.formatEther(totalBalanceWei),
-        totalBalanceWei: totalBalanceWei.toString()
-      };
-      if (privateResult) {
-        const unspentUtxos = privateResult.utxos.filter((u) => !u.isSpent);
-        output.private = {
-          balance: privateResult.privateBalance,
-          balanceWei: privateResult.privateBalanceWei,
-          utxoCount: privateResult.unspentCount,
-          utxos: unspentUtxos.map((u) => ({
-            index: u.index,
-            amount: u.amount
-          }))
-        };
-      } else {
-        output.private = {
-          balance: null,
-          note: "Set VEIL_KEY to see private balance"
-        };
-      }
-      output.queue = {
-        balance: queueResult.queueBalance,
-        balanceWei: queueResult.queueBalanceWei,
-        count: queueResult.pendingCount,
-        deposits: queueResult.pendingDeposits.map((d) => ({
-          nonce: d.nonce,
-          amount: d.amount,
-          status: d.status,
-          timestamp: d.timestamp
-        }))
+        pools
       };
       console.log(JSON.stringify(output, null, 2));
     } catch (error) {
@@ -5530,8 +5835,9 @@ function createBalanceCommand() {
 
 // src/cli/commands/queue-balance.ts
 function createQueueBalanceCommand() {
-  const balance = new Command("queue-balance").description("Show queue balance and pending deposits").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) => {
+  const balance = new Command("queue-balance").description("Show queue balance and pending deposits").option("--pool <pool>", "Pool to check (eth or usdc)", "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();
       let address;
       if (options.address) {
         address = options.address;
@@ -5547,7 +5853,7 @@ function createQueueBalanceCommand() {
         process.stderr.write(`\r\x1B[K${msg}`);
       };
       const rpcUrl = options.rpcUrl || process.env.RPC_URL;
-      const result = await getQueueBalance({ address, rpcUrl, onProgress });
+      const result = await getQueueBalance({ address, pool, rpcUrl, onProgress });
       if (!options.quiet) {
         process.stderr.write("\r\x1B[K");
       }
@@ -5564,8 +5870,9 @@ function createQueueBalanceCommand() {
 
 // src/cli/commands/private-balance.ts
 function createPrivateBalanceCommand() {
-  const privateBalance = new Command("private-balance").description("Show private balance (requires VEIL_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("--show-utxos", "Show individual UTXO details").option("--quiet", "Suppress progress output").action(async (options) => {
+  const privateBalance = new Command("private-balance").description("Show private balance (requires VEIL_KEY)").option("--pool <pool>", "Pool to check (eth or usdc)", "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();
       const veilKey = options.veilKey || process.env.VEIL_KEY;
       if (!veilKey) {
         throw new Error("Must provide --veil-key or set VEIL_KEY env");
@@ -5576,11 +5883,12 @@ function createPrivateBalanceCommand() {
         const msg = detail ? `${stage}: ${detail}` : stage;
         process.stderr.write(`\r\x1B[K${msg}`);
       };
-      const result = await getPrivateBalance({ keypair, rpcUrl, onProgress });
+      const result = await getPrivateBalance({ keypair, pool, rpcUrl, onProgress });
       if (!options.quiet) {
         process.stderr.write("\r\x1B[K");
       }
       const output = {
+        pool: pool.toUpperCase(),
         privateBalance: result.privateBalance,
         privateBalanceWei: result.privateBalanceWei,
         utxoCount: result.utxoCount,
@@ -5916,15 +6224,16 @@ async function buildWithdrawProof(options) {
     amount,
     recipient,
     keypair,
+    pool = "eth",
     rpcUrl,
     onProgress
   } = options;
-  const addresses = getAddresses();
-  const poolConfig = POOL_CONFIG.eth;
-  const poolAddress = addresses.ethPool;
+  const poolConfig = POOL_CONFIG[pool];
+  const poolAddress = getPoolAddress(pool);
   onProgress?.("Fetching your UTXOs...");
   const balanceResult = await getPrivateBalance({
     keypair,
+    pool,
     rpcUrl,
     onProgress
   });
@@ -5998,12 +6307,12 @@ async function buildWithdrawProof(options) {
   };
 }
 async function withdraw(options) {
-  const { amount, recipient, onProgress } = options;
+  const { amount, recipient, pool = "eth", onProgress } = options;
   const proof = await buildWithdrawProof(options);
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
     type: "withdraw",
-    pool: "eth",
+    pool,
     proofArgs: proof.proofArgs,
     extData: proof.extData,
     metadata: {
@@ -6023,16 +6332,18 @@ async function withdraw(options) {
 }
 
 // src/cli/commands/withdraw.ts
+var SUPPORTED_ASSETS2 = ["ETH", "USDC"];
 function progress2(msg, quiet) {
   if (!quiet) {
     process.stderr.write(`\r\x1B[K${msg}`);
   }
 }
 function createWithdrawCommand() {
-  const withdrawCmd = new Command("withdraw").description("Withdraw from private pool to a public address").argument("<asset>", "Asset to withdraw (ETH)").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 (asset, amount, recipient, options) => {
+  const withdrawCmd = new Command("withdraw").description("Withdraw from private pool to a public address").argument("<asset>", "Asset to withdraw (ETH or USDC)").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 (asset, amount, recipient, options) => {
     try {
-      if (asset.toUpperCase() !== "ETH") {
-        throw new CLIError(ErrorCode.INVALID_AMOUNT, "Only ETH is supported");
+      const assetUpper = asset.toUpperCase();
+      if (!SUPPORTED_ASSETS2.includes(assetUpper)) {
+        throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS2.join(", ")}`);
       }
       if (!/^0x[a-fA-F0-9]{40}$/.test(recipient)) {
         throw new CLIError(ErrorCode.INVALID_ADDRESS, "Invalid recipient address format");
@@ -6043,15 +6354,17 @@ function createWithdrawCommand() {
       }
       const keypair = new Keypair(veilKey);
       const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+      const pool = assetUpper.toLowerCase();
       const onProgress = options.quiet ? void 0 : (stage, detail) => {
         const msg = detail ? `${stage}: ${detail}` : stage;
         progress2(msg, options.quiet);
       };
-      progress2("Starting withdrawal...", options.quiet);
+      progress2(`Starting ${assetUpper} withdrawal...`, options.quiet);
       const result = await withdraw({
         amount,
         recipient,
         keypair,
+        pool,
         rpcUrl,
         onProgress
       });
@@ -6060,6 +6373,7 @@ function createWithdrawCommand() {
         success: result.success,
         transactionHash: result.transactionHash,
         blockNumber: result.blockNumber,
+        asset: assetUpper,
         amount: result.amount,
         recipient: result.recipient
       }, null, 2));
@@ -6125,12 +6439,12 @@ async function buildTransferProof(options) {
     amount,
     recipientAddress,
     senderKeypair,
+    pool = "eth",
     rpcUrl,
     onProgress
   } = options;
-  const addresses = getAddresses();
-  const poolConfig = POOL_CONFIG.eth;
-  const poolAddress = addresses.ethPool;
+  const poolConfig = POOL_CONFIG[pool];
+  const poolAddress = getPoolAddress(pool);
   onProgress?.("Checking recipient registration...");
   const { isRegistered: isRegistered2, depositKey } = await checkRecipientRegistration(
     recipientAddress,
@@ -6142,6 +6456,7 @@ async function buildTransferProof(options) {
   onProgress?.("Fetching your UTXOs...");
   const balanceResult = await getPrivateBalance({
     keypair: senderKeypair,
+    pool,
     rpcUrl,
     onProgress
   });
@@ -6222,12 +6537,12 @@ async function buildTransferProof(options) {
   };
 }
 async function transfer(options) {
-  const { amount, recipientAddress, onProgress } = options;
+  const { amount, recipientAddress, pool = "eth", onProgress } = options;
   const proof = await buildTransferProof(options);
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
     type: "transfer",
-    pool: "eth",
+    pool,
     proofArgs: proof.proofArgs,
     extData: proof.extData,
     metadata: {
@@ -6246,13 +6561,13 @@ async function transfer(options) {
   };
 }
 async function mergeUtxos(options) {
-  const { amount, keypair, rpcUrl, onProgress } = options;
-  const addresses = getAddresses();
-  const poolConfig = POOL_CONFIG.eth;
-  const poolAddress = addresses.ethPool;
+  const { amount, keypair, pool = "eth", rpcUrl, onProgress } = options;
+  const poolConfig = POOL_CONFIG[pool];
+  const poolAddress = getPoolAddress(pool);
   onProgress?.("Fetching your UTXOs...");
   const balanceResult = await getPrivateBalance({
     keypair,
+    pool,
     rpcUrl,
     onProgress
   });
@@ -6319,7 +6634,7 @@ async function mergeUtxos(options) {
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
     type: "transfer",
-    pool: "eth",
+    pool,
     proofArgs: {
       proof: result.args.proof,
       root: result.args.root,
@@ -6345,16 +6660,18 @@ async function mergeUtxos(options) {
 }
 
 // src/cli/commands/transfer.ts
+var SUPPORTED_ASSETS3 = ["ETH", "USDC"];
 function progress3(msg, quiet) {
   if (!quiet) {
     process.stderr.write(`\r\x1B[K${msg}`);
   }
 }
 function createTransferCommand() {
-  const transferCmd = new Command("transfer").description("Transfer privately within the pool to another registered address").argument("<asset>", "Asset to transfer (ETH)").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 (asset, amount, recipient, options) => {
+  const transferCmd = new Command("transfer").description("Transfer privately within the pool to another registered address").argument("<asset>", "Asset to transfer (ETH or USDC)").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 (asset, amount, recipient, options) => {
     try {
-      if (asset.toUpperCase() !== "ETH") {
-        throw new CLIError(ErrorCode.INVALID_AMOUNT, "Only ETH is supported");
+      const assetUpper = asset.toUpperCase();
+      if (!SUPPORTED_ASSETS3.includes(assetUpper)) {
+        throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS3.join(", ")}`);
       }
       if (!/^0x[a-fA-F0-9]{40}$/.test(recipient)) {
         throw new CLIError(ErrorCode.INVALID_ADDRESS, "Invalid recipient address format");
@@ -6365,15 +6682,17 @@ function createTransferCommand() {
       }
       const senderKeypair = new Keypair(veilKey);
       const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+      const pool = assetUpper.toLowerCase();
       const onProgress = options.quiet ? void 0 : (stage, detail) => {
         const msg = detail ? `${stage}: ${detail}` : stage;
         progress3(msg, options.quiet);
       };
-      progress3("Starting transfer...", options.quiet);
+      progress3(`Starting ${assetUpper} transfer...`, options.quiet);
       const result = await transfer({
         amount,
         recipientAddress: recipient,
         senderKeypair,
+        pool,
         rpcUrl,
         onProgress
       });
@@ -6382,6 +6701,7 @@ function createTransferCommand() {
         success: result.success,
         transactionHash: result.transactionHash,
         blockNumber: result.blockNumber,
+        asset: assetUpper,
         amount: result.amount,
         recipient: result.recipient,
         type: "transfer"
@@ -6395,10 +6715,11 @@ function createTransferCommand() {
   return transferCmd;
 }
 function createMergeCommand() {
-  const mergeCmd = new Command("merge").description("Merge UTXOs by self-transfer (consolidate small UTXOs)").argument("<asset>", "Asset to merge (ETH)").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 (asset, amount, options) => {
+  const mergeCmd = new Command("merge").description("Merge UTXOs by self-transfer (consolidate small UTXOs)").argument("<asset>", "Asset to merge (ETH or USDC)").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 (asset, amount, options) => {
     try {
-      if (asset.toUpperCase() !== "ETH") {
-        throw new CLIError(ErrorCode.INVALID_AMOUNT, "Only ETH is supported");
+      const assetUpper = asset.toUpperCase();
+      if (!SUPPORTED_ASSETS3.includes(assetUpper)) {
+        throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported asset: ${asset}. Supported: ${SUPPORTED_ASSETS3.join(", ")}`);
       }
       const veilKey = options.veilKey || process.env.VEIL_KEY;
       if (!veilKey) {
@@ -6406,14 +6727,16 @@ function createMergeCommand() {
       }
       const keypair = new Keypair(veilKey);
       const rpcUrl = options.rpcUrl || process.env.RPC_URL;
+      const pool = assetUpper.toLowerCase();
       const onProgress = options.quiet ? void 0 : (stage, detail) => {
         const msg = detail ? `${stage}: ${detail}` : stage;
         progress3(msg, options.quiet);
       };
-      progress3("Starting merge (self-transfer)...", options.quiet);
+      progress3(`Starting ${assetUpper} merge (self-transfer)...`, options.quiet);
       const result = await mergeUtxos({
         amount,
         keypair,
+        pool,
         rpcUrl,
         onProgress
       });
@@ -6422,6 +6745,7 @@ function createMergeCommand() {
         success: result.success,
         transactionHash: result.transactionHash,
         blockNumber: result.blockNumber,
+        asset: assetUpper,
         amount: result.amount,
         type: "merge"
       }, null, 2));
@@ -6506,7 +6830,7 @@ function createStatusCommand() {
 // src/cli/index.ts
 loadEnv();
 var program2 = new Command();
-program2.name("veil").description("CLI for Veil Cash privacy pools on Base").version("0.1.0");
+program2.name("veil").description("CLI for Veil Cash privacy pools on Base").version("0.3.0");
 program2.addCommand(createInitCommand());
 program2.addCommand(createKeypairCommand());
 program2.addCommand(createRegisterCommand());