Search

Search for projects by name or address

Ethscriptions logo
Ethscriptions

Badges

About

Ethscriptions is a based rollup that provides cryptographic state and EVM compatibility for ethscriptions. It uses a derivation pipeline to convert L1 ethscription activity into canonical L2 blocks.



Badges

About

Ethscriptions is a based rollup that provides cryptographic state and EVM compatibility for ethscriptions. It uses a derivation pipeline to convert L1 ethscription activity into canonical L2 blocks.

Past Day UOPS
Past Day Ops count
Max. UOPS
Past day UOPS/TPS Ratio
Compare with other projects

The section shows the operating costs that L2s pay to Ethereum.



Total cost
Avg cost per L2 UOP
Avg cost per day

Compare with other projects

This section shows how "live" the project's operators are by displaying how frequently they submit transactions of the selected type. It also highlights anomalies - significant deviations from their typical schedule.

No ongoing anomalies detected

Avg. state updates interval
Past 30 days anomalies
100% normal uptime

Rollup contract deployed

2025 Jan 6th

Ethscriptions deploys its rollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup. contract with SP1 ZK fault proofs on Ethereum mainnet.

Learn more
Sequencer failureState validationData availabilityExit windowProposer failure
Sequencer failure
Self sequence

Users can self sequence transactions by sending them on L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development.. There is no privileged operatorAn operator is the entity charged with managing a rollup and progressing its state. A rollup operator can be a centralized sequencer, proposer, prover, challenger, pauser of admin that is able to perform upgrades..

State validation
Fraud proofs (1R, ZK)

Actors watching the chain can challenge state proposals, and challenged proposals must provide ZK proofs. SNARKs are zero knowledge proofs that ensure state correctness, but require trusted setupGeneration of a piece of data that must then be used for some cryptographic protocol to run. Generating this data requires some secret information. The "trust" comes from the fact the secret must be destroyed after the ceremony, otherwise cryptographic properties of the protocol could be broken. Once the data is generated, and the secrets are forgotten, no further participation from the creators of the ceremony is required. There are two types of trusted setups for SNARKs: (i) trusted setup per circuit where it is generated from scratch for each circuit, (ii) trusted universal setup per proving system where it can be used for several circuits..

Data availability
Onchain

All of the data needed for proof construction is published on Ethereum L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development..

Exit window
∞

Users can exit funds at any time because contracts are not upgradeable.

Proposer failure
Self propose

Anyone can propose blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. if accompanied by a validity proofThe output of a cryptographic proving system attesting to correct computation. ZK-Rollups use succinct validity proofs (also called zero-knowledge proofs) to prove a batch of rollup transactions and blocks were properly executed. Validity proofs are submitted to a verifier, such as an Ethereum smart contract, which accepts them if properly constructed.. Only the whitelisted proposers can propose state rootsA cryptographic hash succinctly representing a state using a Merkle tree. for recent blocks optimistically. Anyone can propose optimistically for L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. blocks that are older than 14d.

Ethscriptions
Ethscriptions is a
Stage 2
Appchain
Optimistic Rollup.
The project passes the walkaway test: users can exit in the presence of malicious operators even if the Security Council disappears.

Rollup operators cannot compromise the system, but being application-specific might bring additional risk.

The chain derives its state entirely from L1 ethscription activity and there is no general-purpose smart contract deployment. Users interact with ethscriptions (create, transfer) through a derivation pipeline that converts L1 calldata into canonical L2 state. The system intentionally has no canonical bridge; gas is free as geth has been modified to not charge users.

Note:
We're still in the process of formalizing how to properly integrate appchains in the Stages framework.

Learn more about Stages
Please keep in mind that these stages do not reflect project security, this is an opinionated assessment of project maturity based on subjective criteria, created with a goal of incentivizing projects to push toward better decentralization. Each team may have taken different paths to achieve this goal.

Ethscriptions implements a dual-track proving system that combines optimistic proposals with bonds with ZK validity proofs. The system allows bypassing the 7-day fraud proofAlso referred to as a fault proof, it is the construction of an assertion that fraud was perpetrated on an optimistic rollup. More concretely, that an invalid state transition took place according to the protocol rules. The submitter of a fraud proof would expect a reward from the optimistic rollup protocol for helping maintain the integrity of the system. window by providing a ZK proof.


Challenges

The system operates on two parallel tracks: an optimistic track where whitelisted proposers submit state rootsA cryptographic hash succinctly representing a state using a Merkle tree. with ETH bonds that can be challenged within a time window, and a validity-proof track where anyone can submit direct ZK proofs for immediate resolution. Validity proofs bypass the optimistic flow and can invalidate multiple incorrect optimistic proposals simultaneously targeting the same state root. When optimistic proposals are challenged, proposers must defend their claims by providing ZK proofs within the proving window.

Validity proofs

The system uses Succinct’s SP1 zkVMA special type of zk proving system that proves the correctness of state transitions of a virtual machine. Computation is represented by a program in a specific instruction language, it can have private and public inputs and public outputs. Most of zkVMs are STARKs. and ProverAn entity that generates the cryptographic proof to convince the verifier that the statement is true. In a ZK-Rollup, the prover generates the ZK (validity) proof to submit to the verifier contract. NetworkA constellation of nodes (peers) that communicate via a peer-to-peer protocol, for example, in propagating transactions and blocks to other nodes. to generate zero-knowledgeA cryptographic technology and sub-discipline of cryptography that allows an individual to prove that a statement or computation is true without revealing any additional information. proofs that verify L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. state transitions. Anyone can submit a validity proofThe output of a cryptographic proving system attesting to correct computation. ZK-Rollups use succinct validity proofs (also called zero-knowledge proofs) to prove a batch of rollup transactions and blocks were properly executed. Validity proofs are submitted to a verifier, such as an Ethereum smart contract, which accepts them if properly constructed. through the proveBlock() function of the RollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup. contract to bypass the optimistic flow and settle an anchor blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over.. Submitting a validity proof during a challenge settles the dispute in a single transaction.

  1. Ethscriptions ZK Fault Proofs - GitHub Repository
PROVER

Trusted Setups

Onchain verifier

Used in

Mantle logoCelo logoX Layer logoKatana logoRISE logo

Projects used in

Search for projects used in

Onchain verifier

Used in

Mantle logoCelo logoX Layer logoKatana logoRISE logo

Projects used in

Search for projects used in

Program Hashes

Name
Hash
Repository
Verification
Used in
0x001d...acdd
Ethscriptions logo
0x5a02...f594
Ethscriptions logo
2026 January 14, 13:01 UTC
1change

Config change: Removed proxyType: immutable workaround for L2 predeploys (Ethscriptions, EthscriptionsProver, L2ToL1MessagePasser). These contracts are now properly detected by l2b rpc as EIP1967 proxies (DeaD owner) with their implementations tracked.

New and verified contracts

+ Status: CREATED
contract ProxyAdmin (ethscr:0x4200000000000000000000000000000000000018)
+++ description: ProxyAdmin predeploy that manages proxy upgrades for L2 predeploys.
2026 January 12, 09:46 UTC
7changes

Initial discovery.

Initial discovery

+ Status: CREATED
contract SP1Verifier (eth:0x0459d576A6223fEeA177Fb3DF53C9c77BF84C459)
+++ description: Verifier contract for SP1 proofs (v5.0.0).
+ Status: CREATED
contract SP1VerifierGateway (eth:0xa236E6E31d94b613923d18313f534CE5b6b98eE1)
+++ description: This contract is the router for zk proof verification. It stores the mapping between identifiers and the address of onchain verifier contracts, routing each identifier to the corresponding verifier contract.
+ Status: CREATED
contract Rollup (eth:0xA9Bbcad27E1571AAFAD89F953c81c8A1440A0b8b)
+++ description: Core rollup contract that manages the state of the rollup and its ZK fault proof system.
+ Status: CREATED
contract Facet Multisig (eth:0xb2B01DeCb6cd36E7396b78D3744482627F22C525)
+++ description: None
+ Status: CREATED
contract Ethscriptions (ethscr:0x3300000000000000000000000000000000000001)
+++ description: Core Ethscriptions NFT contract that manages ethscription ownership and metadata on L2.
+ Status: CREATED
contract EthscriptionsProver (ethscr:0x3300000000000000000000000000000000000003)
+++ description: L2 predeploy that automatically sends ethscription state snapshots to L1 via the L2ToL1MessagePasser whenever an ethscription is created or transferred.
+ Status: CREATED
contract L2ToL1MessagePasser (ethscr:0x4200000000000000000000000000000000000016)
+++ description: L2 predeploy for passing messages from L2 to L1. Messages are automatically sent by the EthscriptionsProver when ethscriptions are created or transferred.

There is no central operator

There is no privileged entity that sequences transactions or produces blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over.. This activity is permissionlessAnyone willing should be able to join and leave the network at any time, without causing significant disturbance to the network or being detrimental to the party in question. No single entity should have the power to allowlist or blocklist participants. and open to anyone.

Users can force any transaction

Because the system derives L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. state from all valid ethscription transactions on Ethereum L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development., users can circumvent censorship by submitting any transaction with valid Data URI calldata. There is no specific inbox address required.

Based Sequencing

Ethscriptions uses a based sequencingA sequencing strategy for L2s based on Ethereum's own block building pipeline, which gets reused to also build L2 blocks. This strategy is in contrast to centralized sequencing or decentralized sequencing mechanisms that use networks external to Ethereum. model where transaction ordering is determined entirely by Ethereum L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development.. Unlike traditional rollups, Ethscriptions does not use a batch inbox. Instead, it derives L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. directly from L1 receipts and logs by monitoring all Ethereum transactions for valid Data URI calldata (ethscription creations) and ESIP protocol events (transfers). L2 blocks preserve the exact order in which Ethereum includes these transactions.

  1. Ethscriptions Kona - GitHub

Regular exit

Whenever a user submits a valid ethscription transaction on the L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development., the message is automatically processed on the L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. and sent to the L2ToL1MessagePasser with a snapshot of that ethscription state. When the blockAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over. containing that transaction is settled, the user can submit an L1 transaction to prove the ethscription state. The process of block finalization takes a challenge periodIn optimistic rollups, the window of time wherein network participants can assert that some fraud was included in a prior block. Most optimistic rollups currently specify a challenge window of 7 days. By extending the period, there is more time for participants to guard against fraud (invalid state transitions), but also more time until withdrawals gets enabled. of 7 days to complete. The challenge period can be shortened if the block is proven by providing a ZK proof.

Derivation Pipeline

The Ethscriptions AppChain operates as a derivation pipeline that converts L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. ethscription activity into canonical L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. blocksAn ordered list of transactions and chain-related metadata that gets bundled together and published to the L1/DA layer. Nodes execute the transactions contained within blocks to change the rollup chain’s state. Protocol rules dictate what constitutes a valid block, and invalid blocks are skipped over.. A Ruby-based derivation nodeA software client that participates in the network. observes L1 blocks, parses ethscription intents from calldata and events, and constructs deposit-style EVM transactions. These are then executed by a modified geth implementation (ethscriptions-geth) that maintains EVM state and provides standard JSON-RPC interface.

  1. Ethscriptions Node - GitHub
  2. Ethscriptions Geth - GitHub

No direct L2 transactions and free gas

Unlike traditional rollups, users do not submit transactions directly to the L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups.. All user interactions occur on Ethereum L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. through standard ethscription operations (creating via Data URIs in calldata or transferring via ESIP events). The L2 derives its state entirely from this L1 activity through the derivation pipeline. Consequently, there is no gasA virtual fuel used to execute smart contracts on a rollup. The EVM (or other VM within the rollup) uses an accounting mechanism to correspond the consumption of gas to the consumption of computing resources, and to limit the consumption of computing resources. paid by users on the L2 - geth has been modified to execute derived transactions without charging gas fees. Users only pay L1 gas costs for their Ethereum transactions.

A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner

Ethereum

Actors:

Facet Multisig0xb2B0…C525

A Multisig with 2/3 threshold.

  • Can interact with RollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup.
    • can set the whitelisted proposers
Used in:
  • Can interact with RollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup.
    • Can propose state rootsA cryptographic hash succinctly representing a state using a Merkle tree. optimistically without a ZK proof. Note that anyone can propose with a ZK proof, and anyone can propose optimistically after the fallback timeout
Used in:

Ethscriptions

Actors:

ProxyAdmin predeploy that manages proxy upgrades for L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. predeploys.

  • Can upgrade with no delay
    • Ethscriptions
    • EthscriptionsProver
    • L2ToL1MessagePasser
A dashboard to explore contracts and permissions
Go to Disco
Disco UI Banner

Ethereum

Core rollupA blockchain that inherits consensus and data availability from another blockchain called L1. Rollups enable trust minimized bridges with the base layer via proof systems, either optimistic or zero-knowledge. A rollup without a bridge, or without considering the bridge, is called a sovereign rollup. contract that manages the state of the rollup and its ZK fault proof systemThe infrastructure that allows projects to verify their state transitions. It is composed by onchain verifiers and offchain provers. The main two flavors are optimistic and ZK proof systems, but they can be combined in a hybrid model. In general though, if a system is able to accept state roots optimistically, even if it has a ZK component, it is considered an optimistic proof system..

  • Roles:
    • owner: Facet Multisig
    • whitelistedProposers: EOA 1
SP1Verifier0x0459…C459

VerifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contract for SP1 proofs (v5.0.0).

Implementation used in:
SP1VerifierGateway0xa236…8eE1

This contract is the router for zk proof verification. It stores the mapping between identifiers and the address of onchain verifierAn entity in a ZK-Rollup, often a smart contract, that verifies zero-knowledge proofs submitted by a prover. contracts, routing each identifier to the corresponding verifier contract.

Implementation used in:

Ethscriptions

Core Ethscriptions NFT contract that manages ethscription ownership and metadata on L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups..

  • Roles:
    • admin: Proxy
Can be upgraded by:

L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. predeploy that automatically sends ethscription state snapshots to L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development. via the L2ToL1MessagePasser whenever an ethscription is created or transferred.

  • Roles:
    • admin: Proxy
Can be upgraded by:

L2Layer 2 (L2) is a category of technical solutions aimed to scale the base layer in a trust minimized way. This category includes solutions like rollups as well as state channels and plasma. Other solutions are able to scale further, but with the introduction of additional trust assumptions, which are therefore not trust minimized. Sometimes the term Layer 2 is used to refer to include these solutions too, like validiums and optimiums, but to distinguish between trust minimized and non trust minimized solutions they are often referred to as "light" L2s, opposed to "strong" L2s like rollups. predeploy for passing messages from L2 to L1Layer 1 (L1) is a blockchain that is self-reliant on its validator set for its security and consensus properties. Ethereum is an example of a layer 1. Blockchains started receiving the moniker of layer 1 once layer 2 became a meaningful area of development.. Messages are automatically sent by the EthscriptionsProver when ethscriptions are created or transferred.

  • Roles:
    • admin: Proxy
Can be upgraded by:

Program Hashes

Name
Hash
Repository
Verification
Used in
0x001d...acdd
Ethscriptions logo
0x5a02...f594
Ethscriptions logo