Stargate Finance (STG) sustainability report

Stargate Finance is present on the following networks: Arbitrum, Avalanche, Base, Berachain, Binance Smart Chain, Ethereum, Fantom, Kava, Linea, Optimism, Polygon.

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.

Avalanche's Primary Network is not a single chain but three, each specialized and all validated by the same set of operators. The contract chain hosts smart-contract execution in an Ethereum-compatible environment and is where most applications and issued assets live. The exchange chain handles asset creation and transfers. The platform chain tracks the validator set, staking, and the registration of the sovereign networks that run alongside the Primary Network.

Agreement across all three comes from the Snow family of protocols, which reaches consensus through repeated randomized sampling rather than through the round-based voting of classical Byzantine fault tolerant designs. There is no leader gathering votes from the entire validator set. Instead each node repeatedly asks a small random sample of validators what they currently prefer, adopts whichever answer carries a sufficient majority of that sample, and accepts a decision once it has seen enough consecutive samples agree. Because a node queries a fixed-size sample rather than everyone, the messaging load per node barely grows as the validator set grows, which is what allows the set to be large without consensus becoming the constraint.

Snowman is the variant used for linearly ordered chains, and Snowman++ layers a proposer schedule over it: block-building windows are assigned to proposers in proportion to stake, with production opening more widely if a designated proposer fails to act, which limits contention without introducing a fixed committee. Sampling remains the voting mechanism throughout. An earlier design in which the exchange chain ordered transactions as a directed acyclic graph was retired in 2023 when that chain was linearized, and the whole Primary Network now runs on the same linear engine.

Acceptance is fast, typically under a second, and once a decision is accepted the protocol treats it as irreversible. Formally the guarantee is probabilistic: sampling parameters can drive the chance of two conflicting decisions both being accepted arbitrarily close to zero, but not to exactly zero, which is a different kind of statement from the deterministic finality a quorum-certificate protocol offers. Validators join the Primary Network by bonding the native asset for a chosen term, holders may delegate to them, and the protocol does not slash bonded principal.

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.

Berachain splits consensus from execution across two processes that every node operator runs side by side. Execution is handled by an Ethereum-compatible client holding the state and running the virtual machine; consensus is handled by a client built around a modified CometBFT engine, and the two communicate over the same engine interface Ethereum node software already uses. The result is an Ethereum execution environment settling under a Byzantine-fault-tolerant proof-of-stake engine rather than Ethereum's attestation and checkpoint machinery.

Consensus advances in timed rounds. A proposer is designated at each height in proportion to bonded stake, and a block commits once operators representing more than two thirds of bonded weight have voted for it, which makes it final in that same block: there are no attestation committees, no epochs and no delayed finalization. Where a proposer fails to deliver, the round times out and another operator proposes at that height. Entry to the active set is governed by bonded stake in the network's native asset. An operator must bond at least two hundred and fifty thousand units, is capped at ten million, and must rank among the top sixty-nine by bonded amount, a ceiling set by governance. Voting power follows the bonded amount rounded down to a fixed granularity, and an operator leaves the set only by exiting voluntarily or by being displaced by a larger entrant.

Proof of Liquidity describes what happens to the block reward rather than how blocks are ordered. Each block issues a fixed quantity of the native asset in its wrapped form, of which only a small fixed portion goes to the proposing operator. The larger portion is routed by an on-chain allocation contract into reward vaults, contracts that pay out to participants who have deposited approved liquidity positions, and operators decide how their allocation is spread across the approved vaults. Consensus participation therefore determines where liquidity incentives land, which is the design's distinguishing feature.

That design changed substantially after launch. Until July 2026 emissions were paid in a second, non-transferable asset that also carried governance rights, and an operator's emissions scaled with how much of it had been delegated to them. A hard fork removed that asset from the mechanism: emissions are now fixed per block, no longer scale with delegation of a separate token, and the retired asset has no remaining role in reward allocation or governance, with outstanding balances converting when claimed.

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.

Fantom Opera settles on a transaction order through Lachesis, an asynchronous Byzantine fault tolerant protocol running over a proof of stake validator set. There is no proposer chosen for each round. Every validator gathers the transactions it has received into an event, points that event at the most recent events it has seen from its peers, signs it and gossips it onward. Those events pile up into a directed acyclic graph that each participant holds locally, and because the gossip eventually delivers the same events to everyone, the graph itself carries enough information to derive a single ordering without a further round of voting messages. Once an event has been seen, directly or through the references of later events, by validators holding more than two thirds of the bonded native asset, the protocol treats it as decided and the ordering routine converts that region of the graph into a numbered block.

The safety argument is the classical Byzantine one measured in stake rather than in machines: the derived order holds so long as validators controlling more than two thirds of the bonded amount follow the rules. Joining the validator set is open but capital gated. An operator registers through the chain's staking contract with a self bonded minimum, and other holders may delegate to that operator up to a fixed multiple of its own bond, which caps how much weight any one operator can accumulate. Confirmation is deterministic and typically arrives a second or two after an event is gossiped, so there is no confirmation depth to wait out and no reorganization of sealed blocks. Execution is an Ethereum compatible virtual machine, so ordering and execution are separate concerns.

The network is still live and still sealing blocks, but it is in a managed wind down. Development effort, liquidity and most operators have moved to a successor chain that inherits this consensus design, and a retirement date announced for mid 2026 was afterwards deferred. The mechanism above is the one still running, on a much reduced operator base.

Kava is a layer 1 network built with the Cosmos SDK that reaches agreement through CometBFT, the Byzantine-fault-tolerant engine previously released under the Tendermint Core name. The design is proof of stake: voting power is allocated in proportion to the quantity of the network's native asset bonded to each validator, either committed by the operator directly or delegated to it by other holders, and only the hundred highest-weighted operators sit in the active set that produces blocks at any given height.

What separates this network from a conventional single-environment chain is its co-chain arrangement. One validator set and one consensus process secure two execution environments that sit side by side: an Ethereum-compatible environment in which Solidity contracts run, and a Cosmos SDK environment whose state changes are typed module messages rather than contract bytecode and which speaks the Inter-Blockchain Communication protocol to other Cosmos networks. A translator component moves value and calls between the two. Because both environments advance inside the same block, they share a single transaction ordering and a single security budget, rather than being separate chains joined by a bridge.

Block production follows the round structure usual to this consensus family. A proposer is drawn for each height with a frequency weighted by bonded stake, and the remaining validators move through a pre-vote and then a pre-commit round. Once more than two thirds of voting power has pre-committed, the block is committed and treated as final at that moment; there is no confirmation depth to wait out and no reorganization of committed history while fewer than one third of voting power behaves adversarially. On the Ethereum-compatible side blocks arrive roughly every six seconds and are final at the first block. Accountability is economic: operators that sign conflicting blocks at the same height, or that miss too large a share of recent blocks, forfeit part of their bonded stake and are excluded from the active set until they are reinstated.

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.

OP Mainnet operates no validator set and no consensus algorithm of its own. It is an optimistic rollup: blocks are produced away from Ethereum, but the canonical history and final settlement live on Ethereum. A sequencer accepts transactions, orders them and produces Layer 2 blocks on a two-second cadence, which is what gives users a fast confirmation. The ordered transaction data is compressed and published to Ethereum in batches, and every node derives the canonical chain by reading that data back from the settlement layer. Deriving the chain from Ethereum rather than from the sequencer's word is what makes the arrangement verifiable: anyone holding the published data can recompute the same state independently.

Correctness is enforced after the fact. Claims about the chain's output state are posted to a dispute-game contract on Ethereum, and since the fault-proof system was opened to the public in mid-2024 anyone may post such a claim or dispute one, with no allowlist involved. A challenge proceeds as a bisection game in which the two sides repeatedly narrow their disagreement until a single step of execution remains; that step is then executed inside a deterministic fault-proof machine on Ethereum, which settles the matter on-chain. Both sides lock bonds and the loser forfeits. A claim that survives a challenge window of roughly a week is treated as final for the purpose of withdrawing assets to Ethereum.

Two limits belong in any accurate description. Sequencing rests with a single operator, so ordering is centralized in practice; censorship is constrained rather than prevented, because a transaction can be deposited through a contract on Ethereum and must then be included in the chain. And a guardian role, alongside a security council, retains emergency powers, including pausing withdrawals and returning the dispute system to a permissioned mode should it fail — a deliberate safeguard that nonetheless keeps the chain short of full trust-minimization. Ultimate security comes from Ethereum's proof-of-stake consensus, whose validators finalize the data the rollup depends on.

Polygon PoS is an EVM-compatible proof-of-stake network that runs its own validator set and anchors itself to Ethereum by posting periodic checkpoints there. It should not be confused with the other chains that have carried the Polygon name: the zero-knowledge rollup operated under that brand was shut down in 2026, and chains built with Polygon's development kit are independent networks with their own validators. Polygon PoS executes transactions and holds its own transaction data, so it is a sidechain or commit-chain rather than a rollup inheriting Ethereum's execution and data-availability guarantees.

The architecture splits into two node layers that every validator runs together. The execution layer, derived from Go Ethereum, assembles transactions into blocks. The consensus layer coordinates the validator set, tracks staking and finalizes checkpoints; it was rebuilt in 2025 on the Cosmos SDK and CometBFT, which brought checkpoint-based finality down from a wait of one to two minutes to a matter of seconds and capped how deeply the chain may reorganize. At intervals the consensus layer gathers the blocks produced since the last checkpoint into a Merkle tree and submits the root to contracts on Ethereum, where it becomes the reference point for bridge withdrawals.

Staking itself lives on Ethereum. Validators bond the network's native asset, POL, which replaced MATIC in the migration that began in 2024 and now serves as both the staking asset and the gas asset, into contracts on Ethereum mainnet; holders delegate through share-based pools in the same contracts. The active set is capped, so entry requires displacing an incumbent by stake.

Block production changed materially with the Rio upgrade in late 2025. Rather than rotating producers by stake-weighted draw over short intervals, validators now vote, with voting power weighted by stake, to elect the producer or producers for a span. Because a single elected producer builds the span, competing chain tips largely disappear and reorganizations are eliminated. The same upgrade introduced witness-based verification, letting a validator check a block against a supplied witness instead of holding full state, which lowers the storage burden of participating.

Stargate Finance is present on the following networks: Arbitrum, Avalanche, Base, Berachain, Binance Smart Chain, Ethereum, Fantom, Kava, Linea, Optimism, Polygon.

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.

Validators on the Primary Network are compensated out of protocol issuance under a capped supply schedule rather than out of user fees. An operator bonds a minimum amount of the native asset for a chosen staking term and is paid at the end of that term provided it met the uptime requirement. A validator's effective weight is capped relative to its own bonded stake, which limits how much delegated stake any single operator can concentrate. Holders who do not run infrastructure may delegate to a validator for a term and receive the reward net of the fee that validator charges.

The enforcement model is unusual in that bonded principal is not slashed. A validator that fails to meet the uptime threshold simply does not receive its reward for that period and gets its stake back, so the penalty is forfeited income rather than confiscated capital. The most recent protocol upgrade reworked these terms considerably: the minimum staking term was shortened from two weeks to two days, staking terms can now renew automatically with rewards compounded at a chosen ratio, the uptime threshold required to earn a reward was raised for newly started validations, and the average rate at which rewards are issued was reduced.

Sovereign networks running alongside the Primary Network are funded differently. Since the late-2024 upgrade that separated them, their validators no longer need to bond a large stake and validate the Primary Network as well; instead they pay a continuous fee to the platform chain that adjusts with the number of active such validators relative to a target, rising when the population exceeds it and easing when it falls short.

Users of the contract chain pay a base fee plus an optional tip, priced dynamically in the style of Ethereum's fee market. The distinguishing feature is that the fee is burned rather than paid to the block producer, so transaction activity reduces supply and offsets issuance instead of rewarding validators directly. The minimum base fee has been lowered by upgrade and is now a floor that validators adjust collectively rather than a hard-coded constant. The exchange and platform chains likewise price their operations dynamically, and those fees are burned as well. There is no storage rent.

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.

Each block on Berachain issues a fixed quantity of the network's native asset in wrapped form, divided along fixed lines rather than by any variable weighting. A small fixed portion is credited to the proposing operator, and the larger fixed portion goes to the distributor that feeds reward vaults. Because both rates are constant, an operator's emissions no longer scale with delegated balances of a separate token, as they did before the July 2026 fork. Annual issuance from these emissions runs at roughly five percent of supply and is a governance parameter.

The vaults are where the incentive structure becomes unusual. A protocol wanting emissions steered toward its own liquidity supplies incentive tokens of its own to a vault. The operator whose allocation directed emissions there takes a commission on those incentive tokens, and what remains is auctioned for the wrapped native asset, with the proceeds accruing to the staking vault whose share token ordinary stakers hold. Depositors of eligible liquidity positions therefore collect the block emissions, the protocols seeking that liquidity pay for it in their own assets, and stakers who simply bond the native asset receive the value realized from selling those incentives. Allocation is granted through agreements that require demonstrable on-chain usage, replacing the earlier arrangement in which allocation was bid for through delegation-weighted voting.

Additional holders can add stake to an operator directly through the deposit contract or indirectly through pooling contracts, subject to the per-operator ceiling. Enforcement at the consensus layer works chiefly through forfeiture and exclusion: an operator that fails to propose when designated earns nothing for that slot, an operator that stops participating ceases to earn altogether, and an operator displaced from the active set has its bonded stake returned to its withdrawal address and must generate fresh consensus keys before re-entering.

Users pay for execution in the native asset under an Ethereum-style fee market. Every block carries a base fee per unit of gas that the protocol raises when blocks run above their gas target and lowers when they run below, and that base fee is burned, permanently removing those units from circulation. A separate priority tip, set by the sender, goes to the block producer. Contract execution and storage are metered through the standard virtual-machine gas schedule, with no recurring rent charged against stored state.

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.

Compensation on this network changed materially when its successor chain launched. Newly issued native asset that previously paid validators for sealing blocks was redirected to the successor, so ongoing issuance to operators here has been wound down to nothing and what an operator earns now comes from the transactions it helps order. A portion of every fee collected in a period is destroyed rather than paid out, and the remainder is shared among validators when the period closes, weighted by the stake behind each one and by whether it stayed available and responsive. That distribution is handled by an upgradeable staking contract rather than hard coded into the client, so the split can be changed by governance without a coordinated fork.

Holders who do not operate infrastructure participate by delegating to an operator. Delegated amounts count toward the operator's weight in consensus and in the fee split, and the delegator receives the corresponding share of what the operator earns, less a commission the operator retains. Delegation can be left liquid or committed for a fixed term, with longer commitments historically earning a larger share, and withdrawing a bond or a delegation takes effect only after a waiting period, which prevents stake from leaving immediately after misbehavior.

Penalties operate on the bond. An operator that signs conflicting events for the same position is flagged by the protocol as having broken the rules, is removed from the active set and forfeits its bonded amount; balances delegated to that operator can be reduced along with it, which is why the choice of operator is a real decision for a delegator rather than a formality. Simple unavailability is not punished by confiscation, but an absent operator earns nothing for the period.

Users pay for computation and storage through gas metering in the native asset, with the price per unit set by demand for block space. Contract calls cost in proportion to the work they cause, ordinary transfers cost a fixed minimum, and there is no recurring rent charged for data already stored.

Validators and the holders who delegate to them are the paid participants. Fee revenue from each block is spread across the active set in proportion to voting power, with an additional share to the proposer, and each operator passes on what remains to its delegators after deducting a commission rate it sets and publishes. Delegation lets holders contribute stake weight without running infrastructure, and it carries the matching downside: stake delegated to a penalized operator is reduced alongside the operator's own.

The material change in how all this is funded is that the protocol no longer issues new units to pay for security. Emissions were switched off at the start of 2024, the last inflationary issuance having been minted in the final block of 2023, and the protocol retains no mechanism to create further supply — only to destroy it. Rewards consequently come from two places: transaction fees collected in the ordinary course, and distributions out of a community-controlled on-chain treasury whose balance was set aside rather than printed. Ecosystem incentive programs that were once paid from new issuance are funded the same way, with governance deciding allocations and deciding whether any surplus is retired or redeployed. The reward budget is therefore a finite and governed pool rather than an open-ended subsidy, and the security of the network rests on fee revenue over the long run.

Users pay for execution in gas, denominated in the network's native asset on both co-chains. Contract execution in the Ethereum-compatible environment is metered per operation on the familiar opcode schedule, so computation, storage writes and contract deployment cost in proportion to the work they impose on every node; module messages on the Cosmos side are metered on an equivalent gas basis. Validators enforce a minimum acceptable gas price, and transactions offering more than that floor are ordered ahead of those that do not. Penalties form the counterweight: a fraction of bonded stake is confiscated for equivocation, a smaller penalty and temporary exclusion from the set apply to sustained unavailability, and stake withdrawn from bonding stays exposed through an unbonding period before it becomes transferable.

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.

Transactions are paid for in the settlement layer's native asset, and the amount splits in two. The execution component prices computation and state access on Layer 2 through a base fee that adjusts with demand plus an optional priority fee, and it is small because the work happens away from Ethereum. The data component covers publishing the transaction's data to Ethereum so the chain can be reconstructed, and it usually dominates. Since Ethereum introduced a dedicated data space for rollups, batches are posted there instead of as ordinary call data, and the pricing function reads both Ethereum's ordinary base fee and the separate fee for that data space — each relayed onto Layer 2 by a system contract every block — scaled by two parameters the chain operator can tune. What a transaction pays is proportional to its compressed size, estimated with a compression function, so the cost of a posting is apportioned across the transactions in the batch rather than charged to whichever one happens to trigger it.

There is no staking, delegation or reward issuance at this layer, and consequently no slashing. The sequencer's incentive is the margin between the fees it collects and what it spends publishing data to Ethereum, which gives it a direct reason to batch efficiently. Net of those costs, the surplus from this chain is directed to the collective treasury that funds protocol development and public-goods programs, and other chains built on the same software contribute a defined share of their own revenue on the same basis. Participants in the proof system are paid differently: bonds locked in a dispute are forfeited by the losing side to the winner, so challenging an incorrect claim is rewarded while posting one is expensive.

Deploying and calling smart contracts is charged on the resources consumed, on the same basis as on Ethereum, and there is no recurring storage rent — state is paid for when it is written. Underneath, the data the chain posts is subject to Ethereum's own rules, where the base fee is burned and the priority fee goes to the block proposer.

Validators on Polygon PoS are paid for two distinct jobs: producing and executing blocks on the chain itself, and signing the checkpoints submitted to Ethereum. Rewards are distributed per checkpoint, funded by protocol issuance of the native asset together with an allocation of transaction fees, and they are apportioned by stake and by how reliably each validator signed. Because the staking contracts sit on Ethereum, a validator's operating costs include Ethereum gas for checkpoint submission and for staking transactions, a meaningful expense that chain-local fee models do not capture.

Delegation works through validator-specific share pools. A holder exchanges the native asset for shares in a chosen validator, and as rewards accrue the redemption value of each share rises, so returns appear as appreciation of the share rather than as separate payments. Validators take a commission before the remainder flows to their delegators. Stake withdrawn from a validator remains locked for a defined number of checkpoints before it can be moved out, while switching between validators carries no such delay.

The penalty structure is weighted toward lost income. The staking contracts define consequences for double-signing and for sustained unavailability, but in normal operation the dominant economic pressure on a validator is forfeited reward: missed checkpoint signatures and poor block-production uptime reduce what a validator and its delegators earn. The producer election introduced by the Rio upgrade also redistributes fee income, including value captured from transaction ordering, toward validators that are not currently producing, so that supporting the chain stays worthwhile for the rest of the set.

Users pay fees in the native asset under a base-fee-plus-tip model. The base fee moves with how full recent blocks have been and is routed to a burn path, while the optional tip goes to the producer. A 2026 protocol change made that base-fee destination configurable in order to fund a time-limited program that recycles fees for one narrow category of activity, with ordinary transactions continuing to follow the burn path. There is no storage rent, and contract deployment and execution are charged purely as metered gas on the resources they consume.

Stargate Finance is present on the following networks: Arbitrum, Avalanche, Base, Berachain, Binance Smart Chain, Ethereum, Fantom, Kava, Linea, Optimism, Polygon.

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.

Avalanche is a staked network, so its energy estimate is assembled from the machines that participate rather than from hardware economics driven by block rewards. One structural feature shapes the calculation: a single Primary Network validator runs one node that validates the contract chain, the exchange chain and the platform chain together. The three are therefore not summed as though they were three independent populations, which would count the same hardware three times; the footprint is modeled against one node population serving all of them.

The estimate combines three inputs. The validator set is read directly from the platform chain, which makes the consensus-participating population unusually well observed compared with networks where it has to be inferred. The surrounding population of non-validating full and archive nodes, run by applications, data services and trading venues, is approximated from peer-discovery crawls and public listings, which see only nodes that accept inbound connections and so tend to undercount. A representative hardware profile is then inferred from the published requirements for the node software, and the power draw of such a configuration is taken from measurement of comparable machines under sustained load and at idle, since a validator draws power continuously whether or not it is currently proposing.

The result carries qualifications that should be read as part of the figure rather than as footnotes to it. Node counts and hardware profiles are inferred from public observation and stated requirements, not metered at the socket. Where evidence is missing, the assumptions chosen are the ones more likely to overstate consumption than to understate it. Estimates are revised as crawler coverage and hardware information improve. Sovereign networks that maintain their own validator sets are accounted for separately from the Primary Network rather than folded into it. And where a share of the total is attributed to an individual asset issued on the chain, that share is derived from observed on-chain transfer volumes, which measures how heavily an asset is used rather than the energy it uniquely causes.

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.

Berachain reaches agreement through bonded proof of stake, so the estimation approach applied here builds upward from the machines that run the network rather than from any model of mining hardware economics. The starting point is the size of the node population. Consensus operators can be enumerated from chain state; the surrounding population of full nodes, archive nodes, indexers and public endpoints cannot, and is approximated from crawling the peer-to-peer topology, from advertised endpoints and from operator directories, held as a range rather than a single number.

The chain's node architecture shapes the hardware profile in a specific way. A participant does not run one program but two: a consensus client and an execution client, operating as separate processes on the same host and exchanging work over the engine interface. The representative machine is therefore sized from the combined published requirements of both clients rather than from either alone, which raises the assumed processor, memory and storage specification above what a single-process chain would imply. Reward vaults and the allocation contracts that feed them are ordinary contract state executed by the same clients, so they add computational load but no separate infrastructure to count.

Power draw for each profile comes from laboratory measurement of comparable equipment under load and at rest. Idle draw is included deliberately, because machines of this kind are provisioned for peak demand and left running continuously, and that resting consumption forms much of the annual total. Multiplying profiles by the estimated population and by hours of operation yields the network figure, with an allowance added for hosting overhead. Where a figure is needed for one asset rather than the whole network, a share of the network total is attributed to it according to observed on-chain activity, and an asset present on several networks has its shares summed.

The honest qualifications are these. Node counts derive from public observation and will miss machines that stay unadvertised; a single hardware profile stands in for a varied and partly virtualized population; and none of this is metered measurement. Where evidence is absent the assumption taken is the one that raises the estimate, and figures are revised as observation improves.

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 figure reported for this network is an estimate assembled from the machines that run it, not a metered reading taken at the wall. The starting point is the size and composition of the node population. Validating and non validating nodes are counted using network crawlers, peer discovery traffic and information operators publish themselves, and that count is the unit of consumption, because in an asynchronous Byzantine fault tolerant design the work of taking part is ordinary server work: receiving gossip, checking signatures, executing transactions and holding state. There is no competitive computation to model and no hash rate to convert into equipment.

A representative hardware profile is then inferred from what the client software asks for. The processor, memory and storage specifications published as the requirements for running a node are mapped onto commercially available server configurations that meet them, and the electrical draw of those configurations is taken from laboratory measurement of the equipment both under load and at rest. The network total is the aggregate of that draw across the estimated node set for the length of the reporting period, idle time included, since a synchronized node that happens to be handling nothing still consumes power.

Two qualifications matter when reading the result. The node count and the hardware mix are inferences drawn from public observation and from stated software requirements, so neither is exact; where the evidence is thin the assumptions chosen are the ones more likely to overstate consumption than to understate it, and the figures are restated as observation improves. The second qualification is particular to this network. Because development, liquidity and the majority of operators have moved to its successor chain, the operator base is contracting and its composition shifts faster than a periodic estimate can follow, so a figure produced for one reporting period should not be read as a stable rate that will carry into the next one.

The figure is built from the network's node population rather than from any metered reading taken across the network, which is the appropriate treatment for a stake-weighted Byzantine-fault-tolerant chain where the right to produce a block is not won by computational effort. The estimation approach used here begins by establishing how many machines take part. The active and standby validator set is enumerated from public chain state, and the wider population of full, archive and public endpoint nodes is approximated using network crawlers alongside publicly listed infrastructure. A representative hardware profile is then inferred from the specifications the client software states for running a node that can keep pace with the chain, and the electrical draw of machines matching that profile comes from laboratory measurement, recorded both under load and at rest. Aggregating that draw across the estimated population over the reporting period, with idle hours counted rather than assumed away, gives the network total.

The co-chain arrangement matters to this calculation. Since one validator set and one consensus process advance both the Ethereum-compatible and the Cosmos-side environments inside the same block, there is no second node population to add for the contract environment. Counting the validator and node set once captures both, and treating the two environments as though they were distinct networks would double the result.

Several limits should be read alongside the output. The node count and the hardware mix are inferences drawn from public observation and from stated software specifications, not readings taken from the machines themselves, and operators are under no obligation to disclose what they run. Where the evidence is thin, the assumptions chosen sit at the cautious end, so the result is likelier to overstate consumption than to understate it. Figures are restated as observation of the node population improves or as client specifications change. Where an asset is issued across more than one network, the portion attributed to each is derived from observed on-chain transfer volumes rather than divided evenly between them.

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.

Two distinct things are being estimated, and conflating them is the usual source of error. The first is the electricity drawn by the chain's own infrastructure: the sequencer, the process that publishes batches, the challenger software that watches state claims and would contest an invalid one, and the population of nodes that other participants run, each of which pairs a consensus client deriving the chain from Ethereum with an execution client replaying it. The second is the portion of Ethereum's own consumption that belongs to the rollup, since every batch it posts occupies capacity that the settlement layer's validators pay to provide. That portion is apportioned by how much of Ethereum's resources the chain's postings take up. Ethereum publishes its own description of how its consumption is estimated (Ethereum energy consumption).

Nothing in this design is mined, so the chain's own side is estimated at the level of individual machines rather than through the economics of hardware competition. The node population is approximated from crawlers, peer discovery and publicly advertised endpoints. A representative machine specification is inferred from what the client software states it requires to keep pace with the chain, and the power that specification draws is taken from controlled measurement of comparable hardware, recorded both under load and at rest. The network total is the aggregate across the estimated population, including idle draw, since these machines run continuously. From that total, a fraction is assigned to an individual asset according to observed on-chain activity involving it.

The honest caveats belong with the number. The node count is a floor rather than a census, because machines behind private networks are not visible to a crawler. The hardware profile comes from stated requirements, not from a survey of what operators actually bought. And where evidence is thin, the assumption taken is the one that produces the larger figure rather than the smaller one. Estimates are revised as observation of the network improves.

Polygon PoS is a staked network, so its consumption is modeled from the machines that run it rather than from mining economics. Two components are added together. The first is the chain's own infrastructure: every validator operates a paired execution and consensus process, which in practice means a heavier machine than a single-process chain of comparable throughput would need, plus the wider population of full and archive nodes serving applications and data consumers. The second is a share of Ethereum's consumption, because the checkpoint and staking transactions that give Polygon PoS its anchor are executed by Ethereum's validators; that share is apportioned by the gas those transactions consume as a fraction of total Ethereum gas.

For the chain's own component, the node count is estimated from peer-discovery crawls, public node listings and the validator set recorded on chain, with the understanding that crawls see only nodes willing to accept connections. A representative hardware profile is inferred from the published requirements for running both node processes, and the electrical draw of such a configuration is taken from measurement of comparable machines, at load and at idle, since a validator's hardware draws power continuously regardless of whether it is currently producing. Aggregating across the estimated population, with an allowance for the overhead of the facilities housing it, gives the chain-local total.

The usual qualifications apply and matter here. The node population and the hardware behind it are inferred from public observation and stated software requirements, not metered. Where evidence is incomplete, the assumptions used err toward a higher figure rather than a lower one. The estimate is revised as observation improves. The gas-based apportionment of Ethereum's consumption is a convention rather than a physical measurement, since Ethereum's validators would run whether or not the checkpoints were posted. And where a share of the network total is attributed to an individual asset issued on the chain, that attribution is made from observed on-chain transfer volumes, which reflects how heavily an asset is used rather than the energy it uniquely causes.

Stargate Finance is present on the following networks: Arbitrum, Avalanche, Base, Berachain, Binance Smart Chain, Ethereum, Fantom, Kava, Linea, Optimism, Polygon.

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.

Establishing a renewable share for Avalanche is first a question of geography, because the same hardware draws very different electricity depending on which grid it sits on. The validator set is enumerated from the platform chain, and the network addresses behind those validators, together with the wider set of nodes seen through peer discovery and public network observation, are resolved to hosting providers, autonomous systems and countries. That yields an approximate map of where node capacity is concentrated. Where the mapping is too incomplete to support a result, the observed distribution of a network with comparable staking economics is used in its place.

The map is then joined to national electricity statistics. Each country's share of generation 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 country-level shares by the estimated node capacity located in each gives one renewable percentage for the network as a whole.

Energy intensity is a marginal measure rather than an average: the additional electricity associated with one further transaction being processed. Because validators run continuously and blocks are produced on a schedule regardless of how full they are, the marginal figure is considerably lower than the annual total divided by transaction count, and the two answer different questions.

Several limits constrain what the renewable percentage can mean. Hosting location reveals a grid but not a contract, so operators procuring renewable electricity on a carbon-heavy grid are not distinguished from those that are not. Cloud regions and proxied connections can place a node's apparent location away from its actual hardware. Annual national averages flatten the hourly and seasonal movement in generation mix. And validator infrastructure is concentrated in a relatively small number of hosting markets, so the result is sensitive to how a handful of large operators are located.

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 Berachain is inferred rather than measured, by establishing where the network's machines are and then reading the electricity statistics of those places. The inputs are publicly observable: nodes advertise addresses so that peers can reach them, those addresses resolve to hosting providers and regions, and crawling the peer-to-peer layer repeatedly yields a country-level picture of the network. Regions disclosed by operators, and the known siting of the hosting facilities they use, tighten that picture further.

Because a participant runs a consensus client and an execution client on the same host, the two are treated as one physical location for this purpose; the architecture adds to the consumption attributed to a site without spreading it across additional ones. Where the geographic distribution still cannot be resolved with confidence, the observed spread of a structurally similar network is used instead, similar meaning that it rewards participation comparably and demands comparable hardware, so its operators weigh the same considerations when choosing where to host. That substitution approximates, and it is the largest single contributor to uncertainty in the published share.

Locations are then matched against public statistics on how electricity is generated in each country or region, weighted by the consumption attributed to each, and aggregated into the proportion of the network's electricity that comes from renewable sources. The figure is a grid average: it describes what the regional system delivered, not a supply contract held by any particular operator.

Energy intensity is a different measure and should not be confused with the total. It expresses the marginal energy cost of one further transaction, the additional consumption the network incurs by processing one more transaction on top of what it already handles. Since these machines run continuously whether blocks are full or nearly empty, that marginal quantity is small and shrinks as throughput increases.

Electricity generation statistics are drawn from Share of electricity generated by renewables, compiled by Our World in Data from Ember and from 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.

The renewable share reported here is not measured at any node; it is inferred from where the machines appear to be and from what the electricity in those places is generated by. Placement is reconstructed from what the network exposes in public: the addresses observed while peering and in crawler records, resolved only as far as a country or a region, never to a particular building. Coverage is never complete. Operators sit behind hosting providers, relays and privacy services, and on a network whose operator base is shrinking the observable sample thins further, so where a distribution cannot be observed with confidence the geographic spread of a structurally similar network, one with a comparable operating model and a comparable cost of participation, stands in for the missing part.

That distribution is then weighted against regional electricity statistics. The share of generation from renewable sources in each region where nodes are placed is taken from published national and regional figures, drawn here from Share of electricity generated by renewables, compiled by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy. Combining the two gives a weighted renewable proportion for the estimated consumption of the network as a whole, on the working assumption that each machine takes its power from the surrounding grid at that grid's ordinary generation mix. That is an approximation, and it cuts both ways: an operator buying certified clean power is invisible to it, as is one on an unusually carbon heavy local supply.

Energy intensity is reported on a different basis from the total. It expresses the marginal energy associated with one additional transaction rather than an average obtained by dividing annual consumption by annual transaction count. The distinction matters most on a lightly used network, where the equipment continues to draw power whether or not anyone transacts, and where a falling transaction count would otherwise inflate a simple average without any change in the physical energy being consumed.

The renewable share is derived geographically. Node locations are inferred from publicly observable network data — the addresses peers advertise, the hosting ranges those addresses fall within, and operator disclosures that are already public — and each located node is assigned to the electricity grid of the region it sits in. Aggregating those assignments produces a weighted picture of which grids the network's infrastructure actually draws on, which is the input the renewable calculation needs.

Coverage is never complete. A meaningful share of nodes sits behind hosting arrangements or privacy configurations that reveal nothing dependable about physical location. The co-chain arrangement does not complicate this, because the same machines serve both execution environments and so are located once. Where a network's own geographic spread cannot be observed to a usable standard, the spread of a structurally similar network is substituted as a stand-in — one chosen for a comparable validator economy, a comparable cost of entry for node operators, and therefore a comparable hosting pattern. That substitution is a source of uncertainty in its own right and is applied only to the portion that cannot be resolved directly.

Grid assignments are then matched against published statistics on how electricity is generated in each region, yielding the proportion of the network's electricity that comes from renewable generation. Those statistics are taken from Share of electricity generated by renewables, compiled by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy.

Energy intensity is a separate quantity and should not be read as a per-transaction bill. It is defined at the margin: the additional electricity drawn as a consequence of one further transaction being processed, given the infrastructure already running. On a network of this kind, where validators run continuously and commit blocks on a fixed cadence whether or not demand is present, that marginal quantity is small next to the standing consumption, and it moves inversely with throughput — the busier the network, the lower the intensity attributed to each transaction.

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.

Establishing a renewable share begins with location rather than with energy. The infrastructure in question is the sequencing and batch-publishing servers, the challenger nodes that watch the dispute system, and the wider set of full and archive nodes run by applications, bridges and infrastructure providers. Where those machines sit is inferred from publicly observable network information — announced peer addresses resolved against hosting and autonomous-system registries, and public listings of node operators — which supports a country-level picture rather than a precise location for any one machine. Because much of this runs on rented cloud capacity, the region a provider states for a facility is used in place of a finer-grained address. Where the chain's own sample is too thin to support a distribution, the pattern observed on networks built along similar lines, with comparable participant roles and hardware classes, substitutes for the missing portion.

The settlement layer is handled separately and then combined. The share of Ethereum's consumption attributed to the rollup takes on the geographic profile of Ethereum's validator population, which is distributed differently from the rollup's own servers, so the two distributions are weighted by their respective contributions to estimated consumption before being merged.

Those country weights are applied to published figures for the renewable proportion of each country's 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. What comes out is a consumption-weighted average across the inferred footprint, reflecting the grids the infrastructure most likely draws on. It does not capture procurement: renewable supply contracts, certificates and behind-the-meter generation cannot be seen in network data and are not credited.

Energy intensity here means a marginal quantity — the extra electricity associated with one further transaction, given the infrastructure already running. Node and sequencer power draw barely varies with how full a block is, so this marginal figure is small and falls as throughput rises. It is not the network total divided by the transaction count, and the two should not be compared.

The renewable share attributed to Polygon PoS depends on where its infrastructure physically sits, so the method begins with geolocation. Nodes visible through peer discovery and public network observation are resolved to hosting providers, autonomous systems and countries, giving an approximate map of where validator and full-node capacity is concentrated. Coverage is never complete; where it is too thin to be relied on, the geographic distribution of a network with a similar staking design and operator economics is used as a proxy. The same exercise applies to the portion of Ethereum's footprint brought in through checkpointing, using Ethereum's own observed node distribution.

Those locations are then matched to national electricity statistics. Each country's share of generation from renewable sources comes 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 the country-level shares by the estimated node capacity in each produces a single renewable figure for the network.

Energy intensity is reported as a marginal quantity: the extra electricity associated with processing one more transaction, not the annual total divided by the number of transactions. On a chain whose validators run continuously and produce blocks on a schedule, that marginal figure is much smaller than a simple average would suggest, and the two are not interchangeable.

The limitations are inherent to the approach. An observed hosting location identifies a grid, not a power purchase agreement, so an operator sourcing renewable electricity on a carbon-heavy grid is invisible to the method. Cloud hosting and proxying can misplace a node relative to the hardware actually running it. Annual national averages cannot capture the hourly and seasonal swings in generation mix that continuously running machines draw from. And the borrowed share of Ethereum's footprint carries whatever geographic error is present in Ethereum's own distribution.

Stargate Finance is present on the following networks: Arbitrum, Avalanche, Base, Berachain, Binance Smart Chain, Ethereum, Fantom, Kava, Linea, Optimism, Polygon.

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.

The emissions estimate for Avalanche reuses the geographic work behind the renewable share and substitutes carbon factors for renewable percentages. The validator set enumerated from the platform chain, together with the nodes observed through peer discovery and public network data, is resolved to countries; where that resolution is too sparse, the distribution of a network with comparable staking economics stands in. Each country is then paired with the carbon intensity of its electricity, taken 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. The estimated electricity in each region, multiplied by that region's grams of carbon dioxide equivalent per kilowatt-hour and summed across regions, gives the annual emissions figure.

Reporting separates two scopes. Scope 1 covers emissions from sources the operators control directly, such as fuel burned on site for power or heat; for a population of servers hosted in rented facility space this is generally negligible and is reported accordingly. Scope 2 covers the indirect emissions embodied in the electricity those machines buy from their grids, which is where effectively the entire footprint of a staked network falls. Hardware manufacture and end-of-life disposal lie outside the boundary of this accounting.

Greenhouse-gas intensity follows the same marginal logic used for energy: the incremental emissions associated with one more transaction, not the annual total divided by throughput.

Uncertainty accumulates across the two steps. Whatever error exists in the electricity estimate passes straight through into emissions, and the geographic step adds its own, since national grid intensities span more than an order of magnitude and shifting a large operator from one country to another visibly moves the answer. Annual averages also conceal the hourly variation in grid intensity that continuously running machines are exposed to in full.

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.

Greenhouse-gas figures for Berachain follow from the energy estimate by way of the carbon intensity of the electricity the network consumes; they are not observed directly. The geographic distribution assembled for the energy assessment is reused without change: the consumption attributed to each country or region is multiplied by that region's average emissions per unit of electricity generated, and the products are summed across regions. Since grid intensity varies by more than an order of magnitude from one system to another, the assumed geography bears on the result as heavily as the quantity of electricity does.

Two scopes are kept apart. Scope 1 captures emissions from sources the network's operators directly control, in practice fuel combusted on site, chiefly in standby generation. For infrastructure of this kind the quantity is negligible and is generally treated as zero, since the machines sit in facilities that purchase grid electricity rather than generating their own. Scope 2 captures the indirect emissions embodied in that purchased electricity, and effectively the entire reported figure falls there. Emissions arising from manufacturing the hardware, from constructing the facilities that house it, or from the wider activities of the organizations that operate it fall outside both scopes and are excluded.

Greenhouse-gas intensity is defined marginally, in the same way as its energy counterpart: the emission attributable to settling one additional transaction, rather than an annual total divided by a count of transactions. Treating it as an average would misdescribe a network whose infrastructure consumes power continuously regardless of how much it is asked to do.

Uncertainty accumulates at each step. Grid intensity values are annual averages that cannot reflect the hours in which power was actually drawn. Low-carbon supply arrangements held contractually by an individual operator are invisible to a grid-average method. And where a comparable network substituted for locations that could not be established, that approximation passes through into the emissions estimate untouched.

Carbon intensity statistics are drawn from Carbon intensity of electricity generation, compiled by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy and made available under the Creative Commons Attribution 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.

Emissions are derived from the estimated electricity consumption of the network and the carbon content of the electricity that supplies it, not from any direct measurement of exhaust. The chain of reasoning begins with the same inferred geography used for the energy assessment: node locations are approximated from publicly observable network data, resolved to regional level, and where the observation is too sparse to support a distribution, the spread of a network with a comparable operating model is used in its place.

Each region is then matched to a carbon intensity for its electricity supply, expressed as emissions per unit of electricity generated, using Carbon intensity of electricity generation, compiled by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy and made available under the Creative Commons Attribution 4.0 license. Applying each region's intensity to the consumption attributed to that region, and summing, gives the network total.

The result is almost entirely indirect. Scope one covers emissions released by sources the operators themselves control, which for a network of this kind means essentially nothing: there is no combustion in running a node, and on site generation, where it exists at all, is not separately observable, so this component is reported at or near zero. Scope two covers the emissions embodied in the electricity purchased to run the machines, and that is where the network's footprint sits. Because the estimate is grid average by region, it does not credit an operator who buys certified renewable supply, nor does it charge an operator whose actual supply is dirtier than the regional figure suggests.

Greenhouse gas intensity is stated on a marginal basis, as the additional emissions associated with one further transaction, for the same reason that energy intensity is. On a network in wind down, where activity can fall while the infrastructure keeps running, an average computed from a shrinking transaction count would move sharply without anything physical having changed.

Emissions are derived from the same geographic work that supports the energy figures, applied against a different coefficient. Once the node population has been located and assigned to regional grids, each assignment is matched to the carbon intensity of electricity generation in that region — the mass of carbon dioxide equivalent released per unit of electricity delivered — and the network's estimated consumption is apportioned across those regions and converted. Regional variation is wide enough that two networks consuming identical amounts of electricity can differ substantially in emissions, which is why locating the infrastructure carries as much weight in the result as sizing its draw.

The two scopes are treated differently. Scope 1 covers emissions from sources the operators control directly, such as fuel burned on site for backup generation, and for a network of this design it is negligible or zero, since validators run commodity servers on purchased electricity rather than any combustion process of their own. Scope 2 covers the indirect emissions embodied in that purchased electricity and accounts for effectively the whole of the result. Where a node's location cannot be established with confidence, the regional profile of a structurally comparable network stands in for it, and that substitution carries into the emissions result exactly as it does into the energy one.

Carbon intensity coefficients 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 the Creative Commons Attribution 4.0 license.

Greenhouse gas intensity mirrors the definition used for energy intensity: the additional emissions attributable to one further transaction beyond those already being processed, rather than total emissions divided by a transaction count. Because the infrastructure runs continuously regardless of load, that marginal quantity is modest and falls as utilization rises. Results are restated when regional grid statistics are updated or when better observation of the node population becomes available, and the direction of any assumption made under uncertainty favors the higher estimate.

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.

The emissions figures are computed from the energy estimate, not observed directly. The geographic breakdown assembled for the renewable share — sequencing and batch-publishing servers, challenger and full nodes, and the slice of Ethereum's validator population attributed to settlement — is carried over, and each country's portion of estimated electricity is multiplied by that country's average grid carbon intensity. The intensity figures come 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 released under a Creative Commons BY 4.0 license. Country results are summed into a network total, from which a share is attributed to an individual asset in line with observed on-chain activity.

Scope 1 and scope 2 describe different things and are reported separately. Scope 1 is direct combustion under the operators' own control — fuel burned on site, standby generation. For infrastructure hosted in commercial data centers there is normally nothing material to report here, and it is stated as zero or negligible rather than estimated upward. Scope 2 carries the weight: it is the indirect emissions embodied in purchased electricity. The calculation is location-based, applying the average intensity of the grid serving each region, because a market-based calculation would need supplier contracts and certificates that are not observable from outside. Embodied emissions from manufacturing servers or constructing the facilities they occupy are not in scope.

Greenhouse gas intensity is reported as the marginal emissions of one additional transaction, consistent with how energy intensity is treated. The main uncertainties should be read alongside the number. National annual averages smooth away the hourly swings and regional differences a real facility experiences. Every assumption in the underlying energy and location estimates propagates through to the emissions figure. And where a choice between plausible assumptions has to be made, the one producing the higher result is preferred, so these figures are better understood as a conservative ceiling than as a precise measurement.

Emissions attributed to Polygon PoS rest on the same geographic work as the renewable share, with regional carbon factors applied in place of renewable percentages. Validator and full-node locations are approximated from peer discovery, public network observation and hosting attribution, and a comparable network's distribution stands in wherever direct observation is too sparse. The share of Ethereum's footprint brought in through checkpointing is located the same way, against Ethereum's own node distribution. Each location is paired with the carbon intensity of its national grid, taken 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 made available under a CC BY 4.0 license. Multiplying regional electricity by regional grams of carbon dioxide equivalent per kilowatt-hour, then summing, yields the annual total.

Scope matters to how the result should be read. Scope 1 captures emissions from sources under the direct control of the network's operators, such as fuel burned on site, which for servers in rented facility space is generally negligible and reported as such. Scope 2 captures the indirect emissions embodied in purchased electricity, and that is where essentially the entire footprint falls. Manufacture and disposal of the hardware sit outside the boundary of this accounting.

Greenhouse-gas intensity is defined marginally, as the incremental emissions associated with one additional transaction rather than the annual total spread across throughput.

The error bars on the emissions figure inherit those on the electricity estimate and add to them. Grid carbon intensity differs by more than an order of magnitude between countries, so a misallocated share of node capacity shifts the result considerably, and annual national averages hide the hourly swings in intensity that machines running around the clock experience in full.