Every major stablecoin issuer eventually runs into the same infrastructure question: settle billions of dollars in transfers on general-purpose chains built for someone else’s priorities, or build a chain purpose-built for your own asset. Circle answered that question by building Arc — an EVM-compatible Layer 1 where USDC isn’t just the thing that moves, it’s the gas token itself, and where the two client halves that run the network are wired together specifically to make every dollar movement auditable by default.
Public testnet has been live since October 31, 2025; mainnet is scheduled for September 16, 2026, alongside a founding validator cohort that reads more like a partial roster of traditional finance than a typical L1 launch. This piece covers what the architecture actually does, the decimal quirk that trips up nearly every integration, who’s actually backing and validating the chain, how it stacks up against Tempo, Plasma, and Stable, and how to get production RPC access to it.
⏭ Skip ahead: If you’re mainly here for the RPC and infrastructure angle, jump to Getting RPC access to Arc.
What is Arc?
Arc is an EVM-compatible Layer 1 built by Circle, with USDC as its native gas token instead of a separate volatile asset. It’s worth being precise about the chain ID here, because the two networks don’t share one: Arc Testnet runs chain ID 5042002 (hex 0x4cef52), while mainnet — confirmed in Circle’s GitHub release notes and independently on Arcscan’s mainnet developer docs — uses chain ID 5042 (hex 0x13b2). Mixing the two up is an easy way to sign a transaction for the wrong network.
Under the hood, an Arc node is two client halves working together: Reth handles execution — running the EVM, holding state, and exposing the standard eth_* JSON-RPC surface, so existing tooling connects the same way it does on Ethereum — while Malachite handles consensus. Circle didn’t build Malachite from scratch: in mid-2025, Circle welcomed the Malachite team and IP from Informal Systems, the group behind Tendermint/CometBFT, and built the consensus layer on top of that BFT engine. The result is deterministic finality on inclusion — no probabilistic confirmation, no reorg window to wait out — with blocks landing roughly every half second.
USDC as native gas: the 18/6 decimal split (and EIP-7708)
USDC plays two roles on Arc, and the two roles don’t use the same number of decimals. As the native gas token — the balance behind msg.value, gas payments, and eth_getBalance — USDC follows the 18-decimal convention every EVM chain uses for its native asset, the same as ETH or wei on Ethereum. As a standard ERC-20 token, the same underlying balance is exposed through balanceOf at the usual 6-decimal USDC convention. The docs are explicit about this: “Because both interfaces operate on one balance, USDC.balanceOf(addr) and addr.balance are two views of the same value. They use different decimals (6 vs 18), so never compare or mix their raw values without converting first.”
That’s a factor of 1012 between the two representations of what a user experiences as “the same” balance. It’s the single most common integration bug on Arc, and it fails silently rather than throwing:
// Wrong: assumes the native balance and the ERC-20 view share decimals
const nativeBalance = await client.getBalance({ address }); // 18 decimals
const erc20Balance = await usdc.read.balanceOf([address]); // 6 decimals
if (nativeBalance === erc20Balance) { /* ... */ }
// never true — off by a factor of 10^12, not a rounding error
The other Arc-specific mechanism worth understanding before you write any indexing code is EIP-7708. On most EVM chains, a native value transfer (a plain ETH send) leaves no log — only ERC-20 transfer() calls emit a Transfer event. Arc changes that: every native USDC movement — a transfer, a contract endowment, a self-destruct, a precompile mint/burn/transfer — automatically emits a standard ERC-20-style Transfer log from a system address. The documentation notes that “the system emitter log uses 18 decimals and is distinct from the ERC-20 USDC contract’s own 6-decimal Transfer.” In practice, that means eth_getLogs against the system address is a complete, protocol-guaranteed record of every dollar that has ever moved on the chain — the log doesn’t describe the payment, it is the payment record.
What’s actually different from Ethereum
Arc is EVM-compatible, so method names match Ethereum — but several behaviors diverge in ways that change how you build against it:
- No observable mempool.
eth_newPendingTransactionFilterreturns error-32001, “Pending transaction filters are not allowed.”eth_subscribe("newPendingTransactions")returns the same code with “Subscriptions to pending transactions are not allowed.”eth_getBlockByNumber("pending")just returns null rather than erroring. - EIP-155 is mandatory. Arc only accepts replay-protected transactions signed against its chain ID — an unsigned-for-replay transaction is rejected before it ever reaches execution.
- Protocol-level transfer reverts. A value transfer can revert despite sufficient balance if the source or destination is on a compliance blocklist, targets the zero address, or targets certain precompiles — regardless of what the sender’s balance says.
- A custom
arcnamespace. Two methods:arc_getVersion(execution-client build info) andarc_getCertificate, which returns the Malachite consensus commit certificate — round, block hash, and validator signatures — for a given block height. - Archive billing kicks in fast. Arc follows the standard “127+ blocks behind the tip bills as archive” rule, but because blocks land roughly every half second, that threshold covers only about a minute of history — versus roughly 25 minutes on Ethereum. Most historical
eth_getLogsreconciliation queries on Arc end up billing as archive.
Reth also exposes the full debug_* and Parity-style trace_* namespaces — nine methods each, 18 total — so nothing is lost for teams that lean on tracing for compliance or debugging; Arc just adds the mempool and archive-timing wrinkles on top.
| Property | Ethereum | Arc |
|---|---|---|
| Block time | ~12s | ~0.5s |
| Finality | Multiple confirmations, probabilistic | Deterministic on inclusion, no reorgs |
| Gas token | ETH (18 decimals) | USDC (18 decimals native / 6 decimals as ERC-20) |
| Native transfer logs | None — plain ETH sends emit no log | EIP-7708: every native USDC movement emits a system Transfer log |
| Pending mempool | Observable via pending filters/subscriptions | Not observable — returns -32001 |
| Replay protection | EIP-155 optional in practice on most tooling | EIP-155 mandatory — unprotected transactions are rejected |
| Value transfers | Succeed if balance is sufficient | Can revert on blocklist/zero-address/precompile targets despite sufficient balance |
🚀 None of this breaks your tooling — Reth means ethers.js and viem connect exactly the way they do on Ethereum. What changes is how you have to read the responses. Build on Arc with Chainstack →
Who’s behind Arc
Arc is built and owned by Circle — there’s no separate corporate structure or cap table for the chain itself. Publicly, the project is fronted by Circle co-founder, chairman, and CEO Jeremy Allaire; as of this writing, neither Circle’s leadership pages nor the Arc site itself name a separately-titled general manager or head of product, so it’s worth not inventing one. The clearest “who built this” data point is the Malachite consensus engine itself: an announcement from Circle states the company “welcome[d] the Malachite team and IP from Informal Systems to Circle,” with the core software set to ship under a permissive license.
On funding: Circle Internet Group (NYSE: CRCL) disclosed in an SEC Form 8-K filed May 11, 2026 that on May 8, 2026 it entered Token Purchase Agreements to sell 740 million ARC tokens at $0.30 each — roughly $222 million gross — to “certain institutional investors” the filing names as led by a16z crypto, implying a fully diluted valuation near $3 billion. This is a token presale by the public parent company under Reg D, not a separate Arc-only funding round with its own equity investors — and it’s worth being precise that ARC itself hasn’t launched yet: Arc’s own token page states plainly that “ARC is not launched” and that “any discussion of a potential ARC token is merely exploratory.” Circle describes the eventual token as a coordination asset — giving holders a role in setting fees, inflation, and burn parameters, and supporting the network’s planned future transition from proof-of-authority to proof-of-stake through staking and delegation — but none of that is live today, and the presale is a purchase commitment against a token that doesn’t exist yet, not a stake in a functioning one. Media reporting (CNBC, Coindesk, and others citing Circle’s disclosures) names a fuller purchaser list — BlackRock, Apollo Funds, ICE, SBI Group, Janus Henderson, Standard Chartered Ventures, General Catalyst, Marshall Wace, ARK Invest, IDG Capital, Haun Ventures, and Bullish among them — but that fuller list comes from secondary coverage, not from language the 8-K itself spells out beyond naming a16z crypto. Worth flagging separately: several of those same institutional names (BlackRock, ICE, SBI, Standard Chartered) also show up below as founding validators — a validator role and a token-purchase role are different relationships, even when the same logo appears in both places.
Founding validators and the ecosystem
What makes this launch unusual isn’t the tech — it’s who signed up to run it. Circle’s pressroom and the official Arc account both name an 11-member founding validator cohort alongside Circle: BlackRock, DTCC, Galaxy, Global Payments, ICE, Mastercard, MoneyGram, SBI Group, Standard Chartered, Sumitomo Corporation, and Visa. That’s a validator set drawn from custody, clearing, card networks, and cross-border payments rather than the usual crypto-native infrastructure operators.
The same announcement names a separate tier of ecosystem integration partners: DeFi and liquidity — Aave, Aerodrome, FalconX, GSR, Keyrock, Morpho, Uniswap, and XFX; payments — Rain, Thunes, and Wirex; and exchanges/wallets — Binance Wallet, Fireblocks, Kraken, Ledger, MetaMask, and Upbit, alongside Chainlink for oracle infrastructure. The Arc homepage also carries testimonial quotes from named executives at Mastercard (Raj Dhamodharan) and Visa (Cuy Sheffield) — consistent with, but not additional evidence beyond, the validator/partner announcement above. (A third testimonial is attributed on-site to a “Global Head of Digital Assets” whose company tag currently reads Goldman Sachs on arc.io, despite the individual being widely reported elsewhere as a BlackRock executive — we’re not naming him here until that’s cleared up.)
On adoption: the testnet launch is documented in Circle’s own announcement from October 31, 2025. As of this writing, Arcscan’s testnet explorer shows over 666 million cumulative testnet transactions and roughly 49 million testnet addresses — check that page directly rather than trusting a static number, since it moves fast. The Arc site separately reports rolling weekly figures (roughly 13.6 million weekly transactions and an average weekly transaction cost of $0.004, per a footnoted testnet-explorer window) rather than a lifetime total, so treat the two figures as different measurements, not a contradiction.
Arc vs. the stablecoin-chain landscape
Arc isn’t the only bet on a stablecoin-native chain running right now. Tempo, a Stripe and Paradigm collaboration led by Paradigm co-founder Matt Huang, runs Reth under Simplex consensus (via Commonware) and lets users pay gas in any of several supported stablecoins rather than one; it raised $500 million at a $5 billion valuation and reached mainnet in March 2026. Plasma, backed by Tether and Bitfinex, is a Bitcoin-anchored EVM chain built around USDT with a zero-fee transfer mode, and reached mainnet beta in September 2025. Stable, backed by Bitfinex and Hack VC and built by the team behind USDT0, runs its own CometBFT-based consensus and reached mainnet in December 2025. Arc is the one built around USDC specifically, and — mainnet timing aside — the one with the most TradFi-heavy validator set of the group.
| Chain | Gas token | Consensus base | Mainnet | Notable backers |
|---|---|---|---|---|
| Arc | USDC | Reth + Malachite (BFT) | Sep 2026 | Circle; token presale led by a16z crypto |
| Tempo | Multiple stablecoins | Reth + Simplex (Commonware) | Mar 2026 | Stripe, Paradigm |
| Plasma (XPL) | USDT (zero-fee mode) | Bitcoin-anchored, EVM | Sep 2025 (beta) | Tether, Bitfinex |
| Stable | USDT0 | StableBFT (CometBFT) | Dec 2025 | Bitfinex, Hack VC |
📖 Want to learn more about other stablecoin chains? See What is Stable? A deep dive into the USDT0-native payments L1 and Tempo blockchain: infrastructure for stablecoin payments.
Getting RPC access to Arc
The public testnet endpoint for Arc (https://rpc.testnet.arc.io) is a shared, best-effort resource with no rate-limit or log-range guarantees — fine for poking around, not something to build a payment flow on.
Chainstack delivers Arc RPC as a self-serve Global Node, with the eth, debug, trace, txpool, net, web3, and rpc namespaces enabled alongside the custom arc namespace, in both Full and Archive node modes. Arc Testnet is deployable today; Arc Mainnet becomes available once the network launches on September 16, 2026 — the product page already lists it, but there’s no live mainnet to point a node at until then. Dedicated Nodes and the flat-fee Unlimited Node add-on are also listed for teams that need isolated infrastructure or predictable high-throughput billing, and Arc is available through Chainstack Self-Hosted for teams running their own infrastructure.
How to get an Arc RPC endpoint on Chainstack
- Log in to the Chainstack console (or create an account).
- Create a new project.
- Select Arc as your blockchain protocol.
- Choose Arc Testnet (Mainnet unlocks once Arc launches on September 16, 2026).
- Deploy the node — Full or Archive, depending on whether you need complete transfer-log history.
- Open Access and credentials and copy your HTTPS and WebSocket endpoints.
Because Arc runs on Reth, standard EVM tooling connects unchanged. Here’s a viem chain definition — note the 18-decimal native USDC currency, and that mainnet and testnet don’t share a chain ID:
import { createPublicClient, http, defineChain, formatEther } from "viem";
export const arcTestnet = defineChain({
id: 5042002, // Arc Testnet (mainnet is 5042 — don't mix them up)
name: "Arc Testnet",
testnet: true,
nativeCurrency: { decimals: 18, name: "USDC", symbol: "USDC" }, // native USDC is 18-decimal
rpcUrls: { default: { http: ["YOUR_CHAINSTACK_ENDPOINT"] } },
contracts: {
multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" },
},
});
const client = createPublicClient({ chain: arcTestnet, transport: http() });
console.log("Balance:", formatEther(await client.getBalance({ address: "0xYourAddress" })), "USDC");Arc also supports ERC-4337 account abstraction (bundlers, paymasters, session keys) and is listed on Chainlist for both networks — just make sure you add the right one, since mainnet and testnet use different chain IDs.
📖 Related reads: for the full RPC-selection walkthrough, see How to get an Arc RPC endpoint (2026 guide); for a side-by-side of providers, see Top 5 Arc RPC providers for production apps in 2026.
For the full method-level detail — exact error codes, the complete debug_*/trace_* list, and the arc namespace — the reference docs are the source of truth: Arc tooling and Arc methods.
Conclusion
The pitch behind Arc is narrower than most new L1s, and that’s the point: it isn’t trying to be a general-purpose chain that happens to support stablecoins, it’s a settlement rail where USDC is the gas token and every movement of it is, by protocol design, a log entry someone can audit. The validator cohort — BlackRock, DTCC, Mastercard, Visa, and the rest — is the strongest signal that Circle is building for institutional settlement rather than retail DeFi volume. The integration risk is concentrated in exactly two places: the 18/6-decimal split between native and ERC-20 USDC, and the fact that a payment can revert on protocol-level compliance grounds no matter what the sender’s balance says. Both fail silently if you don’t test for them directly, and neither shows up by reading the marketing.
Between now and the September 16, 2026 mainnet launch, testnet is where that testing happens — and where the RPC layer you pick determines whether your eth_getLogs reconciliation is complete or quietly missing transfers.
FAQs
What is Arc’s chain ID?
Mainnet is chain ID 5042 (0x13b2). Testnet uses a different chain ID, 5042002 (0x4cef52) — the two are easy to confuse since they share a prefix, so double-check which one you’ve signed a transaction against.
Is Arc live on mainnet yet?
Testnet has been live since October 31, 2025. Mainnet is scheduled to launch September 16, 2026, alongside the founding validator cohort.
Why can’t I see pending transactions on Arc?
Arc doesn’t expose the mempool through RPC. eth_newPendingTransactionFilter and the newPendingTransactions subscription both return error -32001. With deterministic finality on inclusion, there’s little practical window to watch anyway — build confirmation logic around block inclusion, not a pending-pool watch.
Why might a USDC transfer revert on Arc despite a sufficient balance?
Arc enforces transfer rules at the protocol level. A value transfer reverts if the source or destination is on a compliance blocklist, or if it targets the zero address or certain precompiles — independent of balance. Simulate with eth_call or a trace_* method before broadcasting so you can surface the actual revert reason.
Who invested in Arc?
Circle Internet Group disclosed a token presale — 740 million ARC tokens at $0.30 each, led by a16z crypto — in an SEC 8-K filed May 11, 2026. That’s a token purchase by the public parent company, not a separate Arc equity round. A wider purchaser list (BlackRock, Apollo, ICE, SBI, and others) is reported by financial media, not spelled out in Circle’s own filing beyond naming a16z crypto — and it’s a different relationship from the founding validator cohort, even where the same institutional names appear in both.
Do I need an archive node for Arc?
If you reconcile payments, serve transaction history, or face audit requirements, yes. Because blocks on Arc land roughly every half second, the standard “127+ blocks behind tip bills as archive” rule covers only about a minute of history — so most reconciliation lookups on Arc bill as archive (2 request units versus 1 for full-node requests) far sooner than they would on Ethereum.
Additional resources
- How to get an Arc RPC endpoint (2026 guide)
- Top 5 Arc RPC providers for production apps in 2026
- Arc getting started (Chainstack docs)
- Arc tooling documentation
- Arc methods reference
- Arc EVM differences (official docs)
- Circle: founding validator cohort and integrations for Arc
- Arcscan — Arc testnet explorer