How to: Process Withdrawals

import { getAddress, isAddress } from "viem";

function validateDestination(address: string): string {
  if (!isAddress(address)) {
    throw new Error(`Invalid address: ${address}`);
  }
  // Return EIP-55 checksum-validated address
  return getAddress(address);
}

const destination = validateDestination(
  "0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28",
);

import { createPublicClient, http, parseAbi } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.testnet.arc.io"),
});

const USDC_ADDRESS = "0x3600000000000000000000000000000000000000" as const;

async function isBlocklisted(address: string): Promise<boolean> {
  const blocked = await client.readContract({
    address: USDC_ADDRESS,
    abi: parseAbi(["function isBlacklisted(address) view returns (bool)"]),
    functionName: "isBlacklisted",
    args: [address as `0x${string}`],
  });
  return blocked;
}

const blocked = await isBlocklisted(destination);
if (blocked) {
  throw new Error(`Destination ${destination} is blocklisted`);
}

// 1 USDC in 18-decimal native wei. If you track 6-decimal balances,
// convert with: amount = amount6 * 10n ** 12n
const amount = 1_000_000_000_000_000_000n;

const gasEstimate = await client.estimateGas({
  account: hotWalletAddress,
  to: destination as `0x${string}`,
  value: amount,
});

console.log(`Estimated gas units: ${gasEstimate}`);
// Typical native USDC send: ~21,000 gas units

const gasPrice = await client.getGasPrice();

// Gas cost formula: gas_units * gas_price = cost in USDC wei (18 decimals)
const estimatedCost = gasEstimate * gasPrice;

// Convert to human-readable USDC (18 decimals for native gas accounting)
const costInUsdc = Number(estimatedCost) / 1e18;
console.log(`Estimated fee: ${costInUsdc} USDC`);

cost_usdc_wei = gas_used * effective_gas_price
cost_usdc = cost_usdc_wei / 10^18

21,000 * 20,000,000,000 = 420,000,000,000,000 wei = 0.00042 USDC

import { createWalletClient, http, parseGwei } from "viem";

const walletClient = createWalletClient({
  account: hotWalletAccount, // Your signing account
  transport: http("https://rpc.testnet.arc.io"),
});

const txHash = await walletClient.sendTransaction({
  to: destination as `0x${string}`,
  value: amount, // 18-decimal native USDC
  gas: gasEstimate,
  maxFeePerGas: parseGwei("25"), // Must be >= 20 Gwei
  maxPriorityFeePerGas: parseGwei("1"),
  chain: {
    id: 5042002,
    name: "Arc Testnet",
    nativeCurrency: { name: "USDC", symbol: "USDC", decimals: 18 },
    rpcUrls: { default: { http: ["https://rpc.testnet.arc.io"] } },
  },
});

console.log(`Transaction hash: ${txHash}`);

const receipt = await client.waitForTransactionReceipt({ hash: txHash });

if (receipt.status === "success") {
  console.log(`Withdrawal confirmed in block ${receipt.blockNumber}`);
  // Credit the withdrawal as complete—no further checks needed
} else {
  console.error("Transaction reverted");
  // Handle failure (see Step 7)
}

async function processWithdrawal(to: string, amount: bigint): Promise<string> {
  const validAddress = validateDestination(to);

  if (await isBlocklisted(validAddress)) {
    throw new Error(`Address ${validAddress} is blocklisted`);
  }

  // amount is 18-decimal native USDC wei
  const gas = await client.estimateGas({
    account: hotWalletAddress,
    to: validAddress as `0x${string}`,
    value: amount,
  });

  const txHash = await walletClient.sendTransaction({
    to: validAddress as `0x${string}`,
    value: amount,
    gas: (gas * 120n) / 100n, // 20% buffer
    maxFeePerGas: parseGwei("25"),
    maxPriorityFeePerGas: parseGwei("1"),
  });

  const receipt = await client.waitForTransactionReceipt({ hash: txHash });

  if (receipt.status !== "success") {
    throw new Error(`Withdrawal failed: tx ${txHash} reverted`);
  }

  return txHash;
}