const result = await sdk.vault.withdraw({
  tokenAddress: '0x...token-address',
  amount: 1000000000000000000n, // 1 token
  recipientAddress: '0x...recipient-address',
});

console.log('Transaction hash:', result.txHash);

interface WithdrawParams {
  tokenAddress: Hex;          // Token to withdraw
  amount: bigint;             // Amount in wei
  recipientAddress: Hex;      // Destination address
  unwrapWeth?: boolean;       // Unwrap WETH to ETH
  onProgress?: OnProgress;    // Progress callback
}

await sdk.vault.withdraw({
  tokenAddress: '0x...',
  amount: 1000000000000000000n,
  recipientAddress: '0x...',
  onProgress: ({ step, message, txHash }) => {
    console.log(`Step: ${step}`);
    console.log(`Message: ${message}`);
    if (txHash) {
      console.log(`Transaction: ${txHash}`);
    }
  },
});

enum WithdrawStep {
  preparing = 'preparing',
  signing = 'signing',
  proving = 'proving',
  unshielding = 'unshielding',
  unwrapping = 'unwrapping',
}

interface WithdrawResult {
  txHash: Hex;          // Main withdrawal transaction
  amount: bigint;       // Amount withdrawn
  unwrapTxHash?: Hex;   // WETH unwrap transaction (if applicable)
}

const WETH_ADDRESS = '0x4200000000000000000000000000000000000006';

const result = await sdk.vault.withdraw({
  tokenAddress: WETH_ADDRESS,
  amount: 1000000000000000000n,
  recipientAddress: '0x...',
  unwrapWeth: true, // Unwrap to ETH
});

console.log('Withdraw tx:', result.txHash);
console.log('Unwrap tx:', result.unwrapTxHash);

const myAddress = sdk.auth.getAddress();

await sdk.vault.withdraw({
  tokenAddress: '0x...',
  amount: 1000000000000000000n,
  recipientAddress: myAddress,
});

import { isEvmAddress } from '@testinprod-io/privacy-boost';

const recipientAddress = '0x...';

// Validate address
if (!isEvmAddress(recipientAddress)) {
  throw new Error('Invalid recipient address');
}

await sdk.vault.withdraw({
  tokenAddress: '0x...',
  amount: 1000000000000000000n,
  recipientAddress,
});

// Check available balance first
const balance = await sdk.vault.getBalance(tokenAddress);

if (amount > balance) {
  throw new Error('Insufficient shielded balance');
}

await sdk.vault.withdraw({
  tokenAddress,
  amount, // Any amount <= balance
  recipientAddress,
});

try {
  await sdk.vault.withdraw(params);
} catch (error) {
  switch (error.code) {
    case 'INSUFFICIENT_BALANCE':
      console.log('Not enough shielded balance');
      break;
    case 'INVALID_RECIPIENT':
      console.log('Invalid recipient address');
      break;
    case 'PROOF_GENERATION_FAILED':
      console.log('Failed to generate proof');
      break;
    case 'WITHDRAWAL_FAILED':
      console.log('Withdrawal transaction failed');
      break;
    case 'UNWRAP_FAILED':
      console.log('WETH unwrap failed');
      break;
    default:
      console.log('Withdrawal error:', error.message);
  }
}

// The withdrawal fee is included in the amount
// No separate gas estimation needed as the prover pays gas

import { useState } from 'react';

function WithdrawForm() {
  const [amount, setAmount] = useState('');
  const [recipient, setRecipient] = useState('');
  const [unwrapWeth, setUnwrapWeth] = useState(false);
  const [step, setStep] = useState('');
  const [loading, setLoading] = useState(false);

  const handleWithdraw = async () => {
    setLoading(true);
    try {
      const parsedAmount = await sdk.vault.parseAmount(tokenAddress, amount);

      await sdk.vault.withdraw({
        tokenAddress,
        amount: parsedAmount,
        recipientAddress: recipient,
        unwrapWeth,
        onProgress: ({ step, message }) => {
          setStep(message);
        },
      });

      alert('Withdrawal successful!');
    } catch (error) {
      alert(`Withdrawal failed: ${error.message}`);
    } finally {
      setLoading(false);
      setStep('');
    }
  };

  return (
    <div>
      <input
        type="text"
        value={amount}
        onChange={(e) => setAmount(e.target.value)}
        placeholder="Amount"
        disabled={loading}
      />
      <input
        type="text"
        value={recipient}
        onChange={(e) => setRecipient(e.target.value)}
        placeholder="Recipient address"
        disabled={loading}
      />
      <label>
        <input
          type="checkbox"
          checked={unwrapWeth}
          onChange={(e) => setUnwrapWeth(e.target.checked)}
          disabled={loading}
        />
        Unwrap WETH to ETH
      </label>
      <button onClick={handleWithdraw} disabled={loading}>
        {loading ? step || 'Processing...' : 'Withdraw'}
      </button>
    </div>
  );
}

async function safeWithdraw(params: WithdrawParams) {
  const balance = await sdk.vault.getBalance(params.tokenAddress);

  if (params.amount > balance) {
    throw new Error(
      `Insufficient balance. Available: ${balance}, Requested: ${params.amount}`
    );
  }

  return sdk.vault.withdraw(params);
}

import { isEvmAddress } from '@testinprod-io/privacy-boost';

function validateRecipient(address: string) {
  if (!isEvmAddress(address)) {
    throw new Error('Invalid Ethereum address');
  }
  if (address === '0x0000000000000000000000000000000000000000') {
    throw new Error('Cannot withdraw to zero address');
  }
}

const EXPECTED_DURATION = 30000; // 30 seconds

// Show estimated time
setStatus('Generating proof... This may take up to 30 seconds.');

await sdk.vault.withdraw({
  ...params,
  onProgress: ({ step }) => {
    if (step === 'proving') {
      setStatus('Generating zero-knowledge proof...');
    } else if (step === 'unshielding') {
      setStatus('Submitting withdrawal transaction...');
    }
  },
});