eth_chainId

Returns the chain ID used for signing replay-protected transactions.

When to Use This Method

Use eth_chainId to:

• Network Verification - Ensure connected to the correct network
• Transaction Signing - Include chain ID for EIP-155 replay protection
• Multi-Chain Support - Switch between networks in dApps
• Configuration Validation - Verify network settings
• Cross-Chain Routing - Identify source chain for omnichain operations

xdc Chain ID

The xdc mainnet chain ID is: 0x1b58 (7000 in decimal)

Parameters

This method accepts no parameters.

{
  "jsonrpc": "2.0",
  "method": "eth_chainId",
  "params": [],
  "id": 1
}

Returns

QUANTITY - The chain ID as a hexadecimal string.

• Type: Hexadecimal string
• Format: 0x prefixed
• Value: 0x1b58 for xdc mainnet

Implementation Examples

cURL

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

JavaScript

// Using fetch
const response = await fetch('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_chainId',
    params: [],
    id: 1,
  }),
});

const data = await response.json();
const chainId = parseInt(data.result, 16);
console.log('Chain ID:', chainId); // 7000

// Using ethers.js
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY');
const network = await provider.getNetwork();
console.log('Network chain ID:', network.chainId);

// Using web3.js
import Web3 from 'web3';

const web3 = new Web3('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY');
const chainId = await web3.eth.getChainId();
console.log('xdc chain ID:', chainId);

// Cross-chain aware implementation
class OmnichainProvider {
  constructor() {
    this.providers = new Map();
    this.chainIds = new Map();
  }
  
  async addChain(name, rpcUrl) {
    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const chainId = Number((await provider.getNetwork()).chainId);
    
    this.providers.set(name, provider);
    this.chainIds.set(name, chainId);
    
    if (chainId === 7000) {
      console.log('Connected to xdc omnichain network');
    }
    
    return chainId;
  }
  
  async verifyxdc() {
    const zetaProvider = this.providers.get('xdc');
    if (!zetaProvider) {
      throw new Error('xdc provider not configured');
    }
    
    const chainId = await zetaProvider.send('eth_chainId', []);
    if (parseInt(chainId, 16) !== 7000) {
      throw new Error('Not connected to xdc mainnet');
    }
    
    return true;
  }
}

Python

import requests
import json

# Using requests
url = 'https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY'
headers = {'Content-Type': 'application/json'}
payload = {
    'jsonrpc': '2.0',
    'method': 'eth_chainId',
    'params': [],
    'id': 1
}

response = requests.post(url, headers=headers, data=json.dumps(payload))
result = response.json()
chain_id = int(result['result'], 16)
print(f'Chain ID: {chain_id}')  # 7000

# Using web3.py
from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY'))
chain_id = w3.eth.chain_id
print(f'xdc network chain ID: {chain_id}')

# Multi-chain verification
def verify_omnichain_setup():
    chains = {
        'xdc': 'https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY',
        'ethereum': 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
        'bsc': 'https://bsc-dataseed.binance.org/'
    }
    
    chain_ids = {}
    for name, rpc_url in chains.items():
        w3 = Web3(Web3.HTTPProvider(rpc_url))
        if w3.is_connected():
            chain_ids[name] = w3.eth.chain_id
            print(f'{name}: Chain ID {chain_ids[name]}')
    
    # Verify xdc is configured
    if chain_ids.get('xdc') != 7000:
        raise ValueError('xdc not properly configured')
    
    return chain_ids

Example Response

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x1b58"
}

Network Information

xdc Networks

Network	Chain ID (Hex)	Chain ID (Decimal)	Description
Mainnet	0x1b58	7000	xdc main network
Athens-3 Testnet	0x1b59	7001	xdc test network

Connected Chains

xdc connects to multiple blockchain networks:

Chain	Chain ID	Connection Type
Ethereum	1	Native Integration
Bitcoin	N/A	TSS Bridge
BSC	56	Native Integration
Polygon	137	Native Integration
Avalanche	43114	Native Integration

Common Use Cases

1. Network Verification

async function verifyNetwork() {
  const expectedChainId = 7000; // xdc mainnet
  const chainId = await provider.send('eth_chainId', []);
  const actualChainId = parseInt(chainId, 16);
  
  if (actualChainId !== expectedChainId) {
    throw new Error(`Wrong network! Expected ${expectedChainId}, got ${actualChainId}`);
  }
  
  console.log('Connected to xdc omnichain network');
  return true;
}

2. Omnichain dApp Configuration

const OMNICHAIN_CONFIG = {
  7000: {
    name: 'xdc Mainnet',
    symbol: 'ZETA',
    rpcUrl: 'https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY',
    explorer: 'https://explorer.xdc.com',
    connectorAddress: '0x239e96c8f17C85c30100AC26F635Ea15f23E9c67',
    supportedChains: [1, 56, 137, 43114] // ETH, BSC, Polygon, Avalanche
  },
  7001: {
    name: 'xdc Athens-3 Testnet',
    symbol: 'aZETA',
    rpcUrl: 'https://xdc-athens-3.g.allthatnode.com/archive/evm',
    explorer: 'https://athens.explorer.xdc.com',
    connectorAddress: '0x0000c9ec4042283e8139c74f4c64bcd1e0b9b54f',
    supportedChains: [5, 97, 80001, 43113] // Test networks
  }
};

async function getOmnichainConfig() {
  const chainId = await web3.eth.getChainId();
  const config = OMNICHAIN_CONFIG[chainId];
  
  if (!config) {
    throw new Error(`Unsupported network: ${chainId}`);
  }
  
  // Initialize cross-chain connectors
  for (const supportedChain of config.supportedChains) {
    console.log(`Supported cross-chain to: ${supportedChain}`);
  }
  
  return config;
}

3. EIP-155 Transaction Signing

async function signOmnichainTransaction(tx) {
  const chainId = await provider.send('eth_chainId', []);
  
  // Include chain ID for replay protection
  const signedTx = await wallet.signTransaction({
    ...tx,
    chainId: parseInt(chainId, 16),
    // xdc specific: cross-chain metadata
    zetaParams: tx.crossChain ? {
      destinationChainId: tx.destinationChainId,
      destinationGasLimit: tx.destinationGasLimit
    } : null
  });
  
  return signedTx;
}

4. Wallet Network Switch

async function switchToxdc() {
  try {
    await window.ethereum.request({
      method: 'wallet_switchEthereumChain',
      params: [{ chainId: '0x1b58' }],
    });
  } catch (switchError) {
    // Network not added to wallet
    if (switchError.code === 4902) {
      await window.ethereum.request({
        method: 'wallet_addEthereumChain',
        params: [{
          chainId: '0x1b58',
          chainName: 'xdc Mainnet',
          nativeCurrency: {
            name: 'ZETA',
            symbol: 'ZETA',
            decimals: 18
          },
          rpcUrls: ['https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY'],
          blockExplorerUrls: ['https://explorer.xdc.com']
        }],
      });
    }
  }
}

5. Cross-Chain Transaction Router

class CrossChainRouter {
  constructor() {
    this.chainProviders = new Map();
  }
  
  async initializeChain(chainId, rpcUrl) {
    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const network = await provider.getNetwork();
    
    if (Number(network.chainId) !== chainId) {
      throw new Error(`Chain ID mismatch: expected ${chainId}, got ${network.chainId}`);
    }
    
    this.chainProviders.set(chainId, provider);
    
    // Special handling for xdc
    if (chainId === 7000) {
      this.zetaProvider = provider;
      console.log('xdc omnichain hub initialized');
    }
  }
  
  async routeCrossChainMessage(sourceChainId, destChainId, message) {
    // Verify xdc is available for routing
    if (!this.zetaProvider) {
      throw new Error('xdc hub not initialized');
    }
    
    const xdcId = await this.zetaProvider.send('eth_chainId', []);
    if (parseInt(xdcId, 16) !== 7000) {
      throw new Error('Invalid xdc connection');
    }
    
    // Route through xdc
    const connector = new ethers.Contract(
      CONNECTOR_ADDRESS,
      CONNECTOR_ABI,
      this.zetaProvider
    );
    
    return await connector.send({
      sourceChainId,
      destChainId,
      message,
      gasLimit: 200000
    });
  }
}

Chain ID in Omnichain Context

Cross-Chain Identification

// xdc uses chain IDs to route cross-chain messages
async function sendCrossChainMessage(destChainId, message) {
  const xdcId = await provider.send('eth_chainId', []);
  
  if (parseInt(xdcId, 16) !== 7000) {
    throw new Error('Must be connected to xdc');
  }
  
  const crossChainTx = {
    to: CONNECTOR_CONTRACT,
    data: encodeCrossChainCall(destChainId, message),
    value: calculateCrossChainFee(destChainId)
  };
  
  return await signer.sendTransaction(crossChainTx);
}

Chain ID Mapping

const CHAIN_ID_MAP = {
  // xdc
  7000: { name: 'xdc', type: 'hub', symbol: 'ZETA' },
  
  // Connected EVM Chains
  1: { name: 'Ethereum', type: 'evm', symbol: 'ETH' },
  56: { name: 'BSC', type: 'evm', symbol: 'BNB' },
  137: { name: 'Polygon', type: 'evm', symbol: 'MATIC' },
  43114: { name: 'Avalanche', type: 'evm', symbol: 'AVAX' },
  
  // Bitcoin (special handling)
  8332: { name: 'Bitcoin', type: 'bitcoin', symbol: 'BTC' }
};

function getChainInfo(chainId) {
  return CHAIN_ID_MAP[chainId] || { name: 'Unknown', type: 'unknown' };
}

Best Practices

1. Always verify chain ID before sending transactions
2. Cache chain ID to reduce RPC calls
3. Handle network switches gracefully
4. Use chain ID for transaction replay protection
5. Validate against expected network for omnichain operations

Error Codes

Code	Message	Description
-32600	Invalid Request	The JSON sent is not valid
-32601	Method not found	Method doesn't exist
-32602	Invalid params	Invalid parameters
-32603	Internal error	Internal JSON-RPC error

Related Methods

• net_version - Get network version
• eth_getBlockByNumber - Get block information
• eth_sendRawTransaction - Send signed transaction
• eth_accounts - List available accounts