Mantle - Modular L2 Documentation

Mantle RPC

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

Get your API key

Mantle 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 Mantle supports it.

Details: Pricing · Rate limits · Authentication · Archive nodes

Why Build on Mantle?Copy Anchor Link

Mantle Network is the first modular Layer 2 solution, pioneering the use of EigenDA for data availability. Built on the OP Stack with innovative architectural designs, Mantle offers:

Modular PerformanceCopy Anchor Link

• Sub-second block times - Fast finality with optimistic rollup
• Up to 500x lower costs than Ethereum mainnet
• 20,000+ TPS capacity - High throughput for demanding applications

Advanced SecurityCopy Anchor Link

• EigenDA integration - First L2 with decentralized data availability
• Optimistic rollup security - Fraud proof protection with 7-day challenge period
• Ethereum inheritance - Full L1 security guarantees

Developer ExcellenceCopy Anchor Link

• Full EVM compatibility - Deploy existing contracts without changes
• MNT gas token - Native token for gas and governance
• OP Stack foundation - Battle-tested infrastructure

Quick Start with MantleCopy Anchor Link

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

Mantle RPC Endpoints

MainnetTestnet

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

curlJavaScriptPythonGo

Copy Text

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

Installation & SetupCopy Anchor Link

import { JsonRpcProvider } from 'ethers';

// Connect to Mantle mainnet
const provider = new JsonRpcProvider(
  'https://api-mantle-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Get network info
const network = await provider.getNetwork();
console.log('Connected to Mantle:', network.chainId); // 5000

// Query blockchain data
const blockNumber = await provider.getBlockNumber();
const balance = await provider.getBalance('0x...');
const gas = await provider.getFeeData();

Network InformationCopy Anchor Link

Mainnet ConfigurationCopy Anchor Link

Testnet Configuration (Sepolia)Copy Anchor Link

Available RPC MethodsCopy Anchor Link

Mantle supports all standard Ethereum JSON-RPC methods plus L2-specific extensions:

Core MethodsCopy Anchor Link

• Transaction Management - Send, sign, and track transactions
• State Queries - Get balances, code, storage
• Block Information - Query blocks and receipts
• Event Logs - Filter and retrieve events
• Gas Estimation - Estimate fees including L1 costs

L2-Specific MethodsCopy Anchor Link

• eth_estimateL1Fee - Calculate L1 data posting costs
• rollup_gasPrices - Get current L1/L2 gas prices
• rollup_getInfo - Query rollup configuration

Debug & Trace MethodsCopy Anchor Link

• debug_traceTransaction - Detailed transaction execution traces
• debug_traceBlock - Trace all transactions in a block
• debug_traceCall - Simulate and trace calls

Architecture OverviewCopy Anchor Link

Modular DesignCopy Anchor Link

Mantle's modular architecture separates core blockchain functions for optimal performance:

1. Execution Layer - Processes transactions using the EVM
2. Settlement Layer - Posts state commitments to Ethereum
3. Data Availability Layer - Uses EigenDA for efficient data storage
4. Consensus Layer - Inherits security from Ethereum L1

EigenDA IntegrationCopy Anchor Link

As the first L2 to integrate EigenDA, Mantle benefits from:

• Lower costs - Reduced data storage expenses
• Higher throughput - More efficient data availability
• Decentralization - Distributed DA layer
• ETH restaking - Additional security through EigenLayer

Transaction LifecycleCopy Anchor Link

1. Submission - Users submit transactions to Mantle sequencer
2. Execution - Transactions processed in batches
3. Data Posting - Transaction data posted to EigenDA
4. Settlement - State root submitted to Ethereum L1
5. Finality - After 7-day challenge period

Development ResourcesCopy Anchor Link

Smart Contract DeploymentCopy Anchor Link

Deploy your contracts to Mantle without modifications:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MantleApp {
    mapping(address => uint256) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
}

Using MNT TokenCopy Anchor Link

MNT is used for gas payments on Mantle:

// Send MNT
const tx = await signer.sendTransaction({
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
  value: ethers.parseEther('1.0') // 1 MNT
});

// Estimate gas in MNT
const gasEstimate = await provider.estimateGas(tx);
const gasPrice = await provider.getFeeData();
const gasCost = gasEstimate * gasPrice.gasPrice; // Cost in MNT

Bridging AssetsCopy Anchor Link

Bridge assets between Ethereum and Mantle:

// Bridge configuration
const BRIDGE_ADDRESS = '0x...'; // Mantle Bridge contract
const L1_TOKEN = '0x...'; // Token on Ethereum
const L2_TOKEN = '0x...'; // Token on Mantle

// Deposit from L1 to L2
async function depositToMantle(amount) {
  const bridge = new Contract(BRIDGE_ADDRESS, BRIDGE_ABI, l1Signer);
  const tx = await bridge.depositERC20(
    L1_TOKEN,
    L2_TOKEN,
    amount,
    { value: bridgeFee }
  );
  await tx.wait();
}

Gas OptimizationCopy Anchor Link

Understanding Mantle FeesCopy Anchor Link

Mantle fees consist of two components:

1. L2 Execution Fee - Cost to run transaction on Mantle
2. L1 Data Fee - Cost to post data to Ethereum (via EigenDA)

// Calculate total fee
const l2GasPrice = await provider.getGasPrice();
const l2GasUsed = await provider.estimateGas(tx);
const l1Fee = await provider.send('eth_estimateL1Fee', [tx]);

const totalFee = (l2GasPrice * l2GasUsed) + BigInt(l1Fee);
console.log('Total fee:', ethers.formatEther(totalFee), 'MNT');

Optimization TipsCopy Anchor Link

1. Batch Operations - Combine multiple operations in one transaction
2. Use Events - Cheaper than storage for data that doesn't need to be on-chain
3. Optimize Calldata - Minimize transaction input data
4. Storage Packing - Pack multiple values into single storage slots

Common Use CasesCopy Anchor Link

DeFi ProtocolsCopy Anchor Link

• Lower fees enable more frequent rebalancing and smaller trades
• High throughput supports order book DEXs
• Fast finality improves user experience

Gaming & NFTsCopy Anchor Link

• Affordable minting and trading
• High-frequency game actions
• Complex on-chain game logic

DAOs & GovernanceCopy Anchor Link

• Cost-effective voting
• More frequent proposal submissions
• On-chain treasury management

Best PracticesCopy Anchor Link

Error HandlingCopy Anchor Link

try {
  const tx = await contract.someMethod();
  const receipt = await tx.wait();

  if (receipt.status === 0) {
    throw new Error('Transaction reverted');
  }
} catch (error) {
  if (error.code === 'CALL_EXCEPTION') {
    console.error('Contract reverted:', error.reason);
  } else if (error.code === 'INSUFFICIENT_FUNDS') {
    console.error('Not enough MNT for gas');
  }
}

Rate LimitingCopy Anchor Link

// Implement exponential backoff
async function retryWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;

      const delay = Math.pow(2, i) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Support & ResourcesCopy Anchor Link

Official ResourcesCopy Anchor Link

• Documentation: docs.mantle.xyz
• GitHub: github.com/mantlenetworkio
• Discord: discord.gg/mantle
• Twitter: @0xMantle

Dwellir SupportCopy Anchor Link

• Dashboard: dashboard.dwellir.com
• Status Page: status.dwellir.com
• Support: support@dwellir.com

Start BuildingCopy Anchor Link

Ready to build on Mantle? Get your free API key and start developing:

Need help? Check our API reference or contact support.