Claim Layer3 rewards
.png)
Since our launch in late 2021, Metis has taken bold steps in scaling Ethereum Layer 1. From the outset, we embraced innovation that dared to challenge conventions, setting us apart as an outlier among Layer 2 solutions. This spirit of ingenuity has driven us to take bold steps, face challenges head-on, and stay true to our mission: scaling Ethereum while championing decentralization and groundbreaking innovation.
Over time, this commitment has solidified Metis as more than just a network—it’s a movement. Our novel strategies stem from a deep respect for Ethereum’s foundational values and an unwavering desire to push the boundaries of what’s possible. Alongside our community, we’ve created a unique space for collaboration and inclusivity within the Ethereum ecosystem.
As we move into 2025, we’re doubling down on our vision to demonstrate that being different doesn’t mean straying from Ethereum’s ethos - we intend to bolster Ethereum and its Layer 2 viability, and provide solutions through new technology. Through deliberate and thoughtful upgrades, we’re bridging innovation with tradition, showcasing how a Layer 2 chain can balance forward-thinking technology with Ethereum’s core principles. At the same time, we’re fortifying our infrastructure to ensure Metis becomes the most attractive and reliable destination for projects and users.
This year is about blending the best of Ethereum’s cypherpunk origins with the fearless creativity that defines Metis. Together, we will continue to break new ground, strengthening our position as a key contributor to Ethereum’s future. With collaboration,creativity , and a shared sense of purpose, we’re building a network that embodies the very essence of innovation, community, and authenticity. Let’s scale new heights, together.
Metis is an L2 with optimistic architecture on Ethereum, offering:
• Fast and cheap L2 transactions
• Security anchored on Ethereum
• Decentralized sequencers
• Fraud proofs and DA enhancements in early 2025 (Q1)
Fraud proofs prevent invalid state from persisting on L2, while data availability ensures enough transaction data is posted to Ethereum so watchers can reconstruct and validate L2 state transitions.
With the sequencer layer decentralized, the next step (Q3) is to achieve full EVM equivalence and keep the L2 environment synced with the latest Ethereum Virtual Machine (EVM) features and upgrades.
Fraud proofs are a cornerstone of ensuring the security and integrity of any Layer 2 blockchain. They empower network participants, commonly referred to as watchers, to challenge invalid L2 state roots or transactions. This mechanism ensures that even in the presence of malicious actors, the network remains resilient and trustworthy. The fraud proof process provides a transparent, on-chain method for resolving disputes, making it an essential feature of a decentralized Layer 2 ecosystem.
Data Availability (DA) is vital for every Layer 2 blockchain, ensuring transaction and smart contract data remains secure, verifiable, and accessible. It underpins trust, transparency, and seamless interaction within the ecosystem.
In April 2022, to reduce transaction costs, Metis transitioned its DA from Ethereum to Memo Labs, making us one of the most affordable L2 networks. This strategic move lowered barriers to adoption and enabled greater scalability.
With Ethereum’s Proto-Danksharding upgrade introducing cost-effective L1 blobs for temporary data storage, the DA landscape has evolved. This advancement allows Metis to align with Ethereum’s latest innovations, enhancing affordability, decentralization, and performance.
Fraud proofs empower watchers to challenge any invalid L2 state root or transaction. The high-level flow:
1. Batch Proposal: A proposer (any sequencer node in the decentralized set) sends a batch of L2 transactions/state roots to Ethereum.
2. Challenge Window: A time window (e.g., 7 days) allows watchers to submit fraud proofs if they detect invalid state transitions.
3. Onchain Dispute: The fraud proof contract on L1 replays the disputed transaction(s) to check correctness.
4. Slashing & Reversion: If the state is found fraudulent, the batch is reverted, and the malicious proposer is slashed.
• Increases network security—invalid state cannot persist without being challenged.
• Distributes trust—anyone can become a watcher and help secure the network.
• Aligns Metis with other optimistic rollups that rely on L1-based dispute resolution.
Below is a simplified example of a fraud-proof contract:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/**
* @title FraudProofVerifier
* @notice Illustrative contract to demonstrate a simplified fraud proof mechanism
*/
contract FraudProofVerifier {
// Batch index -> state root
mapping(uint256 => bytes32) public batchStateRoots;
// Whether the batch is under dispute
mapping(uint256 => bool) public isUnderDispute;
event StateRootProposed(uint256 indexed batchIndex, bytes32 stateRoot);
event FraudProofSubmitted(uint256 indexed batchIndex, address indexed challenger);
event BatchInvalidated(uint256 indexed batchIndex);
function proposeStateRoot(uint256 batchIndex, bytes32 stateRoot) external {
require(batchStateRoots[batchIndex] == 0, "State root already set");
batchStateRoots[batchIndex] = stateRoot;
emit StateRootProposed(batchIndex, stateRoot);
}
function submitFraudProof(uint256 batchIndex, bytes calldata proofData) external {
require(!isUnderDispute[batchIndex], "Batch already disputed");
// Validate the proof data—replay or merkle-check the L2 transaction
bool isFraudulent = _verifyProof(proofData);
require(isFraudulent, "No fraud detected");
isUnderDispute[batchIndex] = true;
emit FraudProofSubmitted(batchIndex, msg.sender);
// Invalidate the batch if the proof is valid
_invalidateBatch(batchIndex);
}
function _verifyProof(bytes calldata proofData) internal pure returns (bool) {
// In a real implementation, you'd decode transactions, check state transitions, etc.
// Here, we return true for demonstration
return true;
}
function _invalidateBatch(uint256 batchIndex) internal {
// For demonstration, revert the batch state root
batchStateRoots[batchIndex] = bytes32(0);
emit BatchInvalidated(batchIndex);
}
}
EIP-4844 introduces “blob” transactions that store data cheaply and temporarily on Ethereum. This approach reduces L2 fees because data posting to Ethereum mainnet becomes more cost-effective than older calldata methods.
• Blob Commitments: The Metis sequencer (now decentralized) bundles L2 user transactions, compresses them, and posts them as blobs.
• Verification: The rollup contract on L1 holds a commitment (e.g., KZG polynomial commitment) to the blob data. Anyone can fetch the actual data from the blob to verify correctness if they need to submit a fraud proof.
• Reduced Costs: Because blobs are cheaper to post and ephemeral, overall L2 gas costs drop for end users.
A conceptual snippet that tracks blob commitments on-chain might look like this:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/**
* @title DataAvailabilityRegistry
* @notice Stores commitments (hashes or polynomial commitments) to EIP-4844 blobs
*/
contract DataAvailabilityRegistry {
// batch index -> blob commitment
mapping(uint256 => bytes32) public blobCommitments;
event BlobCommitted(uint256 indexed batchIndex, bytes32 commitment);
function storeBlobCommitment(uint256 batchIndex, bytes32 commitment) external {
// In practice: verify the caller is an authorized sequencer or aggregator
blobCommitments[batchIndex] = commitment;
emit BlobCommitted(batchIndex, commitment);
}
function validateBlobData(uint256 batchIndex, bytes memory rawData) public view returns (bool) {
// In real usage, you'd do a KZG polynomial check or a Merkle check
return keccak256(rawData) == blobCommitments[batchIndex];
}
}
• Lower Fees for L2 users, because posting data to L1 is the most expensive part of running an optimistic rollup.
• Improved Transparency, as watchers can easily fetch the data from Ethereum for fraud proof purposes.
The current Metis EVM, as of the time of writing, operates at the Berlin (+PUSH0) version. However, it lags behind Ethereum’s evolving EVM, which has undergone substantial upgrades in recent years. These upgrades include the London, Paris, Shanghai, Cancun, and the soon-to-be-released Pectra versions, each of which introduces critical improvements that enhance the Ethereum ecosystem.
An EVM-equivalent rollup means the L2 runtime matches Ethereum’s EVM specification exactly (or as close to 1:1 as possible) so that:
• All opcodes, gas metering, and execution semantics behave as they do on mainnet.
• Developers can use the same tooling (e.g., Hardhat, Truffle, Remix) without modification or custom compilers.
• Deploying a contract on Metis works the same way as deploying it on Ethereum, minimizing surprises.
Note: Some older L2s are “EVM-compatible” but not fully “EVM-equivalent,” which can cause subtle differences in gas usage, block gas limits, or opcode availability. Metis aims to eliminate these discrepancies in Q3 2025.
Ethereum undergoes frequent upgrades—e.g., Shanghai, Cancún, or future hard forks that might introduce new opcodes or behaviors. Metis’s Q3 upgrade is designed to:
• Integrate new EVM opcodes introduced on mainnet (e.g., PUSH0 from Shanghai).
• Match Gas Schedules so that on-chain execution cost is consistent with Ethereum’s cost model.
• Adopt Protocol Upgrades so that any features or bug fixes in the main Ethereum client are also reflected on Metis.
A trivial example of using the PUSH0 opcode (introduced in Shanghai/Shanghai-like forks) in inline assembly is shown below (Solidity 0.8.20+). This opcode pushes a 0 value to the stack:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract ExamplePush0 {
uint256 public someValue;
function usePush0() external {
assembly {
// push0 places 0 on the stack
push0
// sstore at slot 0 (someValue) with the top of the stack (which is 0)
sstore(someValue.slot, 0)
}
}
}
On older EVM implementations that lack PUSH0, this contract would fail to compile or revert at runtime. With Q3’s EVM equivalence update, Metis ensures that the same contract runs identically to Ethereum mainnet.
• No special compilers or config.
• Off-the-shelf Ethereum libraries (e.g., web3.js, ethers.js) work seamlessly.
• Faster onboarding of new devs or migrating existing mainnet projects to Metis.
• Tools like Hardhat and Foundry can test and debug using the exact same environment.
• Less friction for advanced debugging or performance analysis.
• Bridging logic can rely on consistent EVM state transitions and proofs.
• Fewer edge cases and less custom code to maintain for bridging solutions.
• Because Metis stays in sync with Ethereum’s upgrades, new features introduced on Ethereum can quickly be adopted on L2.
• Future merges, forks, or EIPs won’t cause large divergences in the codebase.
• Decreased confusion for end users about “how is L2 different from L1.”
• More reliability, fewer failures when porting dApps over to L2.
1. Decentralized Sequencers: Already implemented in Metis to reduce the single point of failure. Anyone meeting the requirements can join the set of sequencers and propose L2 blocks.
2. Fraud Proofs (Q1): Provide a robust challenge mechanism on L1, ensuring malicious or incorrect state transitions can be disputed and reverted.
3. Data Availability via Ethereum Blobs (Q1): Leveraging EIP-4844 for cheaper, ephemeral data posting, thereby lowering gas fees for L2 transactions and improving accessibility for watchers.
4. Full EVM Equivalence (Q3): Updating the entire Metis stack to match Ethereum’s latest EVM version, ensuring 1:1 opcode coverage, gas metering, and developer tooling compatibility.
• Node Operators: Must upgrade their Metis nodes in Q3 to the new software version that supports the latest EVM changes.
• Developers:
• Existing contracts should “just work,” but if you rely on newly introduced opcodes (e.g., PUSH0), you can only use them post-upgrade.
• Tools like Hardhat or Truffle can be configured with the same compiler version used on mainnet, simplifying the pipeline.
• Watchers: Should remain vigilant, especially during the Q3 transition, verifying that the upgraded L2 environment is producing valid state roots.
By Q3 2025, Metis will have:
1. Deployed Fraud Proofs (Q1) and ensured robust dispute resolution on L1.
2. Adopted EIP-4844 Blobs (Q1) to lower data posting costs, thereby reducing user gas fees and boosting throughput.
3. Fully Aligned with Ethereum’s EVM (Q3), guaranteeing EVM equivalence so that developers can deploy, test, and maintain contracts as if they were on mainnet.
These milestones reinforce Metis as a performant, decentralized, and user-friendly optimistic rollup. The Q3 focus on full EVM equivalence underscores Metis’s commitment to staying on the cutting edge of Ethereum development, ensuring a frictionless developer experience and the highest degree of compatibility with Ethereum’s evolving ecosystem.
Disclaimer: The details, timelines, and implementation specifics are subject to change based on final Metis team announcements. Always refer to official Metis documentation and repositories for the most accurate, up-to-date information.
