Gnosis Chain - Build on the Community-Owned Ethereum Sidechain

Gnosis RPC
With Dwellir, you get access to our global Gnosis network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Gnosis Chain?

Gnosis Chain is a community-owned, fully decentralized Ethereum sidechain designed for stable and accessible DeFi. Built and maintained by the Gnosis community, Gnosis Chain offers:

🚀 Predictable Transaction Costs

• xDAI native token - USD-pegged stablecoin for stable gas fees
• 5-second block times - Fast and predictable confirmations
• Low-cost transactions - Typical fees under $0.01

🛡️ True Decentralization

• 140,000+ validators - World's most decentralized Proof-of-Stake network
• Community governance - No single entity controls the chain
• Battle-tested security - Over 3 years of continuous operation

🌍 Mature Ecosystem

• $200M+ TVL - Established DeFi protocols
• EVM compatibility - Full Ethereum tooling support
• Bridge ecosystem - Native bridges to Ethereum and other chains

Quick Start with Gnosis Chain

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

🔗 RPC Endpoints

Gnosis Mainnet (Chain ID: 100)Live

https://api-gnosis-mainnet.n.dwellir.com/YOUR_API_KEY

✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

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

Installation & Setup

Ethers.js v6

import { JsonRpcProvider } from 'ethers';

// Connect to Gnosis Chain mainnet
const provider = new JsonRpcProvider(
  'https://api-gnosis-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 (returns xDAI balance)
const balance = await provider.getBalance('0x...');
console.log('Balance:', balance.toString(), 'wei (xDAI)');

Web3.js

const Web3 = require('web3');

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

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

// Get gas price (in xDAI)
const gasPrice = await web3.eth.getGasPrice();
console.log('Current gas price:', gasPrice);

Viem

import { createPublicClient, http } from 'viem';
import { gnosis } from 'viem/chains';

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

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

Network Information

Chain ID

100

Mainnet

Block Time

5 seconds

Average

Gas Token

xDAI

USD-pegged

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference

Gnosis Chain supports the full Ethereum JSON-RPC API specification with sidechain-specific optimizations.

Available JSON-RPC Methods

📊 Reading Blockchain Data

Query blocks, transactions, and account states

+

📤 Sending Transactions

Submit and manage transactions

+

📝 Smart Contract Interaction

Call and interact with smart contracts

+

🔧 Node & Network Info

Query node status and network information

+

Ready to integrate Base into your dApp?

Get your API key →

Common Integration Patterns

🔄 Transaction Monitoring

Monitor pending and confirmed transactions efficiently:

// Watch for transaction confirmation on Gnosis Chain
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  // Gnosis Chain has 5-second blocks for fast confirmations
  console.log('Transaction confirmed in ~5 seconds');
  
  return receipt;
}

💰 Gas Optimization

Optimize gas costs on Gnosis Chain:

// Gas estimation on Gnosis Chain
const gasEstimate = await provider.estimateGas(tx);

// xDAI has predictable pricing (~$1.00)
const gasPrice = await provider.getGasPrice();
const costInXDAI = gasEstimate * gasPrice / BigInt(1e18);

console.log(`Transaction cost: ${costInXDAI} xDAI (~$${costInXDAI})`);

🔍 Event Filtering

Efficiently query contract events:

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 3000; // Gnosis Chain 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:

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:

// Singleton pattern for provider
class GnosisProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-gnosis-mainnet.n.dwellir.com/YOUR_API_KEY'
      );
    }
    return this.instance;
  }
}

3. Smart Caching

Cache immutable data to reduce API calls:

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"

Gnosis Chain transactions require xDAI for gas:

// Check xDAI balance before transactions
const balance = await provider.getBalance(address);
const gasEstimate = await provider.estimateGas(tx);
const gasPrice = await provider.getGasPrice();
const totalRequired = gasEstimate * gasPrice + tx.value;

if (balance < totalRequired) {
  const shortage = ethers.formatEther(totalRequired - balance);
  throw new Error(`Need ${shortage} more xDAI`);
}

Error: "Transaction underpriced"

Gnosis Chain uses EIP-1559 pricing:

// 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:

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 Gnosis Chain requires minimal changes:

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

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

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ⚠️ Different chain ID (100)
// ⚠️ Native token is xDAI (not ETH)
// ⚠️ 5-second block times (faster than Ethereum)

Resources & Tools

Official Resources

• Gnosis Chain Documentation
• Gnosis Chain Bridge
• Gnosis Chain Block Explorer

Developer Tools

• Hardhat Config
• Foundry Setup
• Remix Integration

Need Help?

• 📧 Email: support@dwellir.com
• 📚 Docs: You're here!
• 🎯 Dashboard: dashboard.dwellir.com

---

Start building on Gnosis Chain with Dwellir's enterprise-grade RPC infrastructure. Get your API key →