Arc Mainnet RPC is live on SolidRPC

Arc Mainnet requires paid SolidRPC access. It is not available on Free or through a keyless public route; Arc Testnet remains available on Free. Use your personal API key for Mainnet.

Start with a network identity check:

curl -sS -X POST 'https://rpc.solidrpc.io/YOUR_API_KEY/evm/5042' \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'

The response should contain "result":"0x13b2". Replace YOUR_API_KEY with your SolidRPC key, then check eth_blockNumber and the methods your application actually uses. Arc's RPC reference lists chain ID 5042 for Mainnet and 5042002 for Testnet. Do not carry a Testnet RPC URL, key configuration, contract address, or asset assumption into production by accident.

The SolidRPC Arc Mainnet guide is the source of truth for method families and historical coverage. The authenticated catalog lists standard, debug_*, trace_*, Arc-specific, and read-only txpool_* methods. Confirm the exact method and block depth your workload needs; historical eth_getProof has a narrower window, and the pending-transaction view may be incomplete. SolidRPC serves HTTPS JSON-RPC rather than WebSocket subscriptions.

Arc uses USDC for native balances, transfers, and transaction fees. You do not need ETH solely to pay gas, but the sending account needs enough USDC to cover both its transfer and the fee. Fee estimates should come from the live Mainnet RPC, not fixed Testnet parameters. Arc's gas reference explains the fee model.

There is also a decimal detail that matters in application code. Arc's native balance uses 18 decimals, while its USDC ERC-20 interface uses 6. They represent one underlying balance, not two assets. A UI, indexer, or accounting job that compares the raw values without converting units will be wrong. Arc also emits a system Transfer log for USDC movements; an ERC-20 transfer emits the contract's own log as well. Filter by emitter and event meaning to avoid counting the same movement twice. See Arc's stablecoin native model and USDC event guidance.

Arc's consensus design finalizes committed blocks without the probabilistic confirmation window used on some other chains. That changes when an application can treat a transaction as settled, but it does not remove the need to handle timeouts, unknown submission outcomes, nonce conflicts, or its own durable processing. Read Arc's finality model and test the actual receipt and event flow in your application.

A production Arc application needs fresh blocks, correct historical reads, and predictable behavior when an upstream falls behind or fails. Maintaining multiple RPC providers yourself also means comparing method support, watching head lag, choosing routes, and recovering capacity after incidents. SolidRPC owns those upstream tasks for supported HTTPS JSON-RPC traffic behind your Arc endpoint.

Your team still defines its requirements: which methods and oldest blocks it needs, its request rate and deadlines, and what a correct application result looks like. Start with a representative read workload, verify chain ID and block freshness, then test transaction submission and any historical or log queries you intend to run. If an Arc-specific method or deep history is essential, qualify that exact call against the published Arc Mainnet coverage before migrating it. An archive label alone does not prove every historical method works at every block.

The intended production state is one SolidRPC integration for your supported EVM RPC traffic, including Arc, with one team accountable for the service behind it. You should not need to build a second Arc provider router to absorb an upstream incident.

1. Set Arc Mainnet chain ID 5042 and use your authenticated paid-access endpoint; keep Testnet 5042002 isolated.
2. Confirm eth_chainId, advancing eth_blockNumber, and the exact state, block, receipt, and log calls your application needs.
3. Get a live gas estimate and verify the sending account's USDC covers value plus fees.
4. Test 18-decimal native and 6-decimal ERC-20 USDC accounting, including event deduplication.
5. Validate transaction receipt handling, idempotency, and recovery from an ambiguous submission timeout.
6. Check historical depth, Arc-specific methods, throughput, and transport against the current SolidRPC Arc Mainnet guide.

Already using SolidRPC on another chain? Add Arc Mainnet's chain ID and endpoint path to the same integration. If you are replacing a self-run node or a customer-managed provider pool, bring a representative Arc workload and its failure requirements to a workload review. We can verify the route you need and help plan the move.

Need to keep experimenting without Mainnet funds? The Arc Testnet RPC guide covers the free test network and its separate chain configuration.