Peeling back the interface to reveal the infrastructure beneath. Every abstraction layer is a decision about what to hide and what to expose. This site chooses exposure.
Beneath every smart contract, beneath every token transfer, beneath every governance vote, there is a layer of raw consensus — validators agreeing on the order of events in a universe that has no inherent clock. Layer 0 is this agreement, this shared fiction of sequence, maintained through mathematics rather than authority.
An identity on Layer 2 is not a name or a face. It is a cryptographic commitment — a proof that some entity can produce a valid signature for a given public key. The identity exists as a mathematical relationship, not as a human concept.
function verify(proof, publicKey) {
return commitment.check(proof, publicKey);
}
The execution layer transforms static state into dynamic computation. Every transaction is a function call, every block is a batch of function calls, and the entire chain is a deterministic computer that runs the same program on every node simultaneously.
A rollup compresses thousands of transactions into a single proof posted to the base layer. The compression is not lossy — every transaction can be reconstructed from the posted data. What is gained is throughput. What is preserved is security. The trade-off is time: the finality window stretches from seconds to hours, a tax paid in patience.
This is the layer where identity becomes practical. Where the cryptographic commitment meets the user interface. Where the abstract becomes usable.
Brutalist architecture refuses to hide its structure. The concrete is exposed, the rebar is visible, the joints are unfinished. This site follows the same principle: no decorative gradients, no rounded corners, no shadows to create false depth. Every border you see is structural.
Given enough time, water finds every crack in concrete. Moss grows in expansion joints. Roots split foundations. Natural systems infiltrate manufactured ones with the patience of geology. Layer 2 protocols do something similar: they find the gaps in Layer 1's constraints and flow through them, carrying computation to places the base layer cannot reach efficiently.
throughput: 4,200 tps
finality: 7 days (L1)
cost: 0.002 USD/tx
compression: 100:1
A state channel lifts the conversation off-chain entirely. Two parties open a channel, exchange signed messages at the speed of their network connection, and return to the chain only to settle disputes. It is peer-to-peer in the truest sense — the blockchain becomes an arbiter, not a mediator.
A validity proof is a mathematical guarantee that a computation was performed correctly without requiring the verifier to re-execute it. The prover does the work; the verifier checks a small certificate. This asymmetry — expensive to prove, cheap to verify — is the economic engine of Layer 2 scaling.
struct ValidityProof {
commitment: bytes32,
witness: bytes,
public_inputs: uint256[],
verified: bool
}
In concrete construction, formwork is the temporary mold into which concrete is poured. The form shapes the structure but is itself discarded. Layer 2 scaffolding operates similarly: temporary infrastructure that gives shape to permanent state, removed once the proof is settled.
The data availability layer ensures that the inputs to every computation are published and accessible. Without it, a rollup could post a valid proof for a state transition that nobody can reconstruct — a locked safe with no key. Data availability committees, sampling networks, and erasure coding all serve the same purpose: guaranteeing that the concrete is poured transparently.
Every compression is a trade-off. What you compress, you cannot easily inspect. What you batch, you cannot easily reorder. The art of Layer 2 design is finding the compression ratio that preserves expressivity while maximizing throughput.
blocks_processed: 14,207,831
avg_batch_size: 847 txs
proof_generation: 23.4s
state_root: 0x7f3a...c291
At the top of the stack sits the application layer, where users interact with the system through interfaces that hide every layer below. The irony is profound: the entire purpose of Layers 0 through 4 is to be invisible. Good infrastructure disappears. This site exists to make it visible again.
Finality is when a transaction becomes irreversible. On Layer 1, it takes minutes. On Layer 2, the answer depends on which layer you ask: instant for the sequencer, hours for the verifier, days for the base chain. Time, like identity, is relative to the observer's position in the stack.
This document is itself a layer. The HTML is the structure. The CSS is the surface treatment. The JavaScript is the behavior. The fonts are the voice. The colors are the material palette. Every element on this page has been deliberately exposed, its purpose labeled, its boundaries marked. There is nothing hidden. That is the point.