rollup_getInfo

Get modular L2 rollup configuration on the Mantle network. This method provides essential information about the optimistic rollup parameters, settings, and operational details.

Overview

Mantle's modular L2 architecture is an optimistic rollup that leverages modular components for enhanced performance and scalability. The rollup configuration includes important parameters for:

• Batch Processing: How transactions are batched and processed
• Data Availability: EigenDA integration for efficient data posting
• Bridge Operations: L1 ↔ L2 asset bridging configuration
• Network Parameters: Chain ID, block times, and operational settings

Parameters

This method typically takes no parameters, but implementation may vary. Please refer to the official Mantle documentation for the most current parameter specifications.

Returns

Rollup configuration object containing comprehensive information about the modular L2 rollup setup.

Implementation Example

cURL

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

JavaScript

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

const data = await response.json();
console.log('Rollup Info:', data.result);

// Advanced Mantle modular L2 rollup information analyzer
class MantleRollupAnalyzer {
  constructor(rpcUrl) {
    this.rpcUrl = rpcUrl;
  }

  async getRollupInfo() {
    const response = await fetch(this.rpcUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'rollup_getInfo',
        params: [],
        id: 1
      })
    });

    const data = await response.json();
    
    if (data.error) {
      throw new Error(`RPC Error: ${data.error.message}`);
    }

    return data.result;
  }

  async getComprehensiveRollupStatus() {
    try {
      // Get rollup info
      const rollupInfo = await this.getRollupInfo();
      
      // Get current chain info
      const chainIdResponse = await fetch(this.rpcUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          method: 'eth_chainId',
          params: [],
          id: 1
        })
      });

      const chainData = await chainIdResponse.json();
      const chainId = parseInt(chainData.result, 16);

      // Get latest block info
      const blockResponse = await fetch(this.rpcUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          method: 'eth_getBlockByNumber',
          params: ['latest', false],
          id: 1
        })
      });

      const blockData = await blockResponse.json();
      const latestBlock = blockData.result;

      return {
        timestamp: new Date().toISOString(),
        network: {
          name: 'Mantle',
          chainId: chainId,
          type: 'Modular L2 Optimistic Rollup'
        },
        rollupConfig: rollupInfo,
        currentState: {
          latestBlock: parseInt(latestBlock.number, 16),
          blockHash: latestBlock.hash,
          timestamp: parseInt(latestBlock.timestamp, 16),
          gasLimit: parseInt(latestBlock.gasLimit, 16),
          gasUsed: parseInt(latestBlock.gasUsed, 16),
          utilization: ((parseInt(latestBlock.gasUsed, 16) / parseInt(latestBlock.gasLimit, 16)) * 100).toFixed(2)
        },
        analysis: this.analyzeRollupConfig(rollupInfo, chainId)
      };
    } catch (error) {
      throw new Error(`Failed to get comprehensive status: ${error.message}`);
    }
  }

  analyzeRollupConfig(rollupInfo, chainId) {
    const analysis = {
      networkType: 'Modular L2 Optimistic Rollup',
      securityModel: 'Optimistic with fraud proofs',
      dataAvailability: 'EigenDA integration',
      features: [],
      optimizations: [],
      considerations: []
    };

    // Analyze chain ID
    if (chainId === 5000) {
      analysis.features.push('Mantle Mainnet');
      analysis.features.push('Production Network');
    } else if (chainId === 5003) {
      analysis.features.push('Mantle Sepolia Testnet');
      analysis.features.push('Development Network');
    }

    // General modular L2 features
    analysis.features.push('EVM Compatibility');
    analysis.features.push('Optimistic Rollup Architecture');
    analysis.features.push('EigenDA Data Availability');
    analysis.features.push('MNT Gas Token');
    analysis.features.push('OP Stack Foundation');

    // Optimizations
    analysis.optimizations.push('High Throughput via Modular Architecture');
    analysis.optimizations.push('Low Transaction Costs');
    analysis.optimizations.push('Fast L2 Finality');
    analysis.optimizations.push('Ethereum Virtual Machine Compatibility');
    analysis.optimizations.push('Efficient Data Availability via EigenDA');

    // Considerations
    analysis.considerations.push('7-day withdrawal period for L1 finality');
    analysis.considerations.push('L1 data posting costs via EigenDA');
    analysis.considerations.push('Optimistic fraud proof mechanism');

    return analysis;
  }

  async compareWithOtherL2s() {
    const mantleInfo = await this.getComprehensiveRollupStatus();
    
    // This would be expanded with actual data from other L2s
    const comparison = {
      mantle: {
        type: 'Modular L2 Optimistic Rollup',
        proofSystem: 'Fraud Proofs',
        evmCompatibility: 'Full',
        dataAvailability: 'EigenDA',
        finality: 'Optimistic → Proven',
        withdrawalTime: '~7 days',
        gasToken: 'MNT',
        advantages: [
          'Modular architecture for flexibility',
          'EigenDA for efficient data availability',
          'Fast transaction processing',
          'MNT gas token benefits',
          'OP Stack foundation'
        ]
      },
      zkRollups: {
        type: 'Zero-Knowledge',
        proofSystem: 'Zero-Knowledge Proofs',
        evmCompatibility: 'Full (zkEVM)',
        dataAvailability: 'On-chain (Ethereum L1)',
        finality: 'Cryptographic',
        withdrawalTime: '~7 days (pending finalization)',
        tradeoffs: [
          'Cryptographic security guarantees',
          'Privacy-preserving proofs',
          'Higher computational overhead',
          'Proof generation complexity'
        ]
      },
      comparison: {
        security: 'Both provide strong security with different mechanisms',
        performance: 'Mantle optimized for high throughput',
        costs: 'Mantle benefits from EigenDA cost efficiency',
        devExperience: 'Both offer full EVM compatibility'
      }
    };

    return comparison;
  }

  async monitorRollupHealth() {
    const health = {
      timestamp: new Date().toISOString(),
      status: 'unknown',
      metrics: {},
      alerts: []
    };

    try {
      const status = await this.getComprehensiveRollupStatus();
      
      // Check basic connectivity and latest block
      const blockAge = Date.now() / 1000 - status.currentState.timestamp;
      
      health.metrics = {
        latestBlock: status.currentState.latestBlock,
        blockAge: blockAge,
        gasUtilization: parseFloat(status.currentState.utilization),
        chainId: status.network.chainId
      };

      // Health checks
      if (blockAge > 300) { // 5 minutes
        health.alerts.push({
          severity: 'warning',
          message: `Latest block is ${Math.floor(blockAge / 60)} minutes old`,
          recommendation: 'Check network connectivity and block production'
        });
      }

      if (health.metrics.gasUtilization > 90) {
        health.alerts.push({
          severity: 'info',
          message: `High gas utilization: ${health.metrics.gasUtilization}%`,
          recommendation: 'Network is experiencing high usage'
        });
      }

      health.status = health.alerts.length === 0 ? 'healthy' : 
                    health.alerts.some(a => a.severity === 'error') ? 'unhealthy' : 'warning';

    } catch (error) {
      health.status = 'error';
      health.alerts.push({
        severity: 'error',
        message: `Failed to get rollup status: ${error.message}`,
        recommendation: 'Check RPC endpoint connectivity'
      });
    }

    return health;
  }

  async getNetworkCapacityInfo() {
    try {
      const status = await this.getComprehensiveRollupStatus();
      
      const capacity = {
        current: {
          blockGasLimit: status.currentState.gasLimit,
          blockGasUsed: status.currentState.gasUsed,
          utilizationPercentage: parseFloat(status.currentState.utilization)
        },
        theoretical: {
          maxTxPerSecond: 0, // Would be calculated based on average gas per tx
          maxTxPerBlock: 0,
          avgBlockTime: 0 // Would need historical data
        },
        estimates: {
          simpleTransfers: Math.floor(status.currentState.gasLimit / 21000),
          erc20Transfers: Math.floor(status.currentState.gasLimit / 65000),
          complexContracts: Math.floor(status.currentState.gasLimit / 200000)
        }
      };

      return capacity;
    } catch (error) {
      throw new Error(`Failed to get capacity info: ${error.message}`);
    }
  }

  async analyzeUpgradeability() {
    const rollupInfo = await this.getRollupInfo();
    
    // This would analyze the actual rollup configuration
    // For demonstration, providing general modular L2 upgrade analysis
    return {
      upgradeType: 'Governed Upgrades',
      governanceModel: 'Multi-signature or DAO governance',
      upgradeProcess: [
        'Proposal submission',
        'Community review',
        'Governance voting',
        'Implementation timeline',
        'Upgrade execution'
      ],
      considerations: [
        'Modular architecture allows component upgrades',
        'Smart contract upgrades follow standard patterns',
        'L1 contract upgrades need careful coordination',
        'Backward compatibility maintenance'
      ],
      riskMitigation: [
        'Extensive testing on testnets',
        'Gradual rollout procedures',
        'Emergency pause mechanisms',
        'Rollback capabilities where possible'
      ]
    };
  }

  async getBridgeInfo() {
    // This would integrate with bridge contracts
    // For demonstration, providing general bridge information
    return {
      bridgeType: 'Canonical Bridge',
      supportedAssets: [
        'ETH (bridged)',
        'MNT (native gas token)',
        'ERC-20 Tokens',
        'ERC-721 NFTs',
        'ERC-1155 Multi-tokens'
      ],
      bridgeProcess: {
        deposit: {
          timeToL2: '~15 minutes',
          steps: [
            'Lock tokens on L1',
            'Wait for L1 confirmation',
            'Mint on L2',
            'Tokens available on L2'
          ]
        },
        withdrawal: {
          timeToL1: '~7 days',
          steps: [
            'Burn tokens on L2',
            'Include in batch',
            'Submit to L1',
            'Challenge period (7 days)',
            'Claim on L1'
          ]
        }
      },
      security: {
        model: 'Optimistic fraud proofs',
        assumptions: 'Ethereum L1 security + honest validator assumption',
        risks: [
          'Smart contract bugs',
          'Fraud proof mechanism vulnerabilities',
          'Bridge implementation issues'
        ]
      }
    };
  }
}

// Usage examples
const rollupAnalyzer = new MantleRollupAnalyzer('https://api-mantle-mainnet.n.dwellir.com/YOUR_API_KEY');

// Get basic rollup info
const rollupInfo = await rollupAnalyzer.getRollupInfo();
console.log('Rollup Configuration:', rollupInfo);

// Get comprehensive status
const comprehensiveStatus = await rollupAnalyzer.getComprehensiveRollupStatus();
console.log('Network Status:', comprehensiveStatus);

// Monitor rollup health
const healthStatus = await rollupAnalyzer.monitorRollupHealth();
console.log('Health Status:', healthStatus.status);
console.log('Alerts:', healthStatus.alerts);

// Get network capacity info
const capacityInfo = await rollupAnalyzer.getNetworkCapacityInfo();
console.log('Network Capacity:', capacityInfo);

// Compare with other L2s
const comparison = await rollupAnalyzer.compareWithOtherL2s();
console.log('L2 Comparison:', comparison);

// Analyze upgradeability
const upgradeAnalysis = await rollupAnalyzer.analyzeUpgradeability();
console.log('Upgrade Model:', upgradeAnalysis);

// Get bridge information
const bridgeInfo = await rollupAnalyzer.getBridgeInfo();
console.log('Bridge Details:', bridgeInfo);

Python

import requests
import json
import time
from typing import Dict, List, Any, Optional
from datetime import datetime

class MantleRollupInfoAnalyzer:
    """Comprehensive analyzer for Mantle modular L2 rollup information"""
    
    def __init__(self, rpc_url: str):
        self.rpc_url = rpc_url
    
    def get_rollup_info(self) -> Dict[str, Any]:
        """Get basic rollup configuration information"""
        
        payload = {
            "jsonrpc": "2.0",
            "method": "rollup_getInfo",
            "params": [],
            "id": 1
        }
        
        response = requests.post(self.rpc_url, json=payload)
        data = response.json()
        
        if 'error' in data:
            raise Exception(f"RPC Error: {data['error']['message']}")
        
        return data['result']
    
    def _make_rpc_call(self, method: str, params: List = None) -> Any:
        """Helper method for making RPC calls"""
        
        payload = {
            "jsonrpc": "2.0",
            "method": method,
            "params": params or [],
            "id": 1
        }
        
        response = requests.post(self.rpc_url, json=payload)
        data = response.json()
        
        if 'error' in data:
            raise Exception(f"RPC Error: {data['error']['message']}")
        
        return data['result']
    
    def get_comprehensive_rollup_status(self) -> Dict[str, Any]:
        """Get comprehensive rollup status and configuration"""
        
        rollup_info = self.get_rollup_info()
        
        # Get additional network information
        chain_id = int(self._make_rpc_call('eth_chainId'), 16)
        latest_block = self._make_rpc_call('eth_getBlockByNumber', ['latest', False])
        
        block_number = int(latest_block['number'], 16)
        block_timestamp = int(latest_block['timestamp'], 16)
        gas_limit = int(latest_block['gasLimit'], 16)
        gas_used = int(latest_block['gasUsed'], 16)
        
        return {
            'timestamp': datetime.now().isoformat(),
            'network_info': {
                'name': 'Mantle',
                'chain_id': chain_id,
                'type': 'Modular L2 Optimistic Rollup',
                'consensus': 'Optimistic with fraud proofs'
            },
            'rollup_config': rollup_info,
            'current_state': {
                'latest_block': block_number,
                'block_hash': latest_block['hash'],
                'block_timestamp': block_timestamp,
                'gas_limit': gas_limit,
                'gas_used': gas_used,
                'gas_utilization': round((gas_used / gas_limit) * 100, 2),
                'block_age_seconds': int(time.time()) - block_timestamp
            },
            'analysis': self._analyze_rollup_configuration(rollup_info, chain_id)
        }
    
    def _analyze_rollup_configuration(
        self, 
        rollup_info: Dict[str, Any], 
        chain_id: int
    ) -> Dict[str, Any]:
        """Analyze rollup configuration and provide insights"""
        
        analysis = {
            'rollup_type': 'Modular L2 Optimistic Rollup',
            'security_model': 'Optimistic fraud proofs with L1 data availability',
            'key_features': [
                'Full EVM compatibility',
                'Optimistic fraud proof validation',
                'EigenDA data availability',
                'MNT gas token',
                'OP Stack foundation',
                'Modular architecture'
            ],
            'network_classification': 'Mainnet' if chain_id == 5000 else 'Testnet',
            'performance_characteristics': {
                'finality': 'Optimistic with 7-day challenge period',
                'withdrawal_time': '~7 days (challenge period)',
                'throughput': 'High (optimized via modular architecture)',
                'costs': 'Low L2 execution + efficient L1 data costs via EigenDA'
            }
        }
        
        # Add specific insights based on chain
        if chain_id == 5000:  # Mantle Mainnet
            analysis['environment'] = 'Production'
            analysis['considerations'] = [
                'Real value at risk',
                'Production-grade security',
                'Full audit coverage',
                'Mainnet gas costs with MNT token'
            ]
        elif chain_id == 5003:  # Mantle Sepolia Testnet
            analysis['environment'] = 'Testing'
            analysis['considerations'] = [
                'Testing and development use',
                'No real value',
                'Latest features may be experimental',
                'Network resets possible'
            ]
        
        return analysis
    
    def monitor_rollup_performance(self, duration_minutes: int = 10) -> Dict[str, Any]:
        """Monitor rollup performance over time"""
        
        monitoring_data = []
        start_time = datetime.now()
        
        print(f"Monitoring rollup for {duration_minutes} minutes...")
        
        try:
            while (datetime.now() - start_time).seconds < duration_minutes * 60:
                status = self.get_comprehensive_rollup_status()
                monitoring_data.append(status)
                
                print(f"Block: {status['current_state']['latest_block']}, "
                      f"Utilization: {status['current_state']['gas_utilization']}%")
                
                time.sleep(30)  # Check every 30 seconds
                
        except KeyboardInterrupt:
            print("Monitoring stopped by user")
        
        return self._analyze_performance_data(monitoring_data)
    
    def _analyze_performance_data(self, monitoring_data: List[Dict]) -> Dict[str, Any]:
        """Analyze collected performance data"""
        
        if not monitoring_data:
            return {'error': 'No monitoring data collected'}
        
        block_numbers = [d['current_state']['latest_block'] for d in monitoring_data]
        gas_utilizations = [d['current_state']['gas_utilization'] for d in monitoring_data]
        block_ages = [d['current_state']['block_age_seconds'] for d in monitoring_data]
        
        # Calculate block production rate
        if len(block_numbers) > 1:
            blocks_produced = block_numbers[-1] - block_numbers[0]
            time_elapsed = (
                datetime.fromisoformat(monitoring_data[-1]['timestamp']) -
                datetime.fromisoformat(monitoring_data[0]['timestamp'])
            ).seconds
            avg_block_time = time_elapsed / blocks_produced if blocks_produced > 0 else 0
        else:
            avg_block_time = 0
            blocks_produced = 0
        
        return {
            'monitoring_period': {
                'start': monitoring_data[0]['timestamp'],
                'end': monitoring_data[-1]['timestamp'],
                'data_points': len(monitoring_data)
            },
            'block_production': {
                'blocks_produced': blocks_produced,
                'average_block_time': round(avg_block_time, 2),
                'block_range': f"{block_numbers[0]} - {block_numbers[-1]}"
            },
            'gas_utilization': {
                'average': round(sum(gas_utilizations) / len(gas_utilizations), 2),
                'min': min(gas_utilizations),
                'max': max(gas_utilizations),
                'trend': self._calculate_trend(gas_utilizations)
            },
            'network_health': {
                'consistent_block_production': blocks_produced > 0,
                'average_block_age': round(sum(block_ages) / len(block_ages), 2),
                'health_score': self._calculate_health_score(monitoring_data)
            }
        }
    
    def _calculate_trend(self, values: List[float]) -> str:
        """Calculate trend direction for a series of values"""
        
        if len(values) < 2:
            return 'insufficient_data'
        
        first_half = values[:len(values)//2]
        second_half = values[len(values)//2:]
        
        first_avg = sum(first_half) / len(first_half)
        second_avg = sum(second_half) / len(second_half)
        
        change_pct = ((second_avg - first_avg) / first_avg) * 100 if first_avg > 0 else 0
        
        if change_pct > 5:
            return 'increasing'
        elif change_pct < -5:
            return 'decreasing'
        else:
            return 'stable'
    
    def _calculate_health_score(self, monitoring_data: List[Dict]) -> float:
        """Calculate a health score for the rollup"""
        
        score = 100.0
        
        # Check for stale blocks
        avg_block_age = sum(d['current_state']['block_age_seconds'] for d in monitoring_data) / len(monitoring_data)
        if avg_block_age > 300:  # 5 minutes
            score -= 20
        elif avg_block_age > 120:  # 2 minutes
            score -= 10
        
        # Check gas utilization patterns
        gas_utils = [d['current_state']['gas_utilization'] for d in monitoring_data]
        avg_util = sum(gas_utils) / len(gas_utils)
        
        if avg_util > 95:  # Very high utilization
            score -= 15
        elif avg_util < 5:  # Very low utilization (might indicate issues)
            score -= 10
        
        return max(0, score)
    
    def compare_with_ethereum_l1(self, eth_l1_rpc_url: str = None) -> Dict[str, Any]:
        """Compare Mantle with Ethereum L1 characteristics"""
        
        mantle_status = self.get_comprehensive_rollup_status()
        
        comparison = {
            'mantle_modular_l2': {
                'type': 'Modular L2 Optimistic Rollup',
                'consensus': 'Optimistic fraud proofs',
                'finality': 'Optimistic → Proven (7 days)',
                'block_time': '~2 seconds',
                'gas_limit': mantle_status['current_state']['gas_limit'],
                'gas_token': 'MNT',
                'transaction_throughput': 'High',
                'transaction_costs': 'Low'
            },
            'ethereum_l1': {
                'type': 'Layer 1 Blockchain',
                'consensus': 'Proof of Stake',
                'finality': 'Probabilistic',
                'block_time': '~12 seconds',
                'gas_limit': '~30M gas',
                'gas_token': 'ETH',
                'transaction_throughput': 'Limited',
                'transaction_costs': 'High'
            },
            'advantages_mantle': [
                'Lower transaction costs with MNT token',
                'Higher throughput via modular architecture',
                'EVM compatibility',
                'Inherits Ethereum security',
                'EigenDA data availability efficiency',
                'OP Stack foundation'
            ],
            'advantages_l1': [
                'No additional trust assumptions',
                'Direct composability',
                'Immediate finality',
                'No bridge requirements',
                'Maximum decentralization'
            ]
        }
        
        return comparison
    
    def analyze_upgradeability_governance(self) -> Dict[str, Any]:
        """Analyze upgradeability and governance mechanisms"""
        
        return {
            'upgrade_mechanism': 'Governed Smart Contracts',
            'governance_model': {
                'type': 'Multi-signature or DAO governance',
                'participants': [
                    'Core development team',
                    'Community stakeholders',
                    'Security auditors',
                    'Ecosystem partners'
                ]
            },
            'upgrade_process': {
                'steps': [
                    '1. Proposal creation and review',
                    '2. Community discussion period',
                    '3. Technical evaluation',
                    '4. Governance voting',
                    '5. Implementation timeline',
                    '6. Staged rollout',
                    '7. Post-upgrade monitoring'
                ],
                'timeframes': {
                    'discussion_period': '1-2 weeks',
                    'voting_period': '1 week',
                    'implementation_delay': '1-2 weeks',
                    'total_process': '4-6 weeks minimum'
                }
            },
            'risk_mitigation': [
                'Extensive testnet validation',
                'Audit requirements',
                'Emergency pause mechanisms',
                'Gradual feature activation',
                'Rollback procedures where possible'
            ],
            'recent_upgrades': 'Check governance forum for latest information'
        }
    
    def get_bridge_integration_info(self) -> Dict[str, Any]:
        """Get information about bridge integrations and interoperability"""
        
        return {
            'canonical_bridge': {
                'purpose': 'Official L1 ↔ L2 asset transfer',
                'supported_assets': [
                    'ETH (bridged from Ethereum)',
                    'MNT (native gas token)',
                    'ERC-20 tokens',
                    'ERC-721 NFTs',
                    'ERC-1155 multi-tokens'
                ],
                'security_model': 'Optimistic fraud proof validation'
            },
            'bridge_process': {
                'deposits_l1_to_l2': {
                    'time': '~15 minutes',
                    'process': [
                        'Lock assets on L1',
                        'Wait for L1 confirmation',
                        'Automatic minting on L2',
                        'Assets available on L2'
                    ]
                },
                'withdrawals_l2_to_l1': {
                    'time': '~7 days',
                    'process': [
                        'Burn assets on L2',
                        'Include in batch',
                        'Submit to L1',
                        'Challenge period (7 days)',
                        'Claim assets on L1'
                    ]
                }
            },
            'third_party_bridges': {
                'availability': 'Multiple third-party bridge providers',
                'considerations': [
                    'Different security models',
                    'Varying withdrawal times',
                    'Different supported assets',
                    'Additional trust assumptions'
                ]
            }
        }

# Usage examples
analyzer = MantleRollupInfoAnalyzer('https://api-mantle-mainnet.n.dwellir.com/YOUR_API_KEY')

# Get basic rollup information
rollup_info = analyzer.get_rollup_info()
print("Basic Rollup Info:", json.dumps(rollup_info, indent=2))

# Get comprehensive status
comprehensive_status = analyzer.get_comprehensive_rollup_status()
print(f"\nNetwork: {comprehensive_status['network_info']['name']}")
print(f"Chain ID: {comprehensive_status['network_info']['chain_id']}")
print(f"Latest Block: {comprehensive_status['current_state']['latest_block']}")
print(f"Gas Utilization: {comprehensive_status['current_state']['gas_utilization']}%")

# Analyze network type
analysis = comprehensive_status['analysis']
print(f"\nRollup Type: {analysis['rollup_type']}")
print(f"Environment: {analysis['environment']}")
print("Key Features:")
for feature in analysis['key_features']:
    print(f"  - {feature}")

# Monitor performance (short demo)
print("\nStarting performance monitoring...")
performance_data = analyzer.monitor_rollup_performance(duration_minutes=2)
print("Performance Analysis:")
print(f"  Average block time: {performance_data['block_production']['average_block_time']}s")
print(f"  Health score: {performance_data['network_health']['health_score']}/100")

# Compare with L1
comparison = analyzer.compare_with_ethereum_l1()
print("\nMantle Advantages:")
for advantage in comparison['advantages_mantle']:
    print(f"  - {advantage}")

# Governance analysis
governance = analyzer.analyze_upgradeability_governance()
print(f"\nGovernance Model: {governance['governance_model']['type']}")
print(f"Upgrade Process Duration: {governance['upgrade_process']['timeframes']['total_process']}")

# Bridge information
bridge_info = analyzer.get_bridge_integration_info()
print(f"\nBridge Withdrawal Time: {bridge_info['bridge_process']['withdrawals_l2_to_l1']['time']}")
print("Supported Assets:")
for asset in bridge_info['canonical_bridge']['supported_assets']:
    print(f"  - {asset}")

Response Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "mode": "optimistic",
    "chainId": "0x1388",
    "batchHash": "0x...",
    "stateRoot": "0x...",
    "withdrawalRoot": "0x...",
    "sequencer": "0x...",
    "version": "1.0.0"
  }
}

Understanding Mantle Modular L2 Configuration

Key Components

1. Mode: Operating mode of the rollup (optimistic)
2. Chain ID: Network identifier (5000 for mainnet, 5003 for testnet)
3. State Root: Root hash of the current state tree
4. Batch Hash: Hash of the current batch of transactions
5. Sequencer: Address of the transaction sequencing system
6. Version: Current version of the rollup implementation

Modular L2 Architecture

• Sequencing: Optimistic transaction ordering and execution
• Data Availability: EigenDA integration for efficient data posting
• EVM Compatibility: Full compatibility with Ethereum Virtual Machine
• Finality: Fast L2 finality with 7-day challenge period for L1 finality

Common Use Cases

1. Network Health Monitoring

// Monitor rollup health and performance
async function monitorRollupHealth(analyzer) {
  const healthCheck = async () => {
    const status = await analyzer.getComprehensiveRollupStatus();
    
    const alerts = [];
    
    // Check block production
    if (status.current_state.block_age_seconds > 300) {
      alerts.push({
        type: 'stale_blocks',
        severity: 'warning',
        message: 'Blocks are older than expected'
      });
    }
    
    // Check gas utilization
    if (status.current_state.gas_utilization > 95) {
      alerts.push({
        type: 'high_utilization',
        severity: 'info',
        message: 'Network experiencing high usage'
      });
    }
    
    return {
      status: alerts.length === 0 ? 'healthy' : 'warning',
      alerts: alerts,
      metrics: status.current_state
    };
  };
  
  return healthCheck;
}

2. Integration Compatibility Check

def check_integration_compatibility(analyzer):
    """Check if current rollup config is compatible with integration"""
    
    status = analyzer.get_comprehensive_rollup_status()
    rollup_info = status['rollup_config']
    
    compatibility = {
        'evm_compatible': True,  # Modular L2 is fully EVM compatible
        'supported_features': [
            'Standard Ethereum transactions',
            'Smart contract deployment',
            'ERC token standards',
            'Event emission and filtering',
            'eth_call and eth_estimateGas',
            'Debug and trace methods'
        ],
        'limitations': [
            '7-day withdrawal period for L1 finality',
            'L1 data posting affects costs',
            'Optimistic fraud proof mechanism'
        ],
        'recommended_practices': [
            'Use standard Ethereum tooling',
            'Account for withdrawal delays',
            'Monitor gas price fluctuations with MNT token',
            'Leverage EigenDA data availability benefits'
        ]
    }
    
    return compatibility

3. Performance Benchmarking

// Benchmark rollup performance characteristics
async function benchmarkRollupPerformance(analyzer) {
  const benchmark = {
    testDuration: '10 minutes',
    metrics: {},
    recommendations: []
  };
  
  // Monitor for performance data
  const performanceData = await analyzer.monitorRollupPerformance(10);
  
  benchmark.metrics = {
    avgBlockTime: performanceData.block_production.average_block_time,
    gasUtilization: performanceData.gas_utilization.average,
    healthScore: performanceData.network_health.health_score
  };
  
  // Generate recommendations
  if (benchmark.metrics.avgBlockTime > 5) {
    benchmark.recommendations.push(
      'Block times are longer than expected - monitor network congestion'
    );
  }
  
  if (benchmark.metrics.gasUtilization > 80) {
    benchmark.recommendations.push(
      'High gas utilization - consider transaction timing optimization'
    );
  }
  
  return benchmark;
}

Integration Considerations

Development

• Tooling: Use standard Ethereum development tools (Hardhat, Truffle, Remix)
• RPC Compatibility: Full JSON-RPC compatibility with additional rollup-specific methods
• Gas Estimation: Account for MNT gas token and EigenDA data costs

Production Deployment

• Security: Leverage optimistic rollup security with fraud proofs
• Monitoring: Monitor both L2 state and L1 batch submission
• Bridge Integration: Plan for canonical bridge usage and withdrawal delays

User Experience

• Transaction Speed: Fast L2 confirmation with 7-day L1 finality
• Cost Optimization: Benefit from MNT gas token and EigenDA efficiency
• Bridge UX: Clear communication about withdrawal timeframes

Related Methods

• rollup_gasPrices - Get gas price oracle data
• eth_chainId - Get network chain ID
• eth_getBlockByNumber - Get block information

---

Need help? Contact our support team or check the Mantle documentation.