DEV Community

SwiftNodes
SwiftNodes

Posted on • Originally published at swiftnodes.io

Metis RPC: The Optimistic Rollup That Decentralized Its Sequencer

#web3 #blockchain #ethereum #tutorial

Almost every L2 has the same quiet centralization: one sequencer, run by the team, ordering every transaction. It's fast and it usually works — but it's a single operator that could censor, reorder, or (if it goes down) halt the chain. Different L2s answer that differently. Taiko removes the sequencer entirely (a "based" rollup). Metis takes the middle path: it decentralized the sequencer into a pool. Metis is an EVM-equivalent optimistic rollup (chain ID 1088) that moved from a single sequencer to a rotating sequencer pool — among the first optimistic rollups to do so. Underneath it's standard EVM (viem/ethers/foundry all work), so the interesting part isn't the RPC surface, it's what that design choice means for you. Here's the map.

The essentials

Metis (Andromeda) mainnet is chain ID 1088, an optimistic rollup with:

  • METIS as the native gas token (18 decimals) — not ETH, which trips up funding and balance code (see below).
  • ~2-second blocks — fast L2 soft confirmation.
  • A decentralized sequencer pool — multiple staked sequencers take turns producing blocks, instead of one team-run operator.
  • EVM-equivalent — originally forked from Optimism's OVM; Solidity, ABIs, Hardhat, Foundry, ethers, and viem apply directly.
  • Optimistic rollup finality — soft confirmation is immediate on the L2; withdrawals to Ethereum follow the optimistic challenge window.

Connecting is standard EVM — just set the native currency correctly:

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

const metis = defineChain({
  id: 1088,
  name: "Metis Andromeda",
  nativeCurrency: { name: "Metis", symbol: "METIS", decimals: 18 },  // not ETH
  rpcUrls: { default: { http: ["https://rpc.swiftnodes.io/rpc/metis?key=YOUR_API_KEY"] } },
});

const client = createPublicClient({ chain: metis, transport: http() });
await client.getBlockNumber();   // just works
Enter fullscreen mode Exit fullscreen mode

The headline: a sequencer pool, not a single operator

A quick refresher (the full version is in what is a sequencer): on a rollup, the sequencer receives transactions, orders them, and produces L2 blocks — giving you near-instant soft confirmation before the data settles to Ethereum. On most L2s that role is a single service the team operates. That's a real centralization point: it can in principle censor or reorder transactions, and if it stalls, the chain's soft confirmations stall with it.

Metis moved that role to a pool of staked sequencers that rotate block production. The point isn't a different developer API — it's reduced single-operator risk:

  • Liveness no longer hinges on one process staying up; block production can continue across the pool.
  • Censorship resistance improves, because no single operator holds the ordering pen indefinitely.
  • Accountability comes from staking — sequencers have skin in the game.

Think of it as a spectrum of who orders your transactions: one operator (most L2s: Base, Arbitrum, Optimism, Blast, Unichain) → a decentralized pool (Metis) → Ethereum's own validators, no dedicated sequencer (Taiko's based-rollup model). Metis's answer keeps the fast-soft-confirmation UX of a sequencer while spreading the trust.

What that does — and doesn't — change for you

Here's the honest part: from the RPC, sequencer decentralization is mostly transparent. You still:

  • Send transactions with eth_sendRawTransaction; the pool orders and includes them.
  • Get fast soft confirmation at the L2 head, then hard finality once data settles to Ethereum.
  • Use the exact same EVM tooling and methods you'd use anywhere.

What changes is the trust story you can tell, not the code you write: your soft-confirmation reliance is spread across a staked pool rather than resting on one company's uptime. For most apps that's a background assurance; for anything where censorship-resistance or liveness guarantees matter to your users, it's a genuine differentiator worth understanding.

And treat the L2 head like any optimistic rollup: reasonably reliable but reorg-capable at the tip until settlement, so key your indexer on block hash and reconcile — see handling chain reorgs.

Gas is METIS, not ETH

Like Fraxtal and a handful of other L2s, Metis doesn't use ETH for gas — it uses METIS. eth_estimateGas still returns gas units the usual way (gas estimation basics), but the balance a user needs, the token your relayer must hold, and anything you display as "the native token" are all METIS. Wherever your code assumes ETH is the gas asset, read it from the chain config instead.

Finality: fast soft, challenge-window hard

As an optimistic rollup, Metis gives fast soft confirmation (~2s) at the sequencer pool, but true L1 settlement — and withdrawals back to Ethereum — waits out the optimistic challenge window. If your app moves value L2→L1, design for that delay; the model is in soft vs. hard finality.

What carries over unchanged

Because Metis is EVM-equivalent, treat it as a standard EVM chain:

  • eth_call, eth_getBalance, eth_getLogs, eth_getTransactionReceipt, eth_estimateGas, eth_sendRawTransaction, eth_subscribe all behave normally.
  • Solidity contracts, ABIs, and the viem/ethers/hardhat/foundry toolchain deploy and run as-is.
  • METIS is the 18-decimal gas token; WebSocket subscriptions work; at ~2s blocks, stream rather than tight-poll.

The short version

Metis (chain ID 1088) is an EVM-equivalent optimistic rollup whose distinguishing choice is a decentralized sequencer pool — multiple staked sequencers rotate block production instead of one team-run operator, improving liveness and censorship resistance. From the RPC it's transparent (standard eth_*, viem/ethers/foundry unchanged); what changes is the trust story, not your code. Gas is METIS, not ETH (read the native asset from config), and as an optimistic rollup it has fast ~2s soft confirmation but a challenge-window delay for L1 withdrawals. Build it like any EVM chain — and if sequencer decentralization matters to your users, this is the L2 that made it a priority.

Building on Metis — DeFi, gaming, or DAC-style apps? A flat-rate Metis RPC endpoint gives you chain 1088 over HTTP and WebSocket alongside 75+ other chains under one key. Grab a free key and point your stack at:

https://rpc.swiftnodes.io/rpc/metis?key=YOUR_API_KEY
Enter fullscreen mode Exit fullscreen mode

Originally published on the SwiftNodes blog. SwiftNodes provides flat-rate multi-chain RPC endpoints — HTTP + WebSocket, 75+ chains, no per-request metering. Grab a free key.

Top comments (0)