USD Coin (USDC) sustainability report

USD Coin is present on the following networks: Algorand, Aptos Coin, Arbitrum, Avalanche, Base, Celo, Cronos, Ethereum, Hedera Hbar, Hyperliquid, Injective, Near Protocol, Optimism, Plume, Polkadot, Polygon, Sei, Solana, Sonic, Starknet, Stellar, Sui, Tron, Xdc Network, Ripple, Zksync.

Algorand reaches agreement through a pure proof-of-stake protocol in which every unit of the network's native asset held in an online account carries the same weight, and in which no bonding, no delegation to a fixed validator set, and no minimum hardware commitment is required to take part. Instead of electing a known roster of block producers, the protocol uses cryptographic sortition. At each step of each round, every participating account evaluates a verifiable random function locally, using a seed derived from the chain itself together with its own private participation key. The output tells that account privately whether it has been drawn and with what weight, and it carries a proof that anyone else can check once the account speaks. Because the draw happens in secret and becomes visible only when a selected account broadcasts, an adversary has nobody to attack, bribe or censor in advance.

A round proceeds in three steps. A small set of accounts is drawn to propose a block, and the proposal carrying the strongest sortition credential prevails. A soft-vote committee, sampled afresh, converges on a single proposal. A certify-vote committee, sampled afresh again, votes to commit that block to the ledger. Every step draws a new committee, so subverting the members of one step buys nothing for the next. Once a block is certified it is final; the chain does not fork in normal operation, and no confirmation depth or challenge window applies. Safety holds while honest accounts control more than two thirds of the online weight, and the design is deliberately biased toward never producing two conflicting ledgers, so a severe partition stalls the chain rather than splitting it.

Participation is opt-in and non-custodial. A holder registers short-lived participation keys against an account and keeps a node online; the balance backing that account never moves and is never bonded. Nodes exchange messages over a peer-to-peer gossip layer. The protocol itself changes by node-runner voting, in which produced blocks count as ballots and a large supermajority is needed to adopt a new consensus version, followed by a fixed cooldown before activation. The version adopted in August 2026 added native post-quantum account signatures alongside the existing signature scheme.

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

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

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

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

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

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

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.

Celo has not operated as a standalone Layer 1 since March 2025, when a governance-approved hard fork converted it into a Layer 2 network that settles on Ethereum. The current design is built on the OP Stack. Transaction ordering is the job of a sequencer, which assembles blocks at roughly one-second intervals and runs an execution environment equivalent to the Ethereum Virtual Machine, so contracts and tooling written for Ethereum behave identically here. One element of the former Layer 1 survives as a precompiled contract: the network's native asset can be moved either as the gas asset or through a standard fungible-token interface, without a wrapper.

Agreement on the canonical chain therefore no longer comes from a local committee of block-producing validators voting among themselves. Batched transaction data is published to an external data availability service, and only a short commitment to that data is recorded on Ethereum. Because the data itself lives off the settlement chain, the design is generally classified as an optimium rather than a full rollup, and it carries the extra assumption that the availability service will serve the data when it is asked for. State roots are proposed to contracts on Ethereum and become final only after a challenge window of about three and a half days, during which a permissioned group of challengers may dispute a proposal. A disputed proposal is resolved by generating a succinct cryptographic proof of the contested execution rather than by an interactive bisection game. A user who believes the sequencer is censoring them can force a transaction in through the Ethereum contracts, subject to a delay.

The elected operator set that once produced blocks still exists, but its function has changed: those operators now run public remote-procedure-call infrastructure serving reads and transaction submission, and election to the set remains an on-chain, stake-weighted process resolved once per epoch. Safety for funds leaving the network rests on Ethereum and the dispute process; ordering and liveness rest on a single sequencer; retrievability of transaction data rests on the external availability layer.

The identifier cronos refers to the Cronos EVM chain, the Ethereum-compatible layer 1 addressed as chain 25 by Ethereum tooling, and not to the other networks that share the Cronos name. It is distinct from the Cronos POS chain, a separate Cosmos SDK network on which the native asset is bonded and where governance sits, and from the zero-knowledge rollup variant that was introduced separately and is now being wound down. The EVM chain is standalone: it proposes and finalizes its own blocks, posts neither state roots nor validity proofs to Ethereum for settlement, and takes no security from the Cosmos Hub. Its links to other Cosmos SDK networks, the POS chain included, carry messages and assets over the Inter-Blockchain Communication protocol; they are not a security relationship.

Agreement is reached through CometBFT, the Byzantine-fault-tolerant engine used across Cosmos SDK chains, operated here in a proof of authority configuration. This is the network's most distinctive property and the one most often described incorrectly. Validator slots are not allocated by an open contest ranked on bonded stake. Operators are admitted by review, with the incumbent validators weighing a candidate's record of running highly available infrastructure, its ability to apply protocol upgrades promptly, and its commitment to the network. The active set is consequently a small, identified group of institutional operators rather than an open population, and while anyone may run a full node, running one confers no route into the set.

Block production follows the standard round structure for this engine. A proposer is selected for each height, and the remaining validators pre-vote and then pre-commit; a block gathering more than two thirds of voting power is committed and is final at that moment, with no confirmation depth to wait out and no reorganization of committed history. Safety holds while fewer than one third of the set acts adversarially, and the protocol tolerates that same fraction failing outright without halting. Demonstrable Byzantine behavior, such as signing two different blocks at one height, results in the offending operator being penalized and removed from the set.

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.

Hedera does not assemble transactions into a chain of blocks proposed by a leader. Its nodes instead build a shared directed acyclic graph of communication events. Whenever two nodes speak, the initiating node passes on everything it knows that the other does not, and each event it creates records the two prior events it builds upon, namely its own most recent one and the one it has just received. Because every event carries that ancestry, the graph is itself a verifiable record of who learned what and when, and it propagates across the network exponentially without any node needing to broadcast to all the others.

Ordering is then derived from the graph rather than negotiated through voting messages. Since each node holds the same ancestry information, each can compute what every other node would have voted at each stage of the protocol and arrive independently at the same answer. This virtual voting removes an entire round of network traffic, and it produces both an agreed order and an agreed timestamp for every transaction, the timestamp being derived from when the participating nodes first received it rather than chosen by whoever proposed a block. Once settled, the order is settled permanently: the protocol offers asynchronous Byzantine fault tolerance, meaning it stays safe without assuming any bound on message delivery times, provided less than a third of the voting weight is dishonest. Finality arrives within seconds, with no probabilistic confirmation window and no fork to resolve.

Voting weight is proportional to the quantity of the network's native asset staked to each node, but the right to operate a consensus node is not open. The set is permissioned, and the address book of consensus nodes is maintained by the council of organizations that governs the network, whose members operate those nodes and vote on protocol and treasury decisions. The published roadmap moves through a stage of permissioned third-party operators toward eventual open participation, and that transition remains incomplete: consensus node operation is still restricted to approved operators, while the mirror nodes that answer historical queries are already open to anyone who wishes to run one.

Hyperliquid is a proof-of-stake layer-one network running its own Byzantine fault tolerant consensus protocol, HyperBFT, implemented from scratch and derived from the HotStuff line of leader-based BFT designs. Consensus advances in rounds. A rotating leader proposes an ordered bundle of transactions, validators vote, and a round commits once signatures representing more than two-thirds of stake-weighted voting power have been gathered; voting is pipelined so that the vote confirming one round also advances the next. Ordering is therefore agreed before execution, and a committed round is final immediately rather than after a probabilistic waiting period. Safety holds provided that faulty or dishonest validators control less than a third of stake-weighted voting power.

What sets this network apart is what the agreed ordering is fed into. Two execution environments sit on the same consensus and the same validator set. The first, the native state machine, holds fully on-chain central limit order books together with margin, perpetual futures and spot balances, so order placement, cancellation, matching and liquidation are consensus operations of the chain itself rather than calls into a deployed contract. The second is an EVM environment added in 2025, which inherits ordering and finality from the same consensus and can read from and write to the native state. It uses two interleaved block types: small blocks produced roughly every second with a low gas ceiling, for ordinary transfers and trades, and much larger blocks produced about once a minute, for contract deployment and heavy batch work, so bulky transactions cannot delay time-sensitive ones.

Validators are selected by stake. An operator must self-delegate a minimum amount of the network's native asset to become active, and any holder may delegate to a validator to add to its weight. The active set and the stake behind it are fixed within staking epochs of a hundred thousand consensus rounds, roughly an hour and a half, and are recomputed between them. Validators police each other's liveness directly: a validator that does not answer consensus messages with acceptable latency or frequency can be voted into a jailed state by its peers, in which it stops producing blocks until it returns itself to service.

Injective is a sovereign Cosmos SDK chain whose consensus is driven by CometBFT, the Byzantine fault tolerant engine released for years under the name Tendermint Core before its rename in 2023. Consensus proceeds in rounds, with a proposer taken from the active validator set, a prevote stage, and a precommit stage; a block is committed as soon as precommits amounting to more than two thirds of bonded voting power have been collected, and it is final at that instant rather than after a number of confirmations. The chain remains safe while validators holding less than one third of bonded voting power deviate from the protocol, and if that bound is ever exceeded it stops producing blocks rather than continuing on two conflicting histories. Blocks are produced at sub-second intervals, a cadence chosen because the applications this chain is designed for are latency-sensitive.

The active set is small and stake-ranked. Operators are ordered by the total bonded to them, self-bonded and delegated together, and only the highest-ranked forty-five occupy consensus slots, with voting weight proportional to bonded stake. Holders of the native asset delegate to an operator to share in its rewards and its penalties without running a node, and stake withdrawn from an operator remains locked for three weeks before it becomes transferable.

Two features distinguish this chain from a general-purpose Cosmos network. First, a central limit order book is part of the protocol itself rather than a contract deployed on it: orders rest in chain state, and matching, clearing, and settlement are executed by validators during block processing. Orders arriving in the same block are cleared together at a uniform price instead of being processed in the sequence they arrived, which removes most of the advantage of winning a latency race and blunts the reordering strategies that afflict chains with ordinary first-come sequencing. Second, since a network upgrade in November 2025 the chain has executed an Ethereum virtual machine natively alongside its existing WebAssembly environment, both sharing a single chain state, so Solidity contracts settle against the same balances and reach the same order book through protocol-level entry points.

NEAR Protocol is a sharded proof-of-stake network. Rather than running independent chains alongside one another, it treats the whole system as a single logical chain whose every block is assembled from per-shard pieces called chunks, so one block header commits to the state of every shard at once. An account's address determines which shard holds it. The network launched with a single shard and has since grown to several; a 2026 protocol release made the split automatic, so a shard now divides at an epoch boundary once its state passes a configured size threshold, instead of waiting for a coordinated upgrade.

Participation is decided by a recurring auction over stake. An operator wanting to validate submits a staking proposal; at each epoch boundary the protocol sorts the proposals, derives a seat price from them, and assigns duties to those clearing it, with some accounts producing blocks, others producing the chunks of a particular shard, and the rest acting as chunk validators. Epochs last roughly half a day and assignments are reshuffled each time, so no operator holds a given shard indefinitely. Because the seat price floats with the total stake competing for entry, the threshold rises and falls with demand rather than being fixed in the protocol.

The design that most distinguishes this network is stateless validation, adopted in 2024. A chunk producer publishes, alongside its chunk, a compact witness carrying exactly the state that chunk touched together with proofs against the shard's state root. Chunk validators check the work from that witness alone, so they can verify a shard without storing it, and shards can be added without pushing hardware requirements steadily upward.

Blocks are produced under Doomslug, which allows the next block to be built once more than half of the stake has endorsed its predecessor, giving a fast practical guarantee that the chain will not reorganize. Full finality comes from a separate rule once two-thirds of the stake has endorsed, normally within a small number of blocks. Safety rests on more than two-thirds of staked value behaving honestly, and activity crossing shard boundaries travels as receipts routed asynchronously over subsequent blocks.

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.

Plume is an Ethereum Layer 2 built on the Arbitrum Nitro codebase and deployed through the Orbit framework, oriented toward tokenized real-world assets. Like other chains of that design it runs no consensus protocol among competing block producers. A single sequencer receives transactions, orders them, executes them against the current state, and emits blocks; users get a fast provisional commitment from that sequencer, and the ordering becomes final only once the corresponding data and state claims have been accepted on Ethereum, which is the settlement layer.

The arrangement for making transaction data retrievable changed after the public mainnet opened in mid-2025. The chain initially published its batch data to an external modular availability network, and during late 2025 moved to the committee-based scheme available in the Nitro stack, in which a designated group of parties signs certificates attesting that it holds a batch and will serve it on request. Only those certificates, rather than the full transaction data, are posted to Ethereum. The choice lowers what publishing costs, and it also means the guarantee that data can be retrieved rests on that committee honoring its attestation rather than on Ethereum alone; the stack retains a fallback in which data is posted directly to Ethereum when the committee does not sign.

Correctness of the state, as distinct from retrievability of the data, is enforced optimistically. A whitelisted party posts assertions about the chain's state to contracts on Ethereum, and those assertions can be contested on-chain during a confirmation window of roughly five and a half days. In early 2026 the chain adopted Arbitrum's newer dispute protocol, which replaces one-against-one interactive challenges with a design in which many parties can contest an assertion at once and the total delay a dispute can impose is bounded. The right to post assertions and to challenge them is currently held by a permissioned set, so the honest-party assumption presently rests on a small number of operators rather than on open participation.

Polkadot runs a Nominated Proof of Stake system on its relay chain, and it deliberately separates producing blocks from declaring them irreversible. Holders of the native asset may bond it and either stand as a validator candidate or act as a nominator, naming a short list of candidates they are willing to back. At the start of each era an on-chain election algorithm derived from Phragmén's methods — a sequential variant and a maximin-support refinement of it — picks the active validator set from the candidates and also decides how each nominator's bond is divided among the validators it named. The aim is not merely to seat the largest stakes but to even out the backing behind elected validators, so no single validator concentrates a disproportionate share and the cost of capturing the set stays high. The size of the active set is a governance parameter rather than a fixed constant.

Block production is handled by BABE. Time is cut into epochs of six-second slots, and for every slot each validator privately evaluates a verifiable random function against the epoch's shared randomness; an output below a stake-weighted threshold entitles that validator to author the slot. Two validators can win the same slot, briefly forking the chain; when nobody wins, a deterministic fallback fills it so authoring never halts. Finality is a distinct mechanism, GRANDPA, running alongside the chain BABE builds. Validators vote on chains rather than individual blocks, and once more than two thirds of the active set have voted for a chain containing a given block, that block and all of its ancestors are finalized in one step. The interaction is loose by design: authoring proceeds at a steady rate whatever finality is doing, and finality can confirm a long run of blocks in a single round rather than gating production.

Parachains do not elect validators of their own. Their collators assemble candidate blocks with a proof of validity, a small group of relay chain validators re-executes that proof and backs the candidate, and the candidate data is erasure coded across the whole validator set so any large enough subset can reconstruct it. Further validators then self-select by lottery to re-check the work; a contradictory result opens a dispute that the entire set must settle, and validators on the losing side are slashed. Only candidates that survive this approval stage are finalized.

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.

The identifier sei-v2 refers to the release in which the Sei network gained an Ethereum-compatible execution layer on top of what had been a Cosmos SDK chain, which reached mainnet in 2024. The network has moved on considerably since then, and what follows describes how it operates now rather than at that release. Sei is a standalone layer 1: it proposes and finalizes its own blocks and settles to no other chain.

Consensus runs on Twin Turbo, a latency-tuned variant of the CometBFT protocol used across Cosmos SDK networks. Voting power is weighted by bonded stake. A single proposer is selected for each height and the remaining validators move through pre-vote and pre-commit rounds; a block committed by more than two thirds of voting power is final at that moment, with no confirmation depth and no reorganization of committed history, and safety holds while fewer than one third of voting power behaves adversarially. Two modifications give the mechanism its name. Proposals travel in compressed form, carrying references to transactions that receiving nodes already hold rather than the transaction bodies themselves, so each node rebuilds the block locally instead of receiving it whole. And validators start executing a proposal speculatively while the voting rounds are still running, discarding the work if the block is not committed, which lifts execution off the critical path. Blocks commit on a sub-second cadence.

Further changes belong in the current picture. A parallel execution client, running transactions concurrently under optimistic concurrency control and falling back to sequential execution where they conflict, together with a restructured state store, reached mainnet during 2026. A redesigned consensus layer in which every validator disseminates its own stream of transactions concurrently — separating data availability from ordering instead of funneling both through one proposer per height — has been specified and tested but was not yet active on mainnet. Separately, governance has approved retiring the chain's Cosmos-native surface, halting new CosmWasm contract deployments and disabling Inter-Blockchain Communication transfers in both directions during 2026.

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

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

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

Sonic is an independent layer one network that reaches agreement with Lachesis, a leaderless asynchronous Byzantine fault tolerant protocol operating over a proof of stake validator set. It inherits this design from the earlier chain whose community and token it succeeded, and it runs it on a rebuilt client. No validator is designated to propose for a given round. Each one bundles the transactions it has received into an event, references the latest events it has seen from its peers, signs the result and gossips it on, so every participant accumulates a directed acyclic graph of the same events. Ordering is then derived from the structure of that graph: once an event has been observed, directly or through the references of later events, by validators holding more than two thirds of the bonded native asset, it is settled, and the ordering procedure turns that portion of the graph into a sequential chain of blocks.

A 2025 revision of the consensus implementation restructured how these decisions are computed, running the elections that resolve successive positions in an overlapping fashion instead of one after another. The change did not alter the safety or finality properties; it cut the processing and memory a validator needs to seal an epoch, which lowers the hardware burden of participating. Execution is deliberately separated from consensus: an Ethereum compatible virtual machine tuned for fast contract execution sits behind a dedicated state storage layer, and the node software distinguishes validating nodes from archival ones that retain full history.

Finality is deterministic and typically reached about a second after submission, with no confirmation depth and no dispute window; agreement is reached by this network's own validators and is not deferred to, or settled on, any other chain. Bridges to other networks exist but sit outside consensus. Operators register through the staking contract with a substantial self bond, set high while the validator set was young and intended to fall over time, and delegated stake is capped at a fixed multiple of that self bond.

Starknet is a validity rollup that settles to Ethereum. Transactions are executed away from the settlement layer, and their correctness is established by a cryptographic proof rather than by a challenge period: a prover produces a succinct argument that a batch of transactions was executed according to the rules, a contract on Ethereum verifies that argument, and once verification succeeds the resulting state is final. There is no window during which a submitted state can be disputed, because an invalid state transition cannot be proven in the first place. The proof system relies on collision-resistant hash functions rather than elliptic-curve assumptions.

Ordering and execution are the responsibility of sequencers. A 2025 upgrade replaced the single sequencer with several running a Byzantine fault tolerant agreement among themselves at a majority threshold, which cut block times substantially and introduced pre-confirmations that give users a response well before a block closes. Those sequencer nodes remain operated by one organization, so the arrangement removes a single point of failure in the software sense without yet making participation open. Proving likewise remains centralized.

A staking system is being introduced in stages and is the route by which that changes. The first stage opened staking and delegation to anyone willing to run a full node; the second added attestation, which makes a validator's liveness and reliability publicly measurable; the stage now being rolled out has validators validate and vote on sequenced blocks, with a block finalized only once more than two-thirds of stake has voted for it; a final stage would hand validators responsibility for operating the network, with proof generation expected to remain the last centralized component. Published schedules for the later stages have moved, and the network should be described as partially decentralized: state validity is enforced by proofs verified on Ethereum and does not depend on trusting any operator, while liveness and transaction ordering still do. Data is published to the settlement layer, so the information needed to reconstruct state is available independently of the operators.

Stellar reaches agreement through the Stellar Consensus Protocol, an implementation of federated Byzantine agreement. It is neither proof of work nor proof of stake: nothing is mined, nothing is bonded, and holdings of the native asset confer no voting weight whatsoever. What decides influence is trust that each operator declares for itself. Every validating node publishes a quorum set naming the other nodes it is willing to rely on, together with thresholds over that set. Any subset of a node's quorum set that meets its threshold is a quorum slice, and a quorum is a group of nodes that contains a slice for each of its members. There is no global register of validators and no authority that admits or expels one; a node joins the system in practice only when enough existing operators choose to name it.

Safety rests on quorum intersection. If the quorum sets operators have chosen overlap sufficiently, no two quorums can commit conflicting values and the ledger cannot fork. If they overlap too little, the guarantee lapses, which makes configuration choices and the diversity of operators the real security parameter. The protocol is deliberately biased toward safety over liveness: when trust fails to intersect or too many nodes disagree, the network stops closing ledgers rather than producing divergent histories. Concentration is the corresponding risk, since a small number of widely trusted operators sit in most quorum sets.

A ledger closes in two phases. Nomination runs a federated vote until candidate values converge and are combined into a single composite value, and the ballot protocol then runs prepare and commit rounds until a value is externalized. Ledgers close every few seconds and an externalized ledger is final immediately. Operators run validators that either publish a full history archive or do not, and organizations expected to anchor the trust graph run several geographically separated archive-publishing nodes. Protocol versions are adopted by validator vote; recent ones added parallel smart contract execution, moved contract state into memory, and introduced a consensus-maintained mechanism for freezing specified ledger entries.

Sui runs a delegated proof-of-stake network whose validator committee is fixed for an epoch of roughly one day, with voting power proportional to the stake bonded to each member. Agreement uses a directed acyclic graph rather than a single chain of proposals: validators produce blocks each round that reference blocks from the previous round, and the resulting structure is read directly by every validator to work out which blocks are committed and in what order. Because the commit rule is evaluated over the graph itself, no separate round of explicit certification is needed, which removes network round trips from the critical path and brings commit latency down to a few hundred milliseconds. A more recent revision folded transaction validation into the same process and routes each submitted transaction through a single coordinating validator, cutting duplicated signature work.

The distinctive part of the design is that not every transaction has to pass through that machinery. State is modeled as discrete objects, each either owned by a single address, shared, or immutable, and a transaction declares the objects it will read and write before it executes. A transaction touching only objects owned by its sender cannot conflict with anything another party might submit, so it does not need a global ordering: a quorum of stake signing it by reliable broadcast is enough to settle it, and it finalizes on this fast path in roughly the time of two network round trips. Transactions that touch shared objects, which is what most decentralized finance activity involves, do require the graph-based protocol to sequence competing accesses, and carry slightly higher latency and cost as a result, rising further when many transactions contend for the same popular object.

Execution takes advantage of the same declarations: transactions whose object sets do not overlap run concurrently. The protocol remains safe provided faulty or malicious validators hold less than a third of voting power.

The TRON network reaches agreement through delegated proof of stake. Holders of the native asset lock it up, which yields voting weight, and use that weight to back candidates who have registered to produce blocks. Votes are counted afresh at the end of every six-hour cycle. The twenty-seven candidates ranked highest by votes become the super representatives that produce blocks for the cycle that follows; those ranked immediately below them form a standby tier of partners, which does not produce blocks but remains in the reward distribution and supplies replacements as the ranking shifts. Because the count repeats four times a day, the producing set is re-derived continuously rather than fixed for a term.

Block production follows a fixed rotation among the twenty-seven, with one slot every three seconds. A producer that misses its slot is skipped and the schedule continues. A block is treated as settled once more than two-thirds of the producing set has built on it, so settlement follows from producers confirming one another's work rather than from a separate voting protocol, and takes on the order of a minute in normal conditions. Smart contracts execute in a virtual machine built for compatibility with Ethereum tooling, under the same producing set.

The security argument rests on an honest supermajority within a small, elected and publicly identified group. Entry is open in the sense that anyone may register as a candidate, subject to a deposit that is destroyed on registration, but a candidate only produces blocks by accumulating votes. The same twenty-seven form the committee that governs the chain's adjustable parameters: proposals to change values such as resource pricing, reward sizes and protocol feature switches are voted on by the producers, and a proposal passes on the support of a supermajority of them. A substantial part of what users experience as the cost of using the network is therefore a governance variable rather than a fixed property of the protocol.

The XDC Network runs a delegated proof-of-stake design known as XDPoS, currently in its second major version, which pairs stake-weighted election of block producers with a Byzantine fault tolerant agreement protocol derived from the HotStuff family. Block-producing nodes are called masternodes. Standing as a candidate requires locking a fixed amount of the native asset, currently ten million units, and candidates are ranked by the stake behind them, combining the operator's own deposit with the weight other holders direct to them. The ranking is recalculated at the start of each epoch, an epoch being a fixed run of nine hundred consecutive blocks, and the leading one hundred and eight candidates form the committee that produces blocks for that epoch. Candidates outside the committee remain staked and ready to step in, and nodes that only follow the chain and serve queries carry no stake requirement at all.

Within an epoch the committee takes turns proposing, and every block must gather a certificate signed by a supermajority of committee members before the chain advances past it. That certification is what supplies finality: once the required quorum has signed, the block cannot be reversed, provided fewer than a third of the committee is acting adversarially. Blocks are produced at roughly two-second intervals and a transaction is final within a few seconds of inclusion, rather than becoming progressively harder to reverse as further blocks accumulate. The protocol does not fork under normal operation.

The distinctive element is accountability. Consensus messages are recorded in a form that allows the network to attribute contradictory signatures to the specific masternode that produced them, using evidence already on the chain and querying comparatively few participants to establish it. This turns a detected safety violation into an identified and provable offense rather than an anonymous one, which is what makes the penalties described in the network's incentive rules enforceable against a named operator rather than against the committee collectively.

The XRP Ledger reaches agreement through a trust-based Byzantine agreement procedure rather than through mining or staking. Every server running the ledger software keeps a configured roster of validators whose votes it will listen to, known as its unique node list, and it discards proposals from anyone outside that roster. The security assumption is not that participants have put capital at risk but that the operators named on a given roster are independent enough that they will not fail, or collude, in the same way at the same time. Most operators adopt one of the default rosters curated and published by the XRP Ledger Foundation and by Ripple, although any server is free to compose its own.

Agreement proceeds in short rounds. A server accepts incoming transactions into an open set, closes that set, then exchanges proposals with the validators it trusts, repeatedly adjusting its own proposal to converge on the transactions its trusted peers also hold. When roughly eighty percent of the trusted validators support the same set, each server applies those transactions in a deterministic canonical order to the previous state and publishes a signed hash of the result. Agreement on that hash marks the ledger version as validated, and validation is final: there is no probabilistic confirmation period and no reorganization of settled history. A new ledger version closes every few seconds.

The design deliberately favors halting over divergence. If the proportion of faulty, unreachable or dishonest validators on a roster rises past what the threshold tolerates but falls short of overwhelming it, the affected servers stop advancing rather than splitting into competing histories. A companion mechanism tracks validators that have fallen silent and temporarily discounts them from the quorum calculation, so that ordinary outages do not stall progress. The validator operators named on a roster also carry the network's governance: protocol changes activate only after sustained on-chain support from that same set, and the same votes set network-wide parameters such as the base transaction cost and the minimum balance an account must hold.

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

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

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

USD Coin is present on the following networks: Algorand, Aptos Coin, Arbitrum, Avalanche, Base, Celo, Cronos, Ethereum, Hedera Hbar, Hyperliquid, Injective, Near Protocol, Optimism, Plume, Polkadot, Polygon, Sei, Solana, Sonic, Starknet, Stellar, Sui, Tron, Xdc Network, Ripple, Zksync.

Under the incentive arrangement that took effect in January 2025, the account that proposes a block is paid the moment its block is certified, and the payment is credited directly to the account balance rather than appearing as a separate transfer. The payout combines two sources: a share of the fees the protocol has collected in its fee sink, and a bonus drawn from a reserve funded by the network's foundation. The bonus begins at a fixed amount per block and decays by a small fraction every million blocks, so the subsidized component tapers away over time and fee revenue is intended to become the durable source of reward.

Eligibility is open in one respect and bounded in another. Any account may register participation keys and vote in consensus, but to earn proposer payouts an account must also signal that intent by paying a raised key-registration fee and must hold a balance inside a defined band, with a floor in the tens of thousands of units of the native asset and a ceiling that discourages very large single concentrations. Holders below the floor reach the same rewards through pooled or custodial arrangements. There is no bonding, no lock-up and no unbonding queue: the balance that backs consensus stays liquid and spendable throughout.

The network does not slash. Misconduct and neglect are answered by removal rather than confiscation. An account that stops answering for its share of the work is marked absent and suspended from consensus within minutes, stops earning, and must pay the registration fee again before it can resume; a heartbeat mechanism and a safeguard for accounts whose weight rises abruptly limit false suspensions. The consequence of failure is therefore forgone reward and a small re-entry cost, not loss of principal.

Users pay a minimum fee of one thousandth of a unit of the native asset per transaction. The consensus version activated in 2026 replaced what had been an essentially flat charge with one that prices what a transaction carries, adding a per-byte surcharge above a size threshold and charging several times the minimum where a post-quantum signature must be verified; under congestion the per-byte rate rises further. Fees can be pooled across an atomic group so one transaction covers another, and every account must retain a minimum balance that grows with the assets and applications it holds.

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

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

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

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

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

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

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.

Fees on this network are unusual in one respect: gas need not be paid in the native asset. A dedicated transaction type lets an account settle fees in any currency an on-chain allowlist admits, which in practice means several dollar-denominated stablecoins, so an account can transact holding none of the gas asset at all. The pricing itself follows the mechanism Ethereum introduced with EIP-1559. Each transaction carries an algorithmically determined base fee that rises and falls with demand for block space and an optional priority fee paid for earlier inclusion, with a floor under the base fee to deter spam and uncontrolled state growth. Because transaction data goes to a low-cost external availability layer rather than onto the settlement chain, the surcharge many Layer 2 networks pass on for settlement data is configured at zero here, and users are not billed separately for it. Smart contract execution is metered in gas and priced by the same components; there is no recurring rent on stored state.

Fee revenue accrues to the sequencer, and a protocol contract routes a configured share onward, destroying part of it and allocating the rest to beneficiaries that governance nominates, among them a fund that purchases carbon offsets. The allocation is a governance parameter rather than a fixed constant.

A separate reward stream runs each epoch, an epoch being a period of at least a day whose processing is triggered by an on-chain call rather than emitted by a special block. A treasury contract releases the native asset to four groups: the operators running public endpoint infrastructure, the holders whose locked stake voted for the elected groups, a community fund, and the carbon offsetting fund. An operator's share is scaled by a score reflecting the service it actually provides, and the group it belongs to takes a commission before passing the remainder to its voters. Penalties changed with the architecture: the automatic slashers for downtime and double-signing were retired along with local block production, while a governance-controlled slashing path remains, and an operator that stops serving without deregistering sees its score, and eventually its rewards and those of its voters, fall to nothing.

Because the validator set is admitted by review rather than won with bonded stake, this chain runs no open delegation market and pays no inflationary block reward to a public staking population. Its validators are compensated out of transaction fees, and their incentive to behave correctly is reputational and contractual as much as economic: an operator that misbehaves or fails to stay available loses a seat it cannot simply buy back. Public staking of the native asset happens instead on the separate Cronos POS chain, where an open validator set capped at a hundred active operators is ranked by bonded stake, earns newly issued units alongside a share of fees, and passes rewards to delegators net of a commission each operator sets, with the remainder of the fee take routed to a community pool. That chain confiscates stake for equivocation and for sustained unavailability, and holds withdrawn stake through an unbonding period.

Users of the EVM chain pay in gas, denominated in the network's native asset. The fee market follows the structure popularized by Ethereum's EIP-1559: every block carries a base fee that rises when recent blocks have run above their gas target and falls when they have run below it, and a transaction may attach a priority fee on top to compete for earlier inclusion. The important divergence concerns where that revenue goes. This network burns none of the base fee; the base and priority components alike are collected by the validator producing the block. Fee pressure here redistributes value rather than retiring supply, which is the opposite of the effect the same fee structure has on Ethereum.

Execution costs follow the Ethereum gas schedule, so contract deployment, computation and writes to persistent storage are priced by the work they impose on every node, and a transaction that exhausts its gas limit still pays for what it consumed before failing. There is no recurring storage rent and no rent exemption to maintain: state paid for once persists without further charge, placing the cost of state growth on the writer at the moment of writing rather than spreading it over time.

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.

Costs on Hedera are quoted in United States dollars and settled in the network's native asset. Each operation type carries a price in a fee schedule the network publishes, and when a transaction is handled the nodes convert that dollar price into a quantity of the native asset at an exchange rate they agree on. The practical effect is that the cost of an operation holds roughly constant in purchasing-power terms while the quantity of the asset charged moves inversely to its market rate, which is the property enterprise users were intended to be able to budget against. Pricing is per operation rather than metered through a gas auction, so there is no bidding contest for inclusion; a recent revision simplified how the components of a price are computed without altering the dollar denomination or the conversion step. Reading data back out of the network through the archival query nodes carries no charge at all.

A charge splits by purpose. One portion compensates the network as a whole for reaching consensus on the transaction, one goes to the particular node that accepted and submitted it, and one covers the specific service invoked, whether that is persisting a file, executing contract bytecode, creating an account or a token, or submitting a message to a topic. Collected charges accumulate in network accounts, part of which funds the pool from which node payments are made.

Consensus node operators receive a daily payment when they have genuinely taken part in consensus over the period, measured by their contribution to the rounds the protocol produces rather than by how many transactions they happened to route. An operator whose node was inactive receives nothing for that day, and an operator may also decline the payment outright. Holders of the native asset may stake to a node, which raises that node's voting weight and earns them a share of a reward pool whose maximum rate is a governance-set parameter. Staking of this kind does not lock the asset, which stays transferable throughout, and the protocol does not confiscate staked balances: the consequence for a node that fails to participate is forfeiture of its reward, not loss of a bond.

Validators and their delegators are paid from a reserved pool of the native asset held for that purpose, not from the network's trading revenue. Rewards accrue continuously, are paid out daily and are automatically re-delegated, and the rate scales inversely with the square root of the total amount staked, so the yield falls as participation grows. A validator earns only for epochs in which it actually took part in consensus, and its delegators earn nothing while it is jailed. Validators set a commission on delegator rewards; raising one is constrained, since a commission may only be changed to a rate at or below a low ceiling, which prevents an operator from attracting delegation cheaply and then repricing it.

Delegated stake cannot be withdrawn quickly. A delegation is locked for a day before it can be undone, and moving stake back to a spendable balance then takes a further week in a withdrawal queue, which makes it impractical to assemble voting weight, attack consensus and exit. There is no automatic confiscation of stake in the protocol as it currently operates; the sanction for poor performance is jailing, which costs the validator and its delegators their rewards rather than their principal.

The fee model is the most distinctive part. Trading fees on the native order books are charged to takers and makers on a volume-tiered schedule, and execution fees on the EVM side are paid as gas. Almost none of this reaches validators. The great majority of protocol fee revenue is routed to an on-chain fund that continuously buys the native asset on the open market; the address holding it has no private key, so under current protocol rules those holdings cannot return to circulation. Alongside that, several streams are destroyed outright: spot trading fees denominated in the native asset, the base-token fees from token deployments that a deployer has not redirected, and both the base fee and, unusually, the priority fee on the EVM, since block producers do not collect them. Optional priority fees for faster order handling, introduced in 2026, are likewise burned. Token listings are allocated through descending-price auctions rather than sold at a fixed price.

Validators and their delegators are paid from newly issued units of the native asset and from the fees attached to transactions. Issuance moves within a band whose bounds have been tightened repeatedly by governance, so the rate sits well below where it began, and it adjusts against a target proportion of supply being bonded: when the bonded proportion falls short of the target the rate rises toward the upper bound, and when it is exceeded the rate drifts toward the lower one. Rewards are shared out in proportion to bonded stake, each validator retaining a commission that the protocol requires to be at least five percent, and the remainder accruing to its delegators. Penalties on this chain are principally exclusionary. A validator that signs conflicting blocks at the same height is permanently barred from the set and cannot return under the same key, while one that fails to sign enough blocks over the measurement window is jailed until it applies to be released; the confiscation rates attached to these faults are governance parameters, and removal from the set is the sharper deterrent of the two.

The fee model has an unusual second stage. Ordinary transactions pay gas in the native asset, priced by a base rate that rises as blocks fill and falls as they empty and cannot drop below a governance-set minimum; the same asset pays for execution in both the WebAssembly and the Ethereum virtual machine environments. Trading, however, is charged separately by the exchange module, which applies distinct maker and taker rates to each market and routes a portion of what it collects to the interface that introduced the order, as a standing reward for bringing order flow to the chain.

What the exchange module retains does not go to validators. It accumulates as a basket of whatever assets the trading was denominated in, and at the end of each auction period, currently four weeks long, that basket is sold in an ascending open auction in which bids may only be placed in the native asset. The highest bidder receives the basket and the winning bid is destroyed outright, so activity on the chain translates continuously into removal of supply. Applications beyond the order book, and holders acting on their own account, may add assets to the basket as well.

The network issues a fixed proportion of the supply of its native asset each year, on the order of five percent, and divides it: roughly nine-tenths is paid to the validators of each epoch and the remaining tenth goes to a protocol treasury. Epoch rewards are proportional to the seats an account holds, and they are conditional on work actually performed. A validator that produces fewer than the required proportion of the blocks or chunks it was assigned earns nothing for that epoch and is removed from the set for the following one, with re-entry taking a further two epochs. Holders who do not want to operate infrastructure can delegate to a staking pool contract, which pools their stake behind an operator and passes back rewards net of that operator's commission.

Penalties deserve to be stated precisely. The protocol specifies a design under which stake could be confiscated for provable misbehavior, but that mechanism is not switched on. What actually operates is economic exclusion: forfeited rewards, ejection from the validator set, and the delay before an ejected account can return. Stake itself is not taken.

Execution is paid for in gas. Unlike an auction-priced fee market, the cost of each operation is fixed in protocol configuration, and the gas price moves only gradually in response to how full recent blocks have been, so costs stay predictable and do not spike sharply with congestion. Gas spent is destroyed rather than handed to validators, who are paid from issuance instead. Historically three-tenths of the gas burned by a contract call was credited to the account of the contract being called, a rebate meant to fund contract authors; network governance has voted to set that share to zero so the entire amount is burned.

State is charged for separately through storage staking. An account must keep an amount of the native asset locked in proportion to the bytes it occupies, in the region of one unit per hundred kilobytes, and the lock is released when the data is deleted, so there is no recurring rent. Access keys and meta-transactions additionally let one party cover another's gas.

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.

Block production at this layer is not contested, so there is no staking for the right to propose, no delegation to block producers, and no issuance of new units as a block subsidy. What the network's incentive design has to fund instead is the operator that sequences transactions, the parties that post batches and availability certificates, and the parties willing to watch the chain's published assertions and contest a wrong one.

Fees are paid in the network's own native asset rather than in ether, which is unusual among chains built on this stack and required changes to the bridge and dispute contracts so they escrow and account for a token instead of the settlement chain's currency. A user's fee has two parts. One prices computation and state access on the Layer 2, using a base fee that rises as blocks fill and falls when they empty, so congestion is rationed by price rather than by queueing. The other recovers what the network spends posting batch data and availability certificates to Ethereum, charged in proportion to the bytes a transaction contributes; because certificates rather than full transaction data go to Ethereum, this component is markedly smaller than it would be for a chain publishing everything to the settlement layer. Collected fees accumulate in on-chain accounts that the chain's owner directs toward the operators posting downstream and toward network upkeep.

Penalties are attached to the dispute game rather than to block production. A party posting an assertion about the chain's state must lock a bond, and so must a party challenging one; whoever loses the dispute forfeits that bond to a designated recipient. Misconduct is therefore punished economically at the point where it matters, which is the claim about state that the settlement contracts will act upon, and there is no separate slashing mechanism operating against a validator set, since this layer does not have one.

Validators are paid once per era out of newly issued units of the network's native asset. Payment follows era points, awarded for authoring relay chain blocks and for validation work performed on parachain candidates, so a validator with a larger bond does not automatically out-earn a diligent smaller one. Each validator first takes the commission it advertises; the remainder is shared between its own bonded stake and the stake nominators placed behind it, in the proportions the era's election assigned. Nomination pools let smaller holders combine bonds and back validators collectively. Rewards are claimed rather than pushed out, and unclaimed payouts expire after a set number of eras.

Penalties distinguish serious faults from ordinary unreliability. Equivocation — authoring or voting for two conflicting things in the same slot or round — and backing a parachain candidate that proves invalid are slashable, and the slashed fraction rises with the number of validators committing the same offense in the same window, so an isolated fault costs far less than a coordinated one. Nominators behind a slashed validator forfeit a matching share of their bond. Downtime alone is not slashed; a persistently unresponsive validator is dropped from the active set and stops earning until it is restored. Bonded funds released by a validator or nominator sit through an unbonding delay before they can be moved and stay exposed to slashing for offenses committed beforehand. These staking parameters are governance-controlled and have been revised more than once.

Users pay a weight-based fee. Every call carries a weight expressing the execution time and storage access it is expected to need, and the charge is a fixed base amount, plus an amount for the encoded length of the transaction, plus an amount derived from that weight; an optional tip buys queue priority. A multiplier tracks how full recent blocks have been and moves the weight-to-fee conversion up or down between blocks within a bounded range, so sustained congestion raises costs gradually instead of spiking. Roughly four fifths of the inclusion fee is directed to the on-chain treasury and the remainder to the block author. Storing data on chain requires refundable deposits returned when the data is released. Blockspace itself is no longer won at auction: a chain buys coretime, either as a bulk region covering a fixed span or on demand for a single block, and the native asset spent on it is burned.

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.

Validators and their delegators are the paid participants. Voting power derives from bonded stake, and holders who do not run infrastructure may delegate to an operator and share in its rewards net of a commission the operator sets. Stake taken out of bonding is locked for twenty-one days before it becomes transferable and earns nothing across that window; stake moved directly from one operator to another skips the wait, though the receiving operator is then barred from passing it on again for the same period, and an account may keep only a limited number of such moves open at once. Reward flow comes from transaction fees and from scheduled releases of units set aside at genesis rather than from open-ended issuance.

The penalty design departs from the Cosmos SDK default and is easily misstated. Bonded stake is not confiscated. A validator that goes offline or misbehaves is jailed — removed from the active set and cut off from rewards — but neither its own stake nor its delegators' stake is reduced. Security therefore rests on exclusion from future revenue and on the operational standing of the set rather than on a direct economic forfeit. The redesigned consensus layer under development would introduce a punishable offense for signing conflicting proposals at the same height, which would change this position once it is active.

Users pay in gas, denominated in the network's native asset. Ethereum's typed fee transactions are accepted, but no portion of the fee is burned: base and priority components alike accrue to validators and flow through to their delegators, so activity redistributes value rather than retiring supply. A minimum acceptable gas price is a governance parameter rather than a constant fixed in the client. Execution follows the Ethereum gas schedule with deliberate divergences, most notably a substantially higher charge for writing to persistent storage, which is itself an on-chain parameter and can be retuned by governance without a chain upgrade. There is no recurring storage rent: state paid for when it is written persists without further charge.

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

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

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

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

Validators are paid for sealing epochs and for the transactions they order. For the network's early years the reward pool is not fresh issuance but a carried forward allocation redirected from the predecessor chain, which the staking contract pays out per sealed epoch; the target rate is tied to how much of the supply is bonded, falling as more is staked and rising as less is, so the yield tracks the security actually being purchased rather than a fixed schedule. Rewards accumulate in the contract and are claimed rather than credited automatically.

Holders who do not run infrastructure delegate to an operator. Delegation adds to the operator's consensus weight and to its reward entitlement, and the delegator receives the corresponding share less a commission the operator keeps. Each operator can accept only a fixed multiple of its own self bond in delegations, which limits how much weight a single operator can gather. Unbonding a delegation is not immediate: withdrawals enter a waiting period of about two weeks before the balance is released, so stake cannot be pulled out ahead of a penalty.

Penalties act on the bond. An operator found to have acted maliciously, for instance by signing conflicting events, has its stake reduced by the staking contract, and the delegations behind it are reduced in proportion, which is paid out of what delegators receive when they withdraw. Persistent unavailability is not confiscatory but earns nothing for the periods missed.

The fee a user pays is gas metered in the native asset, priced by demand for block space, with contract calls charged in proportion to the work they cause and no recurring charge for data already stored. What happens to that fee is unusual. Applications may register their contracts to receive a share of the fees their own usage generates, which can reach the large majority of the fee, with a further share going to validators and the balance destroyed. The proportions are governance controlled and have been revised since launch, and the accounting attributes gas consumed in nested calls so that shares cannot be double counted.

Users pay a single fee that covers three distinct costs, and understanding the split explains why this network's economics differ from those of a standalone chain. The first is execution: contracts are metered in computational steps and in calls to specialized built-in operations, and the submitter pays for the resources their transaction consumes. The second is the cost of publishing data to the settlement layer so that anyone can reconstruct the rollup's state, which is passed through at whatever the settlement layer charges for the dedicated data space it makes available, and which therefore moves with conditions on a network this one does not control. The third is the cost of producing and verifying the validity proof.

That third component behaves in a way with no equivalent on a monolithic chain. A proof covers a whole batch, and the cost of generating it and having it verified is amortized across every transaction inside that batch, so the per-transaction share falls as the batch fills. Periods of heavy use are therefore cheaper per transaction than quiet ones, which inverts the usual relationship between congestion and cost for this part of the fee. Fees may be paid in the network's native asset or in ether.

On the incentive side, validators lock the native asset and delegators may assign their holdings to a validator without running infrastructure, sharing in rewards after the validator's commission. Rewards are funded by protocol issuance. Eligibility is conditioned on performance: attestation makes it observable whether a validator is doing the work, and a validator that fails to attest does not earn for that period. The published design penalizes absence by withholding rewards, and this text does not assert any confiscatory penalty on locked principal, as the parameters governing that are still being settled alongside the remaining decentralization stages. Sequencer and prover operation is currently funded by the operating organization rather than by an open market in those roles.

Stellar pays nobody for running the network. There are no block rewards, no staking rewards and no protocol-level payment to validators of any kind, and the inflation mechanism that once distributed new units of the native asset was switched off by validator vote in 2019 and has not been replaced. Transaction fees are not routed to whichever node closed the ledger; they accumulate in a network-wide fee pool that is not redistributed to anyone. The incentive to operate a validator is therefore indirect and institutional: the businesses that run them, payment providers, asset issuers, custodians and infrastructure operators, depend on the ledger continuing to close and on its trust graph remaining diverse, so they carry the cost themselves. The consequence is that participation is sustained by who chooses to show up rather than by a yield, which concentrates responsibility on a comparatively small set of organizations.

Fees are charged per operation rather than per transaction, so a transaction bundling several operations pays a multiple of the per-operation rate. The network minimum is one hundred stroops, a hundred-thousandth of a unit of the native asset, and validators can vote to change that floor. When more operations are submitted than a ledger can hold, surge pricing turns inclusion into an auction: a submitter states the maximum it will pay per operation, competing transactions are ranked, and those included are charged the lowest amount that would still have secured a place rather than the maximum bid, with the rest of the offered fee not taken.

Ledger space is rationed by reserves rather than rent. An account must hold a minimum balance of two base reserves, and each subentry it adds, a trustline for an issued asset, an offer on the order book, an extra signer or a data entry, raises that minimum by a further reserve. Reserved balance is locked rather than destroyed and is released when the subentry is removed, and one account can sponsor another's reserves. Smart contracts, added to the network in 2024, are priced separately: a resource fee meters processor instructions, ledger reads and writes and bandwidth, part of it refunded for resources not consumed, and contract state carries a time-to-live that must be extended by paying rent or the entry is archived and must be restored before use.

Stake is bonded by wrapping the native asset in a stake object delegated to a validator's pool; the holder keeps custody of that object and the pool's exchange rate appreciates as rewards accrue, so redeeming it later returns principal plus accumulated reward net of the validator's commission. Rewards are settled at epoch boundaries and come from the computation fees collected during the epoch together with issuance intended to support the validator set in the network's early years. Stake counts toward rewards only for epochs it was active throughout.

Penalties bite on reward, not on principal. Validators grade each other over the epoch, and if holders of more than two thirds of voting power report a given validator for poor operation, that validator's rewards for the epoch are reduced or removed entirely, and the holders who delegated to it forfeit their reward for that epoch as well. The bonded principal itself is not destroyed. A validator whose stake falls below the threshold for committee membership simply leaves the committee. The same reward multiplier enforces the fee market: at the start of each epoch validators submit the lowest price at which they will process transactions, the reference price for the epoch is the stake-weighted two-thirds percentile of those quotes, and validators that quote a low price and then honor it are rewarded relative to those that do not.

Users pay two components. Computation is metered in units placed into coarse buckets, so similar transactions cost the same and developers are not pushed into micro-optimization, and the bucket is priced at the epoch's reference rate. Storage is charged per byte at a price fixed by governance rather than set by congestion, and the amount paid is routed into a storage fund instead of to the validators of the day. Deleting data returns almost all of the storage charge as a rebate, so a transaction that frees more state than it occupies can settle at a net credit. The storage fund is the unusual element: it is counted alongside user stake when rewards are computed, most of the return it earns is paid to whichever validators are currently storing historical data, the remainder is reinvested, and its principal is never paid out, so it cannot be drained by the validators it compensates.

Producers on TRON are paid from two streams of newly issued units. A fixed amount is awarded for each block to the representative that produced it, and a larger per-block amount is divided among the wider set of elected and standby representatives in proportion to the votes each received. Each representative publishes the proportion of its receipts that it passes back to those who voted for it, so what a participant earns depends on which representative is backed. Registering as a candidate requires a deposit that is destroyed rather than held, which discourages frivolous entry. There is no slashing: a representative that produces poorly is not deprived of locked funds but loses votes, and with them its place in the producing set and its share of both streams.

Users do not pay a per-transaction price in the usual sense. The protocol meters two resources. Bandwidth covers the byte size of a transaction and energy covers computation performed by the virtual machine. Each has a fixed network-wide daily ceiling, and locking up the native asset entitles an account to a share of that ceiling proportional to its share of everything locked for the same resource, so an allowance changes as others lock and unlock even when the account itself does nothing. Every account also receives a small free bandwidth allowance that regenerates daily. Under the staking arrangement introduced in 2023 and generally known as the second version, locking up is separated from resource assignment: resources obtained by locking can be delegated to other addresses and reclaimed without unlocking, which is what makes third-party resource provision practical. Recovering the locked balance itself requires a waiting period of fourteen days.

When an account attempts an operation without sufficient resources, the protocol burns the native asset at unit prices set by governance, one per byte of bandwidth and one per unit of energy, both of which have been revised upward in recent parameter changes. That burn is destroyed rather than paid to producers, so what users spend and what producers earn are separate flows. A further mechanism adjusts cost by contract rather than by congestion: a contract whose energy consumption passes a threshold within a cycle carries a multiplier on its energy cost in following cycles, decaying once consumption falls back, so calling a heavily used contract can cost several times what the same computation costs elsewhere.

Block production on the XDC Network is paid from a fixed issuance released at the close of each epoch and divided among the masternodes that were active in the committee for that epoch. The large majority of each share goes to the node operator and the remainder to a network treasury. Because the stake requirement for standing as a candidate is a fixed figure rather than a bid, posting more than the required amount does not increase the reward a node earns; what extra weight buys is a better position in the ranking and therefore a better chance of holding a committee seat. Holders who do not run infrastructure themselves can direct their weight to a candidate and receive a portion of what that candidate earns, which is the route by which participation extends beyond the operators.

Penalties are built around exclusion rather than confiscation. A masternode that signs no block across a complete epoch is marked as failing and is barred from producing blocks for several subsequent epochs, though it may continue verifying the work of others, and it earns nothing while the exclusion runs. Persistent underperformance removes a node from the active list altogether, at which point the committee proceeds with fewer members rather than waiting, and a standing candidate can take the vacant place. The design treats an outage as an operational failure to be priced in lost reward rather than a wrong to be punished by seizing the deposit; the deposit is exposed where misbehavior is demonstrably deliberate and the consensus record proves it.

The fee model changed materially with the network upgrade activated in January 2026, which brought the chain into line with the fee market used on comparable execution environments. Each block now carries a base charge per unit of gas that the protocol adjusts up or down according to how full recent blocks have been, and that base charge is destroyed rather than paid to the producer. A sender may add an optional tip, which does go to the producing masternode and determines priority when demand is heavy. Before this change every unit of the fee went to the producer at a fixed floor price, which has been raised in steps over the network's life. Fees remain low in absolute terms and are calculated from the computation and storage a transaction consumes.

No participant on the XRP Ledger receives a protocol payment for taking part in consensus. There is no block subsidy, no issuance of new units of the network's native asset, and no share of user charges routed to validators. Operators therefore run their servers entirely at their own cost, and their motivation is indirect: payment businesses, custodians, exchanges, universities and foundations that depend on the ledger settling correctly have a direct interest in its continued correctness, and running a validator gives them a voice in the parameter and amendment votes that shape it. Because nothing is bonded, there is correspondingly no slashing and no jailing. A validator that misbehaves is simply dropped from the rosters that reference it, and one that goes quiet is temporarily excluded from quorum accounting until it returns.

Users pay a transaction cost that nobody collects. The amount a transaction specifies is destroyed when that transaction is applied, permanently removing those units from circulation. The purpose is defensive rather than remunerative: because the cost falls on the sender and enriches no one, flooding the network with junk submissions is expensive and pointless. The minimum is set by a vote of the trusted validator set rather than by an auction, and it is kept deliberately small, but an individual server raises the price it is willing to accept as its own queue lengthens, so that under congestion the cheapest submissions wait while higher-paying ones proceed.

The second cost is not a charge but a lock. Each account must hold a minimum balance simply to exist, and that minimum rises for every additional object the account owns in the ledger state, such as offers, trust lines, escrows and issued token balances. This reserved amount is neither burned nor transferred; it stays the account's own property and becomes spendable again once the objects are removed. Its function is to make unbounded growth of stored state costly to the parties causing it, and its level is set by the same validator vote that fixes the base transaction cost.

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

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

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

USD Coin is present on the following networks: Algorand, Aptos Coin, Arbitrum, Avalanche, Base, Celo, Cronos, Ethereum, Hedera Hbar, Hyperliquid, Injective, Near Protocol, Optimism, Plume, Polkadot, Polygon, Sei, Solana, Sonic, Starknet, Stellar, Sui, Tron, Xdc Network, Ripple, Zksync.

The energy figure is assembled from the machines that actually run the network, rather than inferred from a mining market, which is the appropriate treatment for a pure proof-of-stake chain where no computational race takes place and producing a block costs nothing beyond keeping a node running. The starting point is the size and composition of the node population. The relay nodes that carry traffic and the participation nodes that hold registered keys and vote are counted from publicly visible network data, from peer discovery across the gossip layer, and from operator disclosures, and that count is handled as a plausible range rather than a single certain number.

A representative hardware profile is then assigned to that population. The published requirements for running the node software, covering processor class, memory, storage and network throughput, indicate the kind of machine an operator would realistically deploy, and the electrical draw of such machines is taken from controlled bench measurement of comparable equipment at load and at rest rather than from manufacturer nameplate ratings. Annual consumption is the aggregate across the estimated node set with idle draw included, because a participation node draws power continuously whether or not sortition selects it in any given round. Where a specific asset issued on the network is being reported rather than the network as a whole, a share of the network total is attributed to that asset from observed on-chain transfer volumes.

The limits of the approach deserve stating plainly. The node count and the hardware mix are estimates built from public observation and stated software requirements, not metered readings taken from the machines themselves. Virtualized and cloud-hosted nodes cannot be cleanly separated from dedicated hardware, and an operator running several logical nodes on one physical host is not always distinguishable from several operators. Where evidence is thin, the assumption selected is the one more likely to overstate consumption than to understate it, so the result should be read as a conservative upper estimate rather than a precise measurement. Figures are revised as observation of the network improves and as consensus changes alter what a node is required to store, verify and transmit.

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

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

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

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

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

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

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.

The energy figure for this network is assembled from the layers its operation actually spans, because it no longer runs a consensus of its own. The first layer is the infrastructure the network operates directly: the sequencer that orders and executes transactions, the software that batches transaction data and submits it to the external availability service, the component that proposes state roots to the settlement chain, and the population of full nodes and public endpoint servers that serve reads and relay user transactions. The size of that population is estimated from public network information, from crawlers that walk the peer-to-peer layer, and from the operator set recorded on chain. A representative machine specification is inferred from the published requirements for running the client software, and a power draw is attached to that specification from laboratory measurement of comparable equipment, counting idle consumption as well as consumption under load.

The second layer is the share of Ethereum's consumption attributable to what this network posts there. Ethereum is the settlement chain, so the commitments, state-root proposals and any dispute traffic submitted to it occupy a slice of that chain's validator capacity, and that slice is apportioned according to the footprint those submissions take up. Because the bulk of transaction data is sent to a separate availability layer instead, the operator set of that layer is treated as a third component and estimated on the same per-node basis. Dispute resolution depends on generating succinct cryptographic proofs, and proof generation is itself a compute cost, so it is counted where it arises rather than assumed away.

The limits of this are worth stating plainly. Node counts and hardware mixes are inferences drawn from observable network behavior and from stated software requirements, not metered readings taken from the machines. Where evidence is thin, the assumption chosen is the one more likely to overstate consumption than understate it. Figures are revised as observation improves, and the architecture described here is itself recent, so earlier periods rest on a different operating model.

Consumption is estimated from the machines that run the network, which is the appropriate model for a Byzantine-fault-tolerant chain where producing a block costs no more energy than taking part in the protocol already requires. The starting point is the node population, and this network is unusual in one helpful respect: the set of block-producing validators is permissioned and therefore directly enumerable from chain state and public operator disclosures, which removes one of the larger uncertainties that affects open networks. Around that core sit the full nodes, archive nodes and public endpoint infrastructure anyone may operate, and that wider population is approximated using network crawlers and publicly available listings.

A representative hardware profile is inferred from the specifications the client software states for running a node that can keep pace with the chain, and the power draw of machines matching that profile is taken from laboratory measurement, capturing loaded and idle operation alike. The network total is the aggregate of that draw across the estimated population over the reporting period.

Two boundary decisions shape the result and are worth stating plainly. First, the estimate covers this chain's own infrastructure only. Its blocks are proposed, voted on and finalized by its own validator set, so no share of another network's consumption is attributed to it — not a settlement layer, since none is used, and not a hub or relay chain, since the links to other Cosmos SDK networks carry messages rather than security. Second, where an asset is issued on several networks, the portion attributed to each is derived from observed on-chain transfer volumes rather than divided evenly.

The customary caveats apply. Node counts outside the validator set, and the hardware mix throughout, are inferences from public observation and stated software specifications rather than readings taken from the machines, and operators need not disclose their configurations. Where evidence is missing the assumptions adopted sit at the cautious end and are likelier to overstate consumption than understate it, and figures are restated as observation improves or as the client's specifications change.

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 energy figure for Hedera is built up from the machines that run the network rather than read from a meter. The method establishes how many nodes are operating, infers what hardware sits behind each of them, attaches a measured power draw to that hardware and aggregates across the node set for the reporting period. Nothing in this network's design ties electricity expenditure to reward, so the profitability reasoning used to model proof-of-work mining fleets has no counterpart here and is not applied.

The node count is unusually well constrained. Consensus node operation is permissioned and the roster of operators forms part of the network's own published address book, so the population performing consensus can be enumerated directly rather than approximated from crawler observations of an open peer-to-peer network. That removes the single largest source of error in this family of estimates. What remains uncertain is the configuration behind each entry: operators publish little about their individual deployments, and one address book entry may in practice be a redundant cluster rather than a single machine. The hardware assumption is therefore taken from the specification the node software is documented to require, covering processor class, memory, storage and network capacity, and per-device consumption comes from laboratory measurement of comparable equipment. Consumption is counted continuously, including the idle draw of machines that must remain available whether or not transactions arrive, and the separate population of archival query nodes is treated explicitly rather than left ambiguous.

The result remains an estimate. Hardware profiles, utilization and the treatment of redundancy are inferred rather than observed, and where evidence is thin the assumption chosen is the one that raises the figure rather than lowers it, so the published number should be read as a conservative ceiling and is revised as observation improves.

The figure reported for this network is an estimate built from the machines that operate it, not a metered reading. It starts from the population of participating nodes and works upward from the draw attributable to each.

Establishing that population is more tractable here than on most networks, because the set of validators taking part in consensus is small, identified on-chain and recomputed at each staking epoch, so its size and membership can be read from publicly observable network data rather than inferred. Counting only that set would understate the total, however. The chain is also served by non-validating nodes that follow consensus, keep a copy of state and answer the queries that applications and market participants make of it, and by the infrastructure that distributes order book and market data. These are estimated from peer discovery and from publicly available operator information, collected by automated crawling.

The second input is what a single machine draws. A representative hardware profile is inferred from the resources the node software states it requires, and per-device power is attributed from laboratory measurement of equipment matching that profile. Two features of this network push that profile upward relative to a general-purpose chain: consensus targets sub-second commitment, and the state machine continuously matches orders, so participants run high-specification servers in professionally operated facilities and keep them running constantly. Draw is therefore counted on a continuous basis, idle periods included, and multiplied across the estimated population.

The limitations should be stated plainly. The hardware mix is inferred from stated requirements rather than surveyed, and the count of supporting non-consensus infrastructure is the least observable part of the estimate. Because the consensus set is small, the total is sensitive to the per-machine assumption in a way that a large network's total is not: an error in the assumed profile is not diluted across thousands of nodes. Where evidence is thin, assumptions are chosen so that the impact is more likely to be overstated than understated, and figures are revised as observation improves.

The consumption figure for this network is estimated from the machines that operate it rather than metered directly. The first step is to establish the size of the machine population: the forty-five validators in the active set, bonded operators waiting outside it, and the full, archive, and indexing nodes that back explorers, trading front-ends, market-making infrastructure, and the relayers linking this chain to others. Node counts are approximated from peer discovery on the public network, from what operators publish about their deployments, and from the chain's own on-chain record of bonded operators.

A hardware profile is then assigned. The client software states the processor, memory, disk, and bandwidth needed to stay in sync, and a machine meeting those requirements represents the node. The requirements here sit toward the heavier end for this family of chains for three reasons: blocks are produced at sub-second intervals, so a node's duty cycle is high; order matching and settlement run inside block processing rather than in a contract; and since late 2025 each node has also executed an Ethereum virtual machine alongside the existing WebAssembly runtime, with both sharing one state. Power draw for the representative machine is taken from controlled measurement of comparable equipment across its load range, including idle draw, because these nodes are powered continuously. Draw multiplied by the estimated population across the reporting period yields the network total, from which a per-asset share is apportioned using observed on-chain activity.

Two qualifications belong here. The population and the hardware mix are inferences from public observation and published requirements, not from operator disclosure; several operators may share a facility, and rented virtual capacity is hard to distinguish from dedicated machines. Where evidence is absent, the assumption applied is the one that raises the estimate, so the figure is likelier to overstate the impact than understate it. A correction also applies to earlier assessments, which attributed to this network a proportion of a neighboring chain's consumption on the basis of shared security. This chain has always been secured by its own validator set and its own bonded stake, and the estimate covers only its own infrastructure.

The figure reported for this network is an estimate assembled from the infrastructure that runs it, not a metered reading. It works upward from the population of machines taking part, and from what each of those machines can be expected to draw.

The first input is the size and composition of that population. It is estimated from publicly observable network data, including peer discovery, the published validator set and its per-epoch duty assignments, and open directories of operators, gathered by automated collection of the same information. For a sharded network this matters more than a headline count, because duties are divided between block producers, the producers of each shard's chunks, and the chunk validators that verify them; the estimate has to cover all of those roles rather than only the accounts holding seats. Machines that take no part in consensus but that the network needs in order to be usable, such as archival nodes and query-serving infrastructure, are included as well.

The second input is consumption per machine. A representative hardware profile is inferred from the resources the client software states it requires, covering processor cores, memory, disk and bandwidth, and power draw is attributed from laboratory measurement of devices matching that profile. Draw is counted continuously, including the large idle component, since a validator has to stay online whether or not it currently holds an assignment. Multiplying the per-device figure across the estimated population produces the network total.

The limits should be read plainly. Both the population and the hardware mix are inferences drawn from public observation and from stated software requirements; operators are not surveyed and meters are not read. Where the evidence runs out, the assumption chosen is the one that makes the impact look larger rather than smaller, so the resulting figure is more likely to overstate than understate. Stateless validation also changes the profile over time, since verifying a shard no longer requires storing it, and the estimate is revised as observation of the network improves and as the shard count changes.

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.

The estimate is assembled from the machines that run the network rather than from a protocol abstraction, and it has two parts because this is a Layer 2.

The first part is the network's own infrastructure: the sequencer, which orders and executes what users submit; the components that batch and post data; the party that publishes state assertions to Ethereum and any parties standing ready to contest them; the servers run by the committee that holds batch data and serves it on request; and the full and archive machines that outside parties keep running to answer queries and track the chain for themselves. That population is sized from what can be observed, through network crawlers, reachable peers, published endpoints, and operator disclosures. A representative machine specification is inferred from the requirements the client software states for each role, per-device power draw is taken from measurement of comparable hardware under load and at rest, and summing over the estimated population produces the total, with idle draw included, since these machines consume power continuously rather than only while transactions arrive. This is not a validity rollup, so no proof generation runs continuously; the dispute machinery consumes meaningfully only while a challenge is actually being worked through.

The second part is the share of Ethereum attributable to this network, covering the validator infrastructure that carries the certificates and state assertions posted there. It is allocated in proportion to what this chain posts relative to Ethereum's total load, sized from observed on-chain activity data. That is a proportional attribution rather than a measurement of energy caused at the margin.

The caveats belong with the figure. Node counts and hardware profiles are inferred from public observation and stated software requirements, so unreachable or unannounced machines go uncounted and the real mix of hardware is more varied than one representative specification implies. Where evidence is missing, assumptions are chosen toward the higher end, making the result likelier to overstate the impact than to understate it. Estimates are revised as observation improves and as the chain's own architecture changes, which for this network it has since launch.

The figure is assembled from the machines that actually keep the network running, not from any price or revenue signal. Polkadot's consensus rewards no computational effort, so there is no mining hardware to model; what draws electricity is the population of relay chain validators together with the collator and full node infrastructure of the chains that share its security. Sizing that population comes first. Validator counts are read directly from on-chain state, while the wider node population is estimated from network crawlers and publicly visible peer data, producing a reachable-node count that is then adjusted upward for nodes that do not advertise themselves.

A representative hardware profile is inferred for each class of participant from the reference specification the client software asks operators to meet — processor class, memory, and storage type — on the reasoning that operators provision close to what the client demands and rarely far beyond it. Power draw for those device classes is taken from controlled bench measurement rather than from manufacturer nameplate ratings, and the measurement covers idle draw as well as draw under load, since a validator spends much of each slot waiting rather than executing. Total consumption is the aggregate over the estimated node set at those measured rates across the reporting period.

Because the relay chain provides security to the chains connected to it, the line between one chain's consumption and another's is an attribution question rather than a measurement one. A connected chain's figure is its own collator and node infrastructure plus a share of the relay chain validator set, apportioned by the relay chain resources that chain consumes. Where an asset exists on more than one network, the network totals are combined according to observed on-chain transfer activity for that asset.

None of this is metering. The node count, the hardware mix and the utilization rate are inferred from public observation and from stated software requirements, and each is an estimate carrying its own error. Where the evidence is thin, the assumption selected is the one producing the higher number, so the result is more likely to overstate the footprint than to understate it. Figures are revised as crawler coverage and hardware measurement improve, and successive reporting periods are therefore not always directly comparable.

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.

The estimate is constructed from the machines that run the network rather than from a metered reading, which is the correct treatment for a stake-weighted Byzantine-fault-tolerant chain where block production is not a contest of computational work. The first step is sizing the node population: the validator set is enumerated from public chain state, and the surrounding population of full, archive and public endpoint nodes is approximated using network crawlers together with publicly listed infrastructure. A representative hardware profile is then inferred from the specifications the client software states for a node able to keep pace with the chain, which on this network are demanding by the standards of the family, since sub-second block cadence and parallel execution push more work onto each machine. Per-device power draw comes from laboratory measurement taken under load and at rest, and the network total is that draw aggregated across the estimated population over the reporting period, idle hours included.

Two features of the network's current shape bear on the boundary. The consolidation onto a single Ethereum-style execution surface removes the question of whether a second environment should be counted separately; there is one node population and it is counted once. And because the chain finalizes its own blocks rather than posting to a settlement layer, no share of another network's consumption is attributed to it.

The limits are worth stating. Node counts and the hardware mix are inferences from public observation and from stated software specifications, not measurements taken from the machines, and operators are not obliged to publish their configurations. A network in the middle of a staged architectural change is a moving target, so the hardware profile in particular is revisited as client releases alter what a node must do. Where evidence is missing the assumptions adopted sit at the cautious end, making the result likelier to overstate consumption than understate it. Where an asset is issued on more than one network, the share attributed to each is derived from observed on-chain transfer volumes.

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

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

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

The reported consumption is a modeled figure rather than a metered one, built from the population of machines that keep the network running. That population is estimated from network crawlers, peer discovery traffic and operator information published in public sources. Counting nodes is the right unit for this consensus family: in a stake weighted asynchronous Byzantine fault tolerant design, participating means receiving gossip, verifying signatures, executing transactions and maintaining state, which is conventional server work. Nothing in the protocol rewards spending more electricity than the next participant, so there is no mining hardware to infer and no hash rate to translate into equipment.

Hardware is inferred from what the client software requires. Published processor, memory and storage specifications are matched to commercially available server configurations capable of meeting them, and the power draw of those configurations is taken from laboratory measurement under load and at rest. This network's node software distinguishes validating nodes from archival nodes that retain the full history, and the two have appreciably different storage and memory footprints, so the estimated mix between them affects the result. The network total aggregates the modeled draw across the estimated set for the reporting period, including idle time, since a node that is synchronized but momentarily idle still consumes power.

The limits of the method should be read alongside the number. Both the node count and the hardware mix are inferences from public observation and from stated requirements, not an inventory, and operators running on shared or virtualized infrastructure are not distinguishable from those on dedicated machines. Where evidence is missing the assumptions used are the ones more likely to overstate consumption than to understate it, and estimates are revised as observation improves. A further complication here is that consensus and client efficiency have changed since launch, so a figure computed for an earlier period reflects a heavier per node profile than the software now demands.

A rollup's energy accounting has two parts, and reporting only one of them would misstate the result. The first part is the infrastructure this network runs itself: the sequencer nodes that order and execute transactions, the full nodes that follow and serve the chain, and the proving infrastructure. Proving deserves separate treatment because it is unlike anything in a conventional validator set. Generating a succinct proof of a batch is a heavy, sustained computation run on specialized hardware in a small number of facilities, and it recurs for every batch, so it is a continuous load rather than an occasional one. Because that work is concentrated in few locations operated by one organization rather than spread across an anonymous population, the count of machines involved is a far smaller and better-characterized number than a node crawl would produce, though the specification of that hardware is not publicly detailed and has to be approximated from the class of equipment such workloads require.

The second part is the share of the settlement layer attributable to this network. Ethereum's own consumption is estimated from its validator population, and a portion is assigned here in proportion to the settlement resources this network consumes — the data space it occupies and the verification it triggers — measured against the total those resources represent. The settlement layer publishes its own account of its energy profile at ethereum.org.

Where data availability sits matters to the boundary and is stated rather than assumed: this network publishes its data to the settlement layer, so the storage and bandwidth burden of keeping that data retrievable falls inside the settlement share rather than on a separate network. The usual caveats apply and are sharper here. The operator-run portion is not independently observable, so its estimate rests on the class of hardware such work requires rather than on a measured inventory. Where evidence is thin, conservative assumptions are used that are more likely to overstate than understate, and figures are revised as the network's operation opens up and more of it becomes externally measurable.

The estimate is built up from the machines that operate the network, which suits a design where consensus is reached by exchanging votes rather than by expending computation, and where no participant gains anything by adding hardware. The population to be counted is comparatively small and unusually legible: validators name each other in published quorum sets, and operators are expected to publish organizational and node information at well-known locations, so the consensus-relevant set can largely be enumerated from the network's own configuration instead of being inferred statistically. Around that core sit watcher nodes that follow the ledger without voting, and the object storage that serves history archives for nodes catching up.

Hardware is inferred from the stated operating requirements of the core software, which specify processor, memory, disk and bandwidth, and the power draw of machines meeting those specifications is taken from controlled bench measurement at load and at rest rather than from vendor ratings. Consumption is aggregated across the estimated population with idle draw included, because a validator runs continuously whether or not the network is busy. A share of the network total is attributed to a particular asset issued on the ledger, when one is being reported rather than the network itself, using observed on-chain transfer volumes.

Several caveats apply. The enumeration captures validating nodes well but non-validating infrastructure poorly, and history archives are served from object storage whose energy use belongs to a storage provider and is difficult to apportion; archive bandwidth is the largest and most variable element of an operator's cost, and it is estimated rather than observed. Nodes are overwhelmingly cloud-hosted, so a logical node cannot reliably be mapped to a physical machine, and protocol changes that raise in-memory state requirements or enable parallel execution alter the hardware profile an operator must provision. The population and hardware mix are estimates assembled from public observation and published requirements, not metered readings; where evidence is missing the assumption chosen is the one more likely to overstate consumption than understate it; and figures are revised as observation improves.

The estimate starts from the machines that operate the network and works upward. Its first input is the population of nodes, separated into the validators that form the committee, which is recorded on chain and therefore countable rather than guessed, and the far larger and less visible set of full nodes that replicate state, index it and serve application traffic. The size of that second group is inferred from network crawlers and publicly reachable peer information, and is the main source of uncertainty in the count.

Each group is matched to a hardware profile derived from the resources the node software is documented to need. Validators here are expected to execute transactions in parallel across cores and to maintain the object store and its indexes, so their profiles assume multi-core server hardware with generous memory and fast solid-state storage rather than modest equipment. Power draw for each profile is taken from bench measurement of comparable devices under load and at rest, and idle draw is counted, because a node is expected to remain available continuously whether or not transactions are arriving. Multiplying draw by the estimated population across the hours of the period gives consumption for the network. Where a share of that total is attributed to an individual asset issued on the network, that share is based on the asset's observed proportion of on-chain transfer activity.

The limits of the method should be read alongside the result. Node counts outside the committee rest on what is observable from the public network, and operators need not be observable; hardware is inferred from documented requirements rather than collected from operators; and the overhead of cooling and power conversion in hosting facilities is approximated from typical factors rather than metered. Where the evidence does not resolve a question, the assumption chosen is the one that tends to raise rather than lower the reported figure, and estimates are revised as observation improves and as protocol changes alter what a node must do.

The consumption figure reported for this network is estimated from the machines that operate it. A delegated proof-of-stake chain does not expend energy as part of reaching agreement, so there is no work-based quantity to model as there is for mining networks; what consumes electricity is a population of continuously running servers, and estimating that population is the whole of the exercise.

The estimation approach used here starts from the participants the chain itself identifies. Registered producer candidates are visible on chain, as is their ranking, which separates the twenty-seven producing during a cycle from the standby tier and the wider candidate list. Around that core sits a larger population of full nodes, relay nodes and the query-serving infrastructure that applications and wallets depend on, which is estimated from publicly available network data and from scanning for reachable endpoints. A representative machine is then inferred for each part of the population, taking the published operating requirements of the node software as the primary input. Those requirements are demanding relative to many networks, reflecting a three-second block interval, a high sustained transaction rate and a large accumulated state that nodes must keep available. Electrical draw for machines of that class is taken from controlled bench measurement rather than from specification sheets, and includes the draw of a machine that is powered and connected but idle, which for always-on infrastructure is a large part of the annual figure. The total is the sum across the estimated population.

Where a figure is needed for one asset issued on the chain rather than for the chain as a whole, a share of the network total is attributed to it in proportion to observed on-chain activity involving that asset. This matters on a network carrying a high volume of token transfers relative to its other traffic.

The limits are inherent to the method. Node counts and hardware profiles are inferred from public observation and stated requirements, not metered; operators commonly run hardware above the published minimum; and endpoints that do not respond to scanning are not counted. Where evidence is thin, assumptions are chosen to be more likely to overstate impact than to understate it, and figures are revised as observation improves.

Consumption for this network is derived from the machines that run it. The network settles its own transactions and does not depend on another chain for ordering or data availability, so the estimate covers its own infrastructure alone. Three tiers of machine are relevant and are treated separately. Block-producing masternodes are directly enumerable, since candidacy and committee membership are recorded on the chain and the committee size is fixed by protocol. Candidates holding stake outside the active committee run equivalent infrastructure and are counted on the same basis, because a node that must be ready to take a seat must be running continuously. Non-staking machines that follow the chain and serve queries are estimated from network crawling and publicly listed infrastructure, since they are not registered anywhere on-chain.

Hardware for each tier is inferred from what the client software is documented to require, and the requirements for a producing node are materially higher than for an ordinary follower, which is why the tiers are modelled separately rather than averaged. Power draw for equipment matching each profile is taken from controlled bench measurement rather than from manufacturer ratings, and the draw of a machine that is powered up without an active workload is counted, since a staked node runs whether or not its turn to propose has come around. The per-machine figures multiplied across each estimated population over the reporting period give the annual total. Because influence here comes from a fixed stake rather than from computation, nothing in the design rewards deploying more processing power than the client needs.

The honest limits are these. Only the producing and candidate tiers are counted from an authoritative on-chain record; the follower population is an estimate from what is visible on the public network, and machines behind private infrastructure are not observable. Hardware is inferred from stated requirements, so operators running heavier equipment are not captured individually. Where evidence is incomplete, the assumption chosen produces the larger number rather than the smaller, and figures are revised as observation improves.

Energy use on the XRP Ledger is estimated from the machines that run it rather than read from a meter. The unit of analysis is the server: the approach counts how many are operating, decides what kind of hardware each is likely to be, attributes a power draw to that hardware and sums the result across the reporting period. Because this network has no mining, no hash race and no relationship between electricity spent and reward earned, the miner-economics reasoning used for proof-of-work networks has no counterpart here and is not applied.

The population count comes first. Servers that take part in consensus identify themselves publicly, announce their validation keys on the network and appear in openly maintained validator registries alongside the curated rosters that reference them, so the consensus-participating set is more directly observable than on a network where anonymous nodes join and leave at will. That visibility narrows the largest uncertainty in this family of estimates without eliminating it, since servers that merely follow the ledger without validating are harder to enumerate, and a single published identity may sit in front of several physical machines. The hardware assumption is drawn from the published system requirements for the ledger software, which state the processor class, memory, storage and bandwidth a server needs to keep pace with the network; per-device consumption is taken from laboratory measurement of representative equipment rather than from operator self-reporting. Idle draw is included, because a server consumes power continuously whether or not transactions are flowing through it.

These figures are estimates and should be read as such. The machine count, the hardware mix and the utilization level are inferred from public observation and from stated software requirements, not measured at the socket. Where the evidence is incomplete, the assumptions selected are those that push the result upward rather than downward, so the published number is better understood as a cautious ceiling than as a precise reading, and it is restated as observation improves. Attributing a share of the network total to an individual asset issued on the ledger uses observed on-chain transfer activity as the apportionment key.

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

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

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

USD Coin is present on the following networks: Algorand, Aptos Coin, Arbitrum, Avalanche, Base, Celo, Cronos, Ethereum, Hedera Hbar, Hyperliquid, Injective, Near Protocol, Optimism, Plume, Polkadot, Polygon, Sei, Solana, Sonic, Starknet, Stellar, Sui, Tron, Xdc Network, Ripple, Zksync.

Deriving a renewable share begins with where the machines are, because electricity is not the same commodity in every place. Node locations are inferred from publicly observable network data, including the addresses peers advertise to one another, autonomous system and hosting-provider registrations, and operator disclosures, and are resolved to a country or, where the evidence supports it, to a sub-national region. Hosted infrastructure complicates this: an advertised address identifies a data center rather than an owner, and since it is the data center that draws the electricity, hosting location is used in preference to any inferred nationality of the operator.

Coverage is never complete. Participation nodes that accept no inbound connections, and nodes sitting behind relays or proxies, are not directly observable. Where the geographic spread cannot be established from the network's own traffic, the distribution of a network with a comparable operating profile is used as a stand-in, chosen for similar participation requirements, similar reasons to run a node and similar hosting patterns, on the reasoning that operators facing similar conditions make similar siting choices. That substitution is a recognized source of uncertainty and is the main reason the renewable share is less robust than the consumption estimate it rests on.

The resulting location distribution is weighted by estimated consumption and matched to regional electricity statistics, so each portion of the network's power draw is assigned the generation mix of the grid that supplies it. The renewable proportion is the consumption-weighted average of those regional mixes, not a simple count of nodes by country. Grid statistics are annual averages and do not capture hourly variation, so a node drawing power overnight in a solar-heavy region is treated identically to one drawing at midday.

Energy intensity is reported as a marginal quantity: the additional electricity associated with one further transaction, given the current node set and the throughput the network is carrying. On a network whose nodes run continuously and whose consumption barely responds to load, that marginal quantity is small and falls as throughput rises, which is a property of the accounting convention rather than evidence of an efficiency gain. Regional generation mix is 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.

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

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

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

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

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

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

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

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 this network is derived geographically rather than measured at the socket. The first step is to locate the machines doing the work: the sequencing and proposing infrastructure, the full nodes and public endpoint servers, and the operators of the external data availability layer the network depends on. Locations are inferred from publicly observable network data, principally the addresses peers advertise and the hosting providers and regions those addresses resolve to. Coverage is never complete; operators sitting behind relays or content delivery networks cannot always be placed. Where a meaningful part of the population cannot be located directly, the geographic distribution of a network whose operator profile and hosting economics resemble this one is used as a stand-in, on the reasoning that similar incentives produce similar siting decisions.

Once a distribution of locations exists, each is matched to statistics for the electricity grid serving it, and the reported renewable share is the consumption-weighted average across those regional shares. The same procedure is applied to the portion of the settlement chain's operator base carrying this network's activity, so the figure reflects settlement as well as the network's own infrastructure. Regional generation mixes shift seasonally and from year to year, so the result moves with the underlying statistics even in periods when nothing about the network has changed.

Energy intensity carries a specific meaning here. It is the marginal energy attributable to one additional transaction, obtained by dividing estimated consumption over a reporting period by the transactions confirmed in that period. It is not a physical measurement of any individual transaction, and on infrastructure that draws power largely independently of how busy it is, the number is best read as an allocation of shared overhead: it falls as activity rises without any machine using less electricity. Regional generation data is 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 renewable share follows from where the network's machines physically sit. Node locations are inferred from publicly observable network data — the addresses peers advertise, the hosting ranges those addresses belong to, and operator disclosures already in the public domain — and each located node is assigned to the electricity grid serving its region. Those assignments are aggregated into a weighted view of the grids the infrastructure draws on, which is what the renewable calculation consumes.

This network's permissioned validator set helps here. Its block producers are a small number of named institutional operators whose hosting arrangements are comparatively well documented, so the portion of the estimate that matters most for the result rests on firmer ground than it would on a network with an anonymous and freely entered validator population. The surrounding unpermissioned nodes are a different matter: many sit behind hosting or privacy configurations that give no dependable indication of location. For the portion that cannot be resolved directly, the geographic spread of a structurally similar network is used as a stand-in, chosen for a comparable operator profile and a comparable cost of entry, and that substitution is itself a source of uncertainty.

Grid assignments are matched against published statistics on how electricity is generated region by region to yield the proportion drawn from renewable generation. Those statistics come 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.

Energy intensity is a distinct measure and does not represent a per-transaction share of the total. It is defined at the margin: the additional electricity drawn because one further transaction is processed, given infrastructure that is already running. Validators on this network commit blocks on a fixed cadence whether or not there is demand to fill them, so the marginal quantity is small beside the standing consumption and declines as throughput rises.

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 for Hedera begins with locating the machines. Consensus nodes are operated by named organizations listed in the network's published address book, and several of those operators disclose the regions or facilities in which they run, so a substantial part of the geographic picture is available directly rather than inferred. The remainder is resolved by the usual means: advertised network addresses are mapped to countries using publicly available network data, registry records and crawling of the peer-to-peer layer. Where some of the population still cannot be placed, the geographic distribution of a structurally similar network, meaning one whose participation rules and operating incentives resemble this one, stands in for the missing portion.

Located capacity is then matched to the electricity mix of the grid serving it. National generation statistics supply the proportion of electricity produced from renewable sources in each country, and weighting those proportions by the consumption estimated to sit in each country produces the renewable share for the network overall. Two limits follow from that construction. The share describes the grids on which the infrastructure happens to sit rather than any generation an operator has contracted for on its own account, and because the node set is small and concentrated in relatively few countries, the result is more sensitive to a single operator relocating or a single country's grid changing than it would be on a network of thousands of scattered machines.

Energy intensity is reported alongside the share and is a narrower quantity than an average. It is marginal: the additional electricity attributable to one further transaction, with the infrastructure held constant. On a network whose nodes run continuously irrespective of load, that marginal value is small and highly sensitive to the transaction count used as the denominator, so it can shift between reporting periods for reasons that have nothing to do with hardware. The grid statistics behind these calculations are taken from Share of electricity generated by renewables, compiled and processed by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy.

The renewable share attributed to this network follows from where its machines are located, not from any statement about the electricity its operators choose to buy. Locations are established from publicly observable network data: the addresses validators and other nodes announce to their peers, information operators publish about the infrastructure they run, and the hosting providers and data-center address ranges those addresses belong to, gathered by automated crawling of the peer network.

The picture that emerges here has a particular shape. The consensus set is small and professionally operated, and its members run in commercial data centers chosen for network latency to one another rather than for cheap power, which tends to concentrate them in a handful of well-connected regions. That concentration cuts both ways for the estimate: fewer sites make placement easier to observe, but it also means the renewable share is sensitive to a small number of hosting decisions, and a single operator moving facility can shift the network figure noticeably. Where placement cannot be resolved at all, because a node sits behind a relay or the provider does not disclose the site, the geographic distribution of a structurally similar network is used instead, chosen for comparable incentives and comparable validation duties.

Each location is then matched to the grid serving it, and the renewable proportion of that grid's generation is applied, weighted by the share of estimated consumption sitting in each region. The result is a consumption-weighted renewable share that moves when operators relocate and when the underlying generation mixes change.

Energy intensity is reported alongside it and has a narrow meaning: the marginal energy associated with one further transaction. On this network the distinction matters, because consumption is almost entirely the fixed cost of keeping validators running at capacity, while throughput can vary greatly with trading activity. The marginal figure therefore falls as activity rises and should not be read as an average per transaction. Grid statistics come from Share of electricity generated by renewables, compiled by Our World in Data with major processing from Ember and from the Energy Institute's Statistical Review of World Energy.

Establishing the renewable share reported for this network begins with locating its machines, since the generation mix behind a socket varies enormously between grids. Locations are inferred from publicly observable network data: the addresses nodes advertise to their peers, the hosting ranges those addresses sit in, and any information operators publish about their own facilities. The result is a distribution of the node population across countries and regions rather than a verified site for any individual machine. Where the distribution cannot be established with sufficient confidence, the observed distribution of a network with a comparable consensus design and comparable operator incentives is used as a substitute, the assumption being that similar economics tend to put infrastructure in similar places.

Each region is then matched to published statistics on how its electricity is generated, and the network's estimated consumption is weighted across the regions to give the proportion drawn from renewable sources. Those generation statistics come from Share of electricity generated by renewables, compiled by Our World in Data with major processing from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy.

Energy intensity is a marginal measure, not an average. It describes the extra energy the network draws when one further transaction is included, rather than total consumption divided by a transaction count. The gap between the two readings is wide on this chain. Its validators are powered continuously and commit blocks at a fixed sub-second cadence whether or not there is anything to process, so almost the whole draw is a standing cost, and a chain that produces many small blocks quickly will report a very different average from one that produces fewer large ones even where the marginal cost per transaction is comparable.

Geolocation is the least certain step. An address identifies a hosting provider rather than the customer behind it; nodes hosted in large commercial cloud regions are attributed to the advertised region and not to a specific building; and grid statistics are regional or national averages that disregard any supply arrangement a facility may have made for itself. Where a stand-in distribution is used, its representativeness is an assumption rather than an observation.

The renewable share attributed to this network is derived from where its machines sit, not from any claim about the electricity the network chooses to buy. The first step is to place the node population geographically. Locations are inferred from publicly observable network data, including the addresses peers announce to one another, information operators publish about themselves, and the hosting providers and data-center ranges those addresses resolve to, all gathered by automated crawling of the peer network. Sharded duty assignment does not complicate this step, since what matters is where a machine physically sits rather than which shard it happens to serve in a given epoch.

Coverage is never complete. Some operators sit behind relays or cloud infrastructure that hides the physical site, and others publish nothing at all. Where a network's own geographic spread cannot be observed in sufficient detail, the distribution observed for a structurally similar network is used in its place, chosen because its participants face comparable incentives and carry comparable consensus duties, and can therefore be expected to cluster in broadly the same regions.

Those locations are then matched to regional electricity statistics. Each machine is associated with the grid serving its location, and the renewable proportion of that grid's generation is applied, weighted by the share of estimated consumption sitting in each region. The result is a consumption-weighted renewable share for the network as a whole, which moves both when operators relocate and when the underlying grids change from year to year.

Energy intensity is reported alongside it and means something narrow: the marginal energy associated with processing one further transaction. Because most of this network's consumption is the fixed cost of keeping validators online rather than anything proportional to throughput, that marginal figure falls as activity rises, and it should not be read as an average cost per transaction. Grid statistics come from Share of electricity generated by renewables, compiled by Our World in Data with major processing from Ember 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.

Three kinds of machine sit behind the renewable figure, each located by different means. The sequencer and the components that batch and post are run by a few identified operators whose hosting regions are largely public record. The committee servers holding this chain's transaction data are likewise a known, named set rather than an anonymous crowd, which turns their placement into a question of disclosure rather than inference, unlike a design that buys availability from an external network whose own node population must also be characterized. The one genuinely open population is the full and archive nodes outside parties run, placed the ordinary way: announced addresses resolved to the country holding the allocation, and blocks belonging to hosting providers identified as such.

Beyond the chain's own machines sits its share of Ethereum, whose validators occupy a quite different set of countries. That spread is characterized on its own terms and blended in at the weight the allocated share carries. Where any part of a population resists placement, and on a chain of this age the observable sample is small, the geographic profile of a network built along similar lines, whose operators face similar hosting costs, is substituted for the missing part.

The weights that emerge are matched to national generation statistics, and the renewable share is the consumption-weighted proportion of electricity produced from renewable sources across the countries involved. The figure describes grids, not procurement: an operator contracted for wind or solar supply looks identical to one on ordinary tariff in the same country, and an annual national series cannot say what was generating in the hour a given load actually fell.

Energy intensity is the marginal quantity: the extra electricity one further transaction brings once it has been executed, committed to the committee and carried through to settlement. It is not the total divided by a transaction count, since nearly all of this infrastructure draws power whether or not the next transaction arrives. Keeping data with a committee rather than posting it in full to the settlement layer holds that quantity down, and denser batches hold it down further. The generation statistics are Share of electricity generated by renewables, maintained by Our World in Data from Ember's electricity data together with the Energy Institute's Statistical Review of World Energy.

The renewable share is derived geographically rather than from any contractual claim about the electricity the operators buy. The starting point is where the network's machines physically sit. Node locations are inferred from publicly observable network data — the addresses peers advertise, routing information, and the hosting providers those addresses resolve to — and aggregated to the country level, since finer resolution would be spurious and would expose operator detail without improving the estimate. Hosting concentration is treated with care: a large share of nodes sitting in a handful of data center regions is a real feature of the distribution, not a sampling artifact to be smoothed away.

Where the geographic spread cannot be observed directly for part of the node set, a structurally similar network stands in for the missing portion. Similarity here means a comparable participation and reward design and a comparable consensus family, on the reasoning that networks which attract operators on similar terms tend to attract them in similar places. The substitution is applied to the unobserved remainder only, not to the whole distribution.

Each country weight is then matched to that country's generation mix, giving a renewable share for the electricity the network's infrastructure consumes. The public dataset used for the generation mix is Share of electricity generated by renewables, compiled by Ember and the Energy Institute's Statistical Review of World Energy and processed by Our World in Data. Because the mix is an annual national average, it reflects the grid an operator draws from rather than any specific supply arrangement that operator may hold, and short-term or seasonal variation within a country is not captured.

Energy intensity is reported separately and means the marginal energy cost of one additional transaction: the change in consumption attributable to adding one transaction to the load the network already carries, rather than total consumption divided by transaction count. On a network whose validator set draws power continuously regardless of how busy it is, the two are very different quantities, and the marginal figure moves with throughput even when the underlying infrastructure has not changed at all.

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.

The renewable share is derived from where the network's machines are. Node locations are inferred from publicly observable network data — the addresses peers advertise, the hosting ranges those addresses sit in, and operator disclosures already public — and each located node is assigned to the electricity grid serving its region. Aggregating those assignments gives a weighted view of which grids supply the infrastructure, which is the input the renewable calculation requires.

Resolution is partial in practice. A substantial share of nodes runs in hosting arrangements that identify a provider rather than a site, or behind configurations that disclose nothing dependable at all. The demanding hardware profile this network expects tends to concentrate operators in commercial data centers rather than residential connections, which sharpens regional attribution somewhat but also means a handful of large hosting regions can dominate the weighted result. Where a network's own geographic spread cannot be observed to a usable standard, the spread of a structurally similar network is used as a stand-in — one selected for a comparable validator economy and a comparable cost of entry for operators — and that substitution is a source of uncertainty applied only to the unresolved portion.

Grid assignments are matched against published statistics on how electricity is generated region by region, producing the proportion of the network's electricity drawn from renewable generation. Those statistics are 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.

Energy intensity is a separate measure from total consumption and is not the total divided by a transaction count. It is marginal: the extra electricity drawn because one more transaction is processed on infrastructure that is already running. Validators here commit blocks on a fixed sub-second cadence whether or not transactions are waiting, so the marginal quantity is small relative to the standing draw and falls further as throughput increases.

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

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

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

The renewable proportion attached to this network is inferred rather than measured. It starts from where the machines appear to be: node locations are approximated from publicly observable network data, chiefly the addresses seen during peer discovery and in crawler output, resolved to country or regional level and not to individual facilities. That view is partial by construction. Many operators sit behind hosting providers or relays, cloud regions do not always correspond to the jurisdiction of the account holder, and a comparatively young validator set concentrated in a few data center regions can shift quickly. Where the distribution cannot be observed with enough confidence, the geographic spread of a structurally comparable network, one with a similar participation model and similar hardware demands, is substituted for the unobserved part.

Those locations are then weighted against published electricity statistics. The share of generation coming from renewable sources in each region is 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, and applied to the consumption attributed to that region. Summing across regions gives a weighted renewable share for the network. The underlying assumption is that a node draws from its local grid at the average mix for that grid; operators with dedicated renewable supply contracts or on site generation are not separately credited, because that arrangement is not visible in network data.

Energy intensity is expressed as the marginal energy associated with one additional transaction, not as annual consumption divided by annual transactions. The distinction is significant for a high throughput network whose equipment draws much the same power whether blocks are full or nearly empty: the incremental cost of ordering one more transaction is small and largely independent of how busy the chain happens to be, and a simple average would move with usage rather than with anything physical.

Two populations have to be located separately, and they are known with very different confidence. The proving and sequencing infrastructure is operated by a single organization from a small number of facilities, so rather than inferring a geographic distribution from network observation, the estimate rests on the far smaller question of which jurisdictions that organization operates in. That is a narrower uncertainty than a distributed validator set presents, and it means a single siting decision moves this network's renewable share in a way that no individual operator could move a chain with thousands of independent nodes.

The settlement layer share carries the geographic distribution of the settlement layer's own validator population, which is estimated from network observation and is far more dispersed. The renewable proportion reported here is therefore a blend: the operator-run infrastructure weighted by its own consumption and located where that organization runs it, combined with a share of the settlement layer weighted by the settlement resources this network consumes and located according to that network's validator distribution. Each location is matched to published statistics for its regional grid.

The limitations are specific. Hosting arrangements can place equipment in a jurisdiction other than the operator's own, and commercial facilities do not generally publish their supply mix, so the grid average is used in place of the actual supply of a particular building. Grid statistics are annual, which smooths over seasonal and daily variation. Contractual renewable purchases are not counted, since this describes the physical grid mix rather than a procurement position.

Energy intensity per transaction is period consumption divided by transactions settled, and for this network the quotient falls meaningfully as usage rises, more so than on a monolithic chain. Proving and settlement costs are largely per-batch rather than per-transaction, so filling batches spreads a near-fixed cost across more transactions. The figure describes an average across the period rather than the energy one additional transaction causes. Source data is processed by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy: Share of electricity generated by renewables.

Establishing a renewable share means first establishing where the hardware draws its power. This network is comparatively favorable to that exercise, because validators are named in one another's published quorum sets and operators are expected to publish identifying information about themselves and their nodes, so the organizations behind much of the infrastructure and the regions they operate in can be read from public sources rather than guessed. Advertised network addresses, autonomous system registrations and hosting-provider allocations resolve the remainder to a country or region. Since almost all of this infrastructure is cloud-hosted, the facility's location is what determines the grid supplying it, and hosting location is used in preference to the operator's home jurisdiction.

Gaps remain. Non-validating nodes are not systematically observable, an organization running several separated nodes may not disclose all of their locations, and archive storage may sit in a different region from the validator that publishes to it. Where the geographic spread cannot be established from public data, the distribution seen on a network with a comparable operating profile is substituted, selected for similar participation requirements and similar hosting behavior rather than for any resemblance in how consensus is reached. That substitution is the main source of uncertainty in the renewable figure.

Locations are weighted by the consumption attributed to each and matched against regional electricity statistics, so every portion of the network's draw inherits the generation mix of its supplying grid, and the renewable proportion is the consumption-weighted average of those mixes. It is not a count of how many nodes sit in countries with clean grids, and because the statistics are annual averages the method has no visibility into variation across hours or seasons.

Energy intensity is reported at the margin, as the additional electricity associated with one further transaction given the current node population and the throughput being carried. With nodes running continuously and drawing much the same power whether the ledger is full or nearly empty, that marginal quantity is small and declines as throughput grows, which reflects the definition of the measure rather than any change in the equipment. Regional generation mix comes 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.

Working out the renewable share means first working out where the machines sit. Addresses visible through network crawlers and public peer information are resolved to a country or region, which gives incomplete coverage: many nodes sit behind hosting providers or relays, and the announced location of an address need not match the facility housing the hardware. Where the geographic spread cannot be observed directly, the distribution of a structurally similar network is substituted, chosen because its staking economics and agreement protocol impose comparable operating demands and so tend to concentrate operators in comparable hosting markets.

Located nodes are then assigned the generation mix of the grid that supplies them, using Share of electricity generated by renewables, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy. Weighting each region's renewable proportion by the consumption estimated to sit in that region produces a share for the network as a whole. That share describes the physical grids the infrastructure draws from, not contractual sourcing: an operator holding renewable supply agreements is treated the same as any other operator on the same grid, because such arrangements are not visible from outside the network.

Energy intensity is reported as a separate quantity and means the additional energy associated with handling one further transaction, not the annual total divided by the number of transactions. The distinction is material for this network, where the committee runs continuously at a broadly constant power level and much of the traffic settles over a path that adds little incremental work, so the marginal figure is small while the standing consumption of the node population is not. Both the renewable share and the intensity respond to two separate inputs: the size, mix and placement of the node population, and the grid statistics for the years covered, which are themselves restated as national energy reporting is revised.

The renewable proportion reported for this network follows from where its machines run. Locations are inferred from publicly observable network data: the addresses of reachable nodes are resolved to hosting providers and regions, and the on-chain registry of producer candidates helps place the most important part of the population, since candidates campaign for votes publicly and many disclose who operates them and where. The producing set is small and identifiable, which makes the part of the network that matters most for block production easier to locate than the broader population of supporting and query-serving nodes.

Where the geographic spread of that broader population cannot be established from observation, the distribution of a network with a comparable validator selection and reward design is used as a substitute. This substitution is the main source of uncertainty in the reported share and should be read as such.

Each location is then matched to published statistics on how electricity is generated on the grid serving it, and the individual shares are weighted by the electricity attributed to the machines in that location to give a network-level proportion. The underlying statistics describe the average generation mix on a regional grid across a reporting year. They do not capture variation within a day or a season, nor any renewable supply contracted privately by an individual operator, which is not observable from the chain.

Energy intensity is stated as a marginal figure: the additional electricity associated with processing one more transaction, rather than annual consumption divided by transaction count. On a network whose servers run continuously and which sustains a high transaction volume, that marginal quantity is very small, and it is sensitive to the throughput assumed in deriving it.

The generation statistics are taken from Share of electricity generated by renewables, compiled by Ember and the Energy Institute's Statistical Review of World Energy and processed by Our World in Data.

The renewable share is worked out by establishing where the network's machines are and what the local grids there are made of. Addresses observed on the public network are resolved to a country or region using routing records and publicly published hosting information, producing a distribution of the estimated machine population across jurisdictions. Operators of block-producing nodes are expected to run in commercial facilities with a documented service level, which tends to concentrate them in identifiable hosting locations and makes this part of the distribution more tractable than it would otherwise be. Where machines cannot be placed, because they sit behind private networking or return nothing useful, the geographic pattern seen on chains built along similar lines is substituted, on the reasoning that operators facing comparable participation requirements tend to choose comparable places to host.

Each portion of the distribution is weighted by the energy it is estimated to consume and matched to published statistics for the generating mix of the corresponding grid. What results is the share of the network's electricity that came from renewable generation, understood as a property of the grids supplying its infrastructure, averaged across the reporting period and weighted by consumption. It carries no implication that any operator has contracted for renewable supply, and it excludes both generation on site and certificates acquired separately from the electricity.

Energy intensity is calculated on a marginal basis rather than an average one. It is the additional energy associated with one further transaction being processed, not the annual total divided by the transaction count. On a network whose committee runs continuously and produces blocks on a fixed cadence regardless of how full they are, that marginal quantity is small, and it moves with how heavily the network is used even where total consumption is stable.

Generating mix data is 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. Coverage gaps and reporting lags in that data set flow through into the result, and locating the machines remains the largest source of uncertainty.

The renewable share reported for the XRP Ledger is derived geographically. The first task is to place the machines: addresses advertised by servers participating in the network are resolved to countries using publicly available network data, registry records and crawling of the peer-to-peer layer. Because consensus participants on this ledger are named and listed rather than anonymous, and because a substantial number are operated by identifiable institutions that disclose where they run, the location picture is firmer than it would be for a population of unidentified nodes. Where part of the population still cannot be placed, the geographic spread of a structurally similar network, meaning one whose participation rules and operating incentives resemble this one, stands in for the missing portion rather than assuming unplaced machines sit alongside the located ones.

Each located machine is then matched to the electricity mix of the grid that serves it. National generation statistics give the proportion of electricity produced from renewable sources in each country, and weighting those proportions by the consumption estimated to sit in each country yields the renewable share for the network as a whole. The share consequently tracks the composition of the grids the servers happen to occupy at least as much as anything the protocol itself does. It is a statement about where the infrastructure is located, not a claim that operators have procured particular generation on their own account.

Energy intensity is reported alongside the share and means something narrower than an average. It is a marginal quantity: the additional electricity attributable to one further transaction being processed, with the infrastructure held fixed. On a network whose servers run continuously regardless of load, that marginal value is small and is highly sensitive to the transaction count used as its denominator, so it can move between reporting periods for reasons unrelated to the hardware. The grid statistics behind these calculations are taken from Share of electricity generated by renewables, compiled and processed by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy.

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

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

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

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

USD Coin is present on the following networks: Algorand, Aptos Coin, Arbitrum, Avalanche, Base, Celo, Cronos, Ethereum, Hedera Hbar, Hyperliquid, Injective, Near Protocol, Optimism, Plume, Polkadot, Polygon, Sei, Solana, Sonic, Starknet, Stellar, Sui, Tron, Xdc Network, Ripple, Zksync.

Emissions are derived from the consumption estimate rather than measured, by pairing each geographically attributed portion of the network's electricity use with the carbon intensity of the grid that supplies it. The location inference used for the generation mix applies here unchanged: addresses observed on the network and hosting-provider registrations place consumption in a country or region, gaps are filled from the distribution of a structurally similar network, and the outcome is a consumption-weighted spread across grids rather than a headcount of nodes by country.

The split between scopes governs how the figures should be read. Scope 1 covers emissions from sources the operators of the infrastructure control directly, which in practice means fuel burned on site, primarily in backup generators. For a network whose nodes are ordinary servers in data centers and offices rather than dedicated industrial plant, direct combustion attributable to the network is negligible and the reported scope 1 figure is effectively nil. Scope 2 covers the indirect emissions embodied in the electricity those machines purchase, and carries essentially the entire footprint. It is computed on a location basis, using the average carbon intensity of the supplying grid, rather than on a market basis that would credit renewable energy certificates or power purchase agreements held by individual operators, because contractual instruments of that kind cannot be observed from network data and are not reflected here.

Several things sit outside the boundary. Emissions embodied in manufacturing, shipping and disposing of the hardware are excluded, as is the electricity consumed by wallets, indexers, block explorers and other services built on top of the network. Grid carbon intensities are annual averages, so short-term shifts in the generation mix are not captured, and every uncertainty affecting the location estimate propagates into the emissions figure.

Greenhouse gas intensity is expressed as a marginal quantity, the additional emissions associated with one further transaction at the current node set and throughput, and it moves inversely with activity because the underlying consumption scarcely responds to load. Carbon intensity values 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 made available under the CC BY 4.0 license.

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

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

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

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

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

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

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

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.

Emissions are derived from the same geographic picture used for the energy figures, with carbon intensity substituted for renewable share. Machine locations are inferred from publicly observable network data covering the sequencing and proposing infrastructure, the full node and public endpoint population, the operators of the external data availability layer, and the portion of the settlement chain's operator base that carries this network's traffic. Where part of that population cannot be placed directly, the distribution of a structurally comparable network is used in its stead, and the resulting uncertainty is carried into the estimate rather than hidden in it.

Each location is then matched to the carbon intensity of the electricity supplied by the grid serving it, expressed in grams of carbon dioxide equivalent per kilowatt-hour, and the electricity estimated for that location is multiplied by the corresponding factor. Summing across locations produces the total for the network.

What results is overwhelmingly a scope 2 figure: the indirect emissions embodied in electricity purchased from a grid. Scope 1 covers emissions from sources the operators control directly, such as fuel burned on site; for infrastructure of this kind, which is general-purpose server hardware drawing grid power in commercial data centers, scope 1 is normally negligible and is reported as such unless something specific indicates otherwise. Emissions embodied in manufacturing, shipping and disposing of that hardware fall outside this boundary and are not included.

Greenhouse gas intensity is the marginal emission attributable to one additional transaction, obtained by allocating the total across the transactions confirmed in the same period. Like its energy counterpart it is an allocation of shared overhead rather than a property of any single transaction, and it moves when grid factors move or when the composition and location of the infrastructure change, not only when network behavior does. Grid carbon intensity values 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 made available under the Creative Commons Attribution 4.0 license.

Emissions rest on the same geographic groundwork as the energy figures, with a different coefficient applied at the end. Once the node population has been located and assigned to regional grids, each assignment is paired with the carbon intensity of electricity generation in that region — the mass of carbon dioxide equivalent released per unit of electricity delivered — and estimated consumption is apportioned across regions and converted. Because regional carbon intensities differ by an order of magnitude or more, where the machines sit influences the emissions result at least as much as how much electricity they draw.

Scope 1 and scope 2 are separated. Scope 1 captures emissions from sources the operators control directly, such as fuel combusted on site for backup power, and is negligible or zero for a network of this design, whose validators run commodity servers on purchased electricity. Scope 2 captures the indirect emissions embodied in that purchased electricity and makes up effectively the entire figure. The comparatively well-documented hosting of the permissioned block-producing set narrows the uncertainty on the part of the estimate that carries the most weight; for nodes whose location cannot be pinned down, the regional profile of a structurally comparable network stands in, and that approximation propagates into the emissions result 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 is defined in the same marginal terms as energy intensity: the additional emissions attributable to processing one further transaction, not the network's total emissions divided by the number of transactions it carried. Since the machines run continuously irrespective of load, that marginal quantity stays modest and falls as utilization increases. Figures are revised when regional statistics are updated or when observation of the node population improves, and any assumption taken under uncertainty is set so as to favor the higher estimate.

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 attributed to Hedera use the same geographic picture as the energy analysis, applied to a different statistic. Once the consensus nodes have been resolved to countries, partly from the operator identities published in the network's address book and partly from advertised network addresses mapped through public network data and registry records, each location is matched to the average carbon intensity of electricity generation on that grid, expressed as greenhouse gas emitted per unit of electricity produced. Multiplying the electricity estimated to be consumed in each country by that country's intensity, then summing, produces the emissions total. Where part of the population cannot be located, the distribution of a structurally similar network substitutes for the missing portion.

The reporting distinguishes two categories. Scope 1 covers emissions from sources the operators of the network infrastructure directly control, such as fuel burned on their own premises. For a network of this kind these are negligible or absent, because the nodes consume purchased electricity and combust nothing themselves, and a reported value of zero should be understood in that sense rather than as a gap in the data. Scope 2 covers the indirect emissions embodied in the purchased electricity, and accounts for essentially the whole figure. The calculation applies average grid intensities at country level, so it reflects a national generation mix rather than any contractual arrangement, on-site generation or certificate purchase an individual operator may have made, and it does not net off offsets purchased outside the electricity system.

Greenhouse gas intensity is the marginal counterpart to the total: the additional emissions attributable to one further transaction, with the infrastructure held constant. It carries forward every limitation of the inputs beneath it, including an inferred hardware profile, uncertainty about redundancy behind each address book entry, country-level rather than site-level grid data, and a transaction count that varies independently of the infrastructure. Where evidence is thin, the assumptions chosen raise the result rather than lower it. Carbon intensity data is taken from Carbon intensity of electricity generation, compiled and processed by Our World in Data from Ember and from the Energy Institute's Statistical Review of World Energy, and made available under the CC BY 4.0 license.

Emissions are derived from the network's estimated electricity use combined with the carbon content of the grids supplying it. The energy total is first apportioned by location, using the same geographic picture assembled for the energy analysis: node addresses observed on the peer network, operator information published openly, and the hosting ranges those addresses resolve to. Where a node's placement cannot be resolved, the distribution of a structurally comparable network is used in its place, selected for similar incentives and similar validation duties rather than for similar scale.

Each portion of consumption is then multiplied by the carbon intensity of the grid serving that region, expressed as emissions per unit of electricity generated, and the parts are summed. The consequence is that hosting decisions drive the result as strongly as the amount of electricity drawn. That is pronounced here, because the consensus set is small and clustered in a few commercial facilities, so the figure reflects the generation mix of a handful of jurisdictions rather than a global average, and can move when one operator changes provider.

The reported figures distinguish two scopes. Scope 1 covers emissions from sources the operators control directly, such as fuel burned on site; for infrastructure of this kind that is effectively nil, since the machines are commodity servers drawing grid power in third-party facilities. Scope 2 covers the indirect emissions embodied in the electricity bought to run them and accounts for substantially the whole footprint. Emissions from manufacturing the hardware, and from constructing and cooling the buildings that house it, sit outside both scopes and are not counted.

GHG intensity is the marginal quantity: the emissions attributable to processing one additional transaction. As with energy, most of the total is a fixed cost that continues regardless of how busy the network is, so intensity falls as usage rises and is not an average. Carbon intensity values come from Carbon intensity of electricity generation, compiled by Our World in Data with major processing from Ember and from the Energy Institute's Statistical Review of World Energy, and made available under the CC BY 4.0 license.

The emissions figures follow from combining two earlier estimates, how much electricity the network's machines consume and where those machines are, with published data on the carbon intensity of electricity in each region concerned. The geographic distribution is inferred from publicly observable network data, and where that is insufficient the distribution of a structurally comparable network is used in its place. Each region's share of estimated consumption is multiplied by the emissions released per unit of electricity generated on that region's grid, and the products are added together to give a network total.

The carbon intensity data is drawn from Carbon intensity of electricity generation, compiled by Our World in Data with major processing from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy, and released under the Creative Commons CC BY 4.0 license.

The two scopes reported are not interchangeable. Scope 1 accounts for emissions from sources the operators of the infrastructure control directly, which in practice means fuel burned on their own premises. The machines that run this network are conventional servers in data centers supplied from public grids, so there is normally no such combustion to record and the scope 1 figure is reported at or near zero rather than left blank. Scope 2 accounts for the emissions embodied in the electricity purchased to run those machines, and this is where the entire footprint effectively sits. Greenhouse gas intensity is derived on the same marginal basis as energy intensity: the additional emissions attributable to one more transaction, not a total divided by a count.

Each uncertainty in the consumption and location estimates flows through into these numbers, and the intensity data adds one of its own. Published grid intensities are annual averages across a region; they cannot capture the hours at which consumption actually occurs, nor any generation an operator has contracted for directly, and a node hosted by a provider running its own low-carbon supply will be represented by its region's average all the same. Where evidence is thin the conservative assumption is preferred, so the reported emissions are more likely to overstate than understate, and the figures are revised as observation improves.

Emissions for this network are derived from its electricity use and from the carbon content of the grids supplying it. The estimated energy total is first broken down by location, using the same geographic picture built for the energy analysis: node addresses observed on the peer network, operator information published openly, and the hosting ranges those addresses belong to. Where the observed spread is too sparse to rely on, the distribution of a structurally comparable network is substituted, selected for similar incentives and similar validation duties rather than similar size.

Each block of consumption is then multiplied by the carbon intensity of the grid serving it, expressed as emissions per unit of electricity generated in that region, and the results are summed. This means the outcome is driven as much by where operators choose to host as by how much electricity the network draws, and it changes year to year as national generation mixes shift.

The reported figures separate two scopes. Scope 1 covers emissions from sources the network's operators control directly, such as on-site fuel combustion; for a network of this kind that is effectively nil, since the infrastructure is commodity servers drawing grid power in third-party facilities. Scope 2 covers the indirect emissions embodied in the electricity purchased to run that infrastructure, and it accounts for essentially the whole footprint. Emissions embodied in manufacturing the hardware, and in building and cooling the facilities that house it, fall outside both and are not included.

GHG intensity is the marginal figure, the emissions attributable to one additional transaction. As with energy, the bulk of the total is a fixed cost that continues regardless of throughput, so intensity falls as usage grows and is not an average. Carbon intensity values come from Carbon intensity of electricity generation, compiled by Our World in Data with major processing from Ember and from the Energy Institute's Statistical Review of World Energy, and made available 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.

Where the perimeter falls decides much of this figure, and here it sits unusually. Transaction data is not handed to an outside availability network with its own node set but held by a committee known to the chain, so those servers stand inside the perimeter and are counted directly rather than through a share of somebody else's total. Outside it but still attributable is the settlement layer, Ethereum, which receives only certificates and state assertions; a portion of its consumption is allocated here in proportion to what those postings occupy. Each pool needs a location before it can take a coefficient.

Locations come from what the public network reveals: announced endpoints resolved to countries, address blocks registered to hosting operators, and operator disclosures. Coverage is partial, and on a chain this young the observable sample is small, so a network of similar construction and hosting economics supplies a stand-in profile for the remainder. Each country in the resulting weights carries a published figure for greenhouse gas released per unit of electricity generated, in carbon dioxide equivalent. Applying those figures to the electricity estimated in each country and to the allocated settlement share, then adding, gives the total.

Reporting splits direct from indirect. Direct emissions arise from plant the operators own and run, an on-site generator being the plainest case; for equipment in leased commercial facilities there is none, so a zero is entered as a conclusion rather than a placeholder. Indirect emissions are those already contained in the grid electricity the machines draw, and they carry the entire result. Manufacturing the hardware and constructing the buildings fall outside.

Per-transaction intensity is stated at the margin, applying these coefficients to the marginal electricity described alongside the renewable share. Because data goes to a committee rather than to the settlement layer in full, that quantity is smaller than a design posting everything to Ethereum would produce, and it falls further as batches fill. The residual uncertainties are inherited: national annual coefficients cannot represent an hour's generation or a facility's supply, placement is incomplete, and the split between the chain's own machines and its settlement slice follows a rule rather than a meter. The coefficients are published by Our World in Data, processed from Ember's electricity data and the Energy Institute's Statistical Review of World Energy: Carbon intensity of electricity generation. The dataset is available under the Creative Commons Attribution 4.0 license.

Emissions follow from the energy estimate and the same geographic picture, applied to grid carbon intensity instead of generation mix. Node locations are inferred from publicly observable network data and aggregated to the country level; where part of the node set cannot be placed, the distribution of a structurally similar network — one with a comparable participation and reward design — substitutes for the unobserved remainder. Each country weight then carries that country's average carbon intensity of electricity generation, and the weighted result is applied to the energy figure to produce the emissions total.

The reporting distinguishes two scopes. Scope 1 covers emissions from sources the network's operators directly control — combustion on site, refrigerant loss, on-premises generation — and for a network of this kind it is effectively nil, because the infrastructure is servers in third-party facilities rather than anything that burns fuel. Scope 2 covers the indirect emissions embodied in the electricity purchased to run that infrastructure, and it accounts for essentially the whole figure. Emissions further upstream, such as those from manufacturing and shipping the hardware or from constructing the data centers themselves, sit outside both scopes and are not included here.

The carbon intensity data is drawn from Carbon intensity of electricity generation, compiled by Ember and the Energy Institute's Statistical Review of World Energy with substantial processing by Our World in Data, and made available under a CC BY 4.0 license. These are location-based annual averages: they describe the grid serving a country, not any supply contract or renewable certificate a particular operator may hold, so a facility running on contracted clean power is not distinguished from its neighbours.

GHG intensity is the marginal emission attributable to one additional transaction, computed on the same basis as the energy intensity figure. Its uncertainty compounds that of every input beneath it — the node population, the hardware profile, the inferred locations and the national intensity averages — and it should be read as an order-of-magnitude indicator rather than a precise per-transaction 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.

Emissions build on the same geographic work as the energy figures, with a different coefficient applied at the last step. Once nodes have been located and assigned to regional grids, each assignment is paired with the carbon intensity of electricity generation in that region — the mass of carbon dioxide equivalent released per unit of electricity delivered — and estimated consumption is apportioned across regions and converted. Regional carbon intensities vary by an order of magnitude or more, so where the machines sit shapes the emissions result at least as strongly as how much electricity they consume.

The scopes are kept apart. Scope 1 covers emissions from sources the operators control directly, such as fuel burned on site for backup generation; for a network whose validators run commodity servers on purchased electricity it is negligible or zero. Scope 2 covers the indirect emissions embodied in that purchased electricity and accounts for effectively the whole result. Concentration of operators in commercial hosting regions means a comparatively small number of regional coefficients carry most of the weight, so a revision to any one of them moves the total noticeably. Where a node's location cannot be established, the regional profile of a structurally comparable network stands in, and that approximation 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 follows the marginal definition used for energy intensity: the additional emissions attributable to one further transaction beyond those already processed, rather than total emissions divided by transaction count. Because the machines run continuously regardless of demand, that marginal quantity is modest and declines as utilization rises. Results are restated as regional statistics are refreshed and as observation of the node population improves, with assumptions taken under uncertainty set to favor the higher estimate.

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

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

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

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

Emissions are derived, not observed. The estimate combines the modeled electricity consumption of the network with the carbon content of the electricity supplying the regions where its machines appear to run. Those regions come from the same inference used for the energy assessment: addresses seen in peer discovery and crawler output, resolved regionally, with the distribution of a structurally comparable network standing in wherever direct observation is too thin to rely on.

Each region is assigned a carbon intensity for its electricity, measured as emissions per unit generated, taken 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 published under the Creative Commons Attribution 4.0 license. Multiplying each region's intensity by the consumption attributed to it, then summing, produces the network figure.

The split between the two reported scopes follows from how the network operates. Scope one counts emissions from sources the operators control directly, which for server infrastructure means combustion on the operator's own premises; nothing in running a node produces this, and any backup generation is neither material nor observable, so the figure is reported at or close to zero. Scope two counts the emissions embedded in the purchased electricity that runs the machines, and effectively the whole footprint sits there. Because regional grid averages are used, an operator buying certified clean supply is not credited for it, and one drawing from a dirtier local mix than its region's average is not charged for it either.

Greenhouse gas intensity is reported as the marginal emissions attributable to one further transaction, mirroring the treatment of energy intensity. For a network built for high throughput this is the more honest presentation: the infrastructure emits at much the same rate whether it is processing a few transactions or many, so dividing a period total by a transaction count would produce a figure that swings with activity rather than with the emissions actually caused.

Emissions follow from the consumption estimate by applying a carbon intensity to the electricity drawn at each location, and the two-part structure of the consumption estimate carries straight through. The operator-run sequencing and proving infrastructure is assigned the carbon intensity of the grids serving the facilities it runs in. The attributed share of the settlement layer is assigned the intensity implied by that layer's own validator distribution. Summing the two gives the total, and the boundary is operational electricity: neither the manufacture of proving hardware nor the construction of the facilities housing it is included.

Scope 1 covers emissions from sources the operators directly control, which for infrastructure hosted in commercial facilities means occasional backup generation and little else. It is a negligible contributor here and is reported as such rather than modeled in detail. Scope 2 covers emissions embodied in purchased electricity and accounts for effectively the entire footprint, on both the operator-run side and the attributed settlement share.

Greenhouse gas intensity per transaction is period emissions divided by transactions settled in the period. It inherits the batching property described for energy intensity, falling as batches fill, and it also inherits the uncertainty of every step behind it: an error in the assumed proving hardware propagates into consumption and from there into emissions, while the settlement share depends on both that layer's own estimate and the attribution rule used to divide it. Grid carbon intensities are annual averages that conceal substantial variation across a day and a year, and a network whose infrastructure sits in few locations is more exposed to that variation than one spread across many grids, because there is less averaging to smooth it out. Figures are restated each period as the network's operation becomes more openly observable and as grid data is updated. Carbon intensity data is processed by Our World in Data from Ember and the Energy Institute's Statistical Review of World Energy, and is made available under a Creative Commons BY 4.0 license: Carbon intensity of electricity generation.

Emissions are derived from the consumption estimate rather than measured directly. Each geographically attributed portion of the network's electricity use is multiplied by the carbon intensity of the grid supplying that location, using the same placement of infrastructure that underpins the generation-mix analysis: published operator and node information together with advertised addresses and hosting registrations locate most of the consumption, a structurally comparable network stands in where placement cannot be determined, and the outcome is a consumption-weighted distribution across grids rather than a count of nodes per country.

The scope split shapes how the numbers should be interpreted. Scope 1 covers emissions from sources the operators control directly, which for this kind of infrastructure means fuel burned on site, essentially backup generation. Validators and archive servers are general-purpose machines in commercial data centers rather than dedicated industrial plant, so direct combustion attributable to the network is negligible and the scope 1 figure is reported as effectively nil. Scope 2 covers the indirect emissions embodied in the electricity purchased to run that equipment and represents virtually the entire footprint. It is calculated on a location basis from average grid intensity rather than on a market basis, because renewable energy certificates and power purchase agreements procured by individual operators or by their cloud providers cannot be verified from public network data and are therefore not credited.

What falls outside the boundary should be explicit. Emissions embodied in manufacturing, transporting and retiring the hardware are excluded, as is the electricity consumed by wallets, anchors, explorers and applications that use the ledger, which belongs to those services. Grid carbon intensities are annual averages, so variation within a year is not represented, and uncertainty in locating the infrastructure propagates directly into the emissions estimate.

Greenhouse gas intensity is expressed as a marginal quantity, the additional emissions attributable to one further transaction at the present node population and throughput. Because the consumption behind it barely responds to load, that quantity falls as activity rises and is not an efficiency measurement. Carbon intensity values 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 made available under the CC BY 4.0 license.

Emissions are derived by taking the geographic picture assembled for energy sourcing and applying carbon statistics to it instead of generation-mix statistics. Node addresses observable through crawlers and public peer information are resolved to regions, and where that resolution is incomplete the distribution of a structurally comparable network stands in, chosen because its incentive structure and agreement protocol create similar operating requirements and therefore a similar hosting pattern.

Every region is then paired with the carbon intensity of the electricity generated there, taken from Carbon intensity of electricity generation, compiled by Our World in Data from Ember's yearly electricity data and the Energy Institute's Statistical Review of World Energy and published under the CC BY 4.0 licence. The electricity estimated to be consumed in each region is multiplied by that region's intensity and the products are summed to give the emissions attributable to operating the network over the reporting period.

The disclosure keeps two scopes apart. Scope 1 covers emissions from sources directly controlled by those running the infrastructure, for instance fuel burned on site. For a network whose nodes are servers in third-party data centers this is normally nil or immaterial, and a zero figure records the absence of such sources rather than missing data. Scope 2 covers the indirect emissions carried in the electricity those machines purchase, and accounts for substantially the whole footprint reported for this network.

Greenhouse gas intensity is marginal in the same sense as its energy counterpart: it is the emission associated with one additional transaction rather than an average produced by dividing an annual total by throughput. Because the committee draws power at a fairly steady rate regardless of how busy the network is, that marginal figure stays small and should not be treated as each transaction's share of the network's overall footprint. Both the absolute emissions and the intensity shift with the grid data underneath them, which is revised as national energy statistics are updated, and with any protocol change that alters the hardware a node requires.

Emissions attributed to this network are derived from the geographic picture built for its energy mix, applied to a different statistic. Once the machines have been placed in regions, the electricity attributed to each region is multiplied by the carbon intensity of generation on the grid serving it, expressed as emissions per unit of electricity delivered, and the results are summed across regions. Where node geography cannot be observed directly, the distribution of a structurally comparable network stands in, and that assumption propagates into the emissions figure exactly as it does into the renewable share.

The figures separate two categories. Scope 1 covers emissions from sources the operators of the network's infrastructure control directly, such as fuel burned on site; for servers hosted in commercial facilities drawing from public grids, this is ordinarily nil or close to it, with any backup generation contributing negligibly over a reporting year. Scope 2 covers the indirect emissions embodied in the purchased electricity that powers those servers, and represents effectively the whole footprint of a network of this design. The allocation is made from grid electricity drawn and is not adjusted for offsets, attribute certificates or supply agreements held by individual operators, since none of those are visible from the chain.

Greenhouse gas intensity is reported on a marginal basis, as the emissions associated with one additional transaction rather than an average obtained by dividing an annual total. Because the infrastructure draws power whether or not transactions arrive, this marginal quantity is small, and it moves with the throughput assumed at least as much as with anything the protocol does differently from one period to the next.

Carbon intensity values are taken from Carbon intensity of electricity generation, compiled by Ember and the Energy Institute's Statistical Review of World Energy with major processing by Our World in Data, and made available under the CC BY 4.0 license.

Emissions are calculated rather than measured, by applying the carbon properties of the electricity the network's machines consume. The jurisdictional distribution used for the energy mix is reused here: the consumption assigned to each location is multiplied by the published figure for greenhouse gases released per unit of electricity generated on that grid, and the products are added across the distribution. Totals are stated in carbon dioxide equivalent so that gases other than carbon dioxide are captured on a warming-equivalent basis.

The two scopes describe different sources and are kept apart deliberately. Scope 1 covers what the operators release from things they own or control, such as fuel burned on site, standby generators and refrigerant losses. For this network it is ordinarily nil or close to it, because the operators run computing equipment in commercial facilities they generally do not own and burn no fuel of their own in producing or verifying blocks. Scope 2 covers what was released elsewhere to generate the electricity that equipment draws, and that is where effectively the whole footprint sits. What it takes to manufacture the hardware or build the facilities falls outside the boundary drawn here.

Greenhouse gas intensity is reported per transaction on the same marginal basis as energy intensity: the further emissions attributable to processing one additional transaction rather than an annual average spread across throughput. Because the committee produces blocks on a fixed cadence whether the network is busy or idle, that marginal quantity is small and changes with usage more than with the underlying infrastructure.

Carbon intensity values 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 published under the Creative Commons Attribution 4.0 license. Those values are annual national averages, so variation within a country and over shorter periods is not represented, and any error in locating the machines carries straight through into the emissions result.

The input population for this ledger does not have to be discovered. Validators declare themselves and appear in signed lists that server operators subscribe to, so the machines carrying consensus can be read off those lists rather than pieced together from whatever a crawler reaches, and many entries are institutions that state publicly where they operate. The wider population of servers that track the ledger, answer application traffic or retain history without voting is not enumerated that way and must be observed conventionally, by resolving announced addresses to the country holding the allocation. Where part of that outer population will not resolve, a network with comparable participation rules and comparable reasons to run a server lends its profile to the gap.

Emissions then follow from arithmetic over that map. Each country is assigned a published average for greenhouse gas released per unit of electricity generated within it, expressed in carbon dioxide equivalent, and the electricity estimated to be drawn there is multiplied through. Adding across countries gives the figure. Nothing here observes an emission; it converts an electricity estimate with a national coefficient, and is no better than either.

Of the two scopes reported, only one carries weight. Direct emissions from plant the operators run themselves fall in the first, fuel burned on their own premises being the standard case. Servers in commercial facilities burn nothing, so the first is reported at zero, and that zero means the category is genuinely empty rather than unexamined. The second, covering emissions already embodied in the electricity bought to run those servers, holds the whole result. It uses the average mix of a country's grid, which is why an operator contracted for low-carbon supply earns no credit here, and one on a coal-heavy grid no relief from offsets bought elsewhere.

The per-transaction figure is marginal: what one more transaction adds while the server population stays as it is. Because these machines run around the clock at a cadence consensus sets rather than demand, that increment is slight, and the reported number swings with its throughput denominator more than with anything physical. Intensity coefficients are taken from Carbon intensity of electricity generation, a dataset Our World in Data prepares from Ember and from the Energy Institute's Statistical Review of World Energy and distributes under the CC BY 4.0 license.

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

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

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