• :book: Introduction
• :dart: Goals
• :rocket: Quick Start
  • :link: Useful Addresses
  • :computer: Set up Local Environment
  • :wrench: Using the Mantle SDK
  • 🧩 Using the Node RPC API
  • 🎛 Spin up a Verifier Node
• :ledger: Directory Structure
• :sparkles: How to Contribute
• :copyright: License

Introduction

Mantle is a suite of Ethereum scaling solutions including an optimistic rollup and ZK rollup built using an iterative modular chain approach, and supported by Mantle’s native token $MNT.

It is designed to bolster support for hyper-scaled throughput decentralized applications (dApps) — from derivatives decentralized exchanges (DEXs), to gaming, to operations of decentralized autonomous organizations (DAOs).

Goals

Layer 2 rollups are built to address the scaling limitations of Ethereum by taking transaction processing to a separate execution layer, but this inevitably exposes users to the high gas fees and limited throughput on Layer 1.

Mantle's modular architecture helps achieve greater network efficiency for resources at hand, while maintaining the same level of security for all network actors. Increased network performance also enables better fraud proof and ZK proof technology, essentially unlocking the true potential of L2 rollups.

Different parts of the Mantle tech stack are specialized to tackle specific issues.

• Data Availability: Data Availability powered by EigenDA technology, an innovative re-staking solution that leverages Ethereum's validator network to bring the security of L1 to L2
• EVM-level Fraud Proofs: Improved fraud proofs that are evaluated using EVM-level instructions

We encourage you to check out the Mantle tech docs to learn more about the inner workings of Mantle.

Quick Start

Useful Addresses

DApps need to connect to nodes for fetching block data and sending transactions to the Mantle network. Our JSON-RPC API supports HTTPS and WebSocket connections.

Using the Mantle SDK

You can use npm or yarn package managers to download and install the @mantleio/sdk package. We'll use yarn in this example.

1. Set up a project directory.

mkdir MantleSDK
cd MantleSDK
npm init --yes

2. Download and install the SDK package using this command.

yarn add -D @mantleio/sdk

3. Create a <filename>.js script and get started by making a request, for instance, to fetch the current L1 gas price.

const ethers = require("ethers")
const mantle = require("@mantleio/sdk")

const l2RpcProvider = new ethers.providers.JsonRpcProvider("https://rpc.testnet.mantle.xyz")

async function main() {

    console.log(await mantle.getL1GasPrice(l2RpcProvider))
}

main();

4. Run your script using the node <filename>.js command to see the output.

Feel free to browse through our compilation of tutorials that use the Mantle SDK to demonstrate common functionality such as bridging assets between Mantle and Ethereum, and more.

The SDK docs provide complete reference of all the methods available as part of the Mantle SDK to facilitate interaction between applications and Mantle network.

Spin up a Verifier Node

There are multiple roles associated with Mantle nodes. Rollup Verifiers mainly sync rollup data from Mantle's trusted Sequencer (to be decentralized in the future!). dApp builders who run their own verifier nodes have the benefit of being able to simulate L2 transactions, among other advantages, and have ready access to them without rate-limiting (as opposed to public RPCs).

Here's a tutorial describing the process of deploying a verifier node.

Directory Structure

root
├── packages
│   ├── common-ts: Common tools for building apps in TypeScript
│   ├── contracts: L1 and L2 smart contracts for Mantle
│   ├── core-utils: Low-level utilities that make building Mantle easier
│   ├── data-transport-layer: Service for indexing Mantle-related L1 data
│   ├── fault-detector: Service for detecting Sequencer faults
│   ├── message-relayer: Tool for automatically relaying L1<>L2 messages in development
│   ├── replica-healthcheck: Service for monitoring the health of a replica node
│   └── sdk: provides a set of tools for interacting with Mantle

~~ Production ~~
├── batch-submitter: Service for submitting batches of transactions and results to L1
├── mt-batcher: Service for submitting batches of transactions to EigenDA
├── mt-challenger: EigenDA data fraud proof
├── bss-core: Core batch-submitter logic and utilities
├── gas-oracle: Service for updating L1 gas prices on L2
├── integration-tests: Various integration tests for the Mantle network
├── l2geth: Mantle client software, a fork of geth v1.9.10  (deprecated for BEDROCK upgrade)
├── l2geth-exporter: A prometheus exporter to collect/serve metrics from an L2 geth node
├── proxyd: Configurable RPC request router and proxy

How to Contribute

Read through CONTRIBUTING.md for a general overview of our contribution process. Then check out our list of good first issues to find something fun to work on!

License

Code forked from optimism under the name optimism is licensed under the GNU GPLv3 in accordance with the original license.

All other files within this repository are licensed under the MIT License unless stated otherwise.