ZetaChain - Omnichain Smart Contract Platform

ZetaChain RPC

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

Get your API key

ZetaChain RPC plans and rate limitsCopy Anchor Link

• 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 ZetaChain supports it.

Details: Pricing · Rate limits · Authentication · Archive nodes

What is ZetaChain?Copy Anchor Link

ZetaChain is the foundational layer for universal blockchain interoperability, enabling omnichain smart contracts and messaging between any blockchain. As a Proof-of-Stake blockchain built on Cosmos SDK and Tendermint consensus, ZetaChain connects all blockchains, including Bitcoin, Ethereum, and other chains without smart contracts.

Key FeaturesCopy Anchor Link

• ** Universal Connectivity** - Connect to any blockchain, including Bitcoin and non-smart contract chains
• ** Omnichain Smart Contracts** - Deploy contracts that can read and write to multiple chains
• ** Native Cross-Chain Swaps** - Swap assets across chains without wrapped tokens
• ** Decentralized Security** - Secured by a decentralized network of validators
• ** High Performance** - Fast finality with 6-second block times
• ** EVM Compatible** - Full Ethereum compatibility for easy dApp migration

Why Choose ZetaChain?Copy Anchor Link

For Cross-Chain DevelopersCopy Anchor Link

ZetaChain revolutionizes cross-chain development with its unique omnichain smart contract capability:

• Single Contract, Multiple Chains - Write once, interact with all chains
• Native Asset Support - Handle native tokens without wrapping
• Simplified Architecture - No bridges or wrapped tokens needed
• Universal Messaging - Send messages and data between any chains

For DeFi BuildersCopy Anchor Link

Build truly interoperable DeFi applications:

• Cross-Chain Liquidity - Access liquidity from multiple chains
• Omnichain DEXs - Trade assets across chains seamlessly
• Multi-Chain Yield - Optimize yields across different blockchains
• Universal Wallets - One address for all chains

For NFT ProjectsCopy Anchor Link

Create omnichain NFT experiences:

• Cross-Chain NFTs - NFTs that exist across multiple chains
• Multi-Chain Marketplaces - Buy and sell NFTs from any chain
• Interoperable Gaming - Game assets usable across different chains

Quick Start with ZetaChainCopy Anchor Link

Connect to ZetaChain in seconds with Dwellir's optimized endpoints:

ZetaChain RPC Endpoints

HTTPShttps://api-zetachain-mainnet.n.dwellir.com/<your-api-key>

curlJavaScriptPythonGo

Copy Text

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

Network InformationCopy Anchor Link

Installation & SetupCopy Anchor Link

API ReferenceCopy Anchor Link

Omnichain Smart ContractsCopy Anchor Link

ZetaChain's unique omnichain smart contracts can interact with multiple blockchains:

// Example: Omnichain DEX Contract
pragma solidity 0.8.7;

import "@zetachain/protocol-contracts/contracts/zevm/SystemContract.sol";
import "@zetachain/protocol-contracts/contracts/zevm/interfaces/IZRC20.sol";

contract OmnichainDEX {
    SystemContract public systemContract;

    constructor(address systemContractAddress) {
        systemContract = SystemContract(systemContractAddress);
    }

    // Swap tokens across any chain
    function crossChainSwap(
        address zrc20From,
        address zrc20To,
        uint256 amount,
        bytes calldata recipient
    ) external {
        // Transfer from user
        IZRC20(zrc20From).transferFrom(msg.sender, address(this), amount);

        // Perform swap logic
        uint256 amountOut = calculateSwapAmount(zrc20From, zrc20To, amount);

        // Send to recipient on destination chain
        IZRC20(zrc20To).withdraw(recipient, amountOut);
    }
}

Cross-Chain MessagingCopy Anchor Link

Send messages between any blockchains:

// Send cross-chain message from Ethereum to Bitcoin
const connector = new ethers.Contract(connectorAddress, connectorABI, signer);

const tx = await connector.send({
    destinationChainId: "18332", // Bitcoin testnet
    destinationAddress: bitcoinAddress,
    destinationGasLimit: 100000,
    message: ethers.utils.defaultAbiCoder.encode(
        ["string"],
        ["Hello from Ethereum!"]
    ),
    zetaValueAndGas: ethers.utils.parseEther("0.1"),
    zetaParams: "0x"
});

console.log('Cross-chain message sent:', tx.hash);

Available MethodsCopy Anchor Link

ZetaChain supports all standard Ethereum JSON-RPC methods:

Core MethodsCopy Anchor Link

• eth_blockNumber - Get the latest block number
• eth_call - Execute a smart contract call
• eth_chainId - Get the chain ID (7000)
• eth_getBalance - Query account balance

Transaction MethodsCopy Anchor Link

• eth_sendRawTransaction - Send signed transactions
• eth_getTransactionByHash - Get transaction details
• eth_getTransactionReceipt - Get transaction receipt
• eth_estimateGas - Estimate gas for transactions

Block MethodsCopy Anchor Link

• eth_getBlockByNumber - Get block by number
• eth_getBlockByHash - Get block by hash

Smart Contract MethodsCopy Anchor Link

• eth_getCode - Get contract bytecode
• eth_getStorageAt - Read contract storage

Event MethodsCopy Anchor Link

• eth_getLogs - Query event logs
• eth_newFilter - Create event filter (documentation coming soon)

Rate Limits & PerformanceCopy Anchor Link

Endpoint PerformanceCopy Anchor Link

• Throughput: 10,000+ requests/second
• Latency: < 50ms average response time
• Uptime: 99.99% SLA guarantee
• Geographic Distribution: Global edge locations

Rate Limiting TiersCopy Anchor Link

Developer ResourcesCopy Anchor Link

Official DocumentationCopy Anchor Link

• ZetaChain Docs - Official documentation
• GitHub - Source code and examples
• Explorer - Block explorer

SDK & ToolsCopy Anchor Link

• @zetachain/toolkit - JavaScript SDK
• @zetachain/protocol-contracts - Smart contract interfaces
• Hardhat Template - Starter template

Community & SupportCopy Anchor Link

• Discord - Developer community
• Twitter - Latest updates
• Telegram - Community chat

Best PracticesCopy Anchor Link

1. Connection ManagementCopy Anchor Link

// Implement retry logic for resilience
async function createProvider() {
  const provider = new ethers.JsonRpcProvider(
    'https://api-zetachain-mainnet.n.dwellir.com/YOUR_API_KEY'
  );

  // Set custom timeout
  provider._getConnection().timeout = 10000;

  // Verify connection
  try {
    await provider.getNetwork();
    return provider;
  } catch (error) {
    console.error('Connection failed, retrying...');
    await new Promise(r => setTimeout(r, 1000));
    return createProvider();
  }
}

2. Gas OptimizationCopy Anchor Link

// Optimize gas for cross-chain transactions
async function estimateCrossChainGas(contract, method, params) {
  // Get current gas price
  const gasPrice = await provider.getGasPrice();

  // Estimate gas with buffer for cross-chain
  const estimatedGas = await contract.estimateGas[method](...params);
  const gasLimit = estimatedGas.mul(120).div(100); // 20% buffer

  return {
    gasLimit,
    gasPrice: gasPrice.mul(110).div(100) // 10% above current
  };
}

3. Event MonitoringCopy Anchor Link

// Monitor cross-chain events efficiently
function watchCrossChainEvents(contract) {
  const filter = contract.filters.CrossChainCall();

  contract.on(filter, (from, to, amount, destinationChain, event) => {
    console.log(`Cross-chain transfer: ${from} → ${to}`);
    console.log(`Amount: ${amount}, Chain: ${destinationChain}`);
    console.log(`Transaction: ${event.transactionHash}`);
  });
}

Security ConsiderationsCopy Anchor Link

Cross-Chain SecurityCopy Anchor Link

• Always validate destination addresses
• Implement proper access controls
• Use time locks for large transfers
• Monitor cross-chain message status

Smart Contract Best PracticesCopy Anchor Link

// Secure cross-chain transfer
modifier validateCrossChain(uint256 chainId) {
    require(
        systemContract.isValidChainId(chainId),
        "Invalid destination chain"
    );
    _;
}

function secureCrossChainTransfer(
    uint256 destinationChainId,
    bytes calldata recipient,
    uint256 amount
) external validateCrossChain(destinationChainId) {
    // Implementation
}

Need Help?Copy Anchor Link

Email: support@dwellir.com Discord: Join our community More Docs: dwellir.com/docs

Start building omnichain dApps with ZetaChain today!