Quickstart: Transfer USDC on EVM chains

# Set up your directory and initialize a Node.js project
mkdir transfer-usdc-evm
cd transfer-usdc-evm
npm init -y

# Set up module type and start command
npm pkg set type=module
npm pkg set scripts.start="node --env-file=.env index.ts"

# Install runtime dependencies
npm install viem

# Install dev dependencies
npm install --save-dev typescript @types/node

import { createClient, http, publicActions, walletActions } from "viem";
import * as chains from "viem/chains";
import { filterChains, isAddress, isHex } from "viem/utils";
import { privateKeyToAccount } from "viem/accounts";
import { usdc } from "viem/tokens";

import * as process from "node:process";
import * as readline from "node:readline/promises";

// 1. Ensure environment variables are set up
if (!isHex(process.env.PRIVATE_KEY) || process.env.PRIVATE_KEY.length !== 66)
  throw new Error("Set PRIVATE_KEY to a 0x-prefixed 32-byte hex string");
if (!process.env.RECIPIENT_ADDRESS || !isAddress(process.env.RECIPIENT_ADDRESS))
  throw new Error("Set RECIPIENT_ADDRESS to valid EVM address");

// 2. Setup Viem Client with `usdc` token and public/wallet actions
const client = createClient({
  account: privateKeyToAccount(process.env.PRIVATE_KEY),
  chain: await selectChain(),
  tokens: [usdc],
  transport: http(),
})
  .extend(publicActions)
  .extend(walletActions);

try {
  // 3. Read sender token balance before transfer
  const balance = await client.token.getBalance({ token: "usdc" });
  const amount = { formatted: "1" };
  const recipient = process.env.RECIPIENT_ADDRESS;

  console.log("Chain:", client.chain.name);
  console.log("Sender:", client.account.address);
  console.log("Recipient:", recipient);
  console.log("Balance:", balance.formatted, usdc.symbol);

  // 4. Ensure sender has enough balance
  if (Number(amount.formatted) > Number(balance.formatted))
    throw new Error("Insufficient balance");

  // 5. Estimate gas and apply a safety floor
  const estimatedGas = await client.token.transfer.estimateGas({
    amount,
    to: recipient,
    token: "usdc",
  });
  const buffered = estimatedGas + (estimatedGas * 50n) / 100n;
  const floor = 85_000n;

  // 6. Submit USDC transfer
  const hash = await client.token.transfer({
    amount,
    gas: buffered > floor ? buffered : floor,
    to: recipient,
    token: "usdc",
  });

  // 7. Print transaction details
  console.log("Transaction submitted.");
  console.log("Tx hash:", hash);
  if (client.chain.blockExplorers?.default)
    console.log(
      "Explorer:",
      `${client.chain.blockExplorers.default.url}/tx/${hash}`,
    );

  // 8. Wait for transaction confirmation
  const receipt = await client.waitForTransactionReceipt({ hash });
  if (receipt.status !== "success") throw new Error("Transaction reverted");

  console.log("Transfer confirmed!");
} catch (error) {
  // 9. Handle transfer errors
  console.error(
    "Transfer failed:",
    error instanceof Error ? error.message : error,
  );
  process.exit(1);
}

async function selectChain() {
  // Find supported testnet chains for `usdc`
  const supportedChains = filterChains({
    chains,
    sort: "name",
    testnet: true,
    token: usdc,
  });
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });
  try {
    // Prompt user to choose a chain
    const answer = await rl.question(
      `Select a chain for your ${usdc.symbol} transfer:\n${supportedChains
        .map((chain, index) => `${index + 1}. ${chain.name}`)
        .join("\n")}\n\nEnter a number: `,
    );
    // Validate selected chain
    const selected = supportedChains[Number.parseInt(answer, 10) - 1];
    if (!selected) throw new Error("Select a valid chain");
    return selected;
  } finally {
    rl.close();
  }
}

npm start