@veil-cash/sdk 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veil-cash/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "SDK and CLI for interacting with Veil Cash privacy pools - keypair generation, deposits, and status checking",
   "type": "module",
   "main": "./dist/index.js",

package/src/abi.ts

@@ -62,6 +62,24 @@ export const ENTRY_ABI = [
     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' }],
@@ -83,6 +101,18 @@ export const ENTRY_ABI = [
     type: 'function',
   },
 
+  // Queue cbBTC deposit
+  {
+    inputs: [
+      { name: '_amount', type: 'uint256' },
+      { name: '_depositKey', type: 'bytes' },
+    ],
+    name: 'queueBTC',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+
   // Read deposit keys
   {
     inputs: [{ name: '', type: 'address' }],

package/src/addresses.ts

@@ -2,7 +2,7 @@
  * Contract addresses for Veil on Base
  */
 
-import type { NetworkAddresses } from './types.js';
+import type { NetworkAddresses, RelayPool } from './types.js';
 
 /**
  * Contract addresses for Base mainnet
@@ -14,6 +14,9 @@ export const ADDRESSES: NetworkAddresses = {
   usdcPool: '0x5c50d58E49C59d112680c187De2Bf989d2a91242',
   usdcQueue: '0x5530241b24504bF05C9a22e95A1F5458888e6a9B',
   usdcToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+  cbbtcPool: '0x51A021da774b4bBB59B47f7CB4ccd631337680BA',
+  cbbtcQueue: '0x977741CaDF8D1431c4816C0993D32b02094cD35C',
+  cbbtcToken: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
   chainId: 8453,
   relayUrl: 'https://veil-relay.up.railway.app',
 } as const;
@@ -34,6 +37,12 @@ export const POOL_CONFIG = {
     symbol: 'USDC',
     name: 'USD Coin',
   },
+  cbbtc: {
+    decimals: 8,
+    displayDecimals: 6,
+    symbol: 'cbBTC',
+    name: 'Coinbase Bitcoin',
+  },
 } as const;
 
 /**
@@ -44,6 +53,36 @@ export function getAddresses(): NetworkAddresses {
   return ADDRESSES;
 }
 
+/**
+ * Get the pool contract address for a given pool
+ * @param pool - Pool identifier ('eth', 'usdc', or 'cbbtc')
+ * @returns Pool contract address
+ */
+export function getPoolAddress(pool: RelayPool): `0x${string}` {
+  const addresses = getAddresses();
+  switch (pool) {
+    case 'eth': return addresses.ethPool;
+    case 'usdc': return addresses.usdcPool;
+    case 'cbbtc': return addresses.cbbtcPool;
+    default: throw new Error(`Unknown pool: ${pool}`);
+  }
+}
+
+/**
+ * Get the queue contract address for a given pool
+ * @param pool - Pool identifier ('eth', 'usdc', or 'cbbtc')
+ * @returns Queue contract address
+ */
+export function getQueueAddress(pool: RelayPool): `0x${string}` {
+  const addresses = getAddresses();
+  switch (pool) {
+    case 'eth': return addresses.ethQueue;
+    case 'usdc': return addresses.usdcQueue;
+    case 'cbbtc': return addresses.cbbtcQueue;
+    default: throw new Error(`Unknown pool: ${pool}`);
+  }
+}
+
 /**
  * Get Relay URL
  * @returns Relay URL for Base mainnet

package/src/balance.ts

@@ -3,9 +3,9 @@
  * Query queue and private balances directly from blockchain
  */
 
-import { createPublicClient, http, formatEther } from 'viem';
+import { createPublicClient, http, formatUnits } from 'viem';
 import { base } from 'viem/chains';
-import { getAddresses } from './addresses.js';
+import { getPoolAddress, getQueueAddress, POOL_CONFIG } from './addresses.js';
 import { QUEUE_ABI, POOL_ABI } from './abi.js';
 import { Keypair } from './keypair.js';
 import { Utxo } from './utxo.js';
@@ -15,6 +15,7 @@ import type {
   PendingDeposit, 
   PrivateBalanceResult,
   UtxoInfo,
+  RelayPool,
 } from './types.js';
 
 // Deposit status enum from Queue contract
@@ -44,6 +45,7 @@ export type ProgressCallback = (stage: string, detail?: string) => void;
  * ```typescript
  * const result = await getQueueBalance({
  *   address: '0x...',
+ *   pool: 'eth',
  *   onProgress: (stage, detail) => console.log(stage, detail),
  * });
  * 
@@ -53,11 +55,13 @@ export type ProgressCallback = (stage: string, detail?: string) => void;
  */
 export async function getQueueBalance(options: {
   address: `0x${string}`;
+  pool?: RelayPool;
   rpcUrl?: string;
   onProgress?: ProgressCallback;
 }): Promise<QueueBalanceResult> {
-  const { address, rpcUrl, onProgress } = options;
-  const addresses = getAddresses();
+  const { address, pool = 'eth', rpcUrl, onProgress } = options;
+  const queueAddress = getQueueAddress(pool);
+  const poolConfig = POOL_CONFIG[pool];
 
   // Create public client
   const publicClient = createPublicClient({
@@ -68,7 +72,7 @@ export async function getQueueBalance(options: {
   // Get all pending deposit nonces
   onProgress?.('Fetching pending deposits...');
   const pendingNonces = await publicClient.readContract({
-    address: addresses.ethQueue,
+    address: queueAddress,
     abi: QUEUE_ABI,
     functionName: 'getPendingDeposits',
   }) as bigint[];
@@ -83,7 +87,7 @@ export async function getQueueBalance(options: {
     onProgress?.('Checking deposit', `${i + 1}/${pendingNonces.length}`);
     
     const deposit = await publicClient.readContract({
-      address: addresses.ethQueue,
+      address: queueAddress,
       abi: QUEUE_ABI,
       functionName: 'getDeposit',
       args: [nonce],
@@ -103,7 +107,7 @@ export async function getQueueBalance(options: {
       pendingDeposits.push({
         nonce: nonce.toString(),
         status: DEPOSIT_STATUS_MAP[deposit.status as keyof typeof DEPOSIT_STATUS_MAP] || 'pending',
-        amount: formatEther(deposit.amountIn),
+        amount: formatUnits(deposit.amountIn, poolConfig.decimals),
         amountWei: deposit.amountIn.toString(),
         timestamp: new Date(Number(deposit.timestamp) * 1000).toISOString(),
       });
@@ -116,7 +120,7 @@ export async function getQueueBalance(options: {
 
   return {
     address,
-    queueBalance: formatEther(totalQueueBalance),
+    queueBalance: formatUnits(totalQueueBalance, poolConfig.decimals),
     queueBalanceWei: totalQueueBalance.toString(),
     pendingDeposits,
     pendingCount: pendingDeposits.length,
@@ -138,6 +142,7 @@ export async function getQueueBalance(options: {
  * const keypair = new Keypair(process.env.VEIL_KEY);
  * const result = await getPrivateBalance({ 
  *   keypair,
+ *   pool: 'eth',
  *   onProgress: (stage, detail) => console.log(stage, detail),
  * });
  * 
@@ -147,11 +152,13 @@ export async function getQueueBalance(options: {
  */
 export async function getPrivateBalance(options: {
   keypair: Keypair;
+  pool?: RelayPool;
   rpcUrl?: string;
   onProgress?: ProgressCallback;
 }): Promise<PrivateBalanceResult> {
-  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');
@@ -166,7 +173,7 @@ export async function getPrivateBalance(options: {
   // 1. Get total count of encrypted outputs
   onProgress?.('Fetching pool index...');
   const nextIndex = await publicClient.readContract({
-    address: addresses.ethPool,
+    address: poolAddress,
     abi: POOL_ABI,
     functionName: 'nextIndex',
   }) as number;
@@ -194,7 +201,7 @@ export async function getPrivateBalance(options: {
     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)],
@@ -234,7 +241,7 @@ export async function getPrivateBalance(options: {
     const nullifierHex = toFixedHex(nullifier) as `0x${string}`;
 
     const isSpent = await publicClient.readContract({
-      address: addresses.ethPool,
+      address: poolAddress,
       abi: POOL_ABI,
       functionName: 'isSpent',
       args: [nullifierHex],
@@ -242,7 +249,7 @@ export async function getPrivateBalance(options: {
 
     utxoInfos.push({
       index,
-      amount: formatEther(utxo.amount),
+      amount: formatUnits(utxo.amount, poolConfig.decimals),
       amountWei: utxo.amount.toString(),
       isSpent,
     });
@@ -256,7 +263,7 @@ export async function getPrivateBalance(options: {
   }
 
   return {
-    privateBalance: formatEther(totalBalance),
+    privateBalance: formatUnits(totalBalance, poolConfig.decimals),
     privateBalanceWei: totalBalance.toString(),
     utxoCount: decryptedUtxos.length,
     spentCount,

package/src/cli/commands/balance.ts

@@ -4,14 +4,91 @@
 
 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 { formatEther } from 'viem';
+import { formatUnits } from 'viem';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import type { RelayPool } from '../../types.js';
+
+const SUPPORTED_POOLS: RelayPool[] = ['eth', 'usdc', 'cbbtc'];
+
+/**
+ * Fetch balance for a single pool and return structured output
+ */
+async function fetchPoolBalance(
+  pool: RelayPool,
+  address: `0x${string}`,
+  keypair: Keypair | null,
+  rpcUrl: string | undefined,
+  onProgress: ((stage: string, detail?: string) => void) | undefined,
+): Promise<Record<string, unknown>> {
+  const poolConfig = POOL_CONFIG[pool];
+
+  // Get queue balance
+  const poolProgress = onProgress
+    ? (stage: string, detail?: string) => onProgress(`[${pool.toUpperCase()}] ${stage}`, detail)
+    : undefined;
+
+  const queueResult = await getQueueBalance({ address, pool, rpcUrl, onProgress: poolProgress });
+
+  // Get private balance if keypair available
+  let privateResult = null;
+  if (keypair) {
+    privateResult = await getPrivateBalance({ keypair, pool, rpcUrl, onProgress: poolProgress });
+  }
+
+  // Calculate total balance
+  const queueBalanceWei = BigInt(queueResult.queueBalanceWei);
+  const privateBalanceWei = privateResult ? BigInt(privateResult.privateBalanceWei) : 0n;
+  const totalBalanceWei = queueBalanceWei + privateBalanceWei;
+
+  const result: Record<string, unknown> = {
+    pool: pool.toUpperCase(),
+    symbol: poolConfig.symbol,
+    totalBalance: formatUnits(totalBalanceWei, poolConfig.decimals),
+    totalBalanceWei: totalBalanceWei.toString(),
+  };
+
+  // Private balance
+  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',
+    };
+  }
+
+  // Queue details
+  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;
+}
 
 export function createBalanceCommand(): Command {
   const balance = new Command('balance')
-    .description('Show queue and private balances')
+    .description('Show queue and private balances (all pools by default)')
+    .option('--pool <pool>', 'Pool to check (eth, usdc, cbbtc, 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)')
@@ -19,6 +96,15 @@ export function createBalanceCommand(): Command {
     .option('--quiet', 'Suppress progress output')
     .action(async (options) => {
       try {
+        const poolArg = (options.pool || 'all').toLowerCase();
+
+        // Validate pool
+        if (poolArg !== 'all' && !SUPPORTED_POOLS.includes(poolArg as RelayPool)) {
+          throw new CLIError(ErrorCode.INVALID_AMOUNT, `Unsupported pool: ${options.pool}. Supported: ${SUPPORTED_POOLS.join(', ')}, all`);
+        }
+
+        const poolsToQuery: RelayPool[] = poolArg === 'all' ? [...SUPPORTED_POOLS] : [poolArg as RelayPool];
+
         // Get address
         let address: `0x${string}`;
         if (options.address) {
@@ -45,66 +131,40 @@ export function createBalanceCommand(): Command {
               process.stderr.write(`\r\x1b[K${msg}`);
             };
 
-        // Get queue balance
-        const queueResult = await getQueueBalance({ address, rpcUrl, onProgress });
+        // Get deposit key if available
+        const depositKey = process.env.DEPOSIT_KEY || (keypair ? keypair.depositKey() : null);
 
-        // Get private balance if keypair available
-        let privateResult = null;
-        if (keypair) {
-          privateResult = await getPrivateBalance({ keypair, rpcUrl, onProgress });
-        }
+        // Single pool mode -- flat output (backwards compatible)
+        if (poolsToQuery.length === 1) {
+          const poolResult = await fetchPoolBalance(poolsToQuery[0], address, keypair, rpcUrl, onProgress);
 
-        // Clear progress line
-        if (!options.quiet) {
-          process.stderr.write('\r\x1b[K');
+          // Clear progress line
+          if (!options.quiet) process.stderr.write('\r\x1b[K');
+
+          const output = {
+            address,
+            depositKey: depositKey || null,
+            ...poolResult,
+          };
+
+          console.log(JSON.stringify(output, null, 2));
+          return;
         }
 
-        // Calculate total balance
-        const queueBalanceWei = BigInt(queueResult.queueBalanceWei);
-        const privateBalanceWei = privateResult ? BigInt(privateResult.privateBalanceWei) : 0n;
-        const totalBalanceWei = queueBalanceWei + privateBalanceWei;
+        // 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);
+        }
 
-        // Get deposit key if available
-        const depositKey = process.env.DEPOSIT_KEY || (keypair ? keypair.depositKey() : null);
+        // Clear progress line
+        if (!options.quiet) process.stderr.write('\r\x1b[K');
 
-        // Build output structure
-        const output: Record<string, unknown> = {
+        const output = {
           address,
           depositKey: depositKey || null,
-          totalBalance: formatEther(totalBalanceWei),
-          totalBalanceWei: totalBalanceWei.toString(),
-        };
-
-        // Private balance first
-        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',
-          };
-        }
-
-        // Queue details second
-        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));

package/src/cli/commands/deposit.ts

@@ -3,17 +3,27 @@
  */
 
 import { Command } from 'commander';
-import { buildDepositETHTx } from '../../deposit.js';
+import { buildDepositETHTx, buildDepositUSDCTx, buildApproveUSDCTx, buildDepositCBBTCTx, buildApproveCBBTCTx } from '../../deposit.js';
 import { sendTransaction, getAddress, getBalance } from '../wallet.js';
 import { getConfig } from '../config.js';
 import { parseEther, formatEther } from 'viem';
 import { handleCLIError, CLIError, ErrorCode } from '../errors.js';
+import type { TransactionData } from '../../types.js';
 
-// Minimum deposit: 0.01 ETH (net after 0.3% fee)
-// To deposit 0.01 ETH net, you need to send: 0.01 / (1 - 0.003) ≈ 0.01003 ETH
-const MINIMUM_DEPOSIT_ETH = 0.01;
+// Minimum deposits per asset (net after 0.3% fee)
 const DEPOSIT_FEE_PERCENT = 0.3;
-const MINIMUM_DEPOSIT_WITH_FEE = MINIMUM_DEPOSIT_ETH / (1 - DEPOSIT_FEE_PERCENT / 100);
+const MINIMUM_DEPOSITS: 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);
+}
+
+const SUPPORTED_ASSETS = ['ETH', 'USDC', 'CBBTC'];
 
 // Progress helper - writes to stderr so JSON output stays clean
 function progress(msg: string, quiet?: boolean) {
@@ -24,8 +34,8 @@ function progress(msg: string, quiet?: boolean) {
 
 export function createDepositCommand(): Command {
   const deposit = new Command('deposit')
-    .description('Deposit ETH into Veil')
-    .argument('<asset>', 'Asset to deposit (ETH)')
+    .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)')
@@ -34,19 +44,23 @@ export function createDepositCommand(): Command {
     .option('--quiet', 'Suppress progress output')
     .action(async (asset: string, amount: string, options) => {
       try {
-        // Validate asset is ETH
-        if (asset.toUpperCase() !== 'ETH') {
-          throw new CLIError(ErrorCode.INVALID_AMOUNT, 'Only ETH is supported');
+        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 < MINIMUM_DEPOSIT_WITH_FEE) {
+        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}.`
           );
         }
 
@@ -58,24 +72,45 @@ export function createDepositCommand(): Command {
 
         progress('Building transaction...', options.quiet);
 
-        // Build the transaction
-        const tx = buildDepositETHTx({
-          depositKey,
-          amount,
-        });
+        // 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 });
+        } else {
+          tx = buildDepositETHTx({ depositKey, amount });
+        }
 
         // Handle --unsigned mode (no wallet required, just build payload)
         if (options.unsigned) {
           progress('', options.quiet); // Clear line
-          // Output Bankr-compatible format
-          const payload = {
+          const payloads: Record<string, unknown>[] = [];
+
+          // Include approval tx for ERC20 tokens
+          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
-          };
+            chainId: 8453,
+          });
 
-          console.log(JSON.stringify(payload, null, 2));
+          console.log(JSON.stringify(payloads.length === 1 ? payloads[0] : payloads, null, 2));
           return;
         }
 
@@ -83,20 +118,27 @@ export function createDepositCommand(): Command {
         const config = getConfig(options);
         const address = getAddress(config.privateKey);
 
-        progress('Checking balance...', options.quiet);
+        // For ETH deposits, check ETH balance
+        if (assetUpper === 'ETH') {
+          progress('Checking balance...', options.quiet);
+          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`);
+          }
+        }
 
-        // Check 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`);
+        // Send approval transaction for ERC20 tokens
+        if (approveTx) {
+          progress(`Approving ${assetUpper}...`, options.quiet);
+          await sendTransaction(config, approveTx);
         }
 
-        progress('Sending transaction...', options.quiet);
+        progress('Sending deposit transaction...', options.quiet);
 
-        // Send the transaction
+        // Send the deposit transaction
         const result = await sendTransaction(config, tx);
 
         progress('Confirming...', options.quiet);
@@ -107,6 +149,7 @@ export function createDepositCommand(): Command {
         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(),