PancakeSwap (CAKE) sustainability report

PancakeSwap is present on the following networks: Aptos Coin, Arbitrum, Base, Binance Smart Chain, Ethereum, Linea, Opbnb, Solana, Zksync.

Aptos combines proof of stake with a Byzantine fault tolerant agreement protocol in the lineage of pipelined, leader-based designs. Validators hold voting power in proportion to the stake bonded to them, and a committee is fixed for the duration of an epoch, which lasts two hours; changes to the set take effect only at those boundaries. Within an epoch, a leader is chosen for each round to propose the next block, and the choice is weighted not only by stake but by recent performance, so an operator that repeatedly fails to get its proposals committed is proposed less often. Agreement is deterministic: once a quorum of voting power certifies a block, it is final and cannot be reorganized, in contrast to systems where confidence accumulates probabilistically.

Transaction data is disseminated separately from ordering. Validators batch incoming transactions and circulate them ahead of time, collecting proofs of availability, so a proposal need only reference batches that the rest of the committee already holds rather than carry the payload itself. This separation is what allows proposals to stay small and the agreement path to stay short. Successive protocol revisions have compressed that path further, cutting the number of network round trips needed to commit and allowing a leader to propose once per network delay instead of waiting out two, which has brought block intervals down to a few tens of milliseconds and finality comfortably below a second.

Execution is parallel and optimistic. Rather than requiring developers to declare in advance which state a transaction will touch, the engine speculatively executes transactions concurrently across processor cores, detects at runtime where one transaction read state another wrote, and re-executes only the affected transactions. Because the serial order fixed by agreement is used as the reference, the outcome is identical to sequential execution and every validator derives the same result. The network tolerates faulty or malicious behavior by up to one third of voting power.

Arbitrum One does not run a consensus algorithm or a validator set of its own. It is an optimistic rollup: transactions are executed off Ethereum, while Ethereum holds the canonical record and provides final settlement. A sequencer accepts transactions, orders them on a first-come basis and executes them under the chain's state-transition rules, producing blocks roughly four times a second and giving users an immediate local confirmation. The ordered transactions are compressed and published to Ethereum in batches. Because that input data sits on the settlement layer, anyone running the node software can replay it and arrive at the same Layer 2 state without trusting the operator.

Agreement about what that state is happens on Ethereum. Validators post assertions — claims about the rollup's resulting state — to contracts on the settlement layer. Since early 2025 the chain has used a dispute protocol that made validation permissionless, so any party may post an assertion or challenge one rather than only an approved list of operators. Conflicting claims are resolved by an interactive process that narrows the disagreement down to a single step of execution, which Ethereum then adjudicates directly. The protocol is designed so that disputes conclude within a bounded period no matter how many adversaries join them, and so that a single honest participant is enough to defend the correct state. Once the challenge window has passed without a successful dispute, the assertion is confirmed and withdrawals that depend on it become executable through the canonical bridge.

Two qualifications matter for an accurate picture. Ordering is still performed by a single sequencer operated by the chain's development company, so transaction ordering is not decentralized today; censorship is bounded rather than impossible, because a user can submit a transaction to a queue contract on Ethereum and force its inclusion once a defined delay has elapsed. Separately, a security council retains powers over the contracts, which keeps the arrangement short of full trust-minimization. Security therefore rests on Ethereum's proof-of-stake consensus combined with the rollup's fraud-proof mechanism, not on a validator set belonging to the chain itself.

Base is a Layer 2 network that executes transactions away from the Ethereum chain and settles them on it. It runs no consensus protocol of its own and has no validator set of its own. Agreement about which Base transactions occurred, and in what order, is ultimately established by the data and the state commitments the network publishes to Ethereum, which are secured by Ethereum's proof-of-stake consensus.

Ordering and execution on the Layer 2 are carried out by a single sequencer, operated by the company that launched the network. It receives transactions, places them into blocks at a fixed cadence and returns a result to the user straight away; those blocks are then compressed and posted to Ethereum in batches, alongside commitments to the state they produce. Once a batch sits inside a finalized Ethereum block, the ordering it encodes is as hard to reverse as Ethereum itself. Users are not wholly dependent on the sequencer for access: a transaction can instead be submitted through a contract on Ethereum, and the rules by which the Layer 2 chain is derived oblige it to be included, which bounds how far the sequencer can censor.

Base is an optimistic rollup, built on the shared OP Stack codebase and part of the Superchain group of networks that use it. State commitments are accepted as correct unless disputed. Anyone may propose one and anyone may challenge one within a dispute window, by playing an interactive game on Ethereum that narrows the disagreement down to a single step of execution, which an Ethereum contract then settles by running that step itself. Both sides post bonds, so an untrue claim and a frivolous challenge are each expensive. Permissionless fault proofs have run on the main network since late 2024, and a multi-party security council with a supermajority threshold governs changes to the contracts; together these place the network at the intermediate tier of the rollup maturity scale commonly used to compare such systems. A withdrawal to Ethereum cannot complete until the dispute window for the relevant commitment has elapsed. Decentralizing the sequencer itself remains outstanding work.

BNB Smart Chain, the programmable chain of BNB Chain and formerly styled Binance Smart Chain, reaches agreement through Proof of Staked Authority, a design that borrows stake-weighted election from delegated proof of stake and rotating, permissioned block production from proof of authority. Bonded stake decides who may produce blocks rather than who wins any individual slot. The network keeps an active set of forty-five operators, ranked by the amount of the native asset bonded to them through self-delegation and through delegation from holders. The twenty-one highest-ranked form the cabinet tier and the next twenty-four are candidates, with everyone below inactive and producing nothing. Rankings are recomputed once a day, so membership of the set turns over on a daily cycle rather than per block.

Within each epoch a consensus group of twenty-one is drawn from the active set, weighted heavily toward the cabinet tier, and those operators take turns proposing in a fixed rotation. Turn length and epoch length are protocol parameters that have been retuned repeatedly as block intervals shortened: successive upgrades cut the interval from three seconds to 1.5, then to 0.75 in mid-2025, and to 0.45 seconds in January 2026. A separate voting layer sits above the rotation, in which validators sign attestations on recent blocks; once enough signatures accumulate a block is treated as final, giving deterministic finality in roughly a second. Should that voting layer stall, the chain falls back to confirmation by accumulated depth, which takes minutes rather than seconds.

Security rests on an honest supermajority of a deliberately small elected set, backed by on-chain penalty logic. A slashing contract watches for double signing, for contradictory attestations in the fast-finality vote, and for repeated failure to produce during an assigned turn. Consequences range from temporary jailing and lost rewards through to removal from the set and forfeiture of part of a validator's own bonded stake. The trade-off is deliberate: a compact, frequently re-elected validator set buys very short block intervals and cheap execution, at the cost of the broader operator base that larger validator sets provide.

Ethereum reaches agreement through proof of stake, adopted in September 2022 when the original mining-based chain was retired in favor of a validator-driven consensus layer. The protocol family is usually referred to as Gasper. A fork-choice rule named LMD-GHOST selects the head of the chain by following the branch carrying the greatest accumulated weight of validator votes, while a separate finality gadget, Casper FFG, periodically justifies and then finalizes checkpoints, so that reversing them would require destroying an enormous quantity of bonded value.

Time is divided into slots of twelve seconds, and thirty-two slots form an epoch. For each slot the protocol pseudo-randomly designates one active validator to assemble and publish a block, and assigns the rest to committees that vote on what they believe is the correct head and the correct checkpoints. Under healthy conditions a checkpoint becomes final two epochs after it is proposed, a little under thirteen minutes, after which everything beneath it is treated as settled.

Joining the validator set requires a deposit of no fewer than 32 units of the native asset. Since the protocol upgrade of May 2025 a single validator may hold a far larger balance, up to 2,048 units, and earn on the whole of it, which lets an operator running many minimum-sized validators consolidate them into fewer; the activation floor itself did not change. Entry and exit are rate-limited by a queue measured in staked weight rather than in validator headcount, which bounds how fast the composition of the set can turn over.

Security rests on voting power being bonded. A validator that signs contradictory messages can be proved to have done so and is penalized, and the size of that penalty scales with how much other stake was penalized at the same time, so a coordinated attack is punished far more severely than an isolated fault. Should the chain stop finalizing altogether, a separate mechanism gradually erodes the balances of validators that are not participating until the remainder again represents a large enough majority to finalize. Upgrades during 2024 and 2025 changed how large data payloads are distributed and sampled between nodes, without altering this underlying agreement process.

Linea is a Layer 2 network that executes transactions away from the Ethereum chain and then proves their correctness to it. It has no consensus protocol of its own in the sense a base layer does, and no independent validator set standing behind user funds. What settles the question of what is true on Linea is a cryptographic proof, checked by a contract on Ethereum, showing that the state transition the network claims is precisely what its rules produce from the data it has published.

Three components do the work. A sequencer receives transactions, orders them and produces Layer 2 blocks, which gives users an immediate result. A coordinator drives the pipeline that turns those blocks into batches, requests proofs for them and submits the outcome to Ethereum. A prover generates the succinct zero-knowledge proofs themselves, and that is by a wide margin the most computationally demanding part of the system. During 2026 block production inside the sequencer was moved onto a Byzantine-fault-tolerant protocol of the kind used in permissioned enterprise networks, replacing an earlier proof-of-authority arrangement. The change is groundwork for spreading sequencing across several independent operators, but for now a single operator, the network's originator, produces every block.

Because the proof establishes validity mathematically, there is no dispute window and no requirement that a challenger be watching. Once the contract on Ethereum accepts a proof, the state it attests to is settled, subject only to Ethereum finalizing the block that contains the verification. That is the substantive difference from optimistic designs, where commitments are presumed correct and may be contested for a period afterwards. The network also publishes the full transaction data for each batch to Ethereum rather than only the differences in state, so anyone can rebuild the Layer 2 chain from settlement-layer data alone.

Execution aims to be indistinguishable from Ethereum's, and the remaining differences in gas accounting and state representation have been narrowed successively. Operationally the network remains centralized: sequencer and prover are each run by one party, contract upgrades are not yet constrained by a long user exit window, and independent assessments place it at the earliest tier of the common rollup maturity scale, with staking-based permissionless sequencing described as a later goal.

opBNB is a Layer 2 network built with the OP Stack, and it does not run a consensus protocol of its own. Ordering is delegated to a single sequencer, which receives transactions, executes them against the current state, and emits blocks on a fixed cadence; a network upgrade activated in January 2026 halved that cadence to a quarter of a second. Because one party decides the ordering, there is no agreement to reach among competing block producers, and what a user sees immediately after submitting a transaction is a provisional commitment from that sequencer rather than settled history.

Settlement is anchored to BNB Smart Chain rather than to Ethereum, which sets this network apart from most other OP Stack deployments. A batching component compresses the run of Layer 2 transactions and publishes it to contracts on BNB Smart Chain, while a proposer publishes commitments to the resulting Layer 2 state. Once that published material is buried under enough blocks of the settlement chain, the Layer 2 history it encodes becomes as difficult to revise as the settlement chain's own history, so the durability of the ordering ultimately derives from the base chain and not from anything happening at this layer.

That base chain reaches agreement through a staked-authority scheme that blends delegated staking with authority-based block production. A ranked set of validators bonds the base chain's native asset, and a subset is drawn each epoch to take turns proposing blocks; holders who do not operate a node can bond to a validator and thereby influence which nodes enter the active set. Validators that sign conflicting blocks, vote maliciously, or stay offline for long stretches forfeit part of their bond.

The design is optimistic in the sense that published state commitments are accepted unless someone disproves them. The on-chain dispute machinery that would allow anyone to do so is not yet in operation on this network; it has remained a matter of engineering work rather than a live system. Until it runs, the correctness of published state rests on the permissioned proposer and on the parties able to upgrade the bridge contracts.

Solana runs a proof-of-stake network in which the right to produce a block is allocated in proportion to the quantity of the native asset staked to each validator. What sets the design apart is that ordering is established before agreement is sought. A designated leader runs a sequential hash chain, each output feeding the next input, so the chain cannot be computed faster than a fixed number of steps and a transaction's position within it is evidence of when that transaction was received. This construction, called proof of history, spares validators from negotiating timestamps with one another and lets the rest of the protocol treat the order of events as already settled.

Leadership is not auctioned block by block. At the start of each epoch, which runs for roughly two days, a schedule is derived deterministically from the active stake distribution and assigns every short slot in the epoch to a named validator. Slots follow one another a few hundred milliseconds apart. The scheduled leader gathers transactions, executes them and streams the resulting block to the rest of the set in small fragments relayed through a tree structure rather than pushed to every peer at once. Receiving validators replay the block independently and publish votes for the fork they consider canonical.

Fork choice weights those votes by stake, and each vote commits a validator to its chosen fork for a period that doubles with every further confirmation, so abandoning a block grows steadily more costly. A block that a supermajority of stake has voted on is treated as confirmed within about a second, and it is locked in permanently once enough additional confirmations accumulate, which takes on the order of ten seconds. Safety rests on the assumption that participants acting dishonestly control less than a third of staked value. A revision of the voting layer, approved in a stake-weighted validator vote, is being activated on the main network in stages; it retains stake-weighted validation and the existing block distribution scheme while replacing the incremental lockout rule with direct voting that settles in one or two rounds.

zkSync Era is a validity rollup on Ethereum — the family commonly called zero-knowledge rollups — and it runs neither a consensus algorithm nor a validator set of its own. A sequencer receives transactions, orders them and executes them against the chain's state, returning a confirmation within a second or two. Blocks are grouped into batches, and each batch passes through three stages on Ethereum: the resulting data is committed, a cryptographic proof that the batch executed correctly is submitted and checked by a verifier contract, and the state transition is then applied on the settlement layer.

What separates this design from an optimistic rollup is that correctness is established before the fact rather than assumed and disputed afterwards. Once a proof verifies on Ethereum, the batch is known to have followed the protocol's rules, so there is no fraud proof, no challenger role and no week-long challenge window standing between a withdrawal and settlement; the wait is instead however long producing and verifying a proof takes. Proving is carried out by dedicated proving infrastructure, not by ordinary users. Proofs are built recursively, with many small proofs aggregated into one, and the final proof is compact enough to verify cheaply on Ethereum. The proving stack has been replaced more than once as the technology matured; the current generation proves execution of the chain's state-transition program itself, which brings proving close to real time and removes the need to maintain a separate circuit description mirroring the same logic.

Data availability rests on Ethereum. The chain publishes compressed differences in state — what changed as a result of a batch, rather than every transaction in it — into the dedicated data space Ethereum provides for rollups, which is sufficient for an independent party to reconstruct the chain. Two limits apply here as they do across comparable networks: sequencing is performed by a single operator, and the contracts are upgradeable through a governance process with timelocks and an emergency path rather than being fixed.

PancakeSwap is present on the following networks: Aptos Coin, Arbitrum, Base, Binance Smart Chain, Ethereum, Linea, Opbnb, Solana, Zksync.

Validators are paid from newly issued units of the native asset at a rate set by on-chain governance, and the payment is conditioned on output rather than mere presence. The reward for an epoch scales with the stake bonded to a validator multiplied by the proportion of its block proposals that were actually committed, so an operator that is offline, slow, or frequently skipped earns proportionally less. Rewards are added to the staked balance at each epoch boundary and compound from there. Holders who do not run hardware delegate into a validator's staking pool and receive their share after the operator's commission; stake locks and unlocks on epoch boundaries rather than on demand.

Penalties are exclusionary rather than confiscatory. The protocol does not currently implement slashing: there is no mechanism that destroys a validator's bonded stake for double-signing or for prolonged inactivity. What an underperforming operator loses is reward, through the proposal-success term, and eventually its place, since a validator whose stake falls below the minimum required to remain in the active set is moved to inactive status at an epoch transition, and governance can remove a validator directly. Delegators exert the remaining pressure by moving stake elsewhere.

Users pay for transactions in gas units priced in a small subunit of the native asset. The charge separates two things. Execution and input-output gas covers computation and propagation, and its unit price floats with congestion, which is also how transactions are prioritized: validators select from the pending pool by offered gas unit price, banded into discrete tiers rather than compared continuously, so raising a bid within a tier changes nothing. Storage is billed separately and at a price fixed in the native asset rather than in gas units, so the cost of occupying state does not swing with congestion, and the charge is refunded when the storage is released, meaning a transaction that frees more state than it creates can settle as a net credit. Under the fee parameters governance currently sets, collected gas is burned in full rather than routed to the proposing validator.

Fees on Arbitrum One are paid in the settlement layer's native asset and split into two economic components. The execution component prices computation and state access on Layer 2 through a base fee that a control loop raises and lowers with demand, in the style of Ethereum's own fee market. The data component covers the cost of publishing compressed batches to Ethereum. A transaction's share of that component is estimated from how many bytes it adds to a compressed batch, so how well its data compresses matters as much as its size, and the fixed cost of a posting is spread over everything in the batch rather than falling on one transaction. Since Ethereum opened a dedicated data space for rollups, batches are posted there and priced by that space's separate fee market. Both components are converted into a single unit, so a user sees one price rather than two.

Payments flow to several places. The party that posts batches is reimbursed from collected fees, with the data price adjusted over time so that reimbursement tracks what was actually spent. Remaining Layer 2 revenue accrues to protocol-controlled accounts — one covering baseline infrastructure, another collecting congestion revenue — which governance directs, rather than being burned. A portion of ordering rights is also sold: a sealed-bid auction awards a short-lived priority lane for a round lasting under a minute, and the proceeds go to an account that chain governance designates. Contracts compiled to WebAssembly run alongside EVM contracts and are metered on their own resource unit.

There is no staking, delegation, issuance or slashing at this layer. The equivalent penalty is a bond: participants that assert or challenge state must lock collateral, and a party that loses a dispute forfeits it, with part compensating the honest side, so an incorrect claim carries a direct cost. Beneath the rollup, Ethereum's own incentives apply to the data it posts — the base fee there is burned and the priority fee goes to the block proposer. There is no recurring storage rent; state is paid for when it is written.

Base has no native protocol asset, no staking and no issuance. Nothing is minted to reward participation and there is no validator or delegation system on the Layer 2. Fees are denominated and paid in ether, the same asset used on the settlement layer.

What a user pays has two parts, and they behave quite differently. The first is the cost of executing the transaction on the Layer 2, metered in gas exactly as on Ethereum and priced by an equivalent algorithmic base fee that moves with how full recent Layer 2 blocks have been, plus an optional tip. Because Layer 2 block space is plentiful, this component is usually very small and fairly stable. The second is a charge for the cost of publishing that transaction's data to Ethereum. It is assessed per transaction from the compressed byte size of the transaction and the prevailing price of settlement-layer data space, and it is collected when the transaction is processed even though the actual posting happens later, in a batch shared with many others. This second component typically dominates the total and is why Layer 2 costs track conditions on Ethereum.

Since Ethereum opened a dedicated market for rollup data in 2024, the network posts its batches into that market rather than as ordinary transaction data. Those data fees are priced independently of execution and are destroyed rather than paid to anyone, which cut this component sharply. A December 2025 change on the settlement layer raised the available data capacity while introducing a floor that ties the minimum data price to ordinary execution costs, so the charge no longer falls to almost nothing whenever demand for data space is light.

Fees collected on the Layer 2 accrue to the entity operating the sequencer, funding the cost of running it and of settling to Ethereum, with a portion shared with the collective that stewards the shared codebase. The other economic mechanism at work is the dispute system: participants who propose or challenge a state commitment post bonds that are forfeited if they are shown to be wrong, which funds honest challenges and makes dishonest claims costly.

BNB Smart Chain pays for its own security out of transaction fees rather than out of new issuance. The native asset carries no protocol-level block subsidy, so every reward reaching a validator or a delegator originates in gas paid by users. When a block is finalized the proposer's collected fees are routed into system contracts and split three ways. A governed fraction is sent to an unspendable address and permanently removed from supply, a slice accumulates in a reward vault used for network-wide purposes such as paying for fast-finality attestations, and the balance sits in the validator-set contract until it is distributed, on a daily cycle, to active validators and the holders who delegated to them.

Participation is staking-based. An operator must self-delegate a substantial amount of the native asset before it can be considered for the active set, and holders may bond additional stake to any validator to lift its ranking. Delegators receive their proportional share of whatever the validator earns, after the commission that validator sets for itself, and only the forty-five ranked operators earn at all: stake bonded to an inactive validator yields nothing. Unbonding is subject to a waiting period, so stake cannot be pulled out the instant misbehavior comes to light.

Penalties are graduated. Missing assigned turns or going offline for a sustained stretch triggers jailing, during which the validator produces nothing and earns nothing. Double signing and contradictory attestations in the finality vote are treated far more severely and can cost the validator a portion of its own bonded stake alongside ejection from the set.

Users face a conventional gas-metered fee model inherited from the Ethereum virtual machine. Each operation carries a gas cost, the sender chooses a gas price, and the total is charged in the native asset. There is no separate storage rent, so the cost of persisting state is bundled into execution gas, and deploying or calling a contract is priced purely by the computation and storage it consumes. The minimum acceptable gas price is a coordinated parameter that operators and infrastructure providers have revised downward several times, keeping ordinary transfers and contract calls inexpensive in absolute terms.

Payment inside the protocol flows to validators, the only participants the consensus layer compensates directly. A validator earns newly issued units of the network's native asset for voting promptly and correctly on the head of the chain and on the checkpoints being justified, for serving its turn in the committee that signs headers for light clients, and, when selected to propose, for the block itself. The proposer additionally keeps the priority portion of the fees in that block, together with whatever it receives from the separate market through which many proposers outsource block assembly. There is no delegation inside the consensus rules: stake is either operated directly or entrusted to an operator through arrangements that sit outside the protocol.

Users pay for execution in gas, metered per operation, with writes to persistent state priced far above arithmetic. Every transaction carries a base fee per unit of gas that the protocol sets algorithmically from how full recent blocks have been, and that amount is destroyed rather than paid to anyone, so sustained demand withdraws native asset from circulation. On top of it a user adds a voluntary tip, which goes to the proposer and governs how quickly the transaction is picked up. Data posted on behalf of Layer 2 networks is priced in a second, independent market whose fee is likewise destroyed; a December 2025 upgrade tied the floor of that market to ordinary execution costs so it cannot collapse to a negligible level, and capped the gas any one transaction may consume.

Penalties mirror the rewards. Failing to vote, or voting late or incorrectly, costs a validator roughly what correct behavior would have earned it. Provable equivocation is treated far more harshly: the offender is scheduled for ejection, forfeits part of its balance immediately, and later incurs an additional correlated penalty computed from how much other stake was penalized nearby in time. Prolonged absence while the chain is failing to finalize drains balances until finality can resume. Stakers may take out accumulated rewards without leaving the set, and since 2025 may also trigger a full exit from the execution layer rather than only from the consensus client.

Fees on Linea are paid in ether, the asset used on the settlement layer; no separate asset needs to be held in order to transact. The network runs no staking system, issues no rewards to a validator set and has no delegation inside its protocol, because it has no permissionless set of block producers to pay.

A user's fee has two parts in substance even where it is quoted as a single number. The first covers executing the transaction on the Layer 2, metered in gas on the same schedule Ethereum uses and priced by an algorithmic base fee plus a tip. The second covers what the network must spend on Ethereum, which for a validity rollup is of two kinds: publishing the batch's compressed transaction data, and paying for the on-chain verification of the proof that covers it. Verification is a fixed cost per submission and is spread across every transaction in the batch, so the fuller the batch the less each transaction bears. Data publication has used Ethereum's dedicated data market since 2024, priced separately from ordinary execution and destroyed rather than paid out, and compression improvements on the Layer 2 side reduce how much of that space a batch needs.

Fee revenue first pays the cost of running the sequencer, coordinator and prover and of settling to Ethereum. What remains after those costs is destroyed rather than kept: approximately one fifth as ether, which removes supply on the settlement layer, and the remainder used to acquire and destroy the network's own asset on Ethereum. This arrangement has been in force since late 2025 and ties the economics of both assets to how heavily the network is actually used rather than to a fixed schedule.

Penalties in the usual sense do not exist here, because no participant posts a bond that misbehavior could forfeit. Correctness is not encouraged economically but enforced cryptographically: an operator cannot finalize an invalid state, because no proof of one can be produced. What that leaves exposed is liveness and transaction ordering rather than validity, and it is those risks that the move toward multiple independent sequencers and provers is meant to address.

Fees are denominated in the native asset of BNB Smart Chain, and what a user pays divides into two parts. The first covers computation and state access on the Layer 2 itself, priced by a base fee that drifts up and down with how full recent blocks have been, plus a small required tip. The floor under that base fee is only a few units of the asset's smallest denomination and the per-block gas ceiling is generous, so under ordinary load the execution component is close to negligible. The second part recovers what the network spends publishing compressed transaction data to the settlement chain. It is charged in proportion to the bytes a given transaction contributes, and it is normally the larger of the two.

That publishing cost fell sharply once the settlement chain gained a separate class of transaction for carrying bulk data, priced in its own fee market and discarded after a retention period. Routing batches through that channel instead of through ordinary contract input data cut what the network spends to make its history retrievable, and the saving is passed through to the per-transaction data charge.

Fees collected at this layer accumulate in on-chain vaults and fund the operators posting data and state commitments downstream; any surplus is retained by the network's operator rather than distributed, because there is no validator set at this layer to reward and no block subsidy is issued here. Staking, delegation, and penalties all sit on the settlement chain instead. Validators there bond the native asset, receive the bulk of each block's fees when they propose, pass a share to those who have bonded to them after retaining a commission, and lose part of their bond for signing conflicting blocks, voting maliciously, or remaining unavailable.

Deploying and calling smart contracts is priced by the same two-part formula. Deployment is the more expensive operation, because contract bytecode is bulky and therefore costly to publish downstream, not because execution itself is charged differently.

Two streams of payment reach validators. The protocol issues new units of the native asset on a defined schedule and distributes them at the close of every epoch to validators and to the stake delegated to them, in proportion both to that stake and to the voting credits the validator actually accrued over the epoch; an operator that missed its slots or stopped voting accrues fewer credits and receives a correspondingly smaller share. Holders who do not wish to run hardware delegate through a stake account to an operator of their choice, retain control of that account, and receive the reward net of whatever commission the operator has set. Delegated stake becomes active and inactive only at epoch boundaries, so capital committed to securing the network cannot be pulled out on demand.

Users pay a fixed base fee for every signature a transaction carries. Half of that amount is destroyed and half is paid to the validator that produced the block. A transaction may attach an optional priority fee, quoted per unit of requested compute, which under a protocol change adopted in 2025 goes in full to the block producer; this is the mechanism that rations capacity when demand exceeds what a slot can hold. Program execution is metered in compute units against a per-transaction ceiling, so the cost of a contract call tracks the work it requests rather than a flat tariff.

Storage is charged once, not continuously. An account has to hold a minimum balance scaled to the number of bytes it occupies in order to be exempt from rent, and that balance is a refundable deposit rather than a fee: closing the account returns it. Recurring rent collection has been switched off at the protocol level and rent-paying accounts can no longer be created, so ongoing storage charges do not form part of the fee model as it now stands.

Staked assets are not confiscated by the protocol. No implemented mechanism automatically destroys a validator's stake for equivocation or for being offline; the cost of downtime is forgone reward set against operating expense, including the fees an operator pays to submit its own votes. A scheme to record provable duplicate-block violations on chain, as groundwork for any future economic penalty, is still at proposal stage and would not itself remove stake.

Fees on zkSync Era are denominated in the settlement layer's native asset and cover three costs rather than two. The first is executing the transaction on Layer 2. The second is publishing data to Ethereum: because the chain posts compressed state differences instead of full transaction data, a transaction's share of that cost turns on how many storage slots it touches and whether others in the same batch touch the same ones — repeated writes to one slot within a batch collapse into a single published change, so activity concentrated on the same state costs less than its raw size implies. The third is proving. Generating a validity proof consumes real computation on specialized hardware, and verifying it on Ethereum costs a fixed amount per batch however many transactions that batch contains, so both are spread across the batch and both reward filling batches fully.

The incentive structure follows from that. The operator running the sequencer and the proving infrastructure is paid out of collected fees and is out of pocket if those fees fail to cover data publication and proof verification, which ties its revenue to keeping batches full and published data compact. There is no staking, delegation, issuance or slashing at this layer, because the chain does not select block producers economically and so has no stake to penalize. What protects users instead is the proof itself — an invalid state transition simply cannot be verified on Ethereum — together with a queue on the settlement layer that gives users a route around a sequencer unwilling to include them.

Two further features shape what users actually pay. Account abstraction is part of the protocol rather than bolted on, so a contract can sponsor another account's fees or accept payment in a different asset while settlement still happens in the native one. And there is no recurring storage rent: state is paid for when it is written, through the data component of the fee, rather than carried as an ongoing charge against whoever wrote it.

PancakeSwap is present on the following networks: Aptos Coin, Arbitrum, Base, Binance Smart Chain, Ethereum, Linea, Opbnb, Solana, Zksync.

Consumption is built up from the population of machines that operate the network. The first input is a count of those machines, split into the validators that take part in agreement, the fullnodes that operators run beside them to distribute state, and the public fullnodes that serve reads to applications. One part of this population is unusually well observed: the active validator set is recorded on chain and reconstituted at every epoch transition, so its size is known rather than estimated. The wider fullnode population is not, and is inferred from network crawlers and publicly reachable peer information.

Each class of machine is matched to a hardware profile taken from the resources the node software is documented to require. Because the execution engine is built to occupy many processor cores at once, validator profiles assume multi-core server equipment with substantial memory and fast persistent storage rather than a modest configuration. Power draw for a profile comes from bench measurement of equivalent hardware, recorded both under load and at rest, with idle draw included because a node is expected to stay available continuously. Aggregating draw across the estimated population over the hours in the reporting period yields consumption for the network. Where a portion of that total is attributed to an individual asset issued on the network, the share is based on that asset's observed proportion of on-chain transfer activity.

Several qualifications apply. The fullnode population is inferred rather than counted; hardware is deduced from documented requirements rather than reported by the operators themselves; and facility overheads for cooling and power conversion are approximated using typical data-center factors instead of being metered at each site. Where the available evidence leaves a question open, the assumption taken is the one that tends to produce the higher consumption figure, so the disclosure is not made flattering by accident. Estimates are revised as observation improves and after protocol changes that alter the work a node has to do.

The consumption attributed to Arbitrum One has two parts, and they are estimated in different ways. The first is the chain's own infrastructure: the machines running the sequencer and the batch-posting process, the validators that track state assertions and would take part in a dispute, and the broader population of full, archive and RPC nodes that other participants operate. The second is the share of Ethereum's consumption that belongs to the rollup, because settlement and data availability happen there. Ethereum's validators do work on the rollup's behalf whenever a batch is posted, and a proportion of their consumption is apportioned to the chain according to how much of the settlement layer's capacity those postings occupy. Ethereum publishes its own account of how that figure is arrived at (Ethereum energy consumption).

Since nothing here is mined, the first part is estimated by counting machines rather than by modeling operator profitability. The size of the node population is approximated from network crawlers, peer discovery and publicly listed endpoints. A representative hardware specification is inferred from what the client software states it needs to stay in sync — processor class, memory, fast storage and bandwidth — and the electricity that specification draws is taken from controlled measurement of equivalent machines, both under load and idling. The total is the aggregate across the estimated population including idle draw, because nodes run continuously whether or not blocks are full. Dispute participation is episodic and contributes little in normal operation. A fraction of the network total is then attributed to an individual asset in proportion to observed on-chain activity involving it.

These are estimates rather than meter readings, and the limits should be read as part of the figure. Node counts are lower bounds, because machines behind private networks cannot be discovered. The hardware mix is inferred from stated software requirements rather than surveyed from operators. Where the evidence runs out, the assumption chosen is the one more likely to overstate consumption than to understate it, and figures are revised as observation improves.

The estimate for this network has two components, and they are constructed differently.

The first is the network's own infrastructure. This is a small and largely identifiable set of machines rather than a large permissionless population: the sequencer that orders and executes transactions, the batching service that compresses and submits data to the settlement layer, the service that publishes state commitments, and the replica and archive nodes that third parties operate to serve applications and to independently check what the sequencer produced. The number of independent replicas is estimated from crawlers of the Layer 2 peer-to-peer network and from public information about node operators and infrastructure providers. Hardware profiles are inferred from the published requirements of the node software, which for a high-throughput rollup are materially heavier than for an ordinary chain, and per-device power draw comes from measurement on representative equipment under controlled laboratory conditions, counting idle draw as well as load. The fault-proof machinery adds little in normal operation, since the interactive dispute game runs only when a commitment is actually challenged rather than continuously.

The second component is the share of the settlement layer's consumption that this network causes. That layer is Ethereum, whose own consumption is estimated from its validator population using the node-level method described for that network. A portion is attributed here in proportion to what this network occupies there, principally the data space its batches consume, alongside the gas used by its commitment and dispute contracts. Because the settlement layer's consumption is driven by a continuously running validator set rather than by throughput, this attributed share is modest next to the Layer 2's own footprint, but it is included so that settlement is not treated as free.

Both components are estimates built on public observation and stated software requirements, not metered readings. The replica population is the least observable part and the largest source of uncertainty. Where evidence is thin, the assumptions used are those more likely to overstate impact than understate it, and figures are revised as observation improves. The settlement layer publishes its own account of its energy profile at Ethereum energy consumption.

The energy figure for BNB Smart Chain is built upward from the node population rather than downward from operator revenue, which is the appropriate treatment for a staked network where block production is not a computational race. Nothing about the fee model or the value of the native asset determines how much hardware is deployed: the size of the validator set is fixed by protocol, and the wider population of non-validating nodes is driven by demand for chain access.

The estimate has three inputs. The first is the number of machines. The elected validator set is known from the chain itself, while the surrounding population of full and archive nodes is approximated from peer-discovery crawls, public node listings and network scans, all of which observe only nodes willing to accept inbound connections and therefore tend toward undercounting. The second input is a representative hardware profile per node, inferred from the client software's published requirements, which on this chain are demanding relative to slower networks of the same family, since sub-second block intervals and rapid state growth push operators toward high core counts, large memory and fast solid-state storage. The third is the electrical draw of such a machine, taken from measurement of comparable configurations on the bench, both under sustained load and at idle, because a validator idles between its assigned turns and that baseline draw is a real part of the total. Aggregating the per-machine figure across the estimated population, with an allowance for the overhead of the facilities housing it, gives the network total.

Several qualifications belong with the result. It is a modeled estimate resting on observed node counts and stated software requirements, not metered consumption at the socket. Where evidence is thin, the assumptions chosen lean toward overstating rather than understating consumption. Figures are revised as crawler coverage and hardware information improve. Finally, apportioning a share of the network total to any single asset issued on the chain is done from observed on-chain transfer volumes, which measures how heavily an asset is used rather than the energy it uniquely causes.

The figure reported for this network is assembled machine by machine, treating the computers that run the protocol as the thing that draws electricity. The starting point is an estimate of how many independent nodes are operating, built from crawlers that walk the peer-to-peer layer and record every peer they can reach, supplemented by public listings of infrastructure and staking providers and by the protocol's own visible record of how much stake is active and how it is spread across operators.

A representative hardware profile is then inferred for those machines. The client software publishes what it requires in processor, memory and disk terms, and operators have little reason to provision far beyond that, so the profile is derived from those stated requirements rather than from a survey of individual operators. Power draw for the resulting device classes comes from measurement on representative equipment under controlled laboratory conditions, capturing both the load validating places on a machine and the draw of a machine that is powered on but momentarily idle, which for a network of this kind accounts for a large share of the total. Multiplying measured per-device draw across the estimated population over the reporting period yields the network figure. Where a disclosure concerns one of the many assets issued on this network rather than the network itself, a portion of the network total is assigned to it in proportion to observed on-chain transfer volumes.

The limits deserve stating plainly. The node count records what is reachable, not a census, and machines behind restrictive network configurations are missed. The hardware profile is a reasoned inference from published software requirements, not a record of what any particular operator bought. Nothing here is metered at the wall. Where the evidence runs out, the assumptions chosen are those that push the estimate upward rather than downward, so the result is more likely to overstate consumption than to understate it, and it is revised as observation improves. The network's own account of its energy profile is published at Ethereum energy consumption.

The estimate for this network is assembled from two components: the machines the network runs itself, and the share of the settlement layer's consumption that its activity causes.

The first component is unusual among Layer 2 designs because proving dominates it. The sequencer, the coordinator and the replica and archive nodes that third parties operate are conventional server workloads, sized from the published requirements of the node software and assigned power figures measured on representative equipment under controlled laboratory conditions, with idle draw counted alongside load. The prover is a different matter. Producing a succinct proof that a whole batch of transactions executed correctly is an intensive computation, run on large multi-core machines and accelerators, and it is performed for every batch the network settles rather than only when something is contested. That makes proving a recurring, throughput-linked energy cost with no counterpart in an optimistic design, and it is modeled as a distinct workload whose draw scales with the volume of transactions proved rather than with elapsed time alone. Efficiency gains in the proving software reduce this component directly, which is one reason the figure moves between reporting periods.

The second component is the settlement layer, which is Ethereum. Its consumption is estimated from its validator population using the node-level method described for that network, and a share is attributed here in proportion to what this network occupies there: the data space its batches consume and the gas its verification and settlement contracts use.

All of this rests on estimation rather than metering. The number and specification of proving machines are inferred from the operator's published architecture and from what the proving workload demands, not read from a meter, and the replica node population is observed through crawlers and public listings and is necessarily incomplete. Where the evidence does not settle a question, the assumption chosen is the one that raises the estimate rather than lowers it, so the result is more likely to overstate than understate, and it is corrected as observation improves. The settlement layer's own account of its energy profile is published at Ethereum energy consumption.

The estimate is built up from the machines that actually run the network rather than from any protocol-level abstraction, and it has two distinct components because this is a Layer 2.

The first component is the infrastructure operated for the Layer 2 itself: the sequencer, which orders and executes incoming transactions; the components that compress history and publish it downstream; the component responsible for state commitments; and the replica and archive machines that outside parties keep running to answer queries and follow the chain for themselves. The size of that population is approached by counting what can be observed, through network crawlers, reachable peers, published endpoints, and operator disclosures. A representative machine specification is then inferred from the requirements the client software states for each of those roles, power draw for such specifications is taken from measurement of comparable hardware under load and at rest, and summing across the estimated population gives the total. Idle draw is included rather than assumed away, since these machines consume power continuously and not only while a transaction is being processed.

The second component is whatever portion of the settlement layer's consumption is properly charged to this network. Because settlement and data publication happen on BNB Smart Chain and not on Ethereum, it is that chain's validator infrastructure whose consumption is partly allocated here, in proportion to the data and state commitments this network posts there relative to the settlement chain's total load. Observed on-chain activity data is used to size that proportion. The result is a proportional attribution, not a measurement of energy caused at the margin.

Several limits belong next to any resulting figure. The node population and the hardware behind it are inferred from public observation and from stated software requirements, so machines that are unreachable or unannounced go uncounted and the real mix is more varied than a single representative specification suggests. Where evidence is thin, the assumptions chosen lean toward the higher end, so the outcome is likelier to overstate the impact than to understate it. Figures are revised as observation improves and as the network's architecture changes.

The figure reported for this network is assembled from the machines that run it rather than inferred from any single aggregate quantity. The starting point is a count of active nodes, put together from network crawlers, publicly reachable cluster and gossip information, and data operators choose to publish. That population is then divided by role, because a validator taking part in voting, a machine that only replays the ledger, and the infrastructure that answers application requests do not draw comparable amounts of power.

Each role is matched to a representative hardware profile derived from the resources the client software is documented to need. Requirements here are heavy by the standards of proof-of-stake systems, running to many processor cores, large memory and fast solid-state storage, and the profiles reflect that rather than assuming commodity equipment. Electrical draw per profile is taken from controlled bench measurement of equivalent devices, capturing both the load imposed by processing and the draw of a machine that is powered up but idle, since a node consumes electricity continuously whether or not it is producing a block. Multiplying profiles by the estimated population across the hours of the reporting period gives consumption for the network as a whole. Where a figure is attributed to one asset issued on the network rather than to the network itself, the share is taken from observed on-chain transfer activity for that asset.

The output is an estimate and should be read as one. The node count rests on what is visible from outside, and operators are under no obligation to be visible; the hardware mix is inferred from stated requirements rather than surveyed; and facility overheads such as cooling and power conversion are approximated rather than metered. Where the evidence does not settle a question, the assumption adopted is the one more likely to overstate consumption than understate it, and figures are restated as observation improves or as protocol changes alter the work a node must perform. The network's own climate reporting is published at Solana Climate Dashboard.

The estimate combines two sources of consumption. One is the chain's own infrastructure, which has a component most rollups lack: alongside the sequencer, the process that publishes data to Ethereum, and the full and archive nodes that applications and infrastructure providers run, there is a proving fleet. Generating validity proofs is genuine computation on servers with high core counts and accelerator hardware, run continuously as batches arrive, and it is a material line in the total rather than a rounding error. The other source is the share of Ethereum's consumption attributable to the rollup, since every batch commitment and every proof verification consumes capacity that the settlement layer's validators pay to provide; that share is apportioned by how much of Ethereum's resources those postings occupy. Ethereum publishes its own account of how its consumption is estimated (Ethereum energy consumption).

Because nothing is mined, the chain's own side is assessed machine by machine. The node population is approximated from crawlers, peer discovery and published endpoints. Representative hardware is inferred from what the client software states it needs, and for the proving side from what the proving implementation documents as its requirements, which are considerably heavier. Power draw for each profile comes from controlled measurement of equivalent equipment under load and at idle, and the network total aggregates across the estimated population including idle draw. A fraction of that total is then attributed to an individual asset according to observed on-chain activity involving it.

The caveats are the substance of the method, not a disclaimer attached to it. Node counts are floors, since machines on private networks cannot be discovered. Proving capacity is particularly hard to observe from outside, because it is operated privately rather than announced to peers, so its size is inferred from proof cadence and stated hardware requirements. Where evidence is missing, assumptions are chosen that are more likely to overstate consumption than understate it, and figures are revised as observation improves.

PancakeSwap is present on the following networks: Aptos Coin, Arbitrum, Base, Binance Smart Chain, Ethereum, Linea, Opbnb, Solana, Zksync.

Establishing where the network's electricity comes from begins with establishing where its machines are. Node addresses observable through crawlers and public peer information are resolved to a country or region, giving partial geographic coverage; it is only partial, because operators frequently sit behind hosting providers whose announced location need not match the facility actually running the hardware. Where the spread cannot be pinned down directly, the observed distribution of a structurally similar network is used in its place, selected because its staking economics and agreement protocol place comparable demands on operators and so tend to draw them toward comparable hosting markets.

Each located node is then assigned the generation mix of the grid supplying it. Those regional mixes are taken from Share of electricity generated by renewables, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy. Weighting each region's renewable proportion by the consumption estimated to sit there produces a figure for the network overall. The figure describes the grids the infrastructure physically draws on rather than any contractual arrangement: renewable purchase agreements held by individual operators are not reflected, since they cannot be observed from outside the network.

Energy intensity is a separate quantity and is narrower than dividing total consumption by transaction count. It expresses the additional energy associated with processing one further transaction. The distinction carries weight for a network of this design, where validators run continuously at a broadly constant power level and parallel execution absorbs additional transactions using capacity that is already switched on, so the marginal figure is small while the standing consumption of the validator set is not. Both numbers move with two independent inputs: the size, role mix and location of the node population, and the grid statistics for the years covered, which are themselves restated as national energy reporting is revised.

The renewable share is derived geographically, starting from where the machines that keep the chain running actually sit: the servers hosting the sequencer and the batch poster, the validators that participate in the dispute protocol, and the wider population of full and archive nodes. Their locations are inferred from publicly observable network information — the addresses reachable peers announce, hosting and autonomous-system registries, and public node listings — which yields a country-level distribution rather than a precise address for any individual machine. Much of this infrastructure is hosted with commercial cloud and colocation providers, so the region a provider operates a facility in stands in where a single host cannot be placed more precisely. Where the chain's own distribution is too sparse to observe with confidence, the pattern seen on networks of similar shape — alike in how participants are paid and in the class of hardware they run — fills the gap.

The same exercise is applied to the settlement layer, because the portion of Ethereum's consumption attributed to the rollup carries the geographic profile of Ethereum's validator set rather than that of the rollup's own machines. The two distributions are combined, weighted by how much estimated consumption each accounts for.

Country weights are then matched against published statistics on how much of each country's electricity comes from renewable sources, drawn from Share of electricity generated by renewables, compiled by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy. The result is a consumption-weighted average across the estimated footprint. It is not a statement about what any operator has contracted for: power purchase agreements, on-site generation and renewable certificates are invisible in network data and are not assumed.

Energy intensity is expressed marginally, as the additional electricity associated with one more transaction on top of the infrastructure already running. Because the cost of operating a node is largely fixed and barely responds to how full a block is, that marginal figure is small and moves inversely with throughput, which is why it should not be read as a per-transaction share of the total.

The renewable share reported for this network is a weighted average of the electricity mixes of the grids its infrastructure draws on, assembled in two steps: establish where the machines are, then attach regional generation statistics to those places.

Locating them is easier for some parts of the network than others. The sequencing, batching and commitment services run in identifiable data center regions, and the hosting regions an operator uses are publicly observable. The wider population of replica and archive nodes is inferred as it would be for any peer-to-peer network, from the addresses peers advertise so that others can reach them, collected by crawlers and supplemented by public directories of infrastructure providers. Resolving a single address to a country is unreliable, but in aggregate these resolutions describe a distribution well enough to weight against. Where the observable sample is too thin, the geographic spread of a structurally comparable network is used in its place, chosen because its operators face similar hosting economics rather than because it runs similar software. The same exercise is carried out for the settlement layer, because part of the figure reported here is an attributed share of Ethereum's consumption, and Ethereum's validator population is spread quite differently from a rollup's concentrated operator infrastructure. The two distributions are weighted by their respective contributions to consumption and combined.

Each location is then matched to published statistics on how electricity is generated in that country or region, and the renewable proportion is the consumption-weighted share falling in regions supplied by renewable generation. Grid averages are used throughout, because the actual supply arrangements of individual hosting facilities are not observable; a facility on a dedicated renewable supply and one drawing ordinary grid power in the same country are treated alike.

Energy intensity is a marginal figure rather than an average: the additional electricity attributable to one further transaction on the network as it currently runs. Because most of the infrastructure runs continuously whether or not it is busy, that marginal quantity is much smaller than dividing total consumption by the transaction count would suggest. The generation statistics come from Share of electricity generated by renewables, compiled by Our World in Data from Ember's electricity datasets and the Energy Institute's Statistical Review of World Energy.

The renewable share reported for BNB Smart Chain follows from where its machines physically run, so the method begins with locating them. Node addresses visible through peer discovery and public network observation are resolved to hosting providers, autonomous systems and countries, producing an approximate geographic distribution of the validator and full-node population. Where that observation is too sparse to stand on its own, the distribution of a network with a comparable staking design and operator economics is substituted, on the reasoning that similar incentives attract similar operators into similar hosting markets.

That distribution is then matched against national electricity statistics. Each country's share of generation coming from renewable sources is taken from Share of electricity generated by renewables, compiled and processed by Our World in Data from Ember's yearly electricity datasets and the Energy Institute's Statistical Review of World Energy. Weighting those country-level shares by the portion of estimated node capacity sitting in each gives a single renewable percentage for the network.

Energy intensity is a separate quantity and is defined marginally: the additional electricity associated with one further transaction being processed, rather than the annual total divided by the transaction count. On a chain that produces blocks on a fixed schedule whether or not they are full, the marginal figure is far smaller than a simple average would suggest, and the two should not be used interchangeably.

Three limits are worth stating plainly. An observed hosting location identifies a grid but not a procurement arrangement, so an operator buying renewable power on a carbon-heavy grid is indistinguishable from one that is not. Cloud and proxy infrastructure can place a node's apparent location away from the hardware actually running it. And national annual averages smooth over the hourly and seasonal variation in generation mix that a continuously running machine actually draws from.

The renewable share reported here is a weighted average of grid mixes rather than a record of what any operator actually buys. It is produced in two steps: establish where the infrastructure sits, then attach regional electricity statistics to those places.

Location is inferred from what the network exposes publicly. Nodes advertise network addresses in order to be reachable by peers, and those addresses resolve to a country accurately enough to describe an aggregate distribution, even though any single resolution may be wrong. Crawlers of the peer-to-peer layer and public directories of hosting and staking infrastructure supply the input. Where the observable sample is too thin or too skewed to stand for the whole population, the geographic spread of a structurally similar network is substituted, chosen because its participants face comparable hardware costs and comparable pressures over where to site machines, on the reasoning that operators respond to the same commercial forces even where the software differs.

Each location is then matched to published statistics on how electricity in that country or region is generated. The renewable proportion for the network is the consumption-weighted share falling in regions where generation is renewable. Grid averages are used because the alternative, knowing each operator's actual supply contract, is not observable; an operator on a dedicated renewable supply and one drawing ordinary grid power in the same country are treated alike.

Energy intensity is reported on a different basis from total consumption. It is a marginal quantity: the additional electricity attributable to processing one further transaction on the network as it currently runs. For a network whose consumption is driven by a validator set that operates continuously regardless of how busy the chain is, that marginal figure is small, and it is not the total divided by the transaction count. The generation statistics are drawn from Share of electricity generated by renewables, compiled by Our World in Data from Ember's electricity datasets and the Energy Institute's Statistical Review of World Energy.

Most of the electricity behind this network is drawn by proof generation, and proof generation does not happen everywhere. It runs on clusters of high-core-count machines and accelerators in a handful of sites, which gives the geographic weighting an unusual shape: a small number of grids carry most of the weight, and the renewable figure shifts noticeably if the proving fleet is enlarged, retired or moved to a different hosting region. A network of many small scattered nodes averages such changes away. This one does not.

Establishing locations therefore starts with those sites. Hosting regions chosen for the proving fleet, and for the sequencing and coordination services running alongside it, are visible in the operator's published technical material and in the routing of the endpoints it exposes. Independent replica and archive operators form a second, dimmer tier, counted through peer crawling and through directories of infrastructure providers, with a country attached to each by looking up which allocation an announced address falls under. That lookup misfires often enough on any single machine that only the aggregate shape is trusted. A third tier lies outside the network altogether, since part of what is reported here is a slice of the settlement layer, whose validators occupy a far wider spread of grids; that spread is characterized separately and blended in at the weight the slice carries. When a tier resists observation, a stand-in profile is borrowed from a network whose operators choose hosting on comparable commercial grounds.

Generation statistics do the rest. Every country in the weighted distribution carries a published figure for the fraction of its electricity produced from renewable sources, and the network's renewable share is that fraction averaged over the consumption weights. It is a statement about grids rather than about procurement: a proving site buying wind power directly and a neighboring rack on default tariff are indistinguishable under this treatment, and an annual national series cannot describe the hour at which a load actually fell.

Energy intensity means the additional electricity one further transaction brings, with the deployed hardware held as it is. Here that quantity is not close to nothing, because every extra transaction enlarges the work a prover must perform. Generation figures come from Share of electricity generated by renewables, a series Our World in Data maintains from Ember's electricity data and from the Energy Institute's Statistical Review of World Energy.

The renewable share is derived from where the hardware sits, not from any claim the network makes about its own power supply. The first step is to place the machines: the nodes serving this Layer 2, and separately the validator infrastructure of the settlement chain whose consumption is partly allocated to it. Locations are inferred from publicly observable network data, including announced addresses resolved to a country, address ranges belonging to hosting and cloud providers, and operator disclosures where any exist. Coverage is never complete, and for a Layer 2 whose node population is small and partly operated by one organization the observable sample can be thin. Where a chain's geographic spread cannot be read directly, the distribution of a network of similar design and similar operator economics is substituted for it, on the reasoning that comparable infrastructure tends to be hosted in comparable places.

Once locations are assigned, each is matched to statistics for the electricity grid serving it, and the resulting country weights produce a single renewable proportion for the network as a whole. Those grid statistics are annual national series published by Our World in Data and processed from Ember's electricity data together with the Energy Institute's Statistical Review of World Energy: Share of electricity generated by renewables.

Intensity in this section means energy rather than emissions, and it is expressed at the margin: the additional electricity associated with one further transaction being processed here and carried through to settlement. It is not the total divided by the transaction count, because most of what these machines draw is fixed and would be drawn whether or not the next transaction arrived. For a Layer 2 the marginal figure is dominated by the downstream cost of making a transaction's data retrievable on the settlement chain rather than by executing it, so it moves with how densely transactions are packed into published batches.

Two caveats carry through. Grid statistics are national annual averages rather than the mix actually supplied to a given facility at a given hour, and an operator's contractual purchase of renewable electricity does not show up in them.

The renewable share is derived geographically. Node locations are inferred from what the network exposes about itself: addresses observable through crawlers and public cluster information, resolved to a country or region. Coverage is never complete, because operators may sit behind hosting providers or relays that obscure where the hardware physically sits. Where the geographic spread of this network cannot be observed directly, the distribution of a structurally similar network stands in as a proxy, chosen because its validator economics and agreement protocol place comparable demands on operators and therefore tend to attract them to comparable locations.

Each located node is then assigned the generation mix of the grid that serves it. Those regional mixes come from Share of electricity generated by renewables, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy. Weighting each region's renewable share by the estimated consumption sitting in that region produces a network-wide proportion. The result describes the grids the infrastructure draws from, not contractual purchases: an operator buying renewable certificates is not treated differently from a neighbor on the same grid, because that distinction cannot be observed from outside.

Energy intensity is reported separately and means something narrower than total consumption divided by transaction count. It is the marginal quantity of energy associated with processing one further transaction. That distinction matters for a network of this type, where validators run continuously at close to constant power regardless of how full the blocks are, so the incremental energy attached to an additional transaction is small while the standing consumption of the validator set is not. Both the renewable share and the intensity figure therefore move with two separate things: the composition and location of the node population, and the grid statistics for the years covered, which are themselves restated as national reporting is revised.

Working out a renewable share is a question of geography before it is a question of energy. The relevant infrastructure is the sequencing and data-publishing servers, the proving fleet, and the full and archive nodes operated by applications, bridges and infrastructure providers. Locations are inferred from what the network exposes publicly — peer addresses resolved against hosting and autonomous-system registries, and published operator endpoints — giving a country-level distribution rather than a fixed address for any one machine. Since much of this capacity is rented from cloud and colocation providers, the region a provider assigns to a facility stands in where nothing finer is available. The proving fleet is the hardest part to place, because it is run privately and does not announce itself to peers; where it cannot be located directly, the distribution of comparable computation-heavy infrastructure is used in its place. The same substitution applies more generally: where the chain's own sample is too thin, the pattern seen on networks of similar design fills the gap.

The settlement layer is treated on its own terms. The portion of Ethereum's consumption attributed to the rollup follows the geography of Ethereum's validator population, not of the rollup's servers, so the two distributions are weighted by their shares of estimated consumption and then combined.

Those country weights are applied to published figures for the renewable proportion of national electricity generation, taken from Share of electricity generated by renewables, compiled by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy. The output is a consumption-weighted average across the inferred footprint. Procurement is outside what this can see: renewable supply contracts, certificates and on-site generation leave no trace in network data and are not credited.

Energy intensity is a marginal measure — the additional electricity associated with one further transaction on top of infrastructure that is already running. Sequencing and node power draw barely move with block occupancy, and proving cost is amortized across a batch, so the marginal figure is small and declines as batches fill.

PancakeSwap is present on the following networks: Aptos Coin, Arbitrum, Base, Binance Smart Chain, Ethereum, Linea, Opbnb, Solana, Zksync.

The emissions calculation reuses the geographic picture built for energy sources and applies a different body of grid statistics to it. Node addresses visible through crawlers and public peer information are resolved to regions; where that resolution is incomplete, the distribution of a structurally comparable network is substituted, chosen because its incentive design and agreement protocol impose similar operating requirements and therefore a similar hosting footprint.

Each region is paired with the carbon intensity of its electricity, drawn from Carbon intensity of electricity generation, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy and published under the CC BY 4.0 licence. Multiplying the electricity estimated to be drawn in each region by that region's intensity, then summing across regions, gives the emissions attributable to operating the network over the period.

Two scopes are distinguished. Scope 1 captures emissions from sources under the direct control of those running the infrastructure, such as fuel combusted on site. For a network whose nodes are servers in third-party facilities, this is normally nil or immaterial, and a zero entry records the absence of such sources rather than a gap in the data. Scope 2 captures the indirect emissions embodied in the electricity those machines buy, and accounts for effectively the entire footprint reported here.

Greenhouse gas intensity mirrors its energy equivalent in being marginal rather than average: it is the emission associated with one additional transaction, not an annual total divided by throughput. Because validators consume power at a fairly steady rate irrespective of how full their blocks are, that marginal figure stays small and should not be read as a per-transaction apportionment of the network's whole footprint. Both the absolute emissions and the intensity are sensitive to the underlying grid data, which is updated as national energy statistics are revised, and to any protocol change that alters the hardware a validator needs.

Emissions are derived from the energy estimate rather than measured at the source. The geographic distribution built for the renewable calculation — sequencer and batch-posting infrastructure, dispute-protocol validators, full nodes, and the share of Ethereum's validator set attributed to settlement — is reused, and each country's slice of estimated electricity is multiplied by the average carbon intensity of that country's grid. Grid figures are drawn from Carbon intensity of electricity generation, compiled by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy and made available under a Creative Commons BY 4.0 license. Regional totals are summed to give a network figure, and a fraction of that figure is attributed to an individual asset in proportion to observed on-chain activity.

The two scopes are treated separately. Scope 1 covers combustion that the operators themselves control — on-site generators, fuel burned directly on their premises. For a chain whose infrastructure sits in commercial data centers this is ordinarily zero or negligible, and it is reported as such unless direct fuel use is known. Scope 2 is the substantive figure: the emissions embodied in the grid electricity that infrastructure draws. It is computed on a location basis, using the average intensity of the grid a machine draws from, rather than on a market basis reflecting supply contracts or certificates, because supplier-level information cannot be observed from the network. Emissions embodied in manufacturing the hardware or building the facilities that house it fall outside this boundary.

Greenhouse gas intensity is stated marginally, as the additional emissions associated with one more transaction. Two limits are worth stating plainly. Grid intensity statistics are annual national averages, so they miss the hourly and sub-national variation any specific facility experiences, and a data center on a dedicated low-carbon supply will be represented by its country's average. And the figure inherits every uncertainty in the energy and location estimates beneath it; where those rest on assumption, the assumption chosen is the one more likely to overstate the result.

Emissions are not measured directly. They are derived by attaching a carbon intensity to each unit of electricity the network is estimated to consume, across both parts of its footprint: the machines the network operates itself, and the share of the settlement layer's consumption attributed to the data and commitments it posts there.

The geographic step repeats the one used for the renewable share. The hosting regions of the sequencing and batching infrastructure are publicly observable; the wider set of replica and archive nodes is located from the addresses peers advertise, collected by crawlers and public directories. Where observation is too sparse to characterize the population, the spread of a structurally comparable network is used in its place. The settlement layer's validator population is located separately, because it is distributed quite differently, and the two are weighted by how much consumption each accounts for. Each region is then assigned a carbon intensity, the average greenhouse gas released per unit of electricity generated on that grid, expressed in carbon dioxide equivalent so that methane and the other gases are counted on a common basis. Estimated consumption in a region multiplied by that region's intensity, summed across regions, gives the total.

Two scopes are distinguished. Scope 1 covers emissions from sources the operators of the infrastructure control directly, such as fuel burned on site in a generator. For infrastructure that consists of ordinary servers in commercial data centers drawing from public grids, there is generally nothing in that category, and it is reported as such rather than left out. Scope 2 covers the indirect emissions embodied in the purchased electricity, and is where essentially the whole footprint sits. Emissions from manufacturing and transporting the hardware fall outside this boundary.

Greenhouse gas intensity follows the marginal logic used for energy intensity: the additional emissions attributable to one further transaction, not an average spread across all of them. It inherits the uncertainty of both the consumption estimate and the grid averages. Carbon intensities are taken from Carbon intensity of electricity generation, compiled by Our World in Data from Ember's electricity datasets and the Energy Institute's Statistical Review of World Energy, and made available under the CC BY 4.0 license.

Emissions for BNB Smart Chain are derived from the same geographic picture used for the energy mix, then converted using regional carbon factors. Node locations are approximated from peer-discovery data, public network observation and hosting attribution, and where coverage is insufficient the distribution of a structurally similar staked network stands in. Each location carries the carbon intensity of its national grid, drawn from Carbon intensity of electricity generation, processed by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy and published under a CC BY 4.0 license. Multiplying the electricity attributed to each region by that region's grams of carbon dioxide equivalent per kilowatt-hour, and summing across regions, gives the annual emissions figure.

The split between scopes matters for interpretation. Scope 1 covers emissions from sources the network's operators control directly, such as on-site fuel combustion, which for a population of general-purpose servers in rented facility space is generally negligible and is reported as such. Scope 2 covers the indirect emissions embodied in the electricity those machines purchase from the grid, and that is where effectively the whole footprint sits. Emissions upstream of operation, in the manufacture and eventual disposal of the hardware, fall outside this accounting boundary.

Greenhouse-gas intensity mirrors the energy definition: the incremental emissions associated with one additional transaction, not the annual total divided by throughput.

Uncertainty in the emissions figure compounds the uncertainty in the two inputs behind it. Any error in the estimated electricity total propagates directly into the result, and the geographic attribution adds error of its own, since grid carbon intensity varies by more than an order of magnitude between countries and a misplaced share of node capacity moves the answer substantially. Annual national averages also mask the hourly variation in grid intensity to which a machine running around the clock is fully exposed.

Emissions are derived from the consumption estimate rather than measured, by attaching a carbon intensity to each unit of electricity the network is estimated to draw and summing across the network.

The geographic step repeats the one used for the renewable share. Node locations are inferred from publicly observable network data, principally the addresses peers advertise so that others can connect to them, gathered by crawlers and supplemented by public information about where staking and hosting infrastructure is operated. Where that observation is too sparse to characterize the whole population, the distribution of a comparable network stands in for it, selected because its participants face similar operating economics rather than because its software resembles this one. Each region is assigned a carbon intensity, meaning the average greenhouse gas released per unit of electricity generated on that grid, expressed in carbon dioxide equivalent so that methane and the other gases are counted on a common basis. Estimated consumption in a region multiplied by that region's intensity, summed across regions, gives the network total.

The reporting separates two scopes. Scope 1 covers emissions from sources the operators of the infrastructure control directly, such as fuel burned on site in a generator. For a network of this kind, whose participants overwhelmingly run ordinary servers connected to a public grid, there is generally nothing in that category, and it is reported as such rather than left out. Scope 2 covers the indirect emissions embodied in the electricity purchased to run that infrastructure, and that is where essentially the whole footprint sits. Emissions further up the supply chain, such as those from manufacturing and shipping the hardware, fall outside this boundary.

Greenhouse gas intensity follows the same marginal logic as energy intensity: it expresses the additional emissions attributable to one further transaction rather than an average spread across all of them. Because it inherits both the consumption estimate and the grid averages, its uncertainty combines theirs. Carbon intensities are taken from Carbon intensity of electricity generation, compiled by Our World in Data from Ember's electricity datasets and the Energy Institute's Statistical Review of World Energy, and made available under the CC BY 4.0 license.

Where the boundary falls is not obvious here. Two pools of electricity are in scope: the machines the network runs for itself, chiefly the proving cluster together with sequencing, coordination and the replica and archive servers third parties keep; and a slice of the settlement layer, sized by how much of Ethereum's capacity the posted batches and proof verifications occupy. Fabricating the accelerators and constructing the halls that house them lie outside.

Within the boundary nothing is metered for carbon. A coefficient is applied instead: for each country in which consumption has been placed, published statistics give the average greenhouse gas released per unit of electricity generated there, expressed in carbon dioxide equivalent. Estimated electricity is multiplied through and the products added. What makes the calculation distinctive is how lopsided the weights are. Proving concentrates the bulk of the draw into a few hosting sites, so the coefficient of one or two grids governs the answer, and a decision to prove somewhere else would move reported emissions further than most protocol changes could. Those sites are placed from the operator's public technical material; replica nodes by resolving announced addresses to countries, with a borrowed profile from a commercially comparable network covering whatever will not resolve. Settlement-layer validators are placed on their own terms and folded in at the weight their slice carries.

Scope 1 would capture combustion under the operators' own control, an on-site generator being the plain case. In leased facilities full of general-purpose servers there is normally none, and the zero that appears is a finding rather than a gap. Scope 2 is the indirect burden riding on purchased electricity, and effectively the whole figure sits there. National average coefficients mean a site on a specific low-carbon contract scores no differently from a neighbor on default supply.

Greenhouse gas intensity per transaction is marginal rather than averaged: what one additional transaction adds, with the installed fleet unchanged. On this network that increment is real rather than nominal, since one more transaction is one more transaction to prove. It inherits the uncertainty of both the consumption estimate and the grid coefficients. Those coefficients are taken from Carbon intensity of electricity generation, a series Our World in Data builds from Ember's electricity data and from the Energy Institute's Statistical Review of World Energy and releases under the CC BY 4.0 license.

Emissions follow the same path as the renewable share, with a different coefficient applied at the end. Node and validator locations are inferred from publicly observable network data, and where a chain's geographic spread cannot be read directly the distribution of a structurally similar network is substituted for it. Each location is matched to the carbon intensity of electricity generated on the grid serving it, expressed as grams of carbon dioxide equivalent per kilowatt-hour, and the weighted result is applied both to the consumption estimated for this network's own infrastructure and to its attributable share of the settlement chain on BNB Smart Chain.

The two scopes are kept apart. Scope 1 means emissions released by equipment the infrastructure's operators control outright, fuel combusted on site being the usual example; for machines racked in commercial data centers there is normally nothing of the kind, and a zero is stated rather than modeled. Scope 2 is the indirect burden carried in the electricity those machines buy and draw, and that is where effectively the whole footprint sits. Emissions from manufacturing the hardware, constructing the facilities, or running the networks between them fall outside both scopes and are not counted here.

Greenhouse gas intensity is a marginal figure: the additional emissions associated with one further transaction, obtained by applying the same carbon intensities to the marginal energy described in the preceding section. Like that energy figure, it is not the total divided by a transaction count.

The carbon intensity coefficients are annual national series published by Our World in Data and processed from Ember's electricity data together with the Energy Institute's Statistical Review of World Energy: Carbon intensity of electricity generation. That dataset is made available under the Creative Commons Attribution 4.0 license.

The limits are those of the inputs. National annual averages do not capture an hourly generation mix or a particular facility's supply contract, location inference remains incomplete, and the division between this network's own infrastructure and its share of the settlement chain rests on an attribution rule rather than on metering.

Emissions are derived from the same geographic picture used for energy sources, applied to a different set of grid statistics. Node locations are inferred from addresses observable through crawlers and public cluster information and resolved to a region; where direct observation falls short, the geographic distribution of a structurally comparable network is substituted, selected on the basis that its incentive design and agreement protocol impose similar operating demands.

Each region is then paired with a carbon intensity for its electricity, taken from Carbon intensity of electricity generation, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy and made available under the CC BY 4.0 licence. Multiplying the electricity estimated to be consumed in a region by that region's carbon intensity, and summing across regions, gives the emissions attributable to running the network.

The disclosure separates two scopes. Scope 1 covers emissions from sources the operators of the infrastructure control directly, such as fuel burned on site; for a network of this kind, whose nodes are ordinary servers in rented facilities, this is normally nil or immaterial, and a zero figure reflects the absence of such sources rather than an omission. Scope 2 covers the indirect emissions embodied in the electricity those machines purchase, and is where essentially the whole footprint of this network falls.

Greenhouse gas intensity follows the same marginal logic as its energy counterpart: it expresses the emissions associated with one additional transaction rather than an average obtained by dividing an annual total by throughput. Because validators consume electricity at a fairly steady rate whether or not blocks are full, the marginal figure is small and is not a proxy for the footprint of the network as a whole. Both the absolute emissions and the intensity figure are sensitive to the grid statistics underlying them, which are revised as national energy reporting is updated.

Emissions are derived from the energy estimate rather than measured. The geographic breakdown used for the renewable share — sequencing and data-publishing servers, the proving fleet, full nodes, and the portion of Ethereum's validator population attributed to settlement — is reused, and each country's share of estimated electricity is multiplied by the average carbon intensity of that country's grid. Those intensity figures are taken from Carbon intensity of electricity generation, compiled by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy and published under a Creative Commons BY 4.0 license. Country-level results are summed into a network total, and a fraction of that total is attributed to an individual asset in proportion to observed on-chain activity.

The scopes are separated deliberately. Scope 1 covers emissions from sources the operators directly control, meaning fuel burned on their own premises. Infrastructure hosted in commercial data centers normally has nothing material here, and it is reported as zero or negligible rather than inflated by guesswork. Scope 2 is where the figure sits: the indirect emissions embodied in the electricity purchased to run sequencing, proving and node hardware. It is calculated on a location basis, applying the average intensity of the grid serving each region, since a market-based figure would require supply contracts and certificates that are not observable from network data. Emissions embodied in manufacturing the hardware — which for accelerator-heavy proving equipment is not trivial — and in constructing the facilities that host it fall outside this boundary and are not included.

Greenhouse gas intensity is expressed as the marginal emissions of one more transaction, mirroring the treatment of energy intensity. Three limits should be read with the figure: national annual averages conceal hourly and regional variation in real grids; every uncertainty in the energy and location estimates carries through; and where assumptions must be chosen, the more conservative one is taken, so the result is better understood as an upper bound than as a precise quantity.