Send Usdc

Send USDC is a community skill for implementing USDC stablecoin transfers in applications, covering wallet integration, token transfer execution, transaction confirmation, gas estimation, and multi-chain USDC sending patterns.

What Is This?

Overview

Send USDC provides patterns for building stablecoin transfer features in decentralized applications. It covers wallet connection and balance checking for USDC tokens on supported chains, ERC-20 token transfer execution using the USDC contract approve and transfer methods, transaction confirmation with receipt polling and status tracking, gas estimation and fee display so users understand transaction costs before sending, and multi-chain support for USDC on Ethereum, Polygon, Arbitrum, and Base networks. The skill enables developers to build payment and transfer flows using the most widely adopted stablecoin.

Who Should Use This

This skill serves Web3 developers building payment features with stablecoin transfers, teams creating remittance or payroll applications using USDC, and engineers integrating stablecoin payments into existing platforms.

Why Use It?

Problems It Solves

Sending ERC-20 tokens requires interacting with smart contract methods rather than simple native transfers. Gas estimation for token transfers differs from native currency sends and varies by network congestion. Transaction confirmation needs polling or event listeners to detect completion. Multi-chain USDC uses different contract addresses per network requiring chain-aware configuration.

Core Highlights

Token balance reader queries USDC contract for current holdings. Transfer builder constructs and sends ERC-20 transfer transactions. Confirmation tracker polls for transaction receipts with timeout handling. Chain config maps USDC contract addresses across supported networks.

How to Use It?

Basic Usage

import { ethers } from 'ethers';

const USDC_ABI = [
  'function balanceOf('
    + 'address) view '
    + 'returns (uint256)',
  'function transfer('
    + 'address to, '
    + 'uint256 amount) '
    + 'returns (bool)',
  'function decimals() view '
    + 'returns (uint8)',
];

const USDC_ADDRESSES: Record<
    number, string> = {
  1: '0xA0b86991c6218b36c1d1'
    + '9D4a2e9Eb0cE3606eB48',
  137: '0x3c499c542cEF5E3811e1'
    + '192ce70d8cC03d5c3359',
  8453: '0x833589fCD6eDb6E08f4c'
    + '7C32D4f71b54bdA02913',
};

async function getBalance(
  provider: ethers.Provider,
  address: string,
  chainId: number
): Promise<string> {
  const usdc = new ethers.Contract(
    USDC_ADDRESSES[chainId],
    USDC_ABI, provider);
  const raw =
    await usdc.balanceOf(address);
  const decimals =
    await usdc.decimals();
  return ethers.formatUnits(
    raw, decimals);
}

Real-World Examples

import { ethers } from 'ethers';

async function sendUSDC(
  signer: ethers.Signer,
  to: string,
  amount: string,
  chainId: number
) {
  const usdc = new ethers.Contract(
    USDC_ADDRESSES[chainId],
    USDC_ABI, signer);

  const decimals =
    await usdc.decimals();
  const parsed =
    ethers.parseUnits(
      amount, decimals);

  // Estimate gas
  const gasEstimate =
    await usdc.transfer
      .estimateGas(to, parsed);

  // Send transfer
  const tx = await usdc.transfer(
    to, parsed, {
      gasLimit:
        gasEstimate * 120n / 100n,
    });

  // Wait for confirmation
  const receipt =
    await tx.wait(1);

  return {
    hash: tx.hash,
    status: receipt?.status === 1
      ? 'confirmed' : 'failed',
    gasUsed:
      receipt?.gasUsed.toString(),
  };
}

// Usage
const provider =
  new ethers.BrowserProvider(
    window.ethereum);
const signer =
  await provider.getSigner();
const result = await sendUSDC(
  signer,
  '0xRecipientAddress',
  '100.00',
  1);
console.log(
  `TX: ${result.hash}`);

Advanced Tips

Add a gas buffer of 20 percent to estimated gas to prevent out-of-gas failures during network congestion. Use permit-based transfers (EIP-2612) where supported to combine approve and transfer into a single transaction. Implement transaction status polling with exponential backoff for confirmation.

When to Use It?

Use Cases

Build a peer-to-peer payment interface that sends USDC between wallet addresses. Create a payroll system that distributes USDC salary payments to employee wallets. Implement a cross-chain transfer flow that sends USDC on the cheapest network.

Related Topics

ERC-20 tokens, stablecoin transfers, blockchain transactions, gas estimation, and Web3 payments.

Important Notes

Requirements

Ethers.js or web3.js for interacting with ERC-20 contracts. A wallet provider for signing transactions. RPC endpoint for the target blockchain network.

Usage Recommendations

Do: verify the USDC contract address for each network before sending transactions. Display gas costs in the UI so users can confirm before signing. Check balance sufficiency before attempting transfers.

Don't: hardcode a single USDC address when supporting multiple chains with different contracts. Skip gas estimation which can result in failed transactions. Assume transaction success without waiting for receipt confirmation.

Limitations

USDC transfers require the sender to hold native currency for gas fees in addition to the USDC amount. Transaction confirmation times vary significantly across networks. Contract addresses may change if USDC is upgraded on a given network.