# Arbitrum - Leading Ethereum L2 Scaling Solution

## Arbitrum 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 Arbitrum 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 Arbitrum?

Arbitrum is the leading Ethereum Layer 2 scaling solution, processing more transactions than Ethereum mainnet itself. Built with Optimistic Rollup technology, Arbitrum offers:

### **Lightning Fast Performance**

- **Sub-second block times** - Ultra-fast L2 transaction confirmations
- **10-50x lower costs** than Ethereum mainnet
- **40,000 TPS capacity** - Massive throughput for any scale

### **Enterprise Security**

- **$15B+ secured** - Largest L2 by Total Value Locked
- **Ethereum security** - Full fraud proof protection
- **Battle-tested** - Processing 1M+ transactions daily since 2021

### **Massive Ecosystem**

- **3M+ unique addresses** - Largest L2 user base
- **600+ protocols** - Complete DeFi, Gaming, and NFT ecosystem
- **Native integrations** - GMX, Uniswap V3, Aave, Curve

## Quick Start with Arbitrum

Connect to Arbitrum One in seconds with Dwellir's optimized endpoints:

### Installation & Setup

Ethers.js v6
Web3.js
Viem

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

// Connect to Arbitrum One mainnet
const provider = new JsonRpcProvider(
  'https://api-arbitrum-mainnet-archive.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 Arbitrum One mainnet
const web3 = new Web3(
  'https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY'
);

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

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

```typescript
import { createPublicClient, http } from 'viem';
import { arbitrum } from 'viem/chains';

// Create Arbitrum client
const client = createPublicClient({
  chain: arbitrum,
  transport: http('https://api-arbitrum-mainnet-archive.n.dwellir.com/YOUR_API_KEY'),
});

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

## Network Information

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

## API Reference

Arbitrum supports the full [Ethereum JSON-RPC API specification](https://ethereum.org/developers/docs/apis/json-rpc/). Access all standard methods plus L2-specific optimizations.

## 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);

  // L2 specific: Check L1 data availability
  if (receipt.l1Fee) {
    console.log('L1 data cost:', receipt.l1Fee);
  }

  return receipt;
}
```

### Gas Optimization

Optimize gas costs on Arbitrum One:

```javascript
// Estimate L2 execution gas
const l2Gas = await provider.estimateGas(tx);

// Get current L1 data fee (Arbitrum specific)
const l1DataFee = await provider.send('eth_estimateL1Fee', [tx]);

// Total cost = L2 execution + L1 data posting
const totalCost = l2Gas + BigInt(l1DataFee);
```

### Event Filtering

Efficiently query contract events:

```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; // Arbitrum recommended batch size

  for (let i = fromBlock; i <= currentBlock; i += batchSize) {
    const batch = await contract.queryFilter(
      filter,
      i,
      Math.min(i + batchSize - 1, currentBlock)
    );
    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 ArbitrumProvider {
  static instance = null;

  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-arbitrum-mainnet-archive.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 L1 fee"

Arbitrum transactions require ETH for both L2 execution and L1 data availability:

```javascript
// Always account for L1 fees in balance checks
const balance = await provider.getBalance(address);
const l1Fee = await provider.send('eth_estimateL1Fee', [tx]);
const l2Gas = await provider.estimateGas(tx);
const totalRequired = l2Gas + BigInt(l1Fee) + tx.value;

if (balance < totalRequired) {
  throw new Error(`Need ${totalRequired - balance} more ETH`);
}
```

### Error: "Transaction underpriced"

Arbitrum uses EIP-1559 pricing. Always use dynamic gas pricing:

```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;
      }
    }
  }
}
```

## Migration Guide

### From Ethereum Mainnet

Moving from L1 to Arbitrum One requires minimal changes:

```javascript
// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

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

// Smart contracts work identically
// Same tooling and libraries
// Note: Different chain ID (42161)
// Note: Separate block numbers
// Note: L1 data fees apply
```

## Resources & Tools

### Official Resources

- [Arbitrum Documentation](https://docs.arbitrum.io)
- [Arbitrum Bridge](https://bridge.arbitrum.io)
- [Arbitrum Block Explorer](https://arbiscan.io)

### Developer Tools

- [Hardhat Config](https://docs.arbitrum.io/for-devs/quickstart-solidity-hardhat)
- [Foundry Setup](https://docs.arbitrum.io/for-devs/quickstart-solidity-hardhat)
- [Development Frameworks](https://docs.arbitrum.io/build-decentralized-apps/reference/development-frameworks)

### Need Help?

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

***

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