Sonic - The Fastest EVM Layer-1 Blockchain

Sonic RPC
With Dwellir, you get access to our global Sonic 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 Sonic?

Sonic is the highest-performing EVM Layer-1 blockchain, evolved from Fantom, designed to power the next generation of DeFi applications. Combining unprecedented speed with developer-first incentives, Sonic offers:

⚡ Unmatched Performance

• 400,000 TPS capability - Theoretical throughput that sets new industry standards
• Sub-second finality - Get instant transaction confirmations
• 10,000 verifiable TPS - Real-world performance with near-instant settlement

💰 Revolutionary Fee Monetization

• 90% fee rebates - Developers earn up to 90% of transaction fees through FeeM
• Sustainable revenue model - Web2-like monetization for Web3 applications
• Developer incentives - 200M S tokens allocated through Innovator Fund

🔧 Advanced Technology Stack

• SonicVM optimization - Super instructions that accelerate smart contract execution
• SonicDB efficiency - 96% reduction in node operating costs
• Full EVM compatibility - Deploy existing Ethereum apps without code changes

Quick Start with Sonic

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

🔗 RPC Endpoints

Sonic Mainnet (Chain ID: 146)Live

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

✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket

Quick Connect:

curl -X POST https://api-sonic-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 Sonic mainnet
const provider = new JsonRpcProvider(
  'https://api-sonic-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());

Web3.js

const Web3 = require('web3');

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

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

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

Viem

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

// Define Sonic chain
const sonic = defineChain({
  id: 146,
  name: 'Sonic',
  nativeCurrency: {
    decimals: 18,
    name: 'Sonic',
    symbol: 'S',
  },
  rpcUrls: {
    default: {
      http: ['https://api-sonic-mainnet.n.dwellir.com/YOUR_API_KEY'],
    },
  },
});

// Create Sonic client
const client = createPublicClient({
  chain: sonic,
  transport: http('https://api-sonic-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

146

Mainnet

Block Time

< 1 second

Average

Gas Token

S

Native token

RPC Standard

Ethereum

JSON-RPC 2.0

JSON-RPC API Reference

Sonic supports the full Ethereum JSON-RPC API specification. Access all standard methods with industry-leading performance.

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 build blazing-fast dApps on Sonic?

Get your API key →

Common Integration Patterns

🔄 Transaction Monitoring

Monitor pending and confirmed transactions efficiently:

// Watch for transaction confirmation with sub-second finality
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);
  
  // Sonic's fast finality means confirmations are near-instant
  console.log('Transaction confirmed in block:', receipt.blockNumber);
  
  return receipt;
}

💰 Gas Optimization

Optimize gas costs on Sonic:

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

// Get current gas price
const gasPrice = await provider.getGasPrice();

// Total cost in S tokens
const totalCost = gasEstimate * gasPrice;
console.log('Transaction cost:', totalCost, 'S');

🔍 Event Filtering

Efficiently query contract events with Sonic's high throughput:

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 10000; // Sonic can handle larger batches
  
  const currentBlock = await provider.getBlockNumber();
  
  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 SonicProvider {
  static instance = null;
  
  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-sonic-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 for transaction"

Ensure your account has enough S tokens for gas fees:

// Check balance before sending transaction
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) {
  throw new Error(`Need ${totalRequired - balance} more S tokens`);
}

Error: "Transaction underpriced"

Sonic supports EIP-1559 pricing. Always use dynamic gas 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;
      }
    }
  }
}

FAQs

How do I migrate from Fantom to Sonic?

Sonic is a direct evolution of Fantom with a 1:1 token swap from FTM to S. Your existing Fantom applications can be deployed on Sonic with minimal changes - just update your RPC endpoint and chain ID.

What makes Sonic different from other L1s?

Sonic combines industry-leading performance (400k TPS capability) with unique developer incentives through Fee Monetization (FeeM), where developers earn up to 90% of transaction fees generated by their dApps.

Is Sonic compatible with existing Ethereum tools?

Yes! Sonic is fully EVM-compatible and works with all Ethereum tooling including MetaMask, Hardhat, Foundry, Truffle, and more. Simply configure them with Sonic's chain ID (146) and RPC endpoint.

Smoke Tests

Verify your Sonic integration with these quick tests:

// Test 1: Check connection
const chainId = await provider.getNetwork();
console.assert(chainId.chainId === 146n, 'Connected to Sonic mainnet');

// Test 2: Query recent block
const block = await provider.getBlock('latest');
console.log('Current block:', block.number);

// Test 3: Check USDC contract
const usdcAddress = '0x29219dd400f2Bf60E5a23d13Be72B486D4038894';
const code = await provider.getCode(usdcAddress);
console.assert(code !== '0x', 'USDC contract exists');

Migration Guide

From Fantom Opera

Migrating from Fantom Opera to Sonic is straightforward:

// Before (Fantom)
const provider = new JsonRpcProvider('https://rpc.ftm.tools');

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

// ✅ Smart contracts work identically
// ✅ Same tooling and libraries
// ⚠️ Different chain ID (146 vs 250)
// ⚠️ New native token (S instead of FTM)
// ✅ 1:1 token swap available

Resources & Tools

Official Resources

• Sonic Documentation
• Sonic Bridge
• Sonic Explorer

Developer Tools

• Hardhat Config
• Foundry Setup
• Truffle Integration

Need Help?

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

---

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