# World Chain RPC with Dwellir

## World Chain RPC plans and rate limits

- **Free plan:** 20 responses per second, up to 100,000 responses a day.
- **Plans:** $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively.
- **Paid rate limits:** 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit.
- **Billing:** 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where World Chain supports it.

Details: [Pricing](https://www.dwellir.com/docs/getting-started/pricing) · [Rate limits](https://www.dwellir.com/docs/getting-started/rate-limits) · [Authentication](https://www.dwellir.com/docs/getting-started/authentication) · [Archive nodes](https://www.dwellir.com/docs/getting-started/archive-nodes)

## Why Build on World Chain?

World Chain is an Ethereum L2 built on the OP Stack that prioritizes verified humans over bots. Through World ID integration, verified users receive free gas allowances and priority blockspace:

### **Human-First Design**

- **Priority mempool** - Verified World ID holders get preferential block inclusion
- **Free gas allowances** - Recurring gas grants for verified humans
- **Sybil resistance** - Built-in protection against bot spam and attacks

### **Optimism Superchain**

- **OP Stack powered** - Built on battle-tested Optimism technology
- **Ethereum security** - Settles to mainnet for maximum security
- **EVM compatible** - Deploy existing Solidity contracts without changes

### **World Ecosystem**

- **World App integration** - Seamless access via the World super-app
- **World ID verification** - Privacy-preserving identity proof
- **Growing ecosystem** - Part of the broader World Network

## Quick Start with World Chain

Connect to World Chain in seconds with Dwellir's optimized endpoints:

### Installation & Setup

Ethers.js v6
Web3.js
Viem
Web3.py

```javascript
import { JsonRpcProvider } from 'ethers';

// Connect to World Chain mainnet
const provider = new JsonRpcProvider(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Get the latest block
const block = await provider.getBlock('latest');
console.log('Latest block:', block.number);

// Query account balance
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString());
```

```javascript
const Web3 = require('web3');

// Connect to World Chain mainnet
const web3 = new Web3(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Get chain ID to verify connection
const chainId = await web3.eth.getChainId();
console.log('Connected to World Chain:', chainId === 480);

// Get gas price for transaction pricing
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);
```

```typescript
import { createPublicClient, http, defineChain } from 'viem';

// Define World Chain
const worldChain = defineChain({
  id: 480,
  name: 'World Chain',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: {
    default: { http: ['https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'] },
  },
  blockExplorers: {
    default: { name: 'Worldscan', url: 'https://worldscan.org' },
  },
});

// Create World Chain client
const client = createPublicClient({
  chain: worldChain,
  transport: http('https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'),
});

// Read contract data
const data = await client.readContract({
  address: '0x...',
  abi: contractAbi,
  functionName: 'balanceOf',
  args: ['0x...'],
});
```

```python
from web3 import Web3

# Connect to World Chain mainnet
web3 = Web3(Web3.HTTPProvider(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
))

# Verify connection
print('Connected:', web3.is_connected())
print('Chain ID:', web3.eth.chain_id)  # Should be 480

# Get latest block
latest_block = web3.eth.get_block('latest')
print(f'Latest block: {latest_block.number}')
```

## Network Information

| Parameter    | Value     | Details      |
| ------------ | --------- | ------------ |
| Chain ID     | 480       | Mainnet      |
| Block Time   | 2 seconds | Average      |
| Gas Token    | ETH       | Native token |
| RPC Standard | Ethereum  | JSON-RPC 2.0 |

## API Reference

World Chain supports the full [Ethereum JSON-RPC API specification](https://ethereum.org/developers/docs/apis/json-rpc/) as an OP Stack L2.

## Common Integration Patterns

### Transaction Monitoring

Monitor pending and confirmed transactions efficiently:

```javascript
// Watch for transaction confirmation
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);

  // Check transaction status
  if (receipt.status === 1) {
    console.log('Transaction successful');
  } else {
    console.log('Transaction failed');
  }

  return receipt;
}
```

### Gas Optimization

Optimize gas costs on World Chain:

```javascript
// Get current fee data (EIP-1559)
const feeData = await provider.getFeeData();

// Estimate gas for transaction
const gasEstimate = await provider.estimateGas(tx);

// Calculate total cost
const totalCost = gasEstimate * feeData.gasPrice;
console.log('Estimated cost:', totalCost);
```

### Event Filtering

Efficiently query contract events with proper pagination:

```javascript
// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 2000; // Recommended batch size
  const latestBlock = await provider.getBlockNumber();

  for (let i = fromBlock; i <= latestBlock; i += batchSize) {
    const toBlock = Math.min(i + batchSize - 1, latestBlock);
    const batch = await contract.queryFilter(filter, i, toBlock);
    events.push(...batch);
  }

  return events;
}
```

## Performance Best Practices

### 1. **Batch Requests**

Combine multiple RPC calls for optimal performance:

```javascript
const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);
```

### 2. **Connection Pooling**

Reuse provider instances to minimize connection overhead:

```javascript
// Singleton pattern for provider
class WorldChainProvider {
  static instance = null;

  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
      );
    }
    return this.instance;
  }
}
```

### 3. **Smart Caching**

Cache immutable data to reduce API calls:

```javascript
const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;

  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }

  return cache.get(key);
}
```

## Troubleshooting Common Issues

### Error: "Insufficient funds for gas"

World Chain transactions require ETH for gas fees:

```javascript
// Always account for gas in balance checks
const balance = await provider.getBalance(address);
const gasPrice = await provider.getGasPrice();
const gasLimit = await provider.estimateGas(tx);
const gasCost = gasPrice * gasLimit;

if (balance < (tx.value + gasCost)) {
  throw new Error(`Need ${(tx.value + gasCost) - balance} more wei`);
}
```

### Error: "Transaction underpriced"

Use current market gas prices:

```javascript
// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: 21000n
};
```

### Error: "Rate limit exceeded"

Implement exponential backoff for resilient applications:

```javascript
async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}
```

## Smoke Tests

### Test Connection with cURL

```bash
# Test World Chain mainnet
curl -X POST https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
```

### Test with Ethers.js

```javascript
// Test mainnet connection
const mainnetProvider = new JsonRpcProvider(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
);

const blockNumber = await mainnetProvider.getBlockNumber();
const network = await mainnetProvider.getNetwork();

console.log('Block number:', blockNumber);
console.log('Chain ID:', network.chainId); // Should be 480n
```

### Test with Web3.py

```python
from web3 import Web3

# Test connection
web3 = Web3(Web3.HTTPProvider(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
))

print('Connected:', web3.is_connected())
print('Chain ID:', web3.eth.chain_id)  # Should be 480
print('Block number:', web3.eth.block_number)
```

## Migration Guide

### Migrating to Dwellir

Replace your existing RPC endpoint with Dwellir:

```javascript
// Before
const provider = new JsonRpcProvider('https://other-provider.com');

// After
const provider = new JsonRpcProvider(
  'https://api-worldchain-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// All existing code works identically
// Same JSON-RPC methods supported
// Same response formats
// Note: Update your API endpoint URL
// Note: Add your Dwellir API key
```

## Resources & Tools

### Official Resources

- [World Chain Documentation](https://docs.world.org/world-chain)
- [World Chain Website](https://world.org/world-chain)
- [Worldscan Block Explorer](https://worldscan.org)

### Developer Tools

- [World Chain Bridge](https://worldchain-mainnet.bridge.alchemy.com)
- [World Chain Testnet Faucet](https://faucets.chain.link/worldchain-testnet)
- [L2Beat World Chain](https://l2beat.com/scaling/projects/world)

### Need Help?

- **Email**: <support@dwellir.com>
- **Docs**: You're here!
- **Dashboard**: [dashboard.dwellir.com](https://dashboard.dwellir.com)

### Related Reading

- [Top 7 World Chain RPC Providers](https://www.dwellir.com/blog/best-worldchain-rpc-providers)

***

*Start building on World Chain with Dwellir's enterprise-grade RPC infrastructure. [Get your API key](https://dashboard.dwellir.com/register)*