Skip to main content

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.

Arc is fully EVM-compatible—same key derivation, same signing curve (secp256k1), same transaction formats. If your custody platform supports custom EVM chains, you can add Arc without code changes. This guide covers what’s different and what to configure.
Arc uses USDC as its native gas token. There is no separate ETH-like token to fund for gas. A single USDC balance covers both transfer value and transaction fees.

​
What custody engineers need to know

Arc behaves like any EVM chain with three key differences:
PropertyEthereumArc
Gas tokenETH (18 decimals)USDC (6 display decimals, 18 internal decimals)
FinalityProbabilistic (~12 min for safety)Deterministic, sub-second. 1 confirmation = final.
Gas fundingRequires separate ETH balanceNo separate funding—USDC covers everything
Everything else is standard:
  • Address derivation: BIP-44 path m/44'/60'/0'/0/x
  • Signing algorithm: secp256k1 (identical to Ethereum)
  • Transaction types: Legacy (type 0) and EIP-1559 (type 2) both supported
  • Smart contracts: Solidity, same EVM opcodes
  • Multi-sig: Standard Ethereum multi-sig contracts (including SAFE) work without modification

​
Network configuration

Use these parameters when registering Arc as a custom EVM chain:
ParameterTestnet value
Chain ID5042002
RPC (HTTPS)https://rpc.testnet.arc.network
RPC (WebSocket)wss://rpc.testnet.arc.network
Block explorerhttps://testnet.arcscan.app
Native currency symbolUSDC
Native currency decimals18 (internal representation)
Display decimals6
EIP-1559 supportYes (recommended)
Minimum base fee20 Gwei
The native currency uses 18 decimals internally (like ETH uses Wei) but represents USDC which has 6 display decimals. Configure your balance display to show 6 decimal places to users while using 18 decimals for transaction construction.

​
USDC ERC-20 contract

For ERC-20 interactions (approvals, transferFrom, allowance checks), the USDC contract is deployed at a precompile address: 
0x3600000000000000000000000000000000000000
Native USDC transfers (simple sends) and ERC-20 transfer() calls both move the same underlying balance. There is no wrapped/unwrapped distinction.

​
Register Arc in your custody platform

Most custody platforms provide a “custom EVM chain” or “custom network” configuration flow. The following sections provide platform-specific guidance and a generic template.

​
Provider configuration reference

ProviderIntegration methodNotes
FireblocksWorkspace Settings → Add EVM NetworkUse “EVM-based chain” template. Set native asset to USDC.
BitGoAdmin → Coin Management → Custom EVMRegister as custom ERC-20 chain. Configure 1-block finality.
CactusNetwork Management → Add Custom ChainStandard EVM chain wizard. Set gas token symbol to USDC.
ZodiaNetwork Configuration → Custom EVMUse provided chain ID and RPC. No special signing config needed.
SAFEAdd custom network in web interfaceWorks natively—same contract addresses and factory.
TaurusTaurusProtect → Network SettingsRegister RPC endpoint. Configure display decimals separately.
CopperClearLoop → Custom NetworksStandard EVM registration. Set confirmation threshold to 1.
CEFFUAsset Management → Custom ChainFollow EVM chain onboarding flow. Specify USDC as fee token.

​
Generic custom EVM chain template

Use this configuration when your platform has a general-purpose “add custom EVM chain” form: 
const arcNetworkConfig = {
  chainId: 5042002,
  name: "Arc Testnet",
  rpcUrl: "https://rpc.testnet.arc.network",
  wsUrl: "wss://rpc.testnet.arc.network",
  blockExplorer: "https://testnet.arcscan.app",
  nativeCurrency: {
    name: "USDC",
    symbol: "USDC",
    decimals: 18, // Internal representation (like Wei for ETH)
  },
  // Display configuration
  displayDecimals: 6, // Show balances with 6 decimal places
  // Finality configuration
  confirmationsRequired: 1, // Deterministic finality—1 block is final
  // Transaction type preference
  eip1559: true,
  // No separate gas token funding address needed
};

​
Transaction signing

Arc uses standard Ethereum transaction signing. No custom signing schemes or transaction types are required. 
import { createWalletClient, http, parseUnits } from "viem";

const arcTestnet = {
  id: 5042002,
  name: "Arc Testnet",
  nativeCurrency: { name: "USDC", symbol: "USDC", decimals: 18 },
  rpcUrls: {
    default: { http: ["https://rpc.testnet.arc.network"] },
  },
};

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

// Standard EIP-1559 transaction—identical to Ethereum
const txHash = await client.sendTransaction({
  account, // Your custody-managed account
  to: "0x742d35Cc6634C0532925a3b844Bc9e7595f2bD28",
  value: parseUnits("100", 18), // 100 USDC (18 decimals internally)
  maxFeePerGas: parseUnits("30", 9), // 30 Gwei
  maxPriorityFeePerGas: parseUnits("1", 9), // 1 Gwei tip
});

// With deterministic finality, 1 confirmation means the transaction is final

​
Key signing details

  • Curve: secp256k1 (same as Ethereum)
  • Address derivation: Keccak-256 hash of public key, last 20 bytes
  • HD path: m/44'/60'/0'/0/x (coin type 60, same as Ethereum)
  • Transaction serialization: RLP encoding, identical to Ethereum
  • Chain ID in signature: Required (EIP-155). Use 5042002 for testnet.

​
MPC and multi-sig considerations

​
MPC wallets

MPC (multi-party computation) signing works identically to Ethereum:
  • Key shares are generated for the secp256k1 curve
  • Threshold signing produces a standard ECDSA signature
  • The resulting address is a standard Ethereum address
  • No Arc-specific MPC protocol modifications are needed

​
Multi-sig wallets (SAFE)

SAFE multi-sig contracts deploy and operate on Arc without modification:
  • Same factory contract addresses
  • Same proxy pattern
  • Same signature verification logic
  • Transaction confirmation follows the same flow—but only 1 onchain confirmation is needed due to deterministic finality

​
Operational differences

​
Balance management

Because USDC is both the transfer currency and the gas token, custody operations are simpler:
  • No gas station network: You don’t need a separate process to fund addresses with gas tokens.
  • Unified balance: A single eth_getBalance call returns the USDC balance available for both transfers and fees.
  • Threshold alerts: Set a single low-balance threshold instead of monitoring separate gas and transfer balances.
import { createPublicClient, http, formatUnits } from "viem";

const client = createPublicClient({
  transport: http("https://rpc.testnet.arc.network"),
});

const balance = await client.getBalance({
  address: "0xYourCustodyAddress",
});

// Display with 6 decimals (USDC precision)
const displayBalance = formatUnits(balance, 18);
// For user-facing display, round to 6 decimal places
const usdcDisplay = parseFloat(displayBalance).toFixed(6);

​
Finality and confirmation tracking

Arc provides deterministic finality. Once a transaction is included in a block, it is final—no reorgs, no uncle blocks, no chain reorganizations. This means:
  • Set confirmation requirements to 1 in your custody platform
  • Remove pending-state tracking logic (no need to wait for additional confirmations)
  • Transaction receipts are immediately authoritative
  • No need to handle “dropped and replaced” scenarios
If your platform requires a minimum confirmation count greater than 1, setting it to 1 is still safe on Arc. There is no security benefit to waiting for additional blocks.

​
Blocklist enforcement

Arc enforces a protocol-level blocklist. Transactions from blocklisted sender addresses are rejected at the pre-mempool stage—they never appear onchain. For custody operations:
  • Check the blocklist before attempting to sign and broadcast
  • If a send fails with a blocklist rejection, it was not broadcast—no gas is consumed
  • Monitor compliance status of custody-managed addresses

​
Fee estimation

Gas estimation works identically to Ethereum: 
// Use standard eth_estimateGas and eth_gasPrice / eth_maxPriorityFeePerGas
const gasEstimate = await client.estimateGas({
  account: "0xYourCustodyAddress",
  to: "0xRecipientAddress",
  value: parseUnits("1000", 18), // 1000 USDC
});

const feeData = await client.estimateFeesPerGas();

// Total fee in USDC (18 decimals internal)
const maxFee = gasEstimate * feeData.maxFeePerGas;
The minimum base fee is 20 Gwei. Set your gas price floor accordingly to avoid underpriced transaction rejections.

​
Verification and testing

After configuring Arc in your custody platform:
  1. Generate a test address using your standard HD derivation path and verify it matches what you’d get on Ethereum for the same seed.
  2. Fund the address with testnet USDC through the Arc faucet.
  3. Send a transaction and confirm it appears on the block explorer within seconds.
  4. Verify the receipt shows status: 1 (success) with a single block confirmation.
  5. Test balance display to ensure your platform shows the correct USDC amount (6 decimal places).
The same address and private key work on both Arc and Ethereum. If your platform already derives Ethereum addresses for a given seed, those same addresses are valid on Arc.