Highlights
- CCTP lets you move USDC between supported blockchains without creating a wrapped version of the token. Instead, USDC is burned on the source chain and an equivalent amount of native USDC is minted on the destination chain.
- The USDC on the destination chain is native USDC issued by Circle. You are not receiving a separate bridged token that needs to be backed by USDC locked in a bridge contract.
- You can integrate CCTP directly through Circle’s contracts or use Bridge Kit SDK to handle more of the integration details for you.
How traditional bridges move tokens and where they break
Your user taps “Send USDC to Base.” A few seconds later, 100 USDC appear in their wallet. But depending on what’s behind that button, it may not be native USDC at all.
How a traditional bridge moves tokens
Many bridges lock the user’s tokens on the source chain and mint a representation of them on the destination chain.
Say you have 100 USDC on Ethereum and want to move it to Base. You send it to the bridge, which locks it in a smart contract. The bridge then mints 100 new tokens on Base to represent your original USDC. These are called wrapped or bridged tokens.
The bridged token may look like USDC and may be designed to trade at $1. Technically, though, it is a representation of USDC, not native USDC issued on Base. Your original 100 USDC is still sitting in the bridge contract on Ethereum, backing the tokens you now hold.
When you want your USDC back, you send the bridged tokens to the bridge. It burns them and releases the locked USDC.
Where it breaks
This model puts the bridge in the middle of every transfer. The value of the bridged token depends on the bridge continuing to hold and control the assets backing it. If its contracts are exploited, its reserves are compromised, or its accounting breaks down, users can be left holding tokens that are no longer fully backed.
How CCTP is different
Circle’s Cross-Chain Transfer Protocol (CCTP) takes a different approach. It doesn’t lock USDC and issue a wrapped version. Instead, it burns native USDC on the source chain and mints native USDC on the destination chain. For USDC, there is no locked pool and no wrapped token for the user to hold.
This post uses CCTP V2, which Circle now simply calls CCTP. CCTP V1 (Legacy) is being phased out between October 31 and December 1, 2026. If you are still on V1, see Circle’s migration guide.
In this post, we’ll cover what CCTP is, how the burn-and-mint flow works, and how to integrate it. We’ll start with a full TypeScript example and finish with a simpler Bridge Kit version.
What is Circle’s CCTP?
CCTP (Cross-Chain Transfer Protocol) is Circle’s protocol for moving USDC between blockchains as native USDC, not a wrapped token. CCTP now also supports EURC and registered third-party tokens, but this post focuses on native USDC.
Instead of locking USDC and issuing a synthetic, CCTP:
- Burns USDC on the source chain
- Waits for Circle to observe the burn and issue a signed attestation
- Mints fresh, native USDC on the destination chain
The result is native USDC on every supported chain, not a stack of bridged variants.
How does CCTP work end-to-end?
CCTP combines on-chain contracts with Circle’s off-chain attestation service.
- Burn on source — The app calls the source-chain contract to burn USDC and specify destination chain + recipient.
- Message emitted — The burn event includes metadata (amount, destination, nonce, etc.).
- Attestation — Circle’s attestation service observes the burn and issues a signed attestation once the source chain reaches the finality level you requested (see Fast vs Standard below).
- Mint on destination — The app (or a relayer) submits the attestation to the destination-chain contract to mint USDC to the recipient.
This pattern avoids locked liquidity and keeps one native USDC across chains, with no bridged variants.
How do you transfer USDC across chains with CCTP?
At the contract level, every transfer follows four steps:
-
Source chain: USDC —
approve()
Approve the TokenMessenger to transfer a specified amount of the user’s USDC. -
Source chain: TokenMessenger —
depositForBurn()
Deposit USDC to TokenMessenger. This burns USDC, then MessageTransmitter emits aMessageSentevent. -
Off-chain: Fetch attestation from Circle’s API
Use the message / transaction hash fromMessageSentto poll Circle’s attestation API until the burn is validated and the attestation is ready. -
Destination chain: MessageTransmitter —
receiveMessage()
Callable by any address (unless restricted). Decodes the message, mints native USDC via TokenMessenger, and sends it to the recipient specified in the originaldepositForBurn.
Fast vs Standard Transfer
Normally, a burn-and-mint transfer can’t safely mint until the burn reaches hard finality, because a chain reorganization could undo the burn. Fast Transfer gets around this: Circle attests at soft finality and covers the reorg risk itself through a global Fast Transfer allowance. Each Fast burn debits the allowance and is credited back once it reaches hard finality. If the allowance runs out, Fast Transfers pause until it refills, so fall back to Standard.
The last argument to depositForBurn, minFinalityThreshold, selects the transfer speed. It is a finality level, not an amount or a time: pass 1000 for Fast or 2000 for Standard.
ㅤ
| Fast | Standard | |
|---|---|---|
| minFinalityThreshold | 1000 | 2000 |
| Attestation after | Soft finality (tx included in a block) | Hard finality |
| Typical time | Seconds (~20s on Ethereum) | Minutes (~15–19 min on Ethereum) |
| Circle fee | Per-transfer fee in basis points, set by route | None on most chains (a few, such as Sei, enforce a minimum fee) |
ㅤ
By default, the Fast fee is deducted from the amount minted on the destination chain. Circle also supports paying it upfront on the source chain, so the recipient gets the full amount. maxFee caps the fee, in token subunits. If maxFee is below the current Fast fee, the transfer won’t go through as Fast. It may revert, or it may be downgraded to a Standard Transfer. Fees change, so don’t hardcode them. Before each burn, fetch the current rate from GET /v2/burn/USDC/fees/{sourceDomain}/{destDomain}, convert it to subunits for your amount, and add a small buffer. Gas is paid separately on each chain, so the wallet that submits the mint needs native gas on the destination chain. Circle’s optional Forwarding Service, which submits the mint for you, adds its own fee.
High-level integration checklist
- Collect transfer params: source chain, destination domain/chain ID, recipient, amount
- Execute source burn
- Fetch attestation (or let a relayer do it)
- Submit mint on destination
- Confirm and surface status to the user
Implementation tips:
- Abstract chain-specific details behind an adapter so new chains don’t touch core flows
- Build an idempotent “resume” step for attestation retrieval and mint submission
- Emit and index your own transfer IDs for reconciliation and support
⚠️ Method names, domains, and contract addresses vary by network and CCTP version. Treat examples as templates and verify against Circle’s official docs before shipping.
How do you integrate CCTP with TypeScript (viem)?
Below is a CCTP V2 Fast Transfer template from Sepolia to Arc testnet. Replace addresses, domains, and endpoints for your target networks.
If this example looks lengthy, don't drop off. The next section shows the same flow with Bridge Kit SDK in just a few lines.
// Import environment variables
import "dotenv/config";
import { createWalletClient, createPublicClient, http, encodeFunctionData } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { arcTestnet, sepolia } from "viem/chains";
import axios from "axios";
// ============ Configuration Constants ============
const PRIVATE_KEY = process.env.PRIVATE_KEY;
if (!PRIVATE_KEY) throw new Error("PRIVATE_KEY missing");
const account = privateKeyToAccount(`0x${PRIVATE_KEY.replace(/^0x/, "")}`);
const ETHEREUM_SEPOLIA_USDC = "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238";
const ETHEREUM_SEPOLIA_TOKEN_MESSENGER =
"0x8fe6b999dc680ccfdd5bf7eb0974218be2542daa";
const ARC_TESTNET_MESSAGE_TRANSMITTER =
"0xe737e5cebeeba77efe34d4aa090756590b1ce275";
const DESTINATION_ADDRESS = account.address;
const AMOUNT = 1_000_000n; // 1 USDC (6 decimals)
const maxFee = 500n; // 500 subunits = 0.0005 USDC (5 bps of 1 USDC). In production, fetch the fee and add a buffer.
const DESTINATION_ADDRESS_BYTES32 = `0x000000000000000000000000${DESTINATION_ADDRESS.slice(2)}` as const;
const DESTINATION_CALLER_BYTES32 =
"0x0000000000000000000000000000000000000000000000000000000000000000";
const ETHEREUM_SEPOLIA_DOMAIN = 0;
const ARC_TESTNET_DOMAIN = 26;
const sepoliaClient = createWalletClient({
chain: sepolia,
transport: http(),
account,
});
const arcClient = createWalletClient({
chain: arcTestnet,
transport: http(),
account,
});
const sepoliaPublic = createPublicClient({ chain: sepolia, transport: http() });
const arcPublic = createPublicClient({ chain: arcTestnet, transport: http() });
async function approveUSDC() {
console.log("Approving USDC transfer...");
const approveTx = await sepoliaClient.sendTransaction({
to: ETHEREUM_SEPOLIA_USDC,
data: encodeFunctionData({
abi: [
{
type: "function",
name: "approve",
stateMutability: "nonpayable",
inputs: [
{ name: "spender", type: "address" },
{ name: "amount", type: "uint256" },
],
outputs: [{ name: "", type: "bool" }],
},
],
functionName: "approve",
args: [ETHEREUM_SEPOLIA_TOKEN_MESSENGER, 10_000_000_000n],
}),
});
// Wait for the approval to be mined before burning
await sepoliaPublic.waitForTransactionReceipt({ hash: approveTx });
console.log(`USDC Approval Tx: ${approveTx}`);
}
async function burnUSDC() {
console.log("Burning USDC on Ethereum Sepolia...");
const burnTx = await sepoliaClient.sendTransaction({
to: ETHEREUM_SEPOLIA_TOKEN_MESSENGER,
data: encodeFunctionData({
abi: [
{
type: "function",
name: "depositForBurn",
stateMutability: "nonpayable",
inputs: [
{ name: "amount", type: "uint256" },
{ name: "destinationDomain", type: "uint32" },
{ name: "mintRecipient", type: "bytes32" },
{ name: "burnToken", type: "address" },
{ name: "destinationCaller", type: "bytes32" },
{ name: "maxFee", type: "uint256" },
{ name: "minFinalityThreshold", type: "uint32" },
],
outputs: [],
},
],
functionName: "depositForBurn",
args: [
AMOUNT,
ARC_TESTNET_DOMAIN,
DESTINATION_ADDRESS_BYTES32,
ETHEREUM_SEPOLIA_USDC,
DESTINATION_CALLER_BYTES32,
maxFee,
1000, // minFinalityThreshold: 1000 = Fast, 2000 = Standard
],
}),
});
const burnReceipt = await sepoliaPublic.waitForTransactionReceipt({ hash: burnTx });
if (burnReceipt.status !== "success") throw new Error(`Burn reverted: ${burnTx}`);
console.log(`Burn Tx: ${burnTx}`);
return burnTx;
}
async function retrieveAttestation(transactionHash: `0x${string}`) {
console.log("Retrieving attestation...");
const url = `https://iris-api-sandbox.circle.com/v2/messages/${ETHEREUM_SEPOLIA_DOMAIN}?transactionHash=${transactionHash}`;
while (true) {
try {
const response = await axios.get(url);
if (response.data?.messages?.[0]?.status === "complete") {
console.log("Attestation retrieved successfully!");
return response.data.messages[0];
}
console.log("Waiting for attestation...");
await new Promise((resolve) => setTimeout(resolve, 5000));
} catch (error: any) {
console.error("Error fetching attestation:", error.message);
await new Promise((resolve) => setTimeout(resolve, 5000));
}
}
}
async function mintUSDC(attestation: {
message: `0x${string}`;
attestation: `0x${string}`;
}) {
console.log("Minting USDC on Arc testnet...");
const mintTx = await arcClient.sendTransaction({
to: ARC_TESTNET_MESSAGE_TRANSMITTER,
data: encodeFunctionData({
abi: [
{
type: "function",
name: "receiveMessage",
stateMutability: "nonpayable",
inputs: [
{ name: "message", type: "bytes" },
{ name: "attestation", type: "bytes" },
],
outputs: [{ name: "success", type: "bool" }],
},
],
functionName: "receiveMessage",
args: [attestation.message, attestation.attestation],
}),
});
const mintReceipt = await arcPublic.waitForTransactionReceipt({ hash: mintTx });
if (mintReceipt.status !== "success") throw new Error(`Mint reverted: ${mintTx}`);
console.log(`Mint Tx: ${mintTx}`);
}
async function main() {
await approveUSDC();
const burnTx = await burnUSDC();
const attestation = await retrieveAttestation(burnTx);
await mintUSDC(attestation);
console.log("USDC transfer completed!");
}
main().catch(console.error);
{
type: "function",
name: "depositForBurn",
stateMutability: "nonpayable",
inputs: [
{ name: "amount", type: "uint256" },
{ name: "destinationDomain", type: "uint32" },
{ name: "mintRecipient", type: "bytes32" },
{ name: "burnToken", type: "address" },
{ name: "destinationCaller", type: "bytes32" },
{ name: "maxFee", type: "uint256" },
{ name: "minFinalityThreshold", type: "uint32" },
],
outputs: [],
},
],
functionName: "depositForBurn",
args: [
AMOUNT,
ARC_TESTNET_DOMAIN,
DESTINATION_ADDRESS_BYTES32,
ETHEREUM_SEPOLIA_USDC,
DESTINATION_CALLER_BYTES32,
maxFee,
1000, // Fast Transfer threshold example
],
}),
});
console.log(`Burn Tx: ${burnTx}`);
return burnTx;
}
async function retrieveAttestation(transactionHash: `0x${string}`) {
console.log("Retrieving attestation...");
const url = `https://iris-api-sandbox.circle.com/v2/messages/${ETHEREUM_SEPOLIA_DOMAIN}?transactionHash=${transactionHash}`;
while (true) {
try {
const response = await axios.get(url);
if (response.data?.messages?.[0]?.status === "complete") {
console.log("Attestation retrieved successfully!");
return response.data.messages[0];
}
console.log("Waiting for attestation...");
await new Promise((resolve) => setTimeout(resolve, 5000));
} catch (error: any) {
console.error("Error fetching attestation:", error.message);
await new Promise((resolve) => setTimeout(resolve, 5000));
}
}
}
async function mintUSDC(attestation: {
message: `0x${string}`;
attestation: `0x${string}`;
}) {
console.log("Minting USDC on Arc testnet...");
const mintTx = await arcClient.sendTransaction({
to: ARC_TESTNET_MESSAGE_TRANSMITTER,
data: encodeFunctionData({
abi: [
{
type: "function",
name: "receiveMessage",
stateMutability: "nonpayable",
inputs: [
{ name: "message", type: "bytes" },
{ name: "attestation", type: "bytes" },
],
outputs: [],
},
],
functionName: "receiveMessage",
args: [attestation.message, attestation.attestation],
}),
});
console.log(`Mint Tx: ${mintTx}`);
}
async function main() {
await approveUSDC();
const burnTx = await burnUSDC();
const attestation = await retrieveAttestation(burnTx);
await mintUSDC(attestation);
console.log("USDC transfer completed!");
}
main().catch(console.error);
Minimal end-to-end flow (no SDK)
- Approve USDC spend to the CCTP source contract
- Call the source contract to burn/initiate transfer with destination domain + recipient
- Retrieve message identity from event logs (attestation timing depends on Fast vs Standard)
- Poll Circle’s attestation endpoint until ready
- Submit attestation + message on destination to mint native USDC
- Surface source burn tx, attestation status, and destination mint tx in the UI
Too much code? Use Bridge Kit
If hand-rolling approvals, burns, attestation polling, and mints feels heavy, Bridge Kit wraps the same CCTP flow with less boilerplate.
- What it is — A higher-level toolkit over TokenMessenger / MessageTransmitter and Circle attestation retrieval
- Why use it — Fewer moving parts, consistent interfaces, faster time-to-market
- Same security model — Still
approve→depositForBurn→ attestation →receiveMessage
- Optional integrator fee — Some setups let integrators capture revenue per transfer
- Destination gas — The wallet still needs native gas on the destination chain to mint. Bridge Kit checks the source USDC balance, not destination gas
- Production tip — Still log burn tx hash, attestation status, and mint tx hash for support
import "dotenv/config";
import { BridgeKit } from "@circle-fin/bridge-kit";
import { createViemAdapterFromPrivateKey } from "@circle-fin/adapter-viem-v2";
import { inspect } from "util";
const kit = new BridgeKit();
const bridgeUSDC = async (): Promise<void> => {
try {
const adapter = createViemAdapterFromPrivateKey({
privateKey: process.env.PRIVATE_KEY as string,
});
console.log("---------------Starting Bridging---------------");
const result = await kit.bridge({
from: { adapter, chain: "Arc_Testnet" },
to: { adapter, chain: "Base_Sepolia" },
amount: "1.00",
});
console.log("RESULT", inspect(result, false, null, true));
} catch (err) {
console.log("ERROR", inspect(err, false, null, true));
}
};
void bridgeUSDC();
What does a CCTP transfer look like operationally?
- User experience — One “Send USDC cross-chain” action; show burn tx, attestation status, and mint tx
- Monitoring — Track burn events, attestation latency (seconds for Fast, minutes for Standard), and mint success/failure
- Retries — Safe, idempotent retries for attestation fetch and mint submission (nonces / message uniqueness)
Common pitfalls and best practices
- Finality assumptions — Even Fast Transfers wait for soft finality, and Standard Transfers can take minutes or, on some chains, hours. Poll the attestation API; don’t assume a fixed delay
- Address formats — Validate destination formats (EVM vs non-EVM) before burning
- Fees and gas — Fast Transfers carry a Circle fee. Standard Transfers are free on most chains. Set maxFee from the fees API, not a constant. Gas is paid separately on both chains, so consider sponsorship or clear UX hints
- Irreversibility and trust — Once USDC is burned, the transfer can’t be undone. Validate the recipient and domain first. Minting also depends on Circle’s attestation service being available
- Error handling — Separate attestation-not-ready vs invalid attestation vs mint-reverted
- Observability — Log the full lifecycle (burn → attestation → mint) with correlation IDs
When should you choose CCTP?
Use CCTP when:
- Users expect native USDC on the destination chain
- You want to minimize bridge liquidity and redemption risk
- You need predictable UX and simpler USDC accounting across chains
Consider other options when:
- You’re moving assets CCTP doesn’t support (check Circle’s supported asset list)
- You need full cross-chain messaging. CCTP can pass messages and attach hook data, but it isn’t a general-purpose messaging protocol
Resources
CCTP Overview - developers.circle.com/cctp
CCTP API Reference - developers.circle.com/api-reference/cctp
Bridge Kit Docs - developers.circle.com/bridge-kit
Bridge Kit npm - @circle-fin/bridge-kit
FAQs
1. What is Circle’s CCTP?
CCTP is Circle’s Cross-Chain Transfer Protocol for moving USDC between blockchains by burning on the source chain and minting native USDC on the destination after an attestation.
2. How is CCTP different from a normal bridge?
Many bridges lock tokens and mint wrapped copies. For USDC, CCTP burns on the source chain and mints native USDC on the destination, which avoids wrapped-asset fragmentation.
3. What are the main steps in a CCTP transfer?
Approve USDC, call depositForBurn on the source chain, fetch Circle’s attestation, then call receiveMessage on the destination chain to mint USDC.
4. Do I need to write all the low-level contract calls myself?
No. You can integrate directly with CCTP contracts, or use Bridge Kit to wrap approvals, burns, attestation polling, and mints.
5. Why isn’t the attestation available immediately after the burn?
Circle issues the attestation only after the burn reaches the finality level you chose. Fast Transfers wait for soft finality, usually seconds. Standard Transfers wait for hard finality, usually minutes. Poll until the status is complete, then submit the mint.
6. When should I not use CCTP?
If you need to move an asset CCTP doesn’t support, a different bridge may fit better. CCTP supports message passing and hooks, but a dedicated messaging protocol is better suited to full cross-chain messaging.