> ## 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.

# Running a node

> Arc node architecture and the role of full nodes in independently verifying the blockchain.

Anyone can run an Arc node without permission. A node gives you independent
verification of every block and transaction on the network, plus direct API
access through a local JSON-RPC endpoint. Before setting up a node, review the
[Node Requirements](/arc/references/node-requirements) for hardware and software
prerequisites, then follow [Run an Arc Node](/arc/tutorials/run-an-arc-node) for
step-by-step setup instructions.

## What your node does

An Arc node performs three functions:

* **Verifies every block.** Each block is cryptographically verified against the
  signatures of the validator set before it is accepted. Your node independently
  confirms that validators finalized each block.
* **Executes every transaction.** Every transaction is re-executed locally
  through the EVM. Your node maintains its own copy of the complete blockchain
  state.
* **Exposes a local RPC endpoint.** Your node provides a standard Ethereum
  JSON-RPC API (`http://localhost:8545`) for querying blocks, balances, and
  transactions, and for submitting calls directly against your own verified
  state.

## What your node does not do

An Arc node is a full node, not a validator:

* **Does not participate in consensus.** Your node does not propose or vote on
  blocks. Only permissioned
  [validators](/arc/concepts/consensus-layer#proof-of-authority-validator-set)
  participate in the consensus process.
* **Does not observe consensus messages.** Your node does not join the consensus
  gossip network. It verifies finalized decisions by checking the cryptographic
  signatures on each block.

## Node architecture

An Arc node runs two processes that work together:

* **Consensus Layer (CL):** Built on [Malachite](/arc/concepts/consensus-layer),
  a high-performance Tendermint BFT implementation. The CL fetches blocks from
  the network, verifies their cryptographic signatures, and passes them to the
  EL for execution.
* **Execution Layer (EL):** Built on [Reth](https://reth.rs/), a Rust
  implementation of the Ethereum execution client. The EL executes transactions,
  maintains blockchain state, and serves the JSON-RPC API.

The two processes communicate through either local IPC sockets (when running on
the same host) or RPC (when running on separate hosts):

* **IPC mode:** The EL and CL share two Unix sockets on the same machine. This
  is the default and simplest configuration.
* **RPC mode:** The CL connects to the EL over HTTP using the Engine API and a
  shared JWT secret. Use this when the EL and CL run on different hosts.

```mermaid theme={null}
flowchart LR
  subgraph Node["Arc Node"]
    CL["Consensus Layer (Malachite)"]
    EL["Execution Layer (Reth)"]
  end

  Network["Arc Network"] -->|"Fetches blocks"| CL
  CL -->|"Engine API"| EL
  CL -->|"ETH RPC"| EL
  EL -->|"JSON-RPC API"| Client["Your Applications"]
```

## Why run your own node

Running your own node instead of relying on a third-party
[node provider](/arc/tools/node-providers) gives you several advantages:

* **Independent verification.** You verify every block and transaction yourself,
  rather than trusting a third party's RPC responses.
* **Data sovereignty.** Your blockchain data stays on your own infrastructure.
  No third party observes your queries or transaction patterns.
* **No rate limits.** You control your own RPC endpoint without usage
  restrictions, request quotas, or throttling.
* **Lower latency.** A local RPC endpoint eliminates network round-trips to
  external providers, which matters for latency-sensitive applications.

If you prefer managed infrastructure, see
[Node Providers](/arc/tools/node-providers) for a list of third-party RPC
services.

To learn more about the layers that make up an Arc node, see
[System Overview](/arc/concepts/system-overview),
[Consensus Layer](/arc/concepts/consensus-layer), and
[Execution Layer](/arc/concepts/execution-layer).