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

# Network reference

> Chain IDs, public RPC endpoints and their rate limits, explorers, and other parameters for the Whitechain Mainnet and Whitechain Sepolia environments. All network reference data and infrastructure specifications are provided "AS IS" for technical guidance and are subject to modification without prior notice.

Whitechain runs EVM-compatible environments built on the OP Stack. Each settles on Ethereum and uses WBT as the native gas token.

## At a glance

| Network | Chain ID | Status | Intended use |
| - | - | - | - |
| Mainnet | TBD, published before Mainnet launch | Coming soon | Production |
| Whitechain Sepolia | `1874` | Live | Public testing, integrations, dapp deployment |

## Mainnet

L2 Mainnet is not yet live. Chain ID, endpoints, and the launch date will be published before public availability. Statements regarding Mainnet deployment schedules and parameters are forward-looking and subject to technical readiness and regulatory compliance.

## Whitechain Sepolia

Whitechain Sepolia is the public test environment. Use it for dapp deployment, integration testing, and to claim test WBT from the faucet.

| Parameter | Value |
| - | - |
| Chain ID | `1874` (hex `0x752`) |
| L1 settlement | Ethereum Sepolia (`11155111`) |
| Block time | 1s |
| Minimum base fee | 5 gwei, the floor the L2 base fee never drops below. Protocol fee floors are subject to future network upgrades and governance updates. See [Network fees](/learn/network/network-fees#fee-parameters) |
| Currency symbol | WBT |
| Currency decimals | 18 |

| Endpoint | URL |
| - | - |
| Public RPC | `https://rpc.testnet.whitechain.io` |
| WebSocket | `wss://rpc.testnet.whitechain.io/ws` |
| Explorer | [explorer.testnet.whitechain.io](https://explorer.testnet.whitechain.io/) |
| Faucet | [faucet.testnet.whitechain.io](https://faucet.testnet.whitechain.io/) |
| Bridge | [bridge.testnet.whitechain.io](https://bridge.testnet.whitechain.io/) |

To claim test WBT, see [Testnet faucet](/learn/get-started/get-testnet-wbt). To check current uptime for these endpoints, see the [status page](https://status.whitechain.io/).

## Public RPC endpoints

This section lists every public JSON-RPC endpoint for Whitechain, operated by Whitechain and by third parties, with the rate limit that applies to each. No endpoint needs an API key or an IP allowlist. Reads and writes are open to any client, subject to the limits below.

| Network | Type | URL | Operator | Auth | Status |
| - | - | - | - | - | - |
| Whitechain Sepolia | HTTPS JSON-RPC | `https://rpc.testnet.whitechain.io` | Whitechain | None | Live |
| Whitechain Sepolia | WebSocket JSON-RPC | `wss://rpc.testnet.whitechain.io/ws` | Whitechain | None | Live |
| Whitechain Sepolia | HTTPS and WebSocket JSON-RPC | Not yet available, published when the first partner endpoint launches | Third-party provider, under evaluation | To be confirmed with the provider | Planned |
| Mainnet | HTTPS and WebSocket JSON-RPC | Not yet available, published before Mainnet launch | Whitechain | None | Planned |

Third-party public endpoints are not live yet. Whitechain is evaluating partnerships with commercial RPC providers for Whitechain Sepolia and Mainnet. Until a partner endpoint is published in the table above, the two Whitechain endpoints are the only public RPC endpoints for the network. Do not treat any other endpoint claiming to serve chain ID `1874` as official. Whitechain assumes no liability for losses, data interception, or phishing attacks resulting from interaction with unverified or third-party RPC endpoints.

### Rate limits on Whitechain endpoints

The public HTTPS endpoint `https://rpc.testnet.whitechain.io` is rate limited per client IP address. Neither Whitechain endpoint needs an API key or an IP allowlist.

| Property | Value |
| - | - |
| Sustained rate | 50 requests per second per client IP |
| Burst allowance | Up to 500 requests above the sustained rate |
| What the limit counts | Each HTTP request, not each JSON-RPC call inside a batch |
| Status code when you are limited | `429 Too Many Requests` |
| Retry hint | `Retry-After: 1` header on every `429` response |
| WebSocket limits | Published once they are finalized |

Stay at or below 50 requests per second and you do not see a `429`. Above that, the endpoint absorbs a short burst, then returns `429` for the excess while it keeps serving 50 requests per second. Recovery is immediate once your rate drops. Mainnet limits are published before Mainnet launch. Rate limits on third-party endpoints are set by each provider, not by Whitechain, and are published in the table above when those endpoints go live.

### Working within the limits

The limits suit dapp front ends, wallet traffic, and integration testing. They are not sized for indexers, block-by-block backfills, or load tests. If your workload needs more headroom:

* Batch calls into a single JSON-RPC request. The limiter counts one HTTP request per batch, so 20 calls cost the same as one.
* Poll new blocks over WebSocket with `eth_subscribe` on `newHeads` instead of calling `eth_blockNumber` in a loop.
* Reuse one WebSocket connection for several subscriptions instead of opening a connection per query.
* Cache immutable results, such as receipts and finalized blocks, on your side.
* Run your own node for unmetered access. See [Run a node](/operate/run-a-node/overview).

Handle `429` responses with exponential backoff, starting from the `Retry-After` value. A client that retries immediately after a `429` stays above the limit and keeps failing.

## Predeployed contracts

These contracts exist on Whitechain Sepolia at fixed addresses. They are part of the genesis state, so they exist at block 0 and nobody has to deploy them. Predeployed smart contracts are open-source components provided "AS IS" without warranties of fitness, security, or uninterrupted execution.

| Contract | Address | Purpose |
| - | - | - |
| Multicall3 | [`0xcA11bde05977b3631167028862bE2a173976CA11`](https://explorer.testnet.whitechain.io/address/0xcA11bde05977b3631167028862bE2a173976CA11) | Batches many read-only contract calls into one `eth_call` |
| `GasPriceOracle` | [`0x420000000000000000000000000000000000000F`](https://explorer.testnet.whitechain.io/address/0x420000000000000000000000000000000000000F) | Reads the L1 data fee for a transaction. See [Network fees](/learn/network/network-fees) |

Multicall3 sits at the same address it uses on Ethereum and on other OP Stack chains, so tooling that already knows the address needs no configuration.

### Using Multicall3

Multicall3 turns a screenful of separate reads into a single request, which matters here because the public RPC endpoint is rate limited per HTTP request. Twenty reads batched through Multicall3 cost one request against your 50 per second, not twenty.

viem and wagmi use it automatically once the chain entry carries the address. viem ships that entry, so importing the chain is enough:

```ts theme={null}
import { createPublicClient, http } from 'viem';
import { whitechainSepolia } from 'viem/chains';

const client = createPublicClient({ chain: whitechainSepolia, transport: http() });

// One eth_call to Multicall3, not three round trips.
const results = await client.multicall({
  contracts: [
    { address: token, abi, functionName: 'name' },
    { address: token, abi, functionName: 'symbol' },
    { address: token, abi, functionName: 'decimals' },
  ],
});
```

In wagmi, `useReadContracts` batches through the same contract. If you define the chain by hand instead of importing it, include the address under `contracts.multicall3` or both calls fall back to one request per read:

```ts theme={null}
contracts: {
  multicall3: { address: '0xcA11bde05977b3631167028862bE2a173976CA11', blockCreated: 0 },
},
```

Batching is for reads. Multicall3 cannot bundle transactions that need your signature, and every call in a batch shares one block, so results are consistent with each other.

## Gas token

WBT is the native gas token across all Whitechain environments. It uses 18 decimals and is configured as the OP Stack custom gas token. Every transaction fee on Whitechain is paid in WBT, regardless of network.

Whitechain is an open-source, permissionless Layer 2 software protocol. WBT functions strictly as a native Custom Gas Token and technical execution fuel required for EVM computational resource settlement and L1 data posting. WBT does not represent equity, debt, an investment contract, or a regulated financial instrument in any jurisdiction.

## Related

* [Public RPC endpoints and rate limits](#public-rpc-endpoints)
* [Whitechain Sepolia full parameters](/learn/network/testnet)
* [Network artifacts](/operate/run-a-node/network-artifacts)
* [Faucet](/learn/get-started/get-testnet-wbt)
* [Network fees](/learn/network/network-fees)
* [Use viem with Whitechain](/build/dapps/use-viem)
* [OP Stack canonical bridge](/build/bridge/bridge-assets)
* [Migration to L2](/learn/general/migration)
* [Transaction finality](/learn/network/transaction-finality)
* [Service status](https://status.whitechain.io/)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.