BUZZCHAIN IS RUNNING ON TESTNET

(DOCUMENTATION)

A pseudochain driven by real-world events. Powered by X. Anchored on Ethereum.

Everything that makes up Buzzchain, from Proof of Engagement and block rate to tokenomics and validators, plus developer docs: contract addresses, the NatSpec-annotated ABIs and the public API.

DRAFT DESIGN TESTNET V1 LIVE ON SEPOLIA

01 · OVERVIEW

Buzzchain

A chain whose blocks are produced by attention. Every post about a topic on X adds weight to a counter. When the counter fills, a block closes. A quiet day produces a slow chain, and a big event produces a fast one. Block time is not a constant here. It is a live measurement of mindshare.

How it works

Buzzchain reads posts on X about one topic. Every post carries a weight, set by the reach of its author and the engagement it earns. The weights flow into a single counter, and each time the counter crosses the threshold KK, a block closes. This is Proof of Engagement: attention does the work that computation does in Bitcoin.

Each block commits its posts to a Merkle root, and the roots are checkpointed on Ethereum. The rules are public, so anyone with the same data can replay the blocks and compare. Every block also mints $BUZZ, and no two blocks mint the same amount: a block's reward follows how loud it was, meaning the raw engagement its posts drew.

The minted $BUZZ goes to validator seats. A seat is an NFT, and staking it is the only requirement. Each block's reward is split equally among the staked seats. Supply is capped at 280,000,000, and the reward pool shrinks as attention accumulates, not as time passes.

The broader the conversation, the faster the chain. The louder the conversation, the bigger the blocks.

The road to block 0

Launch stages
StageWhat happens
Before BGEThe full data system runs in public as a proof of concept. It produces blocks without a token or rewards.
Block Generation EventDay one. Validator seats are offered, the token is deployed, block 0 is produced, and $BUZZ emission begins.
After BGEProof of Engagement runs live, and staked seats earn the $BUZZ minted in every block.

What makes it a pseudochain

Buzzchain has blocks, hashes and a canonical history. It does not have its own consensus. Ordering comes from the data source, and integrity comes from Ethereum. See Pseudochains.

Design vs. testnet: how to read these docs

These docs describe two things at once, and say which is which:

Protocol design
The mechanism Buzzchain is built towards at the Block Generation Event: weighted Proof of Engagement, breadth and loudness, a capped $BUZZ supply and staked validator seats. Values marked to be set are fixed from measurements taken before BGE. Values marked to be announced are published before BGE.
Testnet v1
The first running version, on Ethereum Sepolia: a relayer that ingests posts mentioning @buzzchain_io, seals blocks, and settles them through BuzzchainSequencer. It is a simplified, tunable instance of the design, used to measure the parameters. Boxes labelled TESTNET V1 describe it.
If you want to understand, read
If you want to understandRead
The idea and where it comes fromPseudochains, From mindshare to blocks
The math behind block productionProof of Engagement
Why every block pays differentlyBreadth and loudness
Supply and emissionTokenomics
How launch worksBefore BGE, Block Generation Event
What validators doValidators
How to build on itDevelopers

02 · KEY CONCEPTS

Key concepts

Pseudochains

A pseudochain is an append-only sequence of blocks whose production rate is driven by a real-world data stream, and whose history is anchored on an existing chain. It has blocks, hashes and one canonical history. It has no consensus of its own:

  • Ordering comes from the data source.
  • Integrity comes from commitments on a host chain. For Buzzchain that host is Ethereum.

Origin: Squeekchain and exogenous blocks

The idea comes from Squeekchain, which proposed producing blocks from exogenous data: a signal from outside the chain that no participant computes or stakes for. In Squeekchain the signal is the movement of a real hamster, reported by an oracle. When the hamster runs, blocks come faster. When it sleeps, the chain slows. Squeekchain called this kind of system a toychain.

That inverts the usual design. In most chains, block time is a constant that the protocol defends. In a pseudochain, block time is the information: the tempo of the chain is a live reading of something happening in the world. Buzzchain keeps the idea and changes the source, replacing one physical signal with a public, high-volume, human-generated one.

Squeekchain vs Buzzchain
SqueekchainBuzzchain
Data sourceOne hamster’s movementPublic X posts matching a query
What speeds up blocksThe hamster runningMore posts, from more and heavier accounts
Who can verifyWhoever trusts the oracleAnyone with access to the same data
ValidatorsPassive recipientsStaked seats. They receive the $BUZZ minted in each block

Not an L2, not an L3

A rollup inherits execution and security from its parent chain and tries to be a faster copy of it. A pseudochain does something else. It does not execute transactions. It turns an outside signal into a public, verifiable clock, and lets tokens and applications be built on that clock.

From mindshare to blocks

Buzzchain is the next step in a line of projects that treated attention as something measurable.

  1. Mindshare becomes a number. Kaito popularized mindshare in crypto: a score for how much of the conversation a project or an account holds, computed by AI over social posts. Its Yaps program turned that score into points for people posting on X, later convertible into the KAITO token.
  2. Mindshare becomes a payout. Loudio (LOUD) launched on May 31, 2025 through what it called an Initial Attention Offering. Kaito's feed scored who was talking about LOUD, a leaderboard ranked them, and trading fees on the token were paid out to the top contributors.
  3. Mindshare becomes a clock. In those systems mindshare ends in a leaderboard and a payout. In Buzzchain, mindshare is the input to block production.

Both earlier projects showed the same thing: attention on X can be measured in public, and people will compete for it.

Kaito/Loudio vs Buzzchain
Kaito / LoudioBuzzchain
What mindshare isA scoreThe clock of a chain
OutputA ranking and rewardsBlocks: a public, verifiable time series
How it is computedA proprietary AI modelA public formula anyone can replay
What can be built on itCampaignsAnything that reads block rate as a signal

Mindshare stops being only something to rank. It becomes a chain for trending data, where the speed of the chain is the measurement.

Why X

X is the fastest public record of what people are paying attention to. Posts are public, every post is tied to an account, and post IDs encode creation time, so sorting by ID gives one global order.

03 · MECHANISM

How block rate works

In Proof of Work, a block appears when enough computation has been spent. In Proof of Engagement, a block appears when enough attention has accumulated. The result is a chain whose speed is the signal.

Proof of Engagement: the rule

  1. Each matching post adds its weight to a running accumulator.
  2. When the accumulator reaches the threshold KK, a block closes. It contains the posts that filled it, ordered by post ID.
  3. The remainder carries over to the next block.
  4. If no block is produced for a set number of hours, an empty heartbeat block is emitted so the chain stays live.

It works like volume bars in trading, or an integrate-and-fire encoder in signal processing.

K2K3K4K5K6K7Kevent: posts arrive 4 to 5 times fastertime (ticks = blocks)H(t)
The accumulator H(t)H(t) climbs by each post's weight. Each crossing of nKnK closes block nn, and the remainder carries over. With the same threshold, more attention gives shorter gaps.

The model

Posts arrive at times tit_i with weights wiw_i. Let λ(t)\lambda(t) be the arrival rate and wˉ\bar{w} the mean weight. Accumulated engagement is:

H(t)=∑i: ti≤twi,E[H(t)]=wˉ∫0tλ(s) dsH(t) = \sum_{i:\, t_i \le t} w_i, \qquad \mathbb{E}\left[H(t)\right] = \bar{w} \int_0^t \lambda(s)\, ds

Block nn is produced the first time the accumulator crosses nKnK, and chain height is accumulated engagement divided by KK:

Tn=inf⁡{ t:H(t)≥nK },B(t)=⌊H(t)K⌋T_n = \inf\{\, t : H(t) \ge nK \,\}, \qquad B(t) = \left\lfloor \frac{H(t)}{K} \right\rfloor

So block rate follows engagement, and block time moves inversely to it:

dBdt≈wˉ λ(t)K,Δ(t)≈Kwˉ λ(t)\frac{dB}{dt} \approx \frac{\bar{w}\,\lambda(t)}{K}, \qquad \Delta(t) \approx \frac{K}{\bar{w}\,\lambda(t)}

The chain never stores the engagement rate. It encodes it in block frequency, and anyone can decode it from two consecutive blocks:

λ^n=Kwˉ(Tn−Tn−1)\hat{\lambda}_n = \frac{K}{\bar{w}\left(T_n - T_{n-1}\right)}

Why K matters

KK is the number of engagement units per block. It trades noise against time resolution. If posts arrive as a Poisson process with unit weights, block times follow an Erlang distribution:

E[Δ]=Kλ,CV⁡[Δ]=1K\mathbb{E}[\Delta] = \frac{K}{\lambda}, \qquad \operatorname{CV}[\Delta] = \frac{1}{\sqrt{K}}
K versus jitter
KK (unit weights)Block-time jitterBehaviour
1±100%Every post is a block: pure noise
20±22%Responsive, visibly noisy
100±10%Clean signal, slow to react

For real streams, with unequal weights and bursty arrivals, the general result is:

E[Δ]≈Kwˉ λ,CV⁡[Δ]2≈DK,D=wˉ(cw2+F)\mathbb{E}[\Delta] \approx \frac{K}{\bar{w}\,\lambda}, \qquad \operatorname{CV}[\Delta]^2 \approx \frac{D}{K}, \qquad D = \bar{w}\left(c_w^2 + F\right)
Here cwc_w is the relative spread of the weights and FF the burstiness of arrivals: F=1F = 1 for Poisson arrivals, and F=1/(1−n)2F = 1/(1 - n)^2 when a fraction nn of posts are reactions to earlier posts.

A change in engagement shorter than one block is invisible. But block time shrinks when engagement rises, so the chain samples faster exactly when more is happening.

Choosing K

KK is set from a target block time Δ∗\Delta^* at the stream's baseline rate λ0\lambda_0:

K=wˉ⋅λ0⋅Δ∗K = \bar{w} \cdot \lambda_0 \cdot \Delta^*

KK is not retargeted quickly. Bitcoin-style difficulty adjustment exists to hold block time constant, which would erase the signal. KK stays fixed within an epoch.

Simulation check

A simulation with 2 million Poisson arrivals matches the noise formula within 2% for K≥20K \ge 20.

Simulated vs predicted CV
KKUnit weights, simulatedPredictedLognormal weights, simulatedPredicted
200.2230.2240.3570.362
600.1290.1290.2080.209
1000.1000.1000.1600.162
4000.0490.0500.0810.081

Try it: block-rate calculator

Move the inputs to see how the threshold, the weights and the arrival rate set block time, and how an event speeds the chain up. Presets are illustrative assumptions, not measurements.

ENGAGEMENT UNITS / H
360
MEAN BLOCK TIME (Δ\Delta)
10.0 min
BLOCKS / DAY
144
POSTS / BLOCK
about 20
BLOCK-TIME JITTER (CV)
±36%
BURSTINESS (FF)
1.00
SIMULATED 12 H · EVENT WINDOW 5X BETWEEN 06:00 AND 08:00 · 121 BLOCKS
00:0006:0012:00

Each line is a block. Before the event the chain closes 5.8 blocks/h; during it, 30.5 blocks/h. The engagement rate λ^n\hat{\lambda}_n is never stored. It is decoded from the gaps between blocks.

Block production on the testnet

The relayer evaluates these rules every tick, in order:

  1. Refresh live metrics for open posts (every refreshInterval, and always right before a seal). A candidate becomes qualified once it has likes ≥ minLikes; candidates that don't qualify by the end of the UTC day they were first read expire.
  2. FULL block. If ≥ blockSize qualified posts from distinct authors are waiting, seal a block with the oldest blockSize of them (one per author) plus up to maxMaturedPerBlock matured posts that are ready. Repeat while the condition holds, which absorbs bursts.
  3. TIMEOUT block. If now − lastBlock.timestamp ≥ maxBlockTime, seal a heartbeat block with whatever is qualified (possibly nothing). TIMEOUT blocks never emit.

Post lifecycle: CANDIDATE → QUALIFIED → INCLUDED (NEW leaf) → MATURED (24 h leaf), or CANDIDATE → EXPIRED. An author's later posts are deferred to the next block, not dropped.

Testnet block-production parameters
ParameterInitialWhere
blockSize10 new posts per FULL blockOn-chain (Sequencer), read by the relayer
maxBlockTime3,600 s (1 h heartbeat; the design uses 6 h)On-chain
minLikes1Off-chain params
candidateWindowUntil 23:59:59 UTC of the first-read dayOff-chain params
refreshInterval300 s, plus a forced refresh before every sealOff-chain params
maturityDelay24 h after the post was createdOff-chain params
maxMaturedPerBlock200Off-chain params
Design vs testnet: block production
Protocol designTestnet v1
Stream$BUZZ cashtag + project reference, original posts onlyPosts mentioning @buzzchain_io, plus the account's own posts and quotes; replies and quotes count, reposts and the account's own replies don't
What closes a blockAccumulated weight reaches KK10 qualified posts from distinct authors (unit weights, K=10K = 10)
Heartbeat6 h1 h (TIMEOUT block)
Target block time Δ∗\Delta^*10 min at baselineSet by how fast 10 qualified posts arrive
Ordering inside a blockPost IDOldest first (created_at), one post per author
Engagement readingsThree checkpoints: 15 minutes, 2 hours and 24 hours after postingTwo: at seal, and 24 hours after the post was created (MATURED leaf)

Per-topic block rate

The mechanism is not tied to one query. Any topic with a steady flow of posts can drive a chain, and each topic gets its own threshold from its own baseline:

Ktopic=wˉ⋅λ0,topic⋅Δ∗K_{\text{topic}} = \bar{w} \cdot \lambda_{0,\text{topic}} \cdot \Delta^*

Block rate then measures activity relative to that topic's normal level: a niche topic that spikes tenfold produces as many extra blocks as a large topic that spikes tenfold. See Beyond $BUZZ.

04 · MECHANISM

Weights, breadth & loudness

Buzzchain measures every block twice. Breadth decides when a block closes. Loudness decides what it pays.

Post weights

A post's weight is an account factor times an engagement factor. Both use log scales, so heavier voices count more without any single account taking over the chain. Weights decide when a block closes, not what it pays.

w=a⋅ea=min⁡(4, 1+log⁡10(1+followers1000))e=1+ln⁡(1+likes+2⋅reposts)\begin{gathered} w = a \cdot e \\ a = \min\left(4,\ 1 + \log_{10}\left(1 + \frac{\text{followers}}{1000}\right)\right) \\ e = 1 + \ln\left(1 + \text{likes} + 2 \cdot \text{reposts}\right) \end{gathered}
Original posts only
Replies and reposts do not enter the stream. A repost counts as engagement on the original post, not as a post of its own.
Account factor
Measures reach, capped at 4.
Engagement factor
Measures how many people reacted to the post. It is read at three checkpoints, described in Engagement over time.
One author per block
Only the first post of each account in a block counts. This blunts spam and repost cascades.
Account age minimum
Accounts younger than a set age do not count. The threshold is to be set.

Why logarithms

Followers and likes are heavy-tailed. With linear weights, one viral post would close thousands of blocks alone, and the chain would measure one account's reach, not mindshare.

Example weights
Example postAccount factorEngagement factorWeight
50 followers, no engagement1.01.01.0
5,000 followers, 20 likes, 5 reposts1.84.47.9
100,000 followers, 1,000 likes, 300 reposts3.08.425.2
10 million followers, 50,000 likes, 10,000 reposts4.0 (capped)12.248.6

The largest account in the table has 200,000 times the followers of the smallest and counts about 49 times as much.

Engagement over time

A post is read at three checkpoints: 15 minutes, 2 hours and 24 hours after posting. The first reading enters the block that is open at that moment, with the full weight w=a⋅ew = a \cdot e. Each later reading adds only the growth since the previous reading, to whichever block is open then:

Δw=a⋅[ln⁡(1+xnow)−ln⁡(1+xbefore)]\Delta w = a \cdot \left[\ln(1 + x_{\text{now}}) - \ln(1 + x_{\text{before}})\right]
Here x=likes+2⋅repostsx = \text{likes} + 2 \cdot \text{reposts} is the post's raw engagement at a reading.

Closed blocks never change. Engagement that disappears is not subtracted.

Example. An account with 5,000 followers has a=1+log⁡10(6)≈1.78a = 1 + \log_{10}(6) \approx 1.78. Its post has 100 likes at 15 minutes, so e=1+ln⁡(101)≈5.62e = 1 + \ln(101) \approx 5.62 and the post enters the open block with weight w≈10.0w \approx 10.0. At 2 hours it has 500 likes. The growth Δw=1.78⋅[ln⁡(501)−ln⁡(101)]≈2.8\Delta w = 1.78 \cdot \left[\ln(501) - \ln(101)\right] \approx 2.8 goes to the block that is open at that moment. The block that received the first 10.0 does not change.

Breadth and loudness

Breadth vs loudness
BreadthLoudness
What it countsWeighted posts, log-compressedRaw engagement, uncompressed
FormulaWn=∑i∈nwiW_n = \sum_{i \in n} w_iLn=∑i∈nℓiL_n = \sum_{i \in n} \ell_i
What it decidesWhen the block closesHow much $BUZZ the block mints
How it behavesNearly the same for every blockDifferent for every block

The sums run over the readings that entered block nn. Here wiw_i is a reading's weight (the full weight at the first checkpoint, the growth Δw\Delta w after that) and ℓi\ell_i is its loudness, computed from the post's raw engagement:

xi=likesi+2⋅repostsix_i = \text{likes}_i + 2 \cdot \text{reposts}_i

A post adds 1+xi1 + x_i to the loudness of the block it first enters, and its growth xnow−xbeforex_{\text{now}} - x_{\text{before}} to the block that is open at each later checkpoint. Engagement per post is capped at xmax⁡x_{\max}.

Why two measures? The logarithms make breadth steady. Every block closes at the same threshold KK, so every block holds about the same number of voices, which is what makes block time a clean signal. But those voices are not equally loud: one block is twenty quiet posts, the next contains a post half the timeline reacted to. Breadth treats them as equals. Loudness does not.

The block reward

Rn=β⋅Ln⋅(1−QnE)R_n = \beta \cdot \sqrt{L_n} \cdot \left(1 - \frac{Q_n}{E}\right)
β\beta
The base emission rate, fixed at BGE.
Ln\sqrt{L_n}
The loudness term: a block four times louder earns twice as much.
1−Qn/E1 - Q_n/E
The share of the block reward pool still left. It scales every reward down as supply grows.

How much blocks vary

A simulation of 3 million posts with heavy-tailed followers and engagement, at K=60K = 60 (about 19 posts per block), shows how the loudness term alone spreads rewards across blocks. The table compares the square root with two other exponents, writing the loudness term as LnγL_n^{\gamma}:

Reward dispersion by exponent
γ\gamma9 in 10 blocks pay less than1 in 100 blocks pays more thanLargest blockShare from top 1% of blocks
12.2× the median6.0× the median112× the median7.7%
0.5 (design)1.5× the median2.4× the median11× the median2.8%
0.251.2× the median1.6× the median3× the median1.7%

These figures come from assumed distributions, not from X data. Real engagement is likely heavier-tailed, which would make blocks vary more. The real distribution is measured before BGE.

Why the square root

  • With γ=1\gamma = 1 the reward would be linear in engagement. A single viral post could claim a large part of the pool, and buying engagement would pay at a constant rate.
  • With the square root, γ=0.5\gamma = 0.5, blocks still differ clearly, but returns diminish: four times the engagement gives twice the reward.

One consequence: with an exponent below 1, block size matters. The same engagement cut into smaller blocks adds up to more reward than in larger blocks, roughly in proportion to K−(1−γ)K^{-(1-\gamma)}. In the simulation, tripling KK lowered the total by about 40%. This is why KK is fixed at BGE together with the emission rate.

Engagement checkpoints

Loudness and weight are read from the same three checkpoints: 15 minutes, 2 hours and 24 hours after posting. Engagement that arrives after the last checkpoint does not count. Later checkpoints never delay a block, because each reading goes to whichever block is open when it is taken. See Engagement over time.

Loudness on the testnet

L(m)=likes+2⋅reposts+replies+quotesL(m) = \text{likes} + 2 \cdot \text{reposts} + \text{replies} + \text{quotes}
Testnet weights: the design's raw engagement x = likes + 2 · reposts, with replies and quotes also counted at weight 1. The design's extra 1 per post is not applied on testnet.
emission={min⁡(cap, maxEmissionPerBlock, β⋅⌊L⌋)FULL block0TIMEOUT block\text{emission} = \begin{cases} \min\left(\text{cap},\ \text{maxEmissionPerBlock},\ \beta \cdot \lfloor\sqrt{L}\rfloor\right) & \text{FULL block} \\ 0 & \text{TIMEOUT block} \end{cases}
Testnet values: the design's square root (curve = sqrt), β\beta = k = 200 BUZZ, and a per-block cap equal to the daily speed limit, cap = maxEmissionPerBlock = 356,440 BUZZ (0.19% of the 187,600,000 pool). β\beta is a testnet estimate: it gives a 24-month attention half-life if blocks close every 10 minutes with an average L≈6.2\sqrt{L} \approx 6.2, and may be adjusted as the testnet runs. The pool factor 1−Qn/E1 - Q_n/E and the daily speed limit are not applied on testnet; at testnet volumes the pool factor stays above 0.999.

Raw metrics never go on-chain. Likes, replies and quotes stay off-chain. The chain and the public API expose only loudness, so nobody compares “100 likes on X” with a smaller on-chain number: loudness is the abstraction.

05 · MECHANISM

Blocks & anchoring

What a block contains and how Ethereum anchors the history.

Block contents

Each block records:

  • Height and the hash of the previous block
  • The Merkle root of its readings, in post-ID order
  • Total weight and the carry-over remainder
  • Loudness: the raw engagement of its readings, which sets the block reward
  • The timestamp of the reading that closed it
leafi=hash⁡(post IDi, checkpointi, hash⁡(readingi), wi, ℓi)\text{leaf}_i = \operatorname{hash}\left(\text{post ID}_i,\ \text{checkpoint}_i,\ \operatorname{hash}(\text{reading}_i),\ w_i,\ \ell_i\right)

A leaf names the post, the checkpoint it was read at (15 minutes, 2 hours or 24 hours), a hash of that reading, and the weight wiw_i and loudness ℓi\ell_i it added to the block. Only IDs, hashes and these numbers are stored, not post text. This keeps the chain verifiable without redistributing X content.

Where each part runs

Components
LayerWhere it runsWhat it does
Stream indexerOff-chainPulls matching posts and records a reading at each checkpoint
Block builderOff-chain, run by the Buzzchain teamApplies Proof of Engagement. The rules are public, so anyone with the same data can replay it and compare
Checkpoint contractEthereumStores block hashes at regular intervals, posted by the Buzzchain team
$BUZZ and rewardsEthereumToken, seat staking, and reward claims

Verification

Block construction is a pure function of the query, the parameters and the readings. Blocks are built and checkpointed by the Buzzchain team. The rules are public, and anyone with the same data can replay them and compare hashes. If a published checkpoint does not match an independent replay, anyone can show it.

Trust model

Trust model
ComponentTrustWhy
XTrusted for ordering and availabilityIt can censor posts or cut access
Buzzchain teamTrusted to build blocks and post checkpointsIts output can be replayed by anyone with the same data, so a wrong checkpoint can be shown
EthereumTrusted for integrityMakes the published history tamper-evident

Whether checkpoints go to Ethereum mainnet or an L2 is open. It depends on gas cost per checkpoint.

Settlement on the testnet

Post
An eligible X post mentioning @buzzchain_io, or one of the account's own posts.
Block
A sealed, off-chain group of posts. Sealing gives a soft confirmation (API status sealed).
Batch
One L1 transaction that settles one or more consecutive blocks. Settlement gives L1 finality (status settled).
  • O(1) storage per batch. The contract stores one headersRoot (a Merkle root over the batch's block hashes) and a two-slot record, whatever the number of blocks or posts.
  • Calldata data availability. Each block's leaves travel as packed calldata (17 bytes per post), bound to the header by dataHash, so anyone can rebuild every block from L1 alone.
  • On-chain safety rails. emission ≤ maxEmissionPerBlock, TIMEOUT ⇒ emission == 0, FULL ⇒ newPosts == blockSize, contiguous numbers, chained parentHash, monotonic timestamps.
  • Gas on Sepolia: about 280k for a one-block TIMEOUT batch and 350k–540k for a one-block FULL batch, which also mints $BUZZ and notifies the vault. Every settle transaction is listed on the sequencer's Etherscan page.

See Encodings for the exact leaf, header and tree formats, and Verify a post for inclusion proofs.

06 · LAUNCH

Launch

Before BGE: the proof of concept

Before block 0, Buzzchain runs as a proof of concept. The full data system is live and public, with no token and no rewards. Its job is to prove the mechanism and fix the parameters.

Engagement already produces blocks and virtual supply, so the pre-BGE data shows what seats would have earned.

What runs before BGE
ComponentState before BGE
Stream indexerLive. Collects qualifying posts and records a reading at each checkpoint
Post weightsLive. Same formula that will be used after BGE
BlocksLive. Built with the real Proof of Engagement rule and published, but not rewarded
Virtual supplyLive. The $BUZZ blocks would have minted, computed with the real reward formula. Nothing is minted
ExplorerLive. Shows the accumulator, blocks and block rate
Checkpoints on EthereumTest only
$BUZZ emissionOff

Blocks produced before BGE mint no $BUZZ.

The stream

The proof of concept uses Buzzchain's own engagement as its data. A post qualifies if it:

  • contains the $BUZZ cashtag, and
  • references the project (the official handle or the word “Buzzchain”), and
  • is an original post, not a reply or a repost.

The project reference matters: other tokens use the BUZZ ticker, and without it their posts would produce Buzzchain blocks.

What it settles

  1. The parameters. The baseline rate λ0\lambda_0, the mean weight wˉ\bar{w} and the weight spread cwc_w are measured, and KK is set from them.
  2. The model. Measured block-time noise is compared with the prediction D/K\sqrt{D/K}.
  3. Determinism. Independent replays of the same data must produce identical blocks.
  4. Loudness. The real engagement per block is measured and projected forward. That fixes the base emission rate β\beta for a 24-month half-life.
  5. Data quality. The share of weight coming from accounts that look inauthentic is tracked, and the filters are tuned.
Pre-BGE parameters
ParameterSymbolValue
Stream query$BUZZ plus a project reference, original posts only
Length of the phaseNNTo be set
Engagement checkpoints15 minutes, 2 hours and 24 hours after posting
Target block time at baselineΔ∗\Delta^*10 minutes
ThresholdKKCalibrated during this phase
Heartbeat interval6 hours
Account weight cap4

Block Generation Event

The Block Generation Event (BGE) is day one of Buzzchain: the moment the proof of concept becomes a live pseudochain. Seats are offered, the token is deployed, block 0 is produced, and $BUZZ emission begins.

  1. Seats. Validator seats are offered at BGE, with a cap on how many one wallet can buy. The terms will be announced before BGE.
  2. Token. The token contract is deployed. 56,000,000 $BUZZ are minted to seed the liquidity pool. The builders and team allocations are minted and locked.
  3. Block 0. KK and β\beta are fixed from the pre-BGE measurements, the accumulator is reset to zero, and the first live block is produced.
What changes at BGE
Before BGEFrom block 0
BlocksPublished without rewardsLive blocks, checkpointed on Ethereum
EmissionVirtual onlySet by each block’s loudness, drawn from a capped pool
SupplyNone92,400,000 at BGE, capped at 280,000,000
ValidatorsNoneStaked seats receive the $BUZZ minted in every block
Reward for postingNoneNone
BGE parameters
ParameterSymbolValue
Validator seatsTo be announced before BGE
Purchase cap per walletTo be announced before BGE
Threshold at block 0KKFrom pre-BGE calibration
Base emission rateβ\betaFixed at BGE for a 24-month half-life
Liquidity pool56,000,000 $BUZZ
Builders and team22,400,000 and 14,000,000 $BUZZ, locked
Maximum supply280,000,000 $BUZZ

The reflexive loop

From block 0, the stream is about a token that the stream itself mints. Posts produce blocks, blocks produce emission, and emission can produce more posts. A simple model: let hjh_j be the engagement in epoch jj, and suppose a fraction gg of it is caused by the previous epoch's activity.

hj+1=h0+g⋅hj⟹h∗=h01−gh_{j+1} = h_0 + g \cdot h_j \quad\Longrightarrow\quad h^* = \frac{h_0}{1 - g}
  • For g<1g < 1 the loop settles, amplifying the organic baseline h0h_0 by 1/(1−g)1/(1-g). Only a fraction 1−g1 - g of blocks reflects outside interest.
  • For g≥1g \ge 1 the loop does not settle by itself. Three things brake it: the square root in the reward (emission grows more slowly than engagement), the shrinking pool (every block mints a share of what is left), and the daily speed limit. A spiral can bring emission forward, up to the speed limit. It cannot push supply past the cap.

This model is a hypothesis. The pre-BGE phase gives the baseline with no emission, and the first epochs after BGE give the first measurement of gg.

Beyond $BUZZ: other topics

After BGE, the same machinery can point at outside topics. Each topic gets its own threshold from its own baseline, as described in Per-topic block rate. The app will have a place to propose and choose topics.

How topics are chosen

The selection rule is not decided. Two candidates:

Topic selection options
OptionHow it worksTrade-off
Vote$BUZZ holders stake and vote on the next topic each epochOne topic at a time. Needs governance
Topic tokensAnyone opens a topic by committing $BUZZ. The topic emits its own token, settled in $BUZZMany topics in parallel. The settlement rule is undefined

07 · NETWORK

Validators

A validator holds a seat, and a seat is a validator NFT. Staking it is the only requirement. Each block's $BUZZ is split equally among the staked seats.

A seat is a validator NFT

Each seat is an NFT. Staking it in the validator contract is the only requirement. There is nothing to install and nothing to run.

What validators do in this version

In this version, validators stake. They do not sign blocks, run software or store data. The integrity of the chain comes from the public rules and the Ethereum checkpoints. Active duties, such as signing checkpoints, may come in a later version.

Rewards

Each block mints a reward RnR_n set by its loudness. It is split equally among the staked seats:

reward per seat=RnSstaked\text{reward per seat} = \frac{R_n}{S_{\text{staked}}}
Here SstakedS_{\text{staked}} is the number of seats staked when block nn closes.

Seats work like hash power: the more seats a holder stakes, the larger their share of each block. An unstaked seat earns nothing. Posts earn nothing.

More engagement, more $BUZZ

When the conversation grows, blocks arrive faster and are louder, and staked seats receive more $BUZZ. When it goes quiet, blocks are fewer and smaller, and fewer new $BUZZ enter circulation.

Getting and trading a seat

Seats are offered at BGE, with a cap on how many one wallet can buy. After BGE they are transferable and can be bought and sold on secondary NFT marketplaces such as OpenSea. No new seats are created after BGE. Holdings are visible onchain.

Validator parameters
ParameterValue
Reward splitEqual per staked seat
Reward per blockSet by loudness, see Block rewards
TransfersAllowed
Number of seatsTo be announced before BGE
Purchase cap per wallet at BGETo be announced before BGE

Validators on the testnet

The vault keeps an exact invariant at all times: token.balanceOf(vault) == queued + Σ pendingRewards(staked seats). See Stake and claim for code.

08 · NETWORK

Tokenomics

$BUZZ is the native token of Buzzchain. Two thirds of it is minted block by block, and every block pays according to how loud it is. Supply is capped, and emission is slow by design.

At a glance

Token parameters
ParameterValue
Ticker$BUZZ
Maximum supply280,000,000
Block rewards187,600,000 (67%)
Liquidity pool56,000,000 (20%)
Builders22,400,000 (8%), locked at BGE
Team14,000,000 (5%), locked at BGE
Supply at BGE, circulating plus locked92,400,000
Target half-life24 months
Speed limitThe pool never halves faster than every 12 months

The cap of 280,000,000 is a nod to the 280 characters of a post on X, the data source that powers the chain.

Supply

No more than 280,000,000 $BUZZ will ever exist. The cap is a constant in the token contract on Ethereum: minting reverts if it would exceed it, and no role can change it.

Allocation
AllocationShare$BUZZTerms
Block rewards67%187,600,000Minted only as blocks are produced. Paid to staked validator seats
Liquidity pool20%56,000,000Minted at BGE to seed the liquidity pool
Builders8%22,400,000For people who build on Buzzchain: new streams, tools, applications. Locked at BGE
Team5%14,000,000Locked at BGE

At BGE, 92,400,000 $BUZZ exist: the liquidity pool in circulation, and the builders and team allocations locked. The other 187,600,000 can only enter circulation as block rewards. Vesting for the builders and team allocations is to be announced.

Block rewards

Buzzchain has no fixed block reward. Each block nn has a loudness LnL_n, the raw engagement of the readings it contains, and its reward follows it:

Rn=β⋅Ln⋅(1−QnE)R_n = \beta \cdot \sqrt{L_n} \cdot \left(1 - \frac{Q_n}{E}\right)
Reward symbols
SymbolMeaning
RnR_n$BUZZ minted in block nn
LnL_nLoudness of block nn
β\betaBase emission rate, fixed at BGE
QnQ_n$BUZZ already emitted as block rewards
EEThe block reward pool, E=187,600,000E = 187{,}600{,}000

Loudness. Louder blocks earn more. The reward grows with the square root of loudness, so a block four times louder earns twice as much. What is left. Every block mints a share of what remains in the pool. At BGE a block earns the full amount. When half the pool has been emitted, an equally loud block earns half as much.

REWARD RnR_n
20.00 β\beta
SAME BLOCK, 4X LOUDER
40.00 β\beta (2.00x)
POOL LEFT
187.6M
DAILY SPEED LIMIT
356,440 BUZZ

β\beta is fixed at BGE, so rewards are shown in units of β\beta. The speed limit is 0.19% of the remaining pool per day, and (1−0.0019)365≈0.50(1 - 0.0019)^{365} \approx 0.50, which is why the pool can never halve faster than once a year. The design uses the square root, γ=0.5\gamma = 0.5.

Emission follows engagement

When the conversation grows, blocks arrive faster and are louder, and staked seats receive more $BUZZ. When it goes quiet, blocks are fewer and smaller, and fewer new $BUZZ enter circulation.

Halving by attention

Buzzchain has no halving dates and no halving block heights. The clock of emission is cumulative attention, the running sum of the loudness term of every block:

An=∑i≤nLiA_n = \sum_{i \le n} \sqrt{L_i}

Each block mints β\beta times its loudness term, scaled by the share of the pool still left. The remaining pool therefore decays exponentially in cumulative attention, and halves every time AnA_n grows by the attention half-life A1/2A_{1/2}:

E−Qn≈E⋅e−βAn/E,A1/2=Eln⁡2βE - Q_n \approx E \cdot e^{-\beta A_n / E}, \qquad A_{1/2} = \frac{E \ln 2}{\beta}

Heavy conversation moves the chain along its emission curve faster. Silence slows it down. Supply approaches 280,000,000 and never crosses it.

Slow by design

The target: 24 months
The base rate β\beta is set once, at BGE, so that A1/2A_{1/2} equals about 24 months of expected engagement. The estimate comes from the engagement measured before BGE.
The speed limit: 12 months
No more than 0.19% of the remaining pool can be emitted in one day, so the pool can never halve faster than once every 12 months, however loud the conversation gets. On a normal day the limit is not reached. If a day’s blocks would exceed it, every reward that day is scaled down by the same factor.

Attention sets the pace, within a speed limit.

92.4M140M210M280MBGEY1Y2Y3Y4fastest pace (12-month speed limit)target pace (24-month half-life)cap 280,000,000
Total $BUZZ supply over the first four years, at the target pace and at the fastest pace the speed limit allows. Attention, not the calendar, moves supply along the curve.
Emission schedule
Years after BGETotal supply, target paceTotal supply, fastest pace
0 (BGE)92,400,00092,400,000
1147,300,000186,200,000
2186,200,000233,100,000
3213,700,000256,600,000
4233,100,000268,300,000

The target column is an estimate, not a promise. Less engagement than expected stretches the schedule. More engagement compresses it, but never past the fastest-pace column.

Who receives rewards, and what is still open

The $BUZZ minted in each block goes to the staked validator seats, as described in Validators. Still to be defined:

  • The value of β\beta, fixed at BGE from the pre-BGE data.
  • What the 56,000,000 $BUZZ in the liquidity pool are paired with.
  • Vesting for the builders and team allocations.
  • How validators are paid once block rewards become small.

Nothing in these docs is financial advice or a promise of returns. A token with emissions may be regulated in some jurisdictions.

09 · DEVELOPERS

Build on Buzzchain

Buzzchain is a public, verifiable time series of attention. Read blocks and block rate, prove that a post was included, index the chain from Ethereum logs, or build on the validator vault. Everything here works against the Sepolia testnet contracts and the relayer's public API.

What you can build

Signals
Anything that reads block rate as a signal: alerts when the chain speeds up, dashboards of attention, markets that settle on block counts. Block rate is decodable from two consecutive block timestamps.
Proofs
“Was my post included, and how loud was it?” Verify any post against L1, through the API or from calldata alone.
Indexers
Follow the chain from BlockSealed and BatchSettled events; every block's leaves are in the settle calldata.
Validator tooling
Stake Buzz Validator NFTs, track pending rewards, claim.
Building blocks
PieceWhereUse it for
Contract ABIsContract referenceJSON ABIs with NatSpec, ready for viem, ethers or any Ethereum library
ContractsSepolia addressesRead views, index events, stake and claim
Public API/api/*Read-only JSON: blocks, posts with proofs, stats, series, params
EncodingsEncodingsRebuild leaves, roots and proofs yourself

The examples below use viem. Save each ABI from the contract reference (COPY ABI) as a JSON file next to your code.

Networks & contract addresses

Ethereum Sepolia (testnet) chainId 11155111 DEPLOYED

Ethereum Sepolia (testnet) addresses
ContractRoleAddress
BuzzchainSequencerSettlement, proofs, params (proxy)0x44e6c7bC1146259Ff63a9b514B42C86F272631a2
BuzzToken$BUZZ ERC-200xc8bdca3cFD13BcB2b1E5C4Aa3bc35C7196009e2b
BuzzchainValidatorValidator NFT (ERC-721)0xb5aAdd62fbC1e42bbEF02dDbBbcef053ff2acdf9
BuzzchainValidatorVaultStaking & rewards (proxy)0x5263121Df28F91EC3c2773814a7c798c0849E148
BuzzchainValidatorFaucetTestnet validator faucet0x0419ecE34c8124Ec121495C9E5f4956620DC6b28
BuzzchainSequencer impl.UUPS implementation0xA6BB84310E5e4964D03d49A7CE2919FA9D70a5C3
BuzzchainValidatorVault impl.UUPS implementation0xB70388371EC3D715AB0F89623d9E67A73e647fEe
Relayer EOAHolds SEQUENCER_ROLE0x19047640CC347F6B8626cD8DE76A7A7a672880f0

Genesis (block 0): hash 0xd4b3ee09f13380bcab2dfdc57e18d4bd5922748e40a02fad77054486b880cc3e, timestamp 1795093152, deployed at L1 block 12168560.

Endpoints

Endpoints
EnvironmentRelayer APINotes
Sepolia testnethttps://api.testnet.buzzchain.xyzRead-only /api/*; settles to the Sepolia sequencer above

Quickstart

client.ts
import { createPublicClient, http } from 'viem';
import { sepolia } from 'viem/chains';
import sequencerAbi from './BuzzchainSequencer.json'; // COPY ABI in the contract reference

export const SEQUENCER = '0x44e6c7bC1146259Ff63a9b514B42C86F272631a2'; // BuzzchainSequencer proxy (Sepolia)
export const API = 'https://<relayer>';                                   // see Endpoints above
export const client = createPublicClient({ chain: sepolia, transport: http(process.env.RPC_URL) });
export { sequencerAbi };

Verify a post

Inclusion is two Merkle proofs: the post's leaf against header.postsRoot, then blockHash(header) against the batch's headersRoot stored on L1. The API is not trusted: it serves both proofs, and the contract's verifyPost view checks them against what is on Ethereum.

Proofs from the API, checked on Ethereum
import { API, SEQUENCER, client, sequencerAbi } from './client';

const id = '2123427782277661174';                               // decimal string: post IDs exceed 2^53
const post = await fetch(`${API}/api/posts/${id}`).then(r => r.json());
for (const leaf of post.inclusions) {                           // NEW first, then MATURED
  if (leaf.status !== 'settled') { console.log(leaf.kind, 'not settled on L1 yet'); continue; }
  const h = leaf.header;                                        // big fields are decimal strings
  const header = { ...h, number: BigInt(h.number), timestamp: BigInt(h.timestamp),
                   loudness: BigInt(h.loudness), emission: BigInt(h.emission) };
  const ok = await client.readContract({
    address: SEQUENCER, abi: sequencerAbi, functionName: 'verifyPost',
    args: [BigInt(leaf.batchIndex), header, leaf.headerProof, BigInt(post.postId),
           leaf.kind === 'NEW' ? 0 : 1, BigInt(leaf.loudness), leaf.postProof],
  });
  console.log(leaf.kind, leaf.loudness, `block #${leaf.blockNumber}`, ok ? '✓ verified on Ethereum' : '✗');
}

From L1 alone (no API)

Every block can be rebuilt from Ethereum without the relayer:

  1. Find the batch: batchOf(blockNumber), then its BatchSettled log and transaction.
  2. Decode the transaction input as settle(headers, postData) with the sequencer ABI.
  3. For each header, check keccak256(postData[i]) == dataHash, split postData[i] into 17-byte leaves (Encodings), and rebuild postsRoot with @openzeppelin/merkle-tree (StandardMerkleTree.of(leaves, ['uint64', 'uint8', 'uint64'])).
  4. Rebuild headersRoot from the block hashes and compare it with batch(i).headersRoot. Leaf counts must match newPosts/maturedPosts, and leaf loudness must sum to header.loudness.

Read the chain & block rate

ts
import { API, SEQUENCER, client, sequencerAbi } from './client';
const read = (functionName: string, args: unknown[] = []) =>
  client.readContract({ address: SEQUENCER, abi: sequencerAbi, functionName, args });

const [number, hash, timestamp] = await read('latestBlock'); // last block on L1
const i = await read('batchOf', [number]);                    // batch index (reverts BlockNotSettled for 0 / unsettled)
const b = await read('batch', [i]);                           // { headersRoot, firstBlock, lastBlock, l1Timestamp }
const [blockSize, maxBlockTime, maxEmissionPerBlock] = await read('params');

// Block rate from the API's hourly series: blocks per bucket is the attention signal.
const series = await fetch(`${API}/api/series?interval=hour`).then(r => r.json());
for (const pt of series.points) console.log(new Date(pt.t * 1000).toISOString(), pt.blocks, pt.loudness);

// Time between the two newest blocks (Proof of Engagement: λ̂ = K / (w̄ · Δt)).
const [b1, b0] = (await fetch(`${API}/api/live?limit=2`).then(r => r.json())).blocks; // newest first
const blocksPerHour = 3600 / Math.max(1, b1.timestamp - b0.timestamp);

Big numbers (post IDs, loudness, emission) are decimal strings in the API. Never parse post IDs as JS numbers: they exceed 253.

Index events

The sequencer emits one BlockSealed per block, in block order, then one BatchSettled per settle call. That is enough to follow the chain without the API.

ts
import { SEQUENCER, client, sequencerAbi } from './client';

const unwatch = client.watchContractEvent({
  address: SEQUENCER,
  abi: sequencerAbi,
  eventName: 'BlockSealed',
  onLogs: logs => {
    for (const { args } of logs)
      console.log(`#${args.number}`, args.kind === 0 ? 'FULL' : 'TIMEOUT', 'loudness', args.loudness, 'emission', args.emission);
  },
});
Events to index
EventIndexedPayload
BlockSealednumber, blockHashpostsRoot, loudness, emission (wei), kind (0 FULL, 1 TIMEOUT)
BatchSettledbatchIndexfirstBlock, lastBlock, headersRoot, totalEmission
ParamsUpdated—blockSize, maxBlockTime, maxEmissionPerBlock
RewardNotified (vault)—amount, distributed, queued
Staked / Unstaked / Claimed (vault)owner, tokenIdamount

Get a validator, stake and claim

Each staked Buzz Validator NFT is one seat with an equal share of emission. These are write calls from the holder's own wallet. On Sepolia, get a validator from BuzzchainValidatorFaucet first: claim() mints AMOUNT_PER_CLAIM validators (currently 1) to the caller, once per address, for exactly PRICE wei (0.01 Sepolia ETH), and returns the first new token ID.

ts
import faucetAbi from './BuzzchainValidatorFaucet.json';
import validatorAbi from './BuzzchainValidator.json';
import vaultAbi from './BuzzchainValidatorVault.json';
import { client } from './client';
// wallet: a viem WalletClient for the holder's account

const FAUCET = '0x0419ecE34c8124Ec121495C9E5f4956620DC6b28';
const VALIDATOR = '0xb5aAdd62fbC1e42bbEF02dDbBbcef053ff2acdf9';
const VAULT = '0x5263121Df28F91EC3c2773814a7c798c0849E148';

// 0. Testnet only: claim a validator from the faucet (once per address, exact payment).
const price = await client.readContract({ address: FAUCET, abi: faucetAbi, functionName: 'PRICE' });
const { result: firstId, request } = await client.simulateContract({
  account: wallet.account, address: FAUCET, abi: faucetAbi, functionName: 'claim', value: price,
});
await wallet.writeContract(request);  // also emitted as Claimed(account, firstId, count, paid)
const ids = [firstId];

// 1. Let the vault move your NFTs (or send one with safeTransferFrom(owner, VAULT, id): it stakes on receipt).
await wallet.writeContract({ address: VALIDATOR, abi: validatorAbi, functionName: 'setApprovalForAll', args: [VAULT, true] });
// 2. Stake.
await wallet.writeContract({ address: VAULT, abi: vaultAbi, functionName: 'stake', args: [ids] });
// 3. Read and claim rewards (BUZZ wei).
const pending = await client.readContract({ address: VAULT, abi: vaultAbi, functionName: 'pendingRewards', args: [ids[0]] });
await wallet.writeContract({ address: VAULT, abi: vaultAbi, functionName: 'claim', args: [ids] });
// 4. Unstake pays pending rewards first, then returns the NFTs.
await wallet.writeContract({ address: VAULT, abi: vaultAbi, functionName: 'unstake', args: [ids] });

Encodings

Normative for Solidity and TypeScript alike.

Leaf
abi.encode(uint64 postId, uint8 kind, uint64 loudness), with kind 0 = NEW (scored at seal), 1 = MATURED (24 h delta). Deliberately minimal: a user can verify inclusion knowing only the post ID and its loudness.
Leaf hash
keccak256(bytes.concat(keccak256(leafAbi))), the OpenZeppelin StandardMerkleTree convention. Pairs are hashed sorted, so proofs work with MerkleProof.verify and @openzeppelin/merkle-tree.
Packed post data
abi.encodePacked(postId, kind, loudness) per leaf: 17 bytes, ≈ 270 gas of calldata per post. Only hashed on-chain (dataHash), so anyone can rebuild postsRoot from L1 alone.
Block hash
keccak256(abi.encode(header)) over the 352-byte ABI encoding of BlockHeader.
headersRoot
Raw block hashes as leaves, sorted-pair keccak level by level; an odd last node is carried up unchanged. A one-block batch has headersRoot == blockHash. This is not the StandardMerkleTree shape.
IBuzzchainSequencer.BlockHeader
struct BlockHeader {
    uint64  number;        // genesis is 0; parent + 1
    uint64  timestamp;     // unix seconds at seal (non-decreasing)
    bytes32 parentHash;    // blockHash of the previous header
    bytes32 postsRoot;     // StandardMerkleTree root of the leaves; 0 if empty
    bytes32 dataHash;      // keccak256 of the packed post data
    uint32  newPosts;      // NEW leaves
    uint32  maturedPosts;  // MATURED leaves
    uint128 loudness;      // Σ leaf loudness
    uint128 emission;      // BUZZ wei minted to the vault
    uint8   kind;          // 0 FULL, 1 TIMEOUT (never emits)
    uint16  paramsVersion; // off-chain params used to build the block
}

Public API

The relayer serves a read-only JSON API under /api. Only GET, HEAD and OPTIONS are served, and responses never include raw engagement metrics. The API is a convenience: verify what it serves against Ethereum (Verify a post).

API routes
RouteReturnsCache
GET /api/blocks?cursor=&limit=Blocks, newest first, cursor-paginated (limit 1–100)Head 5 s; all-settled pages 1 day
GET /api/blocks/:nA block: header, leaves (loudness only), postData, batch. :n may be latestSettled: 1 day; otherwise 5 s
GET /api/posts/:idStatus, total loudness and every inclusion with both proofsMatured & settled: 1 day; expired: 1 h; otherwise 5 s
GET /api/statsTotals, heads and the active (pending) block15 s
GET /api/live?limit=Stats plus the newest blocks (max 30), in one request5 s
GET /api/series?interval=hour|dayDense time buckets: blocks, posts, loudness, emission, supply15 s
GET /api/params[/:version]The params behind any header's paramsVersion15 s
API conventions
ValueJSON type
Post IDs, loudness, emission, supplyDecimal string (uint64 / uint128)
Block numbers, batch indices, counts, timestampsNumber
Hashes, roots, proofs, postData, tx hashesLowercase 0x hex
Block statussealed (soft confirmation) or settled (on L1)
Errors{ "error": string } with HTTP 400 or 404; unknown or repeated query parameters are a 400

Roles & permissions

Roles
ContractRoleHeld byAllows
BuzzchainSequencerSEQUENCER_ROLERelayer EOAsettle
BuzzchainSequencerPARAMS_ROLEAdminsetParams
BuzzchainSequencerPAUSER_ROLEAdminpause / unpause (views keep working)
Sequencer, VaultUPGRADER_ROLEAdminUUPS upgrades
BuzzTokenMINTER_ROLESequencer proxymint
BuzzchainValidatorVaultREWARDER_ROLESequencer proxynotifyReward
BuzzchainValidatorMINTER_ROLEAdmin, faucetmint
AllDEFAULT_ADMIN_ROLEThe Buzzchain teamGrant and revoke roles

10 · REFERENCE

Contract reference

Generated from the compiled contracts: every function, event and error of the public ABI with its NatSpec (@notice, @dev, @param, @return), the Ethereum standard for contract documentation.

BuzzchainSequencer

UUPS PROXYSepolia Etherscan ↗

Settles Buzzchain blocks on Ethereum and mints their emission to the validator vault.

See IBuzzchainSequencer for the protocol and its normative encodings. Gas design: storage per batch is O(1), whatever the number of blocks or posts. A settle call reads and writes one packed "head" slot (latest number/timestamp, batch count, params, paused flag) and the latest block hash, writes the two-slot Batch record, and makes one mint + one notifyReward call only if the batch emits. Post data is only hashed (calldata data availability). UUPS proxy. Roles:

  • DEFAULT_ADMIN_ROLE: grants and revokes roles (should be held by a multisig);
  • SEQUENCER_ROLE: the relayer EOA, calls settle;
  • PARAMS_ROLE: setParams;
  • PAUSER_ROLE: pause / unpause (pausing blocks settle only; views keep working);
  • UPGRADER_ROLE: upgrades the implementation.
Functions (18)
batch
VIEW0x0eaa75fe
function batch(uint256 index) external view returns (Batch)

A settled batch record. Reverts with UnknownBatch for an unknown index.

PARAMETERS

index uint256

Batch index (0-based).

RETURNS

[0] Batch

The batch record.

Batch fields
  • headersRoot bytes32
  • firstBlock uint64
  • lastBlock uint64
  • l1Timestamp uint64
batchCount
VIEW0x06f13056
function batchCount() external view returns (uint256)

Number of settled batches.

RETURNS

[0] uint256
—
batchOf
VIEW0x859f69ad
function batchOf(uint64 blockNumber) external view returns (uint256)

Finds the batch that settled a block, by binary search over the batch records.

Reverts with BlockNotSettled for block 0 (genesis) or a block above latestBlock().

PARAMETERS

blockNumber uint64

The block number.

RETURNS

[0] uint256

The batch index.

latestBlock
VIEW0x07e2da96
function latestBlock() external view returns (uint64 number, bytes32 hash, uint64 timestamp)

The latest settled block (the genesis block before the first settlement).

RETURNS

number uint64

Block number.

hash bytes32

Block hash.

timestamp uint64

Block (seal) timestamp, not the L1 timestamp.

params
VIEW0xcff0ab96
function params() external view returns (uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock)

The on-chain protocol parameters.

RETURNS

blockSize uint32

Number of NEW posts that make a FULL block.

maxBlockTime uint32

Heartbeat interval in seconds (the relayer seals a TIMEOUT block after it).

maxEmissionPerBlock uint128

Upper bound (wei) on any single block's emission.

PARAMS_ROLE
VIEW0x4fc62042
function PARAMS_ROLE() external view returns (bytes32)

Role allowed to call setParams.

RETURNS

[0] bytes32
—
paused
VIEW0x5c975abb
function paused() external view returns (bool)

Whether settlement is paused.

RETURNS

[0] bool
—
PAUSER_ROLE
VIEW0xe63ab1e9
function PAUSER_ROLE() external view returns (bytes32)

Role allowed to pause and unpause settlement.

RETURNS

[0] bytes32
—
SEQUENCER_ROLE
VIEW0x4842855c
function SEQUENCER_ROLE() external view returns (bytes32)

Role allowed to call settle (the relayer).

RETURNS

[0] bytes32
—
token
VIEW0xfc0c546a
function token() external view returns (BuzzToken)

The BUZZ token.

RETURNS

[0] BuzzToken
—
UPGRADER_ROLE
VIEW0xf72c0d8b
function UPGRADER_ROLE() external view returns (bytes32)

Role allowed to upgrade the implementation.

RETURNS

[0] bytes32
—
vault
VIEW0xfbfa77cf
function vault() external view returns (IBuzzchainValidatorVault)

The validator vault.

RETURNS

[0] IBuzzchainValidatorVault
—
verifyPost
VIEW0xea5796aa
function verifyPost(uint256 batchIndex, BlockHeader header, bytes32[] headerProof, uint64 postId, uint8 kind, uint64 loudness, bytes32[] postProof) external view returns (bool)

Checks that a post leaf is included in a block that belongs to a settled batch.

Returns false (never reverts) for an unknown batch, a header outside the batch's block range, or any invalid proof.

PARAMETERS

batchIndex uint256

Index of the batch that settled the block (see batchOf).

header BlockHeader

The full block header.

BlockHeader fields
  • number uint64
  • timestamp uint64
  • parentHash bytes32
  • postsRoot bytes32
  • dataHash bytes32
  • newPosts uint32
  • maturedPosts uint32
  • loudness uint128
  • emission uint128
  • kind uint8
  • paramsVersion uint16
headerProof bytes32[]

Merkle proof of blockHash(header) against the batch's headersRoot.

postId uint64

X post ID.

kind uint8

Leaf kind: 0 = NEW, 1 = MATURED.

loudness uint64

Leaf loudness.

postProof bytes32[]

Merkle proof of the leaf against header.postsRoot.

RETURNS

[0] bool

True if both proofs verify.

initialize
WRITE0x5780ad9b
function initialize(address admin, BuzzToken token_, IBuzzchainValidatorVault vault_, uint64 genesisTimestamp, uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock) external

Initializes the proxy at the genesis block.

The genesis hash is computed on-chain as blockHash(genesisHeader(genesisTimestamp)), so off-chain implementations only need to agree on the header encoding. The relayer must build block 1 on top of that genesis. SEQUENCER_ROLE is granted separately.

PARAMETERS

admin address

Receives DEFAULT_ADMIN_ROLE, PARAMS_ROLE, PAUSER_ROLE and UPGRADER_ROLE.

token_ BuzzToken

The BUZZ token; this contract needs its MINTER_ROLE.

vault_ IBuzzchainValidatorVault

The validator vault; this contract needs its REWARDER_ROLE.

genesisTimestamp uint64

Timestamp of the genesis block (block 0).

blockSize uint32

New posts per FULL block.

maxBlockTime uint32

Heartbeat interval, seconds.

maxEmissionPerBlock uint128

Per-block emission rail (wei), at most type(uint96).max.

pause
WRITEPAUSER_ROLE0x8456cb59
function pause() external

Pauses settlement. Restricted to PAUSER_ROLE.

setParams
WRITEPARAMS_ROLE0x3b0057a0
function setParams(uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock) external

Updates the on-chain protocol parameters.

Restricted to PARAMS_ROLE. Applies to the next settle. The relayer reads them via params().

PARAMETERS

blockSize uint32

New posts per FULL block (> 0).

maxBlockTime uint32

Heartbeat interval in seconds (> 0).

maxEmissionPerBlock uint128

Per-block emission rail (wei), at most type(uint96).max (~7.9e10 BUZZ).

settle
WRITESEQUENCER_ROLE0x93037ea3
function settle(BlockHeader[] headers, bytes[] postData) external

Settles a batch of consecutive blocks that extend the latest settled block.

Restricted to SEQUENCER_ROLE; reverts while paused. For every header i it checks:

  • number == previous.number + 1 and parentHash == previous blockHash;
  • previous.timestamp <= timestamp <= block.timestamp (equal timestamps are allowed);
  • kind is FULL or TIMEOUT; TIMEOUT ⇒ emission == 0; FULL ⇒ newPosts == blockSize;
  • emission <= maxEmissionPerBlock;
  • postData[i].length == 17 * (newPosts + maturedPosts) and keccak256(postData[i]) == dataHash;
  • postsRoot == 0 exactly when the block has no posts. It then stores one Batch, moves the latest-block pointer, emits BlockSealed per block and one BatchSettled, and, if the total emission is non-zero, mints it to the vault and calls notifyReward once.

PARAMETERS

headers BlockHeader[]

The headers, in block order, starting at latestBlock().number + 1.

BlockHeader[] fields
  • number uint64
  • timestamp uint64
  • parentHash bytes32
  • postsRoot bytes32
  • dataHash bytes32
  • newPosts uint32
  • maturedPosts uint32
  • loudness uint128
  • emission uint128
  • kind uint8
  • paramsVersion uint16
postData bytes[]

Packed post data per header (17 bytes per leaf; 0x for an empty block).

unpause
WRITEPAUSER_ROLE0x3f4ba83a
function unpause() external

Unpauses settlement. Restricted to PAUSER_ROLE.

Events (5)
BatchSettled
EVENT
event BatchSettled(uint256 indexed batchIndex, uint64 firstBlock, uint64 lastBlock, bytes32 headersRoot, uint256 totalEmission)

Emitted once per settle call, after all of its BlockSealed events.

FIELDS

batchIndex uint256 · indexed

Index of the new batch (0-based, sequential).

firstBlock uint64

First block number in the batch.

lastBlock uint64

Last block number in the batch.

headersRoot bytes32

Merkle root over the batch's block hashes.

totalEmission uint256

Sum of the batch's emissions, minted to the vault in one call.

BlockSealed
EVENT
event BlockSealed(uint64 indexed number, bytes32 indexed blockHash, bytes32 postsRoot, uint128 loudness, uint128 emission, uint8 kind)

Emitted once per settled block, in block order. Index these to follow the chain from logs.

FIELDS

number uint64 · indexed

Block number.

blockHash bytes32 · indexed

keccak256(abi.encode(header)).

postsRoot bytes32

Merkle root of the block's leaves.

loudness uint128

Total loudness of the block.

emission uint128

BUZZ (wei) minted for the block.

kind uint8

0 = FULL, 1 = TIMEOUT.

ParamsUpdated
EVENT
event ParamsUpdated(uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock)

Emitted when the on-chain protocol parameters change (and once at initialization).

FIELDS

blockSize uint32

Number of NEW posts that make a FULL block.

maxBlockTime uint32

Seconds after which the relayer seals a TIMEOUT block (heartbeat).

maxEmissionPerBlock uint128

Upper bound (wei) on any single block's emission.

Paused
EVENT
event Paused(address account)

Settlement was paused by account.

FIELDS

account address
—
Unpaused
EVENT
event Unpaused(address account)

Settlement was unpaused by account.

FIELDS

account address
—
Errors (19)
BlockNotSettled
ERROR
error BlockNotSettled(uint64 number)

The block number is not part of any settled batch (genesis, or not settled yet).

PARAMETERS

number uint64
—
DataHashMismatch
ERROR
error DataHashMismatch(uint64 number)

A block's post data does not hash to its dataHash.

PARAMETERS

number uint64
—
EmissionTooHigh
ERROR
error EmissionTooHigh(uint64 number, uint128 emission, uint128 max)

A block's emission is above maxEmissionPerBlock.

PARAMETERS

number uint64
—
emission uint128
—
max uint128
—
EmptyBatch
ERROR
error EmptyBatch()

settle was called with no headers.

EnforcedPause
ERROR
error EnforcedPause()

Settlement is paused.

ExpectedPause
ERROR
error ExpectedPause()

Settlement is not paused.

FullBlockSize
ERROR
error FullBlockSize(uint64 number, uint32 expected, uint32 actual)

A FULL block does not have exactly blockSize new posts.

PARAMETERS

number uint64
—
expected uint32
—
actual uint32
—
InvalidKind
ERROR
error InvalidKind(uint64 number, uint8 kind)

A header's kind is neither FULL (0) nor TIMEOUT (1).

PARAMETERS

number uint64
—
kind uint8
—
InvalidParams
ERROR
error InvalidParams()

A parameter value is out of range.

LengthMismatch
ERROR
error LengthMismatch(uint256 headers, uint256 postData)

headers and postData have different lengths.

PARAMETERS

headers uint256
—
postData uint256
—
NonContiguousBlock
ERROR
error NonContiguousBlock(uint64 expected, uint64 actual)

A header's number is not the previous number + 1.

PARAMETERS

expected uint64
—
actual uint64
—
ParentHashMismatch
ERROR
error ParentHashMismatch(uint64 number, bytes32 expected, bytes32 actual)

A header's parentHash is not the previous block's hash.

PARAMETERS

number uint64
—
expected bytes32
—
actual bytes32
—
PostDataLength
ERROR
error PostDataLength(uint64 number, uint256 expected, uint256 actual)

A block's post data is not exactly 17 * (newPosts + maturedPosts) bytes.

PARAMETERS

number uint64
—
expected uint256
—
actual uint256
—
PostsRootMismatch
ERROR
error PostsRootMismatch(uint64 number)

A block's postsRoot is zero while it has posts, or non-zero while it has none.

PARAMETERS

number uint64
—
TimeoutEmission
ERROR
error TimeoutEmission(uint64 number)

A TIMEOUT block declares a non-zero emission.

PARAMETERS

number uint64
—
TimestampDecreasing
ERROR
error TimestampDecreasing(uint64 number, uint64 parentTimestamp, uint64 timestamp)

A header's timestamp is lower than its parent's.

PARAMETERS

number uint64
—
parentTimestamp uint64
—
timestamp uint64
—
TimestampInFuture
ERROR
error TimestampInFuture(uint64 number, uint64 timestamp)

A header's timestamp is later than the settling L1 block.

PARAMETERS

number uint64
—
timestamp uint64
—
UnknownBatch
ERROR
error UnknownBatch(uint256 index)

No batch exists at this index.

PARAMETERS

index uint256
—
ZeroAddress
ERROR
error ZeroAddress()

A zero address was passed where a contract is required.

Inherited (OpenZeppelin AccessControl, UUPS) (25)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddf
function DEFAULT_ADMIN_ROLE() external view returns (bytes32)

RETURNS

[0] bytes32
—
UPGRADE_INTERFACE_VERSION
VIEW0xad3cb1cc
function UPGRADE_INTERFACE_VERSION() external view returns (string)

RETURNS

[0] string
—
getRoleAdmin
VIEW0x248a9ca3
function getRoleAdmin(bytes32 role) external view returns (bytes32)

Returns the admin role that controls role. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.

PARAMETERS

role bytes32
—

RETURNS

[0] bytes32
—
grantRole
WRITE0x2f2ff15d
function grantRole(bytes32 role, address account) external

Grants role to account. If account had not been already granted role, emits a {RoleGranted} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleGranted} event.

PARAMETERS

role bytes32
—
account address
—
hasRole
VIEW0x91d14854
function hasRole(bytes32 role, address account) external view returns (bool)

Returns true if account has been granted role.

PARAMETERS

role bytes32
—
account address
—

RETURNS

[0] bool
—
proxiableUUID
VIEW0x52d1902d
function proxiableUUID() external view returns (bytes32)

Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the notDelegated modifier.

RETURNS

[0] bytes32
—
renounceRole
WRITE0x36568abe
function renounceRole(bytes32 role, address callerConfirmation) external

Revokes role from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). Emits a {RoleRevoked} event if the calling account had role and this call successfully revoked it. Requirements: - the caller must be callerConfirmation. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
callerConfirmation address
—
revokeRole
WRITE0xd547741f
function revokeRole(bytes32 role, address account) external

Revokes role from account. If account had been granted role, emits a {RoleRevoked} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
account address
—
supportsInterface
VIEW0x01ffc9a7
function supportsInterface(bytes4 interfaceId) external view returns (bool)

Returns true if this contract implements the interface defined by interfaceId. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.

PARAMETERS

interfaceId bytes4
—

RETURNS

[0] bool
—
upgradeToAndCall
WRITE0x4f1ef286
function upgradeToAndCall(address newImplementation, bytes data) external payable

Upgrade the implementation of the proxy to newImplementation, and subsequently execute the function call encoded in data. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.

PARAMETERS

newImplementation address
—
data bytes
—
Initialized
EVENT
event Initialized(uint64 version)

Triggered when the contract has been initialized or reinitialized.

FIELDS

version uint64
—
RoleAdminChanged
EVENT
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

Emitted when newAdminRole is set as `role's admin role, replacing previousAdminRole DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this.

FIELDS

role bytes32 · indexed
—
previousAdminRole bytes32 · indexed
—
newAdminRole bytes32 · indexed
—
RoleGranted
EVENT
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is granted role. sender is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
RoleRevoked
EVENT
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is revoked role. sender is the account that originated the contract call:

  • if using revokeRole, it is the admin role bearer
  • if using renounceRole, it is the role bearer (i.e. account)

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
Upgraded
EVENT
event Upgraded(address indexed implementation)

Emitted when the implementation is upgraded.

FIELDS

implementation address · indexed
—
AccessControlBadConfirmation
ERROR
error AccessControlBadConfirmation()

The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.

AccessControlUnauthorizedAccount
ERROR
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole)

The account is missing a role.

PARAMETERS

account address
—
neededRole bytes32
—
AddressEmptyCode
ERROR
error AddressEmptyCode(address target)

There's no code at target (it is not a contract).

PARAMETERS

target address
—
ERC1967InvalidImplementation
ERROR
error ERC1967InvalidImplementation(address implementation)

The implementation of the proxy is invalid.

PARAMETERS

implementation address
—
ERC1967NonPayable
ERROR
error ERC1967NonPayable()

An upgrade function sees msg.value > 0 that may be lost.

FailedCall
ERROR
error FailedCall()

A call to an address target failed. The target may have reverted.

InvalidInitialization
ERROR
error InvalidInitialization()

The contract is already initialized.

NotInitializing
ERROR
error NotInitializing()

The contract is not initializing.

UUPSUnauthorizedCallContext
ERROR
error UUPSUnauthorizedCallContext()

The call is from an unauthorized context.

UUPSUnsupportedProxiableUUID
ERROR
error UUPSUnsupportedProxiableUUID(bytes32 slot)

The storage slot is unsupported as a UUID.

PARAMETERS

slot bytes32
—
JSON ABI (68 entries)
BuzzchainSequencer.abi.json
[
  {
    "type": "constructor",
    "inputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "PARAMS_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "PAUSER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "SEQUENCER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "UPGRADER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "UPGRADE_INTERFACE_VERSION",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "batch",
    "inputs": [
      {
        "name": "index",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "tuple",
        "internalType": "struct IBuzzchainSequencer.Batch",
        "components": [
          {
            "name": "headersRoot",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "firstBlock",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "lastBlock",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "l1Timestamp",
            "type": "uint64",
            "internalType": "uint64"
          }
        ]
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "batchCount",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "batchOf",
    "inputs": [
      {
        "name": "blockNumber",
        "type": "uint64",
        "internalType": "uint64"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "grantRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "initialize",
    "inputs": [
      {
        "name": "admin",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "token_",
        "type": "address",
        "internalType": "contract BuzzToken"
      },
      {
        "name": "vault_",
        "type": "address",
        "internalType": "contract IBuzzchainValidatorVault"
      },
      {
        "name": "genesisTimestamp",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "blockSize",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxBlockTime",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxEmissionPerBlock",
        "type": "uint128",
        "internalType": "uint128"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "latestBlock",
    "inputs": [],
    "outputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "hash",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "timestamp",
        "type": "uint64",
        "internalType": "uint64"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "params",
    "inputs": [],
    "outputs": [
      {
        "name": "blockSize",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxBlockTime",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxEmissionPerBlock",
        "type": "uint128",
        "internalType": "uint128"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "paused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "proxiableUUID",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "callerConfirmation",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "revokeRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setParams",
    "inputs": [
      {
        "name": "blockSize",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxBlockTime",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "maxEmissionPerBlock",
        "type": "uint128",
        "internalType": "uint128"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "settle",
    "inputs": [
      {
        "name": "headers",
        "type": "tuple[]",
        "internalType": "struct IBuzzchainSequencer.BlockHeader[]",
        "components": [
          {
            "name": "number",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "timestamp",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "parentHash",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "postsRoot",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "dataHash",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "newPosts",
            "type": "uint32",
            "internalType": "uint32"
          },
          {
            "name": "maturedPosts",
            "type": "uint32",
            "internalType": "uint32"
          },
          {
            "name": "loudness",
            "type": "uint128",
            "internalType": "uint128"
          },
          {
            "name": "emission",
            "type": "uint128",
            "internalType": "uint128"
          },
          {
            "name": "kind",
            "type": "uint8",
            "internalType": "uint8"
          },
          {
            "name": "paramsVersion",
            "type": "uint16",
            "internalType": "uint16"
          }
        ]
      },
      {
        "name": "postData",
        "type": "bytes[]",
        "internalType": "bytes[]"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "supportsInterface",
    "inputs": [
      {
        "name": "interfaceId",
        "type": "bytes4",
        "internalType": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "token",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "contract BuzzToken"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "unpause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "upgradeToAndCall",
    "inputs": [
      {
        "name": "newImplementation",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "data",
        "type": "bytes",
        "internalType": "bytes"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "vault",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "contract IBuzzchainValidatorVault"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "verifyPost",
    "inputs": [
      {
        "name": "batchIndex",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "header",
        "type": "tuple",
        "internalType": "struct IBuzzchainSequencer.BlockHeader",
        "components": [
          {
            "name": "number",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "timestamp",
            "type": "uint64",
            "internalType": "uint64"
          },
          {
            "name": "parentHash",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "postsRoot",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "dataHash",
            "type": "bytes32",
            "internalType": "bytes32"
          },
          {
            "name": "newPosts",
            "type": "uint32",
            "internalType": "uint32"
          },
          {
            "name": "maturedPosts",
            "type": "uint32",
            "internalType": "uint32"
          },
          {
            "name": "loudness",
            "type": "uint128",
            "internalType": "uint128"
          },
          {
            "name": "emission",
            "type": "uint128",
            "internalType": "uint128"
          },
          {
            "name": "kind",
            "type": "uint8",
            "internalType": "uint8"
          },
          {
            "name": "paramsVersion",
            "type": "uint16",
            "internalType": "uint16"
          }
        ]
      },
      {
        "name": "headerProof",
        "type": "bytes32[]",
        "internalType": "bytes32[]"
      },
      {
        "name": "postId",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "kind",
        "type": "uint8",
        "internalType": "uint8"
      },
      {
        "name": "loudness",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "postProof",
        "type": "bytes32[]",
        "internalType": "bytes32[]"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "BatchSettled",
    "inputs": [
      {
        "name": "batchIndex",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      },
      {
        "name": "firstBlock",
        "type": "uint64",
        "indexed": false,
        "internalType": "uint64"
      },
      {
        "name": "lastBlock",
        "type": "uint64",
        "indexed": false,
        "internalType": "uint64"
      },
      {
        "name": "headersRoot",
        "type": "bytes32",
        "indexed": false,
        "internalType": "bytes32"
      },
      {
        "name": "totalEmission",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "BlockSealed",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "indexed": true,
        "internalType": "uint64"
      },
      {
        "name": "blockHash",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "postsRoot",
        "type": "bytes32",
        "indexed": false,
        "internalType": "bytes32"
      },
      {
        "name": "loudness",
        "type": "uint128",
        "indexed": false,
        "internalType": "uint128"
      },
      {
        "name": "emission",
        "type": "uint128",
        "indexed": false,
        "internalType": "uint128"
      },
      {
        "name": "kind",
        "type": "uint8",
        "indexed": false,
        "internalType": "uint8"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Initialized",
    "inputs": [
      {
        "name": "version",
        "type": "uint64",
        "indexed": false,
        "internalType": "uint64"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "ParamsUpdated",
    "inputs": [
      {
        "name": "blockSize",
        "type": "uint32",
        "indexed": false,
        "internalType": "uint32"
      },
      {
        "name": "maxBlockTime",
        "type": "uint32",
        "indexed": false,
        "internalType": "uint32"
      },
      {
        "name": "maxEmissionPerBlock",
        "type": "uint128",
        "indexed": false,
        "internalType": "uint128"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Paused",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "indexed": false,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleAdminChanged",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "previousAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "newAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Unpaused",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "indexed": false,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Upgraded",
    "inputs": [
      {
        "name": "implementation",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AccessControlBadConfirmation",
    "inputs": []
  },
  {
    "type": "error",
    "name": "AccessControlUnauthorizedAccount",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "neededRole",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "AddressEmptyCode",
    "inputs": [
      {
        "name": "target",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "BlockNotSettled",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "DataHashMismatch",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC1967InvalidImplementation",
    "inputs": [
      {
        "name": "implementation",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC1967NonPayable",
    "inputs": []
  },
  {
    "type": "error",
    "name": "EmissionTooHigh",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "emission",
        "type": "uint128",
        "internalType": "uint128"
      },
      {
        "name": "max",
        "type": "uint128",
        "internalType": "uint128"
      }
    ]
  },
  {
    "type": "error",
    "name": "EmptyBatch",
    "inputs": []
  },
  {
    "type": "error",
    "name": "EnforcedPause",
    "inputs": []
  },
  {
    "type": "error",
    "name": "ExpectedPause",
    "inputs": []
  },
  {
    "type": "error",
    "name": "FailedCall",
    "inputs": []
  },
  {
    "type": "error",
    "name": "FullBlockSize",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "expected",
        "type": "uint32",
        "internalType": "uint32"
      },
      {
        "name": "actual",
        "type": "uint32",
        "internalType": "uint32"
      }
    ]
  },
  {
    "type": "error",
    "name": "InvalidInitialization",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InvalidKind",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "kind",
        "type": "uint8",
        "internalType": "uint8"
      }
    ]
  },
  {
    "type": "error",
    "name": "InvalidParams",
    "inputs": []
  },
  {
    "type": "error",
    "name": "LengthMismatch",
    "inputs": [
      {
        "name": "headers",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "postData",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "NonContiguousBlock",
    "inputs": [
      {
        "name": "expected",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "actual",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "NotInitializing",
    "inputs": []
  },
  {
    "type": "error",
    "name": "ParentHashMismatch",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "expected",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "actual",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "PostDataLength",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "expected",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "actual",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "PostsRootMismatch",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "TimeoutEmission",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "TimestampDecreasing",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "parentTimestamp",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "timestamp",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "TimestampInFuture",
    "inputs": [
      {
        "name": "number",
        "type": "uint64",
        "internalType": "uint64"
      },
      {
        "name": "timestamp",
        "type": "uint64",
        "internalType": "uint64"
      }
    ]
  },
  {
    "type": "error",
    "name": "UUPSUnauthorizedCallContext",
    "inputs": []
  },
  {
    "type": "error",
    "name": "UUPSUnsupportedProxiableUUID",
    "inputs": [
      {
        "name": "slot",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "UnknownBatch",
    "inputs": [
      {
        "name": "index",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ZeroAddress",
    "inputs": []
  }
]

BuzzToken

IMMUTABLESepolia Etherscan ↗

The $BUZZ token ("Buzz", BUZZ, 18 decimals), capped at MAX_SUPPLY. Minted only by MINTER_ROLE: the sequencer mints block emission to the validator vault. Not upgradeable.

The cap is a constant: minting past it reverts with ERC20ExceededCap, and no role can change it.

Functions (13)
allowance
VIEW0xdd62ed3e
function allowance(address owner, address spender) external view returns (uint256)

Returns the remaining number of tokens that spender will be allowed to spend on behalf of owner through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.

PARAMETERS

owner address
—
spender address
—

RETURNS

[0] uint256
—
balanceOf
VIEW0x70a08231
function balanceOf(address account) external view returns (uint256)

Returns the value of tokens owned by account.

PARAMETERS

account address
—

RETURNS

[0] uint256
—
cap
VIEW0x355274ea
function cap() external view returns (uint256)

Returns the cap on the token's total supply.

RETURNS

[0] uint256
—
decimals
VIEW0x313ce567
function decimals() external view returns (uint8)

Returns the number of decimals used to get its user representation. For example, if decimals equals 2, a balance of 505 tokens should be displayed to a user as 5.05 (505 / 10 ** 2). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.

RETURNS

[0] uint8
—
MAX_SUPPLY
VIEW0x32cb6b0c
function MAX_SUPPLY() external view returns (uint256)

Hard cap on the total supply: 280,000,000 BUZZ.

RETURNS

[0] uint256
—
MINTER_ROLE
VIEW0xd5391393
function MINTER_ROLE() external view returns (bytes32)

Role allowed to mint. Granted to the BuzzchainSequencer proxy.

RETURNS

[0] bytes32
—
name
VIEW0x06fdde03
function name() external view returns (string)

Returns the name of the token.

RETURNS

[0] string
—
symbol
VIEW0x95d89b41
function symbol() external view returns (string)

Returns the symbol of the token, usually a shorter version of the name.

RETURNS

[0] string
—
totalSupply
VIEW0x18160ddd
function totalSupply() external view returns (uint256)

Returns the value of tokens in existence.

RETURNS

[0] uint256
—
approve
WRITE0x095ea7b3
function approve(address spender, uint256 value) external returns (bool)

See {IERC20-approve}. NOTE: If value is the maximum uint256, the allowance is not updated on transferFrom. This is semantically equivalent to an infinite approval. Requirements: - spender cannot be the zero address.

PARAMETERS

spender address
—
value uint256
—

RETURNS

[0] bool
—
mint
WRITEMINTER_ROLE0x40c10f19
function mint(address to, uint256 amount) external

Mints amount to to.

Restricted to MINTER_ROLE. Reverts with ERC20ExceededCap past MAX_SUPPLY.

PARAMETERS

to address
—
amount uint256
—
transfer
WRITE0xa9059cbb
function transfer(address to, uint256 value) external returns (bool)

See {IERC20-transfer}. Requirements: - to cannot be the zero address. - the caller must have a balance of at least value.

PARAMETERS

to address
—
value uint256
—

RETURNS

[0] bool
—
transferFrom
WRITE0x23b872dd
function transferFrom(address from, address to, uint256 value) external returns (bool)

See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum uint256. Requirements: - from and to cannot be the zero address. - from must have a balance of at least value. - the caller must have allowance for `from's tokens of at least value`.

PARAMETERS

from address
—
to address
—
value uint256
—

RETURNS

[0] bool
—
Events (2)
Approval
EVENT
event Approval(address indexed owner, address indexed spender, uint256 value)

Emitted when the allowance of a spender for an owner is set by a call to {approve}. value is the new allowance.

FIELDS

owner address · indexed
—
spender address · indexed
—
value uint256
—
Transfer
EVENT
event Transfer(address indexed from, address indexed to, uint256 value)

Emitted when value tokens are moved from one account (from) to another (to). Note that value may be zero.

FIELDS

from address · indexed
—
to address · indexed
—
value uint256
—
Errors (8)
ERC20ExceededCap
ERROR
error ERC20ExceededCap(uint256 increasedSupply, uint256 cap)

Total supply cap has been exceeded.

PARAMETERS

increasedSupply uint256
—
cap uint256
—
ERC20InsufficientAllowance
ERROR
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)

Indicates a failure with the spender’s allowance. Used in transfers.

PARAMETERS

spender address

Address that may be allowed to operate on tokens without being their owner.

allowance uint256

Amount of tokens a spender is allowed to operate with.

needed uint256

Minimum amount required to perform a transfer.

ERC20InsufficientBalance
ERROR
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)

Indicates an error related to the current balance of a sender. Used in transfers.

PARAMETERS

sender address

Address whose tokens are being transferred.

balance uint256

Current balance for the interacting account.

needed uint256

Minimum amount required to perform a transfer.

ERC20InvalidApprover
ERROR
error ERC20InvalidApprover(address approver)

Indicates a failure with the approver of a token to be approved. Used in approvals.

PARAMETERS

approver address

Address initiating an approval operation.

ERC20InvalidCap
ERROR
error ERC20InvalidCap(uint256 cap)

The supplied cap is not a valid cap.

PARAMETERS

cap uint256
—
ERC20InvalidReceiver
ERROR
error ERC20InvalidReceiver(address receiver)

Indicates a failure with the token receiver. Used in transfers.

PARAMETERS

receiver address

Address to which tokens are being transferred.

ERC20InvalidSender
ERROR
error ERC20InvalidSender(address sender)

Indicates a failure with the token sender. Used in transfers.

PARAMETERS

sender address

Address whose tokens are being transferred.

ERC20InvalidSpender
ERROR
error ERC20InvalidSpender(address spender)

Indicates a failure with the spender to be approved. Used in approvals.

PARAMETERS

spender address

Address that may be allowed to operate on tokens without being their owner.

Inherited (OpenZeppelin AccessControl) (12)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddf
function DEFAULT_ADMIN_ROLE() external view returns (bytes32)

RETURNS

[0] bytes32
—
getRoleAdmin
VIEW0x248a9ca3
function getRoleAdmin(bytes32 role) external view returns (bytes32)

Returns the admin role that controls role. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.

PARAMETERS

role bytes32
—

RETURNS

[0] bytes32
—
grantRole
WRITE0x2f2ff15d
function grantRole(bytes32 role, address account) external

Grants role to account. If account had not been already granted role, emits a {RoleGranted} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleGranted} event.

PARAMETERS

role bytes32
—
account address
—
hasRole
VIEW0x91d14854
function hasRole(bytes32 role, address account) external view returns (bool)

Returns true if account has been granted role.

PARAMETERS

role bytes32
—
account address
—

RETURNS

[0] bool
—
renounceRole
WRITE0x36568abe
function renounceRole(bytes32 role, address callerConfirmation) external

Revokes role from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). Emits a {RoleRevoked} event if the calling account had role and this call successfully revoked it. Requirements: - the caller must be callerConfirmation. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
callerConfirmation address
—
revokeRole
WRITE0xd547741f
function revokeRole(bytes32 role, address account) external

Revokes role from account. If account had been granted role, emits a {RoleRevoked} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
account address
—
supportsInterface
VIEW0x01ffc9a7
function supportsInterface(bytes4 interfaceId) external view returns (bool)

Returns true if this contract implements the interface defined by interfaceId. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.

PARAMETERS

interfaceId bytes4
—

RETURNS

[0] bool
—
RoleAdminChanged
EVENT
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

Emitted when newAdminRole is set as `role's admin role, replacing previousAdminRole DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this.

FIELDS

role bytes32 · indexed
—
previousAdminRole bytes32 · indexed
—
newAdminRole bytes32 · indexed
—
RoleGranted
EVENT
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is granted role. sender is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
RoleRevoked
EVENT
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is revoked role. sender is the account that originated the contract call:

  • if using revokeRole, it is the admin role bearer
  • if using renounceRole, it is the role bearer (i.e. account)

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
AccessControlBadConfirmation
ERROR
error AccessControlBadConfirmation()

The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.

AccessControlUnauthorizedAccount
ERROR
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole)

The account is missing a role.

PARAMETERS

account address
—
neededRole bytes32
—
JSON ABI (36 entries)
BuzzToken.abi.json
[
  {
    "type": "constructor",
    "inputs": [
      {
        "name": "admin",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MAX_SUPPLY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MINTER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "allowance",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "spender",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "spender",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "value",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "cap",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint8",
        "internalType": "uint8"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "grantRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "amount",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "callerConfirmation",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "revokeRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "supportsInterface",
    "inputs": [
      {
        "name": "interfaceId",
        "type": "bytes4",
        "internalType": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "value",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "transferFrom",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "value",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "spender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "value",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleAdminChanged",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "previousAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "newAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "value",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AccessControlBadConfirmation",
    "inputs": []
  },
  {
    "type": "error",
    "name": "AccessControlUnauthorizedAccount",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "neededRole",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20ExceededCap",
    "inputs": [
      {
        "name": "increasedSupply",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "cap",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InsufficientAllowance",
    "inputs": [
      {
        "name": "spender",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "allowance",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "needed",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InsufficientBalance",
    "inputs": [
      {
        "name": "sender",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "balance",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "needed",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InvalidApprover",
    "inputs": [
      {
        "name": "approver",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InvalidCap",
    "inputs": [
      {
        "name": "cap",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InvalidReceiver",
    "inputs": [
      {
        "name": "receiver",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InvalidSender",
    "inputs": [
      {
        "name": "sender",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC20InvalidSpender",
    "inputs": [
      {
        "name": "spender",
        "type": "address",
        "internalType": "address"
      }
    ]
  }
]

BuzzchainValidator

IMMUTABLESepolia Etherscan ↗

"Buzz Validator" (BUZZV): the validator NFT collection. IDs start at 1 and are minted sequentially by MINTER_ROLE, optionally up to a fixed MAX_SUPPLY. Staking one in the BuzzchainValidatorVault earns an equal share of emission.

Functions (17)
balanceOf
VIEW0x70a08231
function balanceOf(address owner) external view returns (uint256)

Returns the number of tokens in `owner`'s account.

PARAMETERS

owner address
—

RETURNS

[0] uint256
—
getApproved
VIEW0x081812fc
function getApproved(uint256 tokenId) external view returns (address)

Returns the account approved for tokenId token. Requirements: - tokenId must exist.

PARAMETERS

tokenId uint256
—

RETURNS

[0] address
—
isApprovedForAll
VIEW0xe985e9c5
function isApprovedForAll(address owner, address operator) external view returns (bool)

Returns if the operator is allowed to manage all of the assets of owner. See {setApprovalForAll}

PARAMETERS

owner address
—
operator address
—

RETURNS

[0] bool
—
MAX_SUPPLY
VIEW0x32cb6b0c
function MAX_SUPPLY() external view returns (uint256)

Hard cap on the collection size; 0 means uncapped.

RETURNS

[0] uint256
—
MINTER_ROLE
VIEW0xd5391393
function MINTER_ROLE() external view returns (bytes32)

Role allowed to mint.

RETURNS

[0] bytes32
—
name
VIEW0x06fdde03
function name() external view returns (string)

Returns the token collection name.

RETURNS

[0] string
—
ownerOf
VIEW0x6352211e
function ownerOf(uint256 tokenId) external view returns (address)

Returns the owner of the tokenId token. Requirements: - tokenId must exist.

PARAMETERS

tokenId uint256
—

RETURNS

[0] address
—
symbol
VIEW0x95d89b41
function symbol() external view returns (string)

Returns the token collection symbol.

RETURNS

[0] string
—
tokenURI
VIEW0xc87b56dd
function tokenURI(uint256 tokenId) external view returns (string)

Returns the Uniform Resource Identifier (URI) for tokenId token.

PARAMETERS

tokenId uint256
—

RETURNS

[0] string
—
totalSupply
VIEW0x18160ddd
function totalSupply() external view returns (uint256)

Number of tokens minted so far (also the last minted ID).

RETURNS

[0] uint256
—
approve
WRITE0x095ea7b3
function approve(address to, uint256 tokenId) external

Gives permission to to to transfer tokenId token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - tokenId must exist. Emits an {Approval} event.

PARAMETERS

to address
—
tokenId uint256
—
mint
WRITEMINTER_ROLE0x40c10f19
function mint(address to, uint256 count) external returns (uint256 firstId)

Mints count tokens to to with the next sequential IDs.

Restricted to MINTER_ROLE. Uses _mint (no receiver hook), so it never reenters.

PARAMETERS

to address
—
count uint256
—

RETURNS

firstId uint256

The first minted ID (firstId .. firstId + count - 1).

safeTransferFrom
WRITE0x42842e0e
function safeTransferFrom(address from, address to, uint256 tokenId) external

Safely transfers tokenId token from from to to, checking first that contract recipients are aware of the ERC-721 protocol to prevent tokens from being forever locked. Requirements: - from cannot be the zero address. - to cannot be the zero address. - tokenId token must exist and be owned by from. - If the caller is not from, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If to refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.

PARAMETERS

from address
—
to address
—
tokenId uint256
—
safeTransferFrom
WRITE0xb88d4fde
function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) external

Safely transfers tokenId token from from to to. Requirements: - from cannot be the zero address. - to cannot be the zero address. - tokenId token must exist and be owned by from. - If the caller is not from, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If to refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.

PARAMETERS

from address
—
to address
—
tokenId uint256
—
data bytes
—
setApprovalForAll
WRITE0xa22cb465
function setApprovalForAll(address operator, bool approved) external

Approve or remove operator as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The operator cannot be the address zero. Emits an {ApprovalForAll} event.

PARAMETERS

operator address
—
approved bool
—
setBaseURI
WRITEDEFAULT_ADMIN_ROLE0x55f804b3
function setBaseURI(string baseURI) external

Sets the metadata base URI (tokenURI = baseURI ‖ tokenId).

Restricted to DEFAULT_ADMIN_ROLE.

PARAMETERS

baseURI string
—
transferFrom
WRITE0x23b872dd
function transferFrom(address from, address to, uint256 tokenId) external

Transfers tokenId token from from to to. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - from cannot be the zero address. - to cannot be the zero address. - tokenId token must be owned by from. - If the caller is not from, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.

PARAMETERS

from address
—
to address
—
tokenId uint256
—
Events (4)
Approval
EVENT
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)

Emitted when owner enables approved to manage the tokenId token.

FIELDS

owner address · indexed
—
approved address · indexed
—
tokenId uint256 · indexed
—
ApprovalForAll
EVENT
event ApprovalForAll(address indexed owner, address indexed operator, bool approved)

Emitted when owner enables or disables (approved) operator to manage all of its assets.

FIELDS

owner address · indexed
—
operator address · indexed
—
approved bool
—
BaseURIUpdated
EVENT
event BaseURIUpdated(string baseURI)

The base URI changed.

FIELDS

baseURI string
—
Transfer
EVENT
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)

Emitted when tokenId token is transferred from from to to.

FIELDS

from address · indexed
—
to address · indexed
—
tokenId uint256 · indexed
—
Errors (9)
ERC721IncorrectOwner
ERROR
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)

Indicates an error related to the ownership over a particular token. Used in transfers.

PARAMETERS

sender address

Address whose tokens are being transferred.

tokenId uint256

Identifier number of a token.

owner address

Address of the current owner of a token.

ERC721InsufficientApproval
ERROR
error ERC721InsufficientApproval(address operator, uint256 tokenId)

Indicates a failure with the operator’s approval. Used in transfers.

PARAMETERS

operator address

Address that may be allowed to operate on tokens without being their owner.

tokenId uint256

Identifier number of a token.

ERC721InvalidApprover
ERROR
error ERC721InvalidApprover(address approver)

Indicates a failure with the approver of a token to be approved. Used in approvals.

PARAMETERS

approver address

Address initiating an approval operation.

ERC721InvalidOperator
ERROR
error ERC721InvalidOperator(address operator)

Indicates a failure with the operator to be approved. Used in approvals.

PARAMETERS

operator address

Address that may be allowed to operate on tokens without being their owner.

ERC721InvalidOwner
ERROR
error ERC721InvalidOwner(address owner)

Indicates that an address can't be an owner. For example, address(0) is a forbidden owner in ERC-721. Used in balance queries.

PARAMETERS

owner address

Address of the current owner of a token.

ERC721InvalidReceiver
ERROR
error ERC721InvalidReceiver(address receiver)

Indicates a failure with the token receiver. Used in transfers.

PARAMETERS

receiver address

Address to which tokens are being transferred.

ERC721InvalidSender
ERROR
error ERC721InvalidSender(address sender)

Indicates a failure with the token sender. Used in transfers.

PARAMETERS

sender address

Address whose tokens are being transferred.

ERC721NonexistentToken
ERROR
error ERC721NonexistentToken(uint256 tokenId)

Indicates a tokenId whose owner is the zero address.

PARAMETERS

tokenId uint256

Identifier number of a token.

MaxSupplyExceeded
ERROR
error MaxSupplyExceeded(uint256 requested, uint256 remaining)

Minting count more would exceed MAX_SUPPLY.

PARAMETERS

requested uint256
—
remaining uint256
—
Inherited (OpenZeppelin AccessControl) (12)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddf
function DEFAULT_ADMIN_ROLE() external view returns (bytes32)

RETURNS

[0] bytes32
—
getRoleAdmin
VIEW0x248a9ca3
function getRoleAdmin(bytes32 role) external view returns (bytes32)

Returns the admin role that controls role. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.

PARAMETERS

role bytes32
—

RETURNS

[0] bytes32
—
grantRole
WRITE0x2f2ff15d
function grantRole(bytes32 role, address account) external

Grants role to account. If account had not been already granted role, emits a {RoleGranted} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleGranted} event.

PARAMETERS

role bytes32
—
account address
—
hasRole
VIEW0x91d14854
function hasRole(bytes32 role, address account) external view returns (bool)

Returns true if account has been granted role.

PARAMETERS

role bytes32
—
account address
—

RETURNS

[0] bool
—
renounceRole
WRITE0x36568abe
function renounceRole(bytes32 role, address callerConfirmation) external

Revokes role from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). Emits a {RoleRevoked} event if the calling account had role and this call successfully revoked it. Requirements: - the caller must be callerConfirmation. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
callerConfirmation address
—
revokeRole
WRITE0xd547741f
function revokeRole(bytes32 role, address account) external

Revokes role from account. If account had been granted role, emits a {RoleRevoked} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
account address
—
supportsInterface
VIEW0x01ffc9a7
function supportsInterface(bytes4 interfaceId) external view returns (bool)

Returns true if this contract implements the interface defined by interfaceId. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.

PARAMETERS

interfaceId bytes4
—

RETURNS

[0] bool
—
RoleAdminChanged
EVENT
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

Emitted when newAdminRole is set as `role's admin role, replacing previousAdminRole DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this.

FIELDS

role bytes32 · indexed
—
previousAdminRole bytes32 · indexed
—
newAdminRole bytes32 · indexed
—
RoleGranted
EVENT
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is granted role. sender is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
RoleRevoked
EVENT
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is revoked role. sender is the account that originated the contract call:

  • if using revokeRole, it is the admin role bearer
  • if using renounceRole, it is the role bearer (i.e. account)

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
AccessControlBadConfirmation
ERROR
error AccessControlBadConfirmation()

The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.

AccessControlUnauthorizedAccount
ERROR
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole)

The account is missing a role.

PARAMETERS

account address
—
neededRole bytes32
—
JSON ABI (43 entries)
BuzzchainValidator.abi.json
[
  {
    "type": "constructor",
    "inputs": [
      {
        "name": "admin",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "maxSupply",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MAX_SUPPLY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MINTER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getApproved",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "grantRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isApprovedForAll",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "operator",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "count",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "firstId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "ownerOf",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "callerConfirmation",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "revokeRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "safeTransferFrom",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "safeTransferFrom",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "data",
        "type": "bytes",
        "internalType": "bytes"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setApprovalForAll",
    "inputs": [
      {
        "name": "operator",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "approved",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setBaseURI",
    "inputs": [
      {
        "name": "baseURI",
        "type": "string",
        "internalType": "string"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "supportsInterface",
    "inputs": [
      {
        "name": "interfaceId",
        "type": "bytes4",
        "internalType": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenURI",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferFrom",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "approved",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "ApprovalForAll",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "operator",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "approved",
        "type": "bool",
        "indexed": false,
        "internalType": "bool"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "BaseURIUpdated",
    "inputs": [
      {
        "name": "baseURI",
        "type": "string",
        "indexed": false,
        "internalType": "string"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleAdminChanged",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "previousAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "newAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "from",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "to",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AccessControlBadConfirmation",
    "inputs": []
  },
  {
    "type": "error",
    "name": "AccessControlUnauthorizedAccount",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "neededRole",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721IncorrectOwner",
    "inputs": [
      {
        "name": "sender",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "owner",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InsufficientApproval",
    "inputs": [
      {
        "name": "operator",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InvalidApprover",
    "inputs": [
      {
        "name": "approver",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InvalidOperator",
    "inputs": [
      {
        "name": "operator",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InvalidOwner",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InvalidReceiver",
    "inputs": [
      {
        "name": "receiver",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721InvalidSender",
    "inputs": [
      {
        "name": "sender",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC721NonexistentToken",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "MaxSupplyExceeded",
    "inputs": [
      {
        "name": "requested",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "remaining",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  }
]

BuzzchainValidatorVault

UUPS PROXYSepolia Etherscan ↗

Stakes Buzz Validator NFTs and splits BUZZ emission equally per staked NFT ("seat").

MasterChef-style accounting without a precision multiplier: accRewardPerSeat is the cumulative wei credited to every seat; a seat's pending reward is accRewardPerSeat - rewardDebt. On notifyReward, amount + queued is divided by the number of seats; the indivisible remainder (and everything, while there are no stakers) stays queued for the next notify. Hence, exactly and at all times: token.balanceOf(vault) == queued + Σ pendingRewards(staked seats). UUPS proxy. Roles: DEFAULT_ADMIN_ROLE, REWARDER_ROLE (the sequencer), UPGRADER_ROLE. Hot state (accRewardPerSeat, queued, totalStaked) is packed into one slot so notifyReward touches a single storage word.

Functions (15)
accRewardPerSeat
VIEW0x8718a7bc
function accRewardPerSeat() external view returns (uint256)

Cumulative rewards per seat since deployment (wei).

RETURNS

[0] uint256
—
nft
VIEW0x47ccca02
function nft() external view returns (IERC721)

The Buzz Validator collection.

RETURNS

[0] IERC721
—
pendingRewards
VIEW0x7dcb2abf
function pendingRewards(uint256 tokenId) external view returns (uint256)

Pending (unclaimed) rewards of a staked NFT; 0 if not staked.

PARAMETERS

tokenId uint256
—

RETURNS

[0] uint256
—
queuedRewards
VIEW0x63d38c3b
function queuedRewards() external view returns (uint256)

Rewards waiting for the next distribution (wei).

RETURNS

[0] uint256
—
REWARDER_ROLE
VIEW0x8580cf76
function REWARDER_ROLE() external view returns (bytes32)

Role allowed to call notifyReward. Granted to the BuzzchainSequencer proxy.

RETURNS

[0] bytes32
—
stakerOf
VIEW0xac86e186
function stakerOf(uint256 tokenId) external view returns (address)

Who staked the NFT (address(0) if not staked).

PARAMETERS

tokenId uint256
—

RETURNS

[0] address
—
token
VIEW0xfc0c546a
function token() external view returns (IERC20)

The BUZZ token.

RETURNS

[0] IERC20
—
totalStaked
VIEW0x817b1cd2
function totalStaked() external view returns (uint256)

Number of staked NFTs (seats).

RETURNS

[0] uint256
—
UPGRADER_ROLE
VIEW0xf72c0d8b
function UPGRADER_ROLE() external view returns (bytes32)

Role allowed to upgrade the implementation.

RETURNS

[0] bytes32
—
claim
WRITE0x6ba4c138
function claim(uint256[] tokenIds) external returns (uint256 amount)

Pays the pending rewards of the caller's staked NFTs.

PARAMETERS

tokenIds uint256[]
—

RETURNS

amount uint256

Total BUZZ (wei) paid.

initialize
WRITE0xc0c53b8b
function initialize(address admin, IERC20 token_, IERC721 nft_) external

Initializes the proxy.

PARAMETERS

admin address

Receives DEFAULT_ADMIN_ROLE and UPGRADER_ROLE.

token_ IERC20

The BUZZ token.

nft_ IERC721

The Buzz Validator collection.

notifyReward
WRITE0x60993b5b
function notifyReward(uint256 amount) external

Credits amount of BUZZ, already transferred to the vault, equally to every staked seat.

Reverts (and so would settle) only if the packed counters overflow: accRewardPerSeat > 2^128-1 or queued > 2^112-1 wei, both far above any reachable supply.

PARAMETERS

amount uint256
—
onERC721Received
WRITE0x150b7a02
function onERC721Received(address, address from, uint256 tokenId, bytes) external returns (bytes4)

Stakes an NFT sent with safeTransferFrom(owner, vault, tokenId); the seat belongs to from.

Only accepts the configured collection.

PARAMETERS

[0] address
—
from address
—
tokenId uint256
—
[3] bytes
—

RETURNS

[0] bytes4
—
stake
WRITE0x0fbf0a93
function stake(uint256[] tokenIds) external

Stakes NFTs the caller owns (requires approval of the vault).

PARAMETERS

tokenIds uint256[]
—
unstake
WRITE0xe449f341
function unstake(uint256[] tokenIds) external

Pays the pending rewards of the caller's staked NFTs, then returns them to the caller.

PARAMETERS

tokenIds uint256[]
—
Events (4)
Claimed
EVENT
event Claimed(address indexed owner, uint256 indexed tokenId, uint256 amount)

Rewards were paid for one seat.

FIELDS

owner address · indexed
—
tokenId uint256 · indexed
—
amount uint256
—
RewardNotified
EVENT
event RewardNotified(uint256 amount, uint256 distributed, uint256 queued)

New rewards arrived.

FIELDS

amount uint256

BUZZ (wei) notified.

distributed uint256

Amount added to the seats now (includes previously queued rewards).

queued uint256

Amount left queued (no stakers, or the indivisible remainder).

Staked
EVENT
event Staked(address indexed owner, uint256 indexed tokenId)

A validator NFT was staked.

FIELDS

owner address · indexed
—
tokenId uint256 · indexed
—
Unstaked
EVENT
event Unstaked(address indexed owner, uint256 indexed tokenId)

A validator NFT was unstaked (its pending rewards were paid first).

FIELDS

owner address · indexed
—
tokenId uint256 · indexed
—
Errors (6)
NotStaked
ERROR
error NotStaked(uint256 tokenId)

The NFT is not staked in the vault.

PARAMETERS

tokenId uint256
—
NotStaker
ERROR
error NotStaker(uint256 tokenId, address caller)

The caller is not the staker of the NFT.

PARAMETERS

tokenId uint256
—
caller address
—
SafeCastOverflowedUintDowncast
ERROR
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value)

Value doesn't fit in a uint of bits size.

PARAMETERS

bits uint8
—
value uint256
—
SafeERC20FailedOperation
ERROR
error SafeERC20FailedOperation(address token)

An operation with an ERC-20 token failed.

PARAMETERS

token address
—
WrongCollection
ERROR
error WrongCollection(address collection)

The vault only accepts the configured validator collection.

PARAMETERS

collection address
—
ZeroAddress
ERROR
error ZeroAddress()

A zero address was passed where a contract is required.

Inherited (OpenZeppelin AccessControl, UUPS) (25)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddf
function DEFAULT_ADMIN_ROLE() external view returns (bytes32)

RETURNS

[0] bytes32
—
UPGRADE_INTERFACE_VERSION
VIEW0xad3cb1cc
function UPGRADE_INTERFACE_VERSION() external view returns (string)

RETURNS

[0] string
—
getRoleAdmin
VIEW0x248a9ca3
function getRoleAdmin(bytes32 role) external view returns (bytes32)

Returns the admin role that controls role. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.

PARAMETERS

role bytes32
—

RETURNS

[0] bytes32
—
grantRole
WRITE0x2f2ff15d
function grantRole(bytes32 role, address account) external

Grants role to account. If account had not been already granted role, emits a {RoleGranted} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleGranted} event.

PARAMETERS

role bytes32
—
account address
—
hasRole
VIEW0x91d14854
function hasRole(bytes32 role, address account) external view returns (bool)

Returns true if account has been granted role.

PARAMETERS

role bytes32
—
account address
—

RETURNS

[0] bool
—
proxiableUUID
VIEW0x52d1902d
function proxiableUUID() external view returns (bytes32)

Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the notDelegated modifier.

RETURNS

[0] bytes32
—
renounceRole
WRITE0x36568abe
function renounceRole(bytes32 role, address callerConfirmation) external

Revokes role from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). Emits a {RoleRevoked} event if the calling account had role and this call successfully revoked it. Requirements: - the caller must be callerConfirmation. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
callerConfirmation address
—
revokeRole
WRITE0xd547741f
function revokeRole(bytes32 role, address account) external

Revokes role from account. If account had been granted role, emits a {RoleRevoked} event. Requirements: - the caller must have `role`'s admin role. May emit a {RoleRevoked} event.

PARAMETERS

role bytes32
—
account address
—
supportsInterface
VIEW0x01ffc9a7
function supportsInterface(bytes4 interfaceId) external view returns (bool)

Returns true if this contract implements the interface defined by interfaceId. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.

PARAMETERS

interfaceId bytes4
—

RETURNS

[0] bool
—
upgradeToAndCall
WRITE0x4f1ef286
function upgradeToAndCall(address newImplementation, bytes data) external payable

Upgrade the implementation of the proxy to newImplementation, and subsequently execute the function call encoded in data. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.

PARAMETERS

newImplementation address
—
data bytes
—
Initialized
EVENT
event Initialized(uint64 version)

Triggered when the contract has been initialized or reinitialized.

FIELDS

version uint64
—
RoleAdminChanged
EVENT
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

Emitted when newAdminRole is set as `role's admin role, replacing previousAdminRole DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this.

FIELDS

role bytes32 · indexed
—
previousAdminRole bytes32 · indexed
—
newAdminRole bytes32 · indexed
—
RoleGranted
EVENT
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is granted role. sender is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
RoleRevoked
EVENT
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

Emitted when account is revoked role. sender is the account that originated the contract call:

  • if using revokeRole, it is the admin role bearer
  • if using renounceRole, it is the role bearer (i.e. account)

FIELDS

role bytes32 · indexed
—
account address · indexed
—
sender address · indexed
—
Upgraded
EVENT
event Upgraded(address indexed implementation)

Emitted when the implementation is upgraded.

FIELDS

implementation address · indexed
—
AccessControlBadConfirmation
ERROR
error AccessControlBadConfirmation()

The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.

AccessControlUnauthorizedAccount
ERROR
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole)

The account is missing a role.

PARAMETERS

account address
—
neededRole bytes32
—
AddressEmptyCode
ERROR
error AddressEmptyCode(address target)

There's no code at target (it is not a contract).

PARAMETERS

target address
—
ERC1967InvalidImplementation
ERROR
error ERC1967InvalidImplementation(address implementation)

The implementation of the proxy is invalid.

PARAMETERS

implementation address
—
ERC1967NonPayable
ERROR
error ERC1967NonPayable()

An upgrade function sees msg.value > 0 that may be lost.

FailedCall
ERROR
error FailedCall()

A call to an address target failed. The target may have reverted.

InvalidInitialization
ERROR
error InvalidInitialization()

The contract is already initialized.

NotInitializing
ERROR
error NotInitializing()

The contract is not initializing.

UUPSUnauthorizedCallContext
ERROR
error UUPSUnauthorizedCallContext()

The call is from an unauthorized context.

UUPSUnsupportedProxiableUUID
ERROR
error UUPSUnsupportedProxiableUUID(bytes32 slot)

The storage slot is unsupported as a UUID.

PARAMETERS

slot bytes32
—
JSON ABI (51 entries)
BuzzchainValidatorVault.abi.json
[
  {
    "type": "constructor",
    "inputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "REWARDER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "UPGRADER_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "UPGRADE_INTERFACE_VERSION",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string",
        "internalType": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "accRewardPerSeat",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "claim",
    "inputs": [
      {
        "name": "tokenIds",
        "type": "uint256[]",
        "internalType": "uint256[]"
      }
    ],
    "outputs": [
      {
        "name": "amount",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "grantRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "initialize",
    "inputs": [
      {
        "name": "admin",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "token_",
        "type": "address",
        "internalType": "contract IERC20"
      },
      {
        "name": "nft_",
        "type": "address",
        "internalType": "contract IERC721"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "nft",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "contract IERC721"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "notifyReward",
    "inputs": [
      {
        "name": "amount",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "onERC721Received",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "from",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "",
        "type": "bytes",
        "internalType": "bytes"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes4",
        "internalType": "bytes4"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "pendingRewards",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "proxiableUUID",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "queuedRewards",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "callerConfirmation",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "revokeRole",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "stake",
    "inputs": [
      {
        "name": "tokenIds",
        "type": "uint256[]",
        "internalType": "uint256[]"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "stakerOf",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "supportsInterface",
    "inputs": [
      {
        "name": "interfaceId",
        "type": "bytes4",
        "internalType": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "token",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "contract IERC20"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalStaked",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "unstake",
    "inputs": [
      {
        "name": "tokenIds",
        "type": "uint256[]",
        "internalType": "uint256[]"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "upgradeToAndCall",
    "inputs": [
      {
        "name": "newImplementation",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "data",
        "type": "bytes",
        "internalType": "bytes"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Claimed",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      },
      {
        "name": "amount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Initialized",
    "inputs": [
      {
        "name": "version",
        "type": "uint64",
        "indexed": false,
        "internalType": "uint64"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RewardNotified",
    "inputs": [
      {
        "name": "amount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "distributed",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "queued",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleAdminChanged",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "previousAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "newAdminRole",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "role",
        "type": "bytes32",
        "indexed": true,
        "internalType": "bytes32"
      },
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "sender",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Staked",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Unstaked",
    "inputs": [
      {
        "name": "owner",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenId",
        "type": "uint256",
        "indexed": true,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Upgraded",
    "inputs": [
      {
        "name": "implementation",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AccessControlBadConfirmation",
    "inputs": []
  },
  {
    "type": "error",
    "name": "AccessControlUnauthorizedAccount",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "neededRole",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "AddressEmptyCode",
    "inputs": [
      {
        "name": "target",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC1967InvalidImplementation",
    "inputs": [
      {
        "name": "implementation",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ERC1967NonPayable",
    "inputs": []
  },
  {
    "type": "error",
    "name": "FailedCall",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InvalidInitialization",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NotInitializing",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NotStaked",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "NotStaker",
    "inputs": [
      {
        "name": "tokenId",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "caller",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "SafeCastOverflowedUintDowncast",
    "inputs": [
      {
        "name": "bits",
        "type": "uint8",
        "internalType": "uint8"
      },
      {
        "name": "value",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "SafeERC20FailedOperation",
    "inputs": [
      {
        "name": "token",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "UUPSUnauthorizedCallContext",
    "inputs": []
  },
  {
    "type": "error",
    "name": "UUPSUnsupportedProxiableUUID",
    "inputs": [
      {
        "name": "slot",
        "type": "bytes32",
        "internalType": "bytes32"
      }
    ]
  },
  {
    "type": "error",
    "name": "WrongCollection",
    "inputs": [
      {
        "name": "collection",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ZeroAddress",
    "inputs": []
  }
]

BuzzchainValidatorFaucet

IMMUTABLESepolia Etherscan ↗

Testnet faucet for Buzz Validator NFTs: every address can claim AMOUNT_PER_CLAIM validators once by paying exactly PRICE wei, which is forwarded to RECIPIENT.

Needs MINTER_ROLE on the collection; revoking that role disables the faucet. If the collection has a MAX_SUPPLY, claims revert once it is reached. Not intended for mainnet deployments.

Functions (6)
AMOUNT_PER_CLAIM
VIEW0x290c3852
function AMOUNT_PER_CLAIM() external view returns (uint256)

Number of validators minted per claim.

RETURNS

[0] uint256
—
hasClaimed
VIEW0x73b2e80e
function hasClaimed(address account) external view returns (bool)

Whether an address has already claimed.

PARAMETERS

account address
—

RETURNS

[0] bool
—
NFT
VIEW0x7c0b8de2
function NFT() external view returns (BuzzchainValidator)

The Buzz Validator collection.

RETURNS

[0] BuzzchainValidator
—
PRICE
VIEW0x8d859f3e
function PRICE() external view returns (uint256)

Exact msg.value (wei) required by claim.

RETURNS

[0] uint256
—
RECIPIENT
VIEW0x0d9019e1
function RECIPIENT() external view returns (address)

Receives every claim payment.

RETURNS

[0] address
—
claim
WRITE0x4e71d92d
function claim() external payable returns (uint256 firstId)

Mints AMOUNT_PER_CLAIM validators to the caller, once per address, for exactly PRICE wei.

RETURNS

firstId uint256

The first minted ID.

Events (1)
Claimed
EVENT
event Claimed(address indexed account, uint256 firstId, uint256 count, uint256 paid)

account paid paid wei and received validators firstId .. firstId + count - 1.

FIELDS

account address · indexed
—
firstId uint256
—
count uint256
—
paid uint256
—
Errors (4)
AlreadyClaimed
ERROR
error AlreadyClaimed(address account)

The caller has already claimed.

PARAMETERS

account address
—
IncorrectPayment
ERROR
error IncorrectPayment(uint256 expected, uint256 actual)

msg.value is not exactly PRICE.

PARAMETERS

expected uint256
—
actual uint256
—
InvalidConfig
ERROR
error InvalidConfig()

A zero address or a zero amount was passed to the constructor.

PaymentFailed
ERROR
error PaymentFailed()

Forwarding the payment to RECIPIENT failed.

JSON ABI (12 entries)
BuzzchainValidatorFaucet.abi.json
[
  {
    "type": "constructor",
    "inputs": [
      {
        "name": "nft_",
        "type": "address",
        "internalType": "contract BuzzchainValidator"
      },
      {
        "name": "amountPerClaim_",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "price_",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "recipient_",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "AMOUNT_PER_CLAIM",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "NFT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "contract BuzzchainValidator"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "PRICE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "RECIPIENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "claim",
    "inputs": [],
    "outputs": [
      {
        "name": "firstId",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "hasClaimed",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "Claimed",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "firstId",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "count",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "paid",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "AlreadyClaimed",
    "inputs": [
      {
        "name": "account",
        "type": "address",
        "internalType": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "IncorrectPayment",
    "inputs": [
      {
        "name": "expected",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "actual",
        "type": "uint256",
        "internalType": "uint256"
      }
    ]
  },
  {
    "type": "error",
    "name": "InvalidConfig",
    "inputs": []
  },
  {
    "type": "error",
    "name": "PaymentFailed",
    "inputs": []
  }
]

11 · REFERENCE

Glossary & sources

Glossary

Pseudochain
A sequence of blocks driven by outside data and anchored on a host chain, with no consensus of its own.
Toychain
Squeekchain’s name for this family of systems.
Stream
The set of X posts matching the active query.
Weight
How much one post adds to the accumulator.
Accumulator
The running total of weight since the last block.
KK
The threshold: units of weight needed to close one block.
Block rate
Blocks per unit of time. It follows engagement: dB/dt≈wˉ λ(t)/KdB/dt \approx \bar{w}\,\lambda(t)/K.
Breadth
The total weight of a block. It decides when the block closes.
Loudness
The raw engagement of a block’s readings. It decides what the block pays.
Block reward
The $BUZZ a block mints, computed from its loudness and the share of the pool still left.
Block reward pool
The 187,600,000 $BUZZ (EE) that can only be minted as block rewards.
Genesis allocation
The 92,400,000 $BUZZ minted at BGE: 56,000,000 for the liquidity pool, and 22,400,000 for builders and 14,000,000 for the team, both locked.
Speed limit
At most 0.19% of the remaining pool is emitted per day, so the pool never halves faster than every 12 months.
Cumulative attention
The running sum of the loudness term of every block, An=∑i≤nLiA_n = \sum_{i \le n} \sqrt{L_i}. The clock of emission.
Attention half-life
The cumulative attention A1/2=Eln⁡2/βA_{1/2} = E \ln 2 / \beta that halves the remaining pool. Targeted at 24 months of expected engagement.
Proof of Engagement
The rule that a block is produced when accumulated weight reaches KK.
Heartbeat
An empty block produced after a long silence, to keep the chain live (a TIMEOUT block on testnet).
Engagement checkpoint
One of the three times a post is read: 15 minutes, 2 hours and 24 hours after posting. The first reading adds the full weight, later ones only the growth.
Reading
The record of a post and its engagement at one checkpoint. Its hash is committed in the block leaf.
Virtual supply
The $BUZZ that blocks produced before BGE would have minted. Nothing is minted.
BGE
Block Generation Event. Day one of the chain, when block 0 is produced.
Validator NFT
The token that represents a validator seat.
Seat
A validator NFT. A staked seat receives an equal share of each block’s reward; an unstaked seat earns nothing.
Validator
The holder of a staked seat.
Ethereum checkpoint
A block hash written to Ethereum.
Epoch
A fixed period used for reporting and analysis.
Mindshare
The share of attention a topic or account holds.
$BUZZ
The native token. Capped at 280,000,000. 92,400,000 are minted at BGE and the rest with each block from block 0.
FULL block
Testnet: a block sealed when blockSize qualified posts from distinct authors are waiting. Emits.
TIMEOUT block
Testnet: the heartbeat sealed after maxBlockTime with no FULL block. Never emits.
NEW / MATURED leaf
Testnet: a post’s loudness at seal time, and the extra loudness it earned in its first 24 h.
Batch
One L1 transaction that settles one or more consecutive blocks; stores a single headersRoot.
Sealed / settled
Soft confirmation by the relayer / committed on Ethereum (L1 finality).

Sources

External sources used in this documentation, accessed November 2026.