> ## Documentation Index
> Fetch the complete documentation index at: https://docs.plasma.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Bridge USDC with Bridge Kit

> Transfer native USDC to and from Plasma using Circle Bridge Kit.

Connect Bridge Kit to move native USDC from CCTP-supported chains to Plasma, or from Plasma to another supported chain.

[Circle's Cross-Chain Transfer Protocol (CCTP)](https://developers.circle.com/cctp) enables native USDC transfers across blockchains through a secure burn-and-mint mechanism, without wrapped assets or liquidity pools.

With [Bridge Kit](https://developers.circle.com/bridge-kit), you can integrate CCTP-powered transfers into Plasma applications with a lightweight SDK that abstracts contract interactions, attestations, and the full transfer flow into a few lines of code.

## Supported Networks

Bridge Kit supports bridging between Plasma and other [CCTP v2 chains](https://developers.circle.com/cctp/concepts/supported-chains-and-domains).

## Prerequisites

Before you begin, you must have:

* Node.js 20+
* A funded wallet with:
  * Native USDC on the source chain (use the [Circle Faucet](https://faucet.circle.com/) for testnet)
  * Gas on the source chain (for example, ETH on Ethereum Sepolia)
  * `XPL` on Plasma for destination gas when your wallet signs the mint step ([get testnet XPL](https://docs.plasma.org/docs/guides/testing-and-resources/get-test-tokens.md))
* Plasma added to your wallet. See [Browser Wallet Setup](https://docs.plasma.org/docs/guides/asset-management/browser-wallet-setup.md).

## Get Started

**1. Install Bridge Kit**

Install Bridge Kit and the Viem adapter for EVM chains, including Plasma:

```bash npm theme={null}
npm install @circle-fin/bridge-kit @circle-fin/adapter-viem-v2 viem
```

```bash yarn theme={null}
yarn add @circle-fin/bridge-kit @circle-fin/adapter-viem-v2 viem
```

```bash pnpm theme={null}
pnpm add @circle-fin/bridge-kit @circle-fin/adapter-viem-v2 viem
```

**2. Create an adapter**

Create one Viem adapter from a private key. The same adapter works across EVM chains, including Plasma:

```typescript theme={null}
import { BridgeKit } from "@circle-fin/bridge-kit";
import { createViemAdapterFromPrivateKey } from "@circle-fin/adapter-viem-v2";

const kit = new BridgeKit();

const adapter = createViemAdapterFromPrivateKey({
  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
});
```

> [!TIP]
>
> For browser wallets such as MetaMask, Rabby, or Trust Wallet, use `createViemAdapterFromProvider` with your EIP-1193 provider instead of a private key. See the [Bridge Kit documentation](https://developers.circle.com/bridge-kit).

> [!TIP]
>
> Bridging to or from Solana? Install `@circle-fin/adapter-solana-kit` and create a Solana adapter for that side of the transfer. Keep the Viem adapter for Plasma and other EVM chains. Pass both adapters into `kit.bridge()`, for example `from: { adapter: solanaAdapter, chain: "Solana" }` and `to: { adapter, chain: "Plasma" }`.

**3. Bridge USDC to Plasma**

Estimate fees, then bridge. This example moves 1 USDC from Ethereum Sepolia to Plasma Testnet:

```typescript theme={null}
// Optional: preview gas and protocol fees
const estimate = await kit.estimate({
  from: { adapter, chain: "Ethereum_Sepolia" },
  to: { adapter, chain: "Plasma_Testnet" },
  amount: "1.00",
});
console.dir(estimate, { depth: null });

// Transfer 1.00 USDC to Plasma Testnet
const result = await kit.bridge({
  from: { adapter, chain: "Ethereum_Sepolia" },
  to: { adapter, chain: "Plasma_Testnet" },
  amount: "1.00",
});

console.dir(result, { depth: null });
```

For mainnet, swap the chain identifiers:

```typescript theme={null}
const result = await kit.bridge({
  from: { adapter, chain: "Ethereum" },
  to: { adapter, chain: "Plasma" },
  amount: "10.00",
});
```

**4. Monitor the transfer**

Subscribe to lifecycle events to track approval, burn, attestation, and mint:

```typescript theme={null}
kit.on("*", (event) => {
  console.log(`[${event.method}]`, event.values);
});
```

After `kit.bridge()` resolves, inspect `result.steps` for transaction hashes and explorer URLs for each completed step.

**5. Verify on Plasma**

1. Open the mint step's `explorerUrl`, or search the destination transaction hash on [Plasma Explorer](https://plasmascan.to/) or [Plasma Testnet Explorer](https://testnet.plasmascan.to/).
2. Confirm native USDC arrived at your wallet on Plasma.
3. Confirm `result.state` is `success`.

## Bridge from Plasma

The same kit call works in reverse. Burn USDC on Plasma and mint it on another CCTP chain:

```typescript theme={null}
const result = await kit.bridge({
  from: { adapter, chain: "Plasma" },
  to: { adapter, chain: "Base" },
  amount: "10.00",
});
```

## Troubleshooting

### Route Not Supported

Confirm both chains are available in Bridge Kit and that you are using the correct chain identifiers (`Plasma`, `Plasma_Testnet`). Check [supported chains and domains](https://developers.circle.com/cctp/concepts/supported-chains-and-domains).

### Insufficient Balance or Gas

* The source chain needs enough native USDC for the transfer amount, plus any Fast Transfer fee.
* The source chain needs native gas, such as ETH, for the approval and burn transactions.
* The destination Plasma wallet needs `XPL` when your adapter signs the mint transaction.

### Transaction Stuck or Failed

* Confirm RPC connectivity for both chains. Prefer a private Plasma RPC from an [RPC provider](https://docs.plasma.org/docs/plasma-chain/tools/rpc-providers.md) in production.
* Inspect `result.steps` to see which stage failed. Resume actionable failures with `kit.retry(result, { from: adapter, to: adapter })`.
* Check network status on the [Plasma status page](https://statuspage.incident.io/plasmanetwork).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.