> ## Documentation Index
> Fetch the complete documentation index at: https://a-identity.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Build on Arc

> Connect to Circle Arc, where agents pay gas in USDC. Network config, App Kit unified balance, and deploy steps.

Arc is an EVM chain from Circle where **gas is paid in USDC**, not a volatile native
token, with sub-second deterministic finality. For an agent that just wants to pay
for a thing, that removes a whole class of failure. A-Identity uses Arc as its
primary settlement rail.

> **[Integrate on Arc Mainnet in 10 minutes](/chains/arc-integration)**
>
> Buy a trust check through Circle Gateway nanopayments before your agent pays: the 402,
> the payment, the verdict, and where your payments show up as external on /proof/arc.

![A USDC coin pays gas as Arc produces blocks](https://mintcdn.com/a-identity/AqdIo8YmYME-DxJC/images/arc-gas.svg?fit=max\&auto=format\&n=AqdIo8YmYME-DxJC\&q=85\&s=74676fea650bae5a98711c2d910311ab)

## Why Arc

> **USDC is the gas**
>
> No second token to hold, price, or refill. The agent pays fees in the same dollar it is already moving.

> **Sub-second finality**
>
> Deterministic finality in well under a second. The payment either happened or it did not, and the agent knows at once.

> **EVM compatible**
>
> Standard Ethereum bytecode and RPC. ERC-8004 identity and x402 payments port over with no rewrite.

> [!NOTE]
>
> Arc Mainnet opened on 2026-09-16 and A-Identity went live on it that day (see
> [Arc Mainnet](#arc-mainnet) below). Escrow, KYA anchoring and the account-abstraction
> path still run on **Arc Testnet**, and the rest of this page targets it unless a section
> says Mainnet. Get testnet USDC from
> the [Circle faucet](https://faucet.circle.com). What we did here is on the
> record: agent #849980, the KYA attestation and the first reputation anchor our oracle
> ever wrote are each listed with their transaction at
> [/proof/arc](https://a-identity.xyz/proof/arc), and the index over every chain is at
> [/proof](https://a-identity.xyz/proof).

## Network Config

| Field | Value |
| - | - |
| Chain ID | `5042002` |
| Native currency | USDC (18 decimals) |
| RPC (HTTP) | `https://rpc.testnet.arc.io` |
| RPC (WebSocket) | `wss://rpc.testnet.arc.io` |
| Block explorer | [explorer.testnet.arc.io](https://explorer.testnet.arc.io) |
| Faucet | [faucet.circle.com](https://faucet.circle.com) |

> [!WARNING]
>
> Arc has a **dual USDC interface**: the native balance uses 18 decimals while the
> ERC-20 interface uses 6. Both point at the same underlying balance. Set
> display decimals correctly or amounts will look off by a factor of a trillion.

## Arc Mainnet

Arc Mainnet is in the registry as `arc-mainnet` with status **live** since 2026-09-16, the
day it opened: agent #0 on the canonical registry is ours, an AgentSpendPolicy vault
(`0xe07819e6d28a5dfd5a9f4cd94dc6dc9aeeda4146`) holds real USDC under dust caps, and paid
calls settled through both our EIP-3009 facilitator and Circle Gateway nanopayments. Every
payment so far is self-funded and labeled internal; each transaction is listed at
[/proof/arc](https://a-identity.xyz/proof/arc). It is a separate descriptor from the testnet on purpose,
with its own signer variable (`ARC_MAINNET_SIGNER_KEY`), so a testnet key can never become
a mainnet key by a rename.

| Field | Value |
| - | - |
| Chain ID | `5042` |
| RPC (HTTP) | `https://rpc.mainnet.arc.io` (plus Blockdaemon, dRPC and QuickNode hosts under `mainnet.arc.io`) |
| Block explorer | [explorer.arc.io](https://explorer.arc.io), pages open in a browser; its JSON API challenges non-browser clients |
| USDC (ERC-20 interface) | `0x3600000000000000000000000000000000000000`, the same predeploy address as testnet |
| ERC-8004 identity | `0x8004a169fb4a3325136eb29fa0ceb6d2e539a432` |
| ERC-8004 reputation | `0x8004BAa17C55a88189AE136b182e5fdA19dE9b63` |
| CCTP V2 | domain `26`, TokenMessengerV2 `0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d` |
| Circle Gateway | GatewayWallet `0x77777777Dcc4d5A8B6E418Fd04D8997ef11000eE` |

> [!WARNING]
>
> The ERC-8004 registries on Arc Mainnet are **not** the testnet addresses. The testnet
> set (`0x8004A818...`) has no code on mainnet; mainnet carries the canonical family that
> Base, Arbitrum One, X Layer and Celo share. A 130-byte proxy at an address proves
> nothing by itself, so the pair was checked by reading each proxy's EIP-1967
> implementation slot and matching the implementation code against Base. Mainnet does
> carry a ValidationRegistry from the same family (`0x8004Cc8439f36fd5F9F049D9fF86523Df6dAAB58`,
> listed by docs.arc.io and read live on 2026-10-11), but A-Identity does not wire it yet,
> so KYA is not anchored on mainnet. Arc's reference ERC-8183 contract is documented for
> testnet only.

What stays on testnet until it has its own evidence: Circle developer-controlled wallets
(Circle's Wallets table lists the `ARC` mainnet chain code, but our wallet path has not
created or used one there yet), Paymaster (Circle's Paymaster addresses page lists no Arc
network, and its v0.7 and v0.8 addresses have no code on Arc mainnet), the
account-abstraction path, the treasury and airdrop demos, and ERC-8183 escrow (Arc's
reference contract has code on testnet and none on mainnet). docs.arc.io says the primary
mainnet RPC accepts anonymous requests with no API key, and `ARC_MAINNET_RPC_URL` takes a
provider endpoint of your own if you want one. Not every host keeps old history: on
2026-10-11 the Blockdaemon mainnet host returned none of the Arc Mainnet receipts at /proof/arc, while
the primary, dRPC and QuickNode returned all of them. The explorer's pages open in a
browser without signing in; only its JSON API answers non-browser clients with a bot
challenge.

## Connect With viem

```ts chain.ts theme={null}
import { defineChain } from 'viem'

export const arcTestnet = defineChain({
  id: 5042002,
  name: 'Arc Testnet',
  nativeCurrency: { name: 'USD Coin', symbol: 'USDC', decimals: 18 },
  rpcUrls: {
    default: {
      http: ['https://rpc.testnet.arc.io'],
      webSocket: ['wss://rpc.testnet.arc.io'],
    },
  },
  blockExplorers: {
    default: { name: 'Arc Testnet Explorer', url: 'https://explorer.testnet.arc.io' },
  },
  testnet: true,
})
```

```ts read.ts theme={null}
import { createPublicClient, http } from 'viem'
import { arcTestnet } from './chain'

const client = createPublicClient({ chain: arcTestnet, transport: http() })

// Read-only, no keys needed.
const chainId = await client.getChainId()      // 5042002
const block = await client.getBlockNumber()    // latest block
```

A-Identity already does this read for you. Hit the **live backend** (or a local server
at `http://localhost:3399`):

```bash theme={null}
# live deployment
curl https://a-identity-backend.onrender.com/api/arc
# { "online": true, "chainId": 5042002, "blockNumber": "...", "gasToken": "USDC", ... }

# or read the deployed ERC-8004 + ERC-8183 + USDC contracts, live and unmocked
curl https://a-identity-backend.onrender.com/api/arc/contracts
```

## Unified Balance With App Kit

Circle App Kit pools USDC from several chains into one spendable balance (Circle
Gateway), so an agent is never stuck with funds on the wrong chain.

**1. Install**

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

**2. Deposit from any chain**

```ts theme={null}
await kit.unifiedBalance.deposit({
  from: { adapter: viemAdapter, chain: 'Base_Sepolia' },
  amount: '1.00',
  token: 'USDC',
})
```

**3. Spend on Arc**

```ts theme={null}
await kit.unifiedBalance.spend({
  amount: '1.50',
  from: { adapter: viemAdapter },
  to: { adapter: viemAdapter, chain: 'Arc_Testnet', recipientAddress: '0x...' },
})
```

In A-Identity, the Wallet screen shows this unified balance, and deposit or spend
above your limit pauses for human approval.

## Deploy A Contract

Arc deploys with the standard EVM toolchain. Gas is paid in USDC, so fund the
deployer wallet from the faucet first.

**1. Install Foundry**

```bash theme={null}
curl -L https://foundry.paradigm.xyz | bash
foundryup
```

**2. Create and fund a wallet**

```bash theme={null}
cast wallet new
# then request testnet USDC at https://faucet.circle.com
```

**3. Deploy**

```bash theme={null}
forge create src/Counter.sol:Counter \
  --rpc-url https://rpc.testnet.arc.io \
  --private-key $PRIVATE_KEY \
  --broadcast
```

> [!WARNING]
>
> A-Identity never deploys a contract or moves real value on its own. Deployment
> holds a key, so it is human-on-the-loop: a person runs it and approves it.

## Where Arc Fits

Arc is the **primary rail**: gas in USDC, a unified balance via Circle Gateway,
native-USDC bridging via [CCTP](/chains/cctp), and sub-cent x402 settlement, either
on-chain or gasless via [Nanopayments](/protocols/nanopayments). Base and the other
chains are fallbacks. Identity stays on ERC-8004, which Arc speaks natively because it
is EVM compatible.


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