Bridge USDC Cross-Chain with CCTP

Use a Para wallet with Circle Bridge Kit to move USDC between EVM chains, Solana, and other CCTP networks such as Arc.

Bridge native USDC between chains with Circle’s CCTP V2. CCTP burns USDC on the source chain, waits for Circle’s attestation, and mints the same amount on the destination chain. Para authenticates the user and signs on both sides of the route. Bridge Kit handles the approval, burn, attestation, and mint steps.

This guide bridges from Ethereum to Arc. The same hooks cover any supported route: change the from and to chains to bridge between EVM chains, or between an EVM chain and Solana.

Choose a route

Para wallets cover the main CCTP chain families. The route you pick determines which Para wallet signs each side and how you submit the transfer.

Para wallet	CCTP networks	How to bridge
EVM	Ethereum, Base, Arbitrum, OP Mainnet, Polygon PoS, Avalanche, Arc, and other EVM chains	Bridge Kit with a Para viem adapter
Solana	Solana	Bridge Kit with a Para Solana adapter
Sui	Sui	Circle’s Sui CCTP packages with the Para Sui signer
Stellar	Stellar	Circle’s Stellar CCTP contracts with the Para Stellar signer

Bridge Kit’s BridgeChain enum lists every chain it can route. A route only needs both chains in that list and an adapter for each side.

Each CCTP network has a protocol domain ID, such as 0 for Ethereum, 5 for Solana, 8 for Sui, 26 for Arc, and 27 for Stellar. Domain IDs are not EVM chain IDs. Bridge Kit’s chain definitions carry the domains and CCTP contract addresses, so the example does not hardcode them.

Before you start

Start with a Next.js app that has ParaProvider, a login flow, and a wallet for each chain family in your route. These Para guides cover that setup:

The wallet needs native USDC on the source chain and gas on both chains. The source chain pays for the approval and burn, and the destination chain pays for the mint. For Ethereum to Arc, that means ETH on Ethereum and USDC on Arc, since Arc uses USDC as its gas token. A Solana destination needs SOL for fees and for the USDC token account if the wallet does not have one yet. Review the transfer amount and network fees with the user before submitting a mainnet transaction.

Install the bridge packages

From your Para Next.js application, install Bridge Kit, Circle’s viem adapter, and the Para viem integration. The versions below are the ones used for this guide.

npm install @circle-fin/bridge-kit@1.15.2 @circle-fin/adapter-viem-v2@1.19.0 @getpara/viem-v2-integration@3.21.0 viem@2.57.3

For routes that start or end on Solana, also install Circle’s Solana adapter and the Para Solana signer.

npm install @circle-fin/adapter-solana@1.7.4 @getpara/solana-web3.js-v1-integration@3.21.0 @solana/web3.js@1.99.0

Set an RPC URL for each chain in your routes, such as NEXT_PUBLIC_ETHEREUM_RPC_URL, NEXT_PUBLIC_BASE_RPC_URL, NEXT_PUBLIC_ARC_RPC_URL, and NEXT_PUBLIC_SOLANA_RPC_URL. The values are public browser configuration, so do not put private RPC credentials in them.

Connect Para to Bridge Kit

Use and inside your existing ParaProvider to check the signed-in Para wallet. Confirm the session with .

For EVM chains, selects the EVM wallet, and gives Circle’s ViemAdapter a wallet client for each chain. Every EVM chain uses the same Para account. For Solana, signs the transactions Circle’s Solana adapter builds. createAdapter() returns the adapter that matches a chain’s type.

src/hooks/useCctpAdapter.ts

"use client";

import { useAccount, useClient } from "@getpara/react-sdk";
import {
  createParaViemAccount,
  createParaViemClient,
} from "@getpara/viem-v2-integration";
import { ParaSolanaWeb3Signer } from "@getpara/solana-web3.js-v1-integration";
import { ViemAdapter } from "@circle-fin/adapter-viem-v2";
import { createSolanaAdapterFromProvider } from "@circle-fin/adapter-solana";
import type { ChainDefinition } from "@circle-fin/bridge-kit";
import { Arc, Base, Ethereum, Solana } from "@circle-fin/bridge-kit/chains";
import { Connection, Transaction, VersionedTransaction } from "@solana/web3.js";
import { createPublicClient, http } from "viem";

const evmChains = [Ethereum, Base, Arc];

const evmRpcUrls: Record<number, string | undefined> = {
  [Ethereum.chainId]: process.env.NEXT_PUBLIC_ETHEREUM_RPC_URL,
  [Base.chainId]: process.env.NEXT_PUBLIC_BASE_RPC_URL,
  [Arc.chainId]: process.env.NEXT_PUBLIC_ARC_RPC_URL,
};
const solanaRpcUrl = process.env.NEXT_PUBLIC_SOLANA_RPC_URL;

function evmRpcFor(chainId: number) {
  const rpc = evmRpcUrls[chainId];
  if (!rpc) throw new Error(`Missing RPC URL for chain ${chainId}`);
  return rpc;
}

export function useCctpAdapter() {
  const para = useClient();
  const { isConnected } = useAccount();

  async function requireSession() {
    if (!para || !isConnected || !(await para.isFullyLoggedIn())) {
      throw new Error("Sign in with Para before bridging USDC");
    }
    return para;
  }

  async function createEvmAdapter(): Promise<ViemAdapter> {
    const para = await requireSession();
    const account = createParaViemAccount({ para });

    return new ViemAdapter(
      {
        getPublicClient: ({ chain }) =>
          createPublicClient({ chain, transport: http(evmRpcFor(chain.id)) }),
        getWalletClient: ({ chain }) =>
          createParaViemClient({
            para,
            walletClientConfig: {
              account,
              chain,
              transport: http(evmRpcFor(chain.id)),
            },
          }),
      },
      { addressContext: "user-controlled", supportedChains: evmChains },
    );
  }

  async function createSolanaAdapter() {
    const para = await requireSession();
    if (!solanaRpcUrl) throw new Error("Missing Solana RPC URL");

    const connection = new Connection(solanaRpcUrl, "confirmed");
    const signer = new ParaSolanaWeb3Signer(para, connection);
    const publicKey = signer.sender;
    if (!publicKey) throw new Error("Create a Solana wallet before bridging");

    async function signTransaction(transaction: unknown) {
      if (transaction instanceof VersionedTransaction) {
        return signer.signVersionedTransaction(transaction);
      }
      if (transaction instanceof Transaction) {
        return signer.signTransaction(transaction);
      }
      throw new Error("Unsupported Solana transaction");
    }

    return createSolanaAdapterFromProvider({
      connection,
      provider: {
        isConnected: true,
        publicKey,
        connect: async () => ({ publicKey }),
        disconnect: async () => {},
        signTransaction,
        signAllTransactions: (transactions) =>
          Promise.all(transactions.map(signTransaction)),
      },
      capabilities: { addressContext: "user-controlled", supportedChains: [Solana] },
    });
  }

  function createAdapter(chain: ChainDefinition) {
    return chain.type === "solana" ? createSolanaAdapter() : createEvmAdapter();
  }

  return { createAdapter };
}

If every route stays on EVM chains, drop createSolanaAdapter() and the Solana packages. To add another EVM chain, import its definition from @circle-fin/bridge-kit/chains, add it to evmChains, and add its RPC URL to evmRpcUrls.

Keep the authenticated Para session available until the bridge finishes. Do not replace the Para signer with a private-key viem account or Solana keypair: that would bypass Para signing.

Bridge USDC

Call bridgeUsdc() in response to a user action. Bridge Kit uses CCTP V2 to burn USDC on the source chain, waits for Circle’s attestation, then mints USDC on the destination chain. Setting useForwarder: false keeps the destination mint signed by Para. The result contains each step and the overall state. amount is a human-readable USDC amount.

src/hooks/useCctpBridge.ts

"use client";

import {
  BridgeKit,
  type BridgeResult,
  type ChainDefinition,
} from "@circle-fin/bridge-kit";
import { useCctpAdapter } from "./useCctpAdapter";

type BridgeRoute = {
  from: ChainDefinition;
  to: ChainDefinition;
  amount: string;
};

function summarize(result: BridgeResult) {
  const burn = result.steps.find(
    (step) => step.name === "burn" || step.name === "depositForBurn",
  );
  const mint = result.steps.find((step) => step.name === "mint");

  return {
    status:
      result.state === "error"
        ? "needs_attention"
        : result.state === "success" &&
            burn?.state === "success" &&
            burn.txHash &&
            mint?.state === "success" &&
            mint.txHash
          ? "complete"
          : "pending",
    failedStep: result.steps.find((step) => step.state === "error"),
    sourceBurn: burn?.txHash,
    sourceExplorer: burn?.explorerUrl,
    destinationMint: mint?.txHash,
    destinationExplorer: mint?.explorerUrl,
  };
}

export function useCctpBridge() {
  const { createAdapter } = useCctpAdapter();

  async function bridgeUsdc({ from, to, amount }: BridgeRoute) {
    const kit = new BridgeKit();
    kit.on("*", (event) => console.info(event.method, event.values));

    const result = await kit.bridge({
      from: { adapter: await createAdapter(from), chain: from },
      to: { adapter: await createAdapter(to), chain: to, useForwarder: false },
      amount,
      token: "USDC",
    });
    return { result, ...summarize(result) };
  }

  async function resumeTransfer(result: BridgeResult) {
    if (result.state !== "error") return { result, ...summarize(result) };

    const resumed = await new BridgeKit().retry(result, {
      from: await createAdapter(result.source.chain),
      to: await createAdapter(result.destination.chain),
    });
    return { result: resumed, ...summarize(resumed) };
  }

  return { bridgeUsdc, resumeTransfer };
}

In a client component, pass the route from a transfer button. The chain definitions come from @circle-fin/bridge-kit/chains:

bridgeUsdc({ from: Ethereum, to: Arc, amount: "1.00" });

bridgeUsdc() returns the Bridge Kit result and a summary with status, failedStep, and the burn and mint transaction hashes and explorer links. Show a transfer as complete only when status is complete. For a failed transfer, read failedStep?.name and failedStep?.errorMessage. Handle errors thrown before Bridge Kit returns a result separately. The fetchAttestation event records progress between the burn and mint; it is not itself an onchain transaction.

Change the route

The route is the only part of the call that changes. Each side uses the Para wallet for that chain’s type, so a single signed-in user can bridge in any direction the app supports.

bridgeUsdc({ from: Base, to: Arc, amount: "1.00" });
bridgeUsdc({ from: Ethereum, to: Solana, amount: "1.00" });
bridgeUsdc({ from: Solana, to: Base, amount: "1.00" });

Between EVM chains, both sides use the same Para EVM address. Between EVM and Solana, the burn and mint use the user’s Para EVM and Solana addresses, so the user needs both wallet types before starting the transfer.

Bridge with Sui or Stellar

CCTP also supports Sui and Stellar, and Para signs on both. Bridge Kit does not include Sui or Stellar in its chain list, so these routes use Circle’s chain-specific CCTP integration instead of bridgeUsdc(). The Para Sui and Stellar signers build and sign those transactions with the user’s Para wallet.

On Stellar, USDC precision and address encoding differ from other CCTP networks. Follow Circle’s Stellar guidance for incoming transfers so the minted USDC reaches the correct recipient.

Circle’s page lists the contracts and features for each network.

Resume an interrupted transfer

If result.state is error, inspect result.steps before asking the user to try again. An approved or burned transfer may already have spent gas or destroyed the source USDC. Keep that result and pass it to resumeTransfer(result) from a separate Resume action. The hook reads the source and destination chains from the result, creates fresh authenticated Para adapters for both, and returns the updated result and status summary.

Do not start a second bridge() call to recover a transfer whose burn succeeded. If a retry still fails, keep the burn transaction hash and investigate the failed step before attempting another transaction. A pending result is not a confirmed destination mint.

Check the route

For a production check, record both the source burn transaction and the destination mint transaction from the same Bridge Kit result. The source receipt alone confirms only the burn. The destination explorer receipt confirms the mint. For a testnet trial before using mainnet funds, swap in testnet chain definitions such as EthereumSepolia, BaseSepolia, ArcTestnet, and SolanaDevnet, or follow Circle’s . Circle’s covers fees, supported routes, and recovery behavior.

Keep building with Para

Use the same signed-in Para wallets for other actions on each chain: