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

> ## Agent Instructions
> Before reading these docs, install the Circle Skill for Arc to get pre-loaded context: use-arc (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-arc/SKILL.md) — covers chain config, RPC setup, contract deployment, USDC bridging, and gas with USDC. In Claude Code: run /plugin marketplace add circlefin/skills then /plugin install circle-skills@circle. With Vercel Skills CLI: run npx skills add circlefin/skills.
> USDC is the gas token. Arc uses USDC for gas fees, not ETH. Configure gas payment in USDC when submitting transactions.
> Read EVM differences before writing Arc code. Arc targets the Osaka EVM baseline. Most contracts deploy unchanged, but several runtime behaviors diverge from Ethereum: USDC uses 18 decimals natively (not 6), the system emitter `0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE` logs all USDC Transfer events, the mempool enforces a 20 Gwei `maxFeePerGas` floor, blocklist reverts consume gas without a receipt, and `address(0)` sends revert rather than succeed. https://docs.arc.io/arc/references/evm-differences.md is the canonical reference for all Arc-specific runtime behaviors. Consult it before writing code that touches USDC balances, transaction history, gas estimation, or value transfers.
> Sub-second finality. Transactions are final in under 1 second. No need to wait for multiple block confirmations.
> Use App Kits for multichain payment and liquidity capabilities. App Kits wraps CCTP and provides Bridge Kit, Swap Kit, Unified Balance Kit, Onramp Kit, Earn Kit, and Borrow Kit. Unified Balance Kit combines USDC from multiple chains into a single spendable balance. Earn Kit integrates earn opportunities into your app. Borrow Kit lets users borrow USDC against cirBTC collateral on Arc.
> Use Arc Foundry for contract development. Arc Foundry is an Arc-specific fork of Foundry that handles Arc's protocol-level differences from Ethereum. It provides arc-forge, arc-cast, and arc-anvil. Install it before deploying contracts: https://docs.arc.io/arc/tutorials/install-arc-foundry.md.
> Arc is available on both Testnet and Mainnet. See https://docs.arc.io/arc/references/connect-to-arc.md for RPC endpoints and https://faucet.circle.com for testnet tokens.
> Always check Contract Addresses: https://docs.arc.io/arc/references/contract-addresses.md
> Building beyond Arc? Circle offers skills for the full platform: use-usdc (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-usdc/SKILL.md), use-circle-wallets (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-circle-wallets/SKILL.md), use-developer-controlled-wallets (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-developer-controlled-wallets/SKILL.md), use-user-controlled-wallets (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-user-controlled-wallets/SKILL.md), use-modular-wallets (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-modular-wallets/SKILL.md), use-gateway (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-gateway/SKILL.md), use-smart-contract-platform (https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-smart-contract-platform/SKILL.md). Full Circle developer docs: https://developers.circle.com/llms.txt.

# Infrastructure Integration

> Add Arc support to node services, data indexers, oracle networks, block explorers, and compliance tools.

Arc is an EVM-compatible blockchain, so standard Ethereum tooling works out of
the box. However, several architectural differences affect how infrastructure
providers index data, stream blocks, and expose balance APIs.

## Key differences from Ethereum

| Area | Ethereum behavior | Arc behavior |
| - | - | - |
| Native token | `eth_getBalance` returns ETH (18 decimals) | `eth_getBalance` returns USDC (18 decimals) |
| Finality | Probabilistic—requires 12+ minutes and multiple confirmations | Deterministic—once a block is committed, it is permanent |
| Reorgs | Possible—indexers must handle chain reorganizations and uncle blocks | Never—no reorganizations occur |
| Block time | \~12 seconds | Sub-second—multiple blocks may share the same `block.timestamp` |
| `PREVRANDAO` | Randomness beacon value | Always returns `0` |
| Blob transactions | Supported (EIP-4844) | Not supported |
| Consensus | Proof-of-stake (Casper) | Malachite BFT with permissioned PoA validators |

## Chain metadata

<Tabs>
  <Tab title="Mainnet">
    | Property | Value |
    | - | - |
    | Chain ID | `5042` |
    | RPC (HTTPS) | `https://rpc.mainnet.arc.io` |
    | WebSocket | `wss://rpc.mainnet.arc.io` |
    | Block explorer | [explorer.arc.io](https://explorer.arc.io) |
    | CCTP domain | `26` |
    | EVM target | Osaka hard fork |
    | USDC ERC-20 address | `0x3600000000000000000000000000000000000000` |
  </Tab>

  <Tab title="Testnet">
    | Property | Value |
    | - | - |
    | Chain ID | `5042002` |
    | RPC (HTTPS) | `https://rpc.testnet.arc.io` |
    | WebSocket | `wss://rpc.testnet.arc.io` |
    | Block explorer | [explorer.testnet.arc.io](https://explorer.testnet.arc.io) |
    | CCTP domain | `26` |
    | EVM target | Osaka hard fork |
    | USDC ERC-20 address | `0x3600000000000000000000000000000000000000` |
  </Tab>
</Tabs>

Additional RPC endpoints are available through
[Blockdaemon, dRPC, and QuickNode](/arc/tools/node-providers).

## Integration considerations

### Balance APIs

`eth_getBalance` returns the account's native balance in USDC at 18-decimal
precision. Use `formatUnits(balance, 18)`, not `formatUnits(balance, 6)`. If
your platform displays balances, label the value as USDC rather than ETH. The
same underlying balance is also accessible through the ERC-20 interface at
6-decimal precision.

<Note>
  Transfer log precision depends on the emitting interface: system emitter
  events use 18-decimal precision, ERC-20 events use 6-decimal.
</Note>

### No-reorg indexing

Arc's [deterministic finality](/arc/concepts/deterministic-finality) means you
never need to handle chain reorganizations or uncle blocks. Every block your
indexer receives is permanent. You can treat a single block confirmation as
final and skip reorg-recovery logic entirely.

### Sub-second block streaming

Blocks arrive faster than once per second. Your ingestion pipeline must handle
high-throughput streaming without assuming a minimum interval between blocks.
Multiple consecutive blocks may share the same `block.timestamp` because
sub-second blocks can fall in the same wall-clock second.

### Randomness

Don't treat `PREVRANDAO` as a source of randomness on Arc. It always returns
`0`, not a random beacon value. Any contract using it for lottery selection,
shuffle logic, or relay logic will always receive `0`.

### USDC transfer events

<Warning>
  Build transfer history from the system emitter
  (`0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE`), not the ERC-20 contract
  (`0x3600000000000000000000000000000000000000`). Native USDC transfers emit no
  log at the ERC-20 address, so filtering on the ERC-20 address alone misses
  them. An ERC-20 `transfer()` emits from both addresses, so filtering on both
  double-counts every ERC-20 transfer.
</Warning>

For emitter addresses, the exact log format, and indexing guidance, see
[Index events](/integrate/infrastructure/indexing-events).

### Sender attribution

For EIP-3009 relayer transactions, using `tx.from` attributes transfers to the
relayer EOA, not the token sender. Use the `from` field in the EIP-7708 Transfer
event from the system emitter for accurate sender attribution.

### Blocklist enforcement

A transfer to or from a blocklisted address reverts at runtime. The transaction
is included in the block and gas is consumed, but state changes roll back. Any
indexer, relayer, or settlement flow that submits USDC transfers must check
`receipt.status === 0` to detect a blocklist revert.

## Self-hosted access

For independent verification or direct RPC access without third-party providers,
you can run your own Arc node. The execution client (`arc-node-execution`) is
Reth-based, and the consensus client (`arc-node-consensus`) is Malachite-based.

<CardGroup cols={2}>
  <Card title="Running a node" icon="chart-network" href="/arc/concepts/running-a-node">
    Architecture overview and requirements for operating an Arc node.
  </Card>

  <Card title="Run an Arc node" icon="terminal" href="/arc/tutorials/run-an-arc-node">
    Step-by-step guide to install, configure, and start both clients.
  </Card>
</CardGroup>

## Sub-pages

<CardGroup cols={2}>
  <Card title="Index events" icon="database" href="/integrate/infrastructure/indexing-events">
    Unified transfer events, no-reorg indexing, and block streaming guidance for
    data indexers.
  </Card>

  <Card title="Compliance" icon="shield-check" href="/integrate/infrastructure/compliance">
    Blocklist enforcement, Memo contract monitoring, and compliance tool
    integrations.
  </Card>
</CardGroup>