(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 , 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
| Stage | What happens |
|---|---|
| Before BGE | The full data system runs in public as a proof of concept. It produces blocks without a token or rewards. |
| Block Generation Event | Day one. Validator seats are offered, the token is deployed, block 0 is produced, and $BUZZ emission begins. |
| After BGE | Proof 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 |
|---|---|
| The idea and where it comes from | Pseudochains, From mindshare to blocks |
| The math behind block production | Proof of Engagement |
| Why every block pays differently | Breadth and loudness |
| Supply and emission | Tokenomics |
| How launch works | Before BGE, Block Generation Event |
| What validators do | Validators |
| How to build on it | Developers |
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 | Buzzchain | |
|---|---|---|
| Data source | One hamster’s movement | Public X posts matching a query |
| What speeds up blocks | The hamster running | More posts, from more and heavier accounts |
| Who can verify | Whoever trusts the oracle | Anyone with access to the same data |
| Validators | Passive recipients | Staked 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.
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
- Each matching post adds its weight to a running accumulator.
- When the accumulator reaches the threshold , a block closes. It contains the posts that filled it, ordered by post ID.
- The remainder carries over to the next block.
- 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.
The model
Posts arrive at times with weights . Let be the arrival rate and the mean weight. Accumulated engagement is:
Block is produced the first time the accumulator crosses , and chain height is accumulated engagement divided by :
So block rate follows engagement, and block time moves inversely to it:
The chain never stores the engagement rate. It encodes it in block frequency, and anyone can decode it from two consecutive blocks:
Why K matters
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:
| (unit weights) | Block-time jitter | Behaviour |
|---|---|---|
| 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:
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
is set from a target block time at the stream's baseline rate :
is not retargeted quickly. Bitcoin-style difficulty adjustment exists to hold block time constant, which would erase the signal. stays fixed within an epoch.
Simulation check
A simulation with 2 million Poisson arrivals matches the noise formula within 2% for .
| Unit weights, simulated | Predicted | Lognormal weights, simulated | Predicted | |
|---|---|---|---|---|
| 20 | 0.223 | 0.224 | 0.357 | 0.362 |
| 60 | 0.129 | 0.129 | 0.208 | 0.209 |
| 100 | 0.100 | 0.100 | 0.160 | 0.162 |
| 400 | 0.049 | 0.050 | 0.081 | 0.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 ()
- 10.0 min
- BLOCKS / DAY
- 144
- POSTS / BLOCK
- about 20
- BLOCK-TIME JITTER (CV)
- ±36%
- BURSTINESS ()
- 1.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 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:
- Refresh live metrics for open posts (every
refreshInterval, and always right before a seal). A candidate becomes qualified once it haslikes ≥ minLikes; candidates that don't qualify by the end of the UTC day they were first read expire. - FULL block. If ≥
blockSizequalified posts from distinct authors are waiting, seal a block with the oldestblockSizeof them (one per author) plus up tomaxMaturedPerBlockmatured posts that are ready. Repeat while the condition holds, which absorbs bursts. - 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.
| Parameter | Initial | Where |
|---|---|---|
blockSize | 10 new posts per FULL block | On-chain (Sequencer), read by the relayer |
maxBlockTime | 3,600 s (1 h heartbeat; the design uses 6 h) | On-chain |
minLikes | 1 | Off-chain params |
candidateWindow | Until 23:59:59 UTC of the first-read day | Off-chain params |
refreshInterval | 300 s, plus a forced refresh before every seal | Off-chain params |
maturityDelay | 24 h after the post was created | Off-chain params |
maxMaturedPerBlock | 200 | Off-chain params |
| Protocol design | Testnet v1 | |
|---|---|---|
| Stream | $BUZZ cashtag + project reference, original posts only | Posts 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 block | Accumulated weight reaches | 10 qualified posts from distinct authors (unit weights, ) |
| Heartbeat | 6 h | 1 h (TIMEOUT block) |
| Target block time | 10 min at baseline | Set by how fast 10 qualified posts arrive |
| Ordering inside a block | Post ID | Oldest first (created_at), one post per author |
| Engagement readings | Three checkpoints: 15 minutes, 2 hours and 24 hours after posting | Two: 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:
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.
- 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 post | Account factor | Engagement factor | Weight |
|---|---|---|---|
| 50 followers, no engagement | 1.0 | 1.0 | 1.0 |
| 5,000 followers, 20 likes, 5 reposts | 1.8 | 4.4 | 7.9 |
| 100,000 followers, 1,000 likes, 300 reposts | 3.0 | 8.4 | 25.2 |
| 10 million followers, 50,000 likes, 10,000 reposts | 4.0 (capped) | 12.2 | 48.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 . Each later reading adds only the growth since the previous reading, to whichever block is open then:
Closed blocks never change. Engagement that disappears is not subtracted.
Example. An account with 5,000 followers has . Its post has 100 likes at 15 minutes, so and the post enters the open block with weight . At 2 hours it has 500 likes. The growth 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 | Loudness | |
|---|---|---|
| What it counts | Weighted posts, log-compressed | Raw engagement, uncompressed |
| Formula | ||
| What it decides | When the block closes | How much $BUZZ the block mints |
| How it behaves | Nearly the same for every block | Different for every block |
The sums run over the readings that entered block . Here is a reading's weight (the full weight at the first checkpoint, the growth after that) and is its loudness, computed from the post's raw engagement:
A post adds to the loudness of the block it first enters, and its growth to the block that is open at each later checkpoint. Engagement per post is capped at .
Why two measures? The logarithms make breadth steady. Every block closes at the same threshold , 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
- The base emission rate, fixed at BGE.
- The loudness term: a block four times louder earns twice as much.
- 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 (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 :
| 9 in 10 blocks pay less than | 1 in 100 blocks pays more than | Largest block | Share from top 1% of blocks | |
|---|---|---|---|---|
| 1 | 2.2× the median | 6.0× the median | 112× the median | 7.7% |
| 0.5 (design) | 1.5× the median | 2.4× the median | 11× the median | 2.8% |
| 0.25 | 1.2× the median | 1.6× the median | 3× the median | 1.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 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, , 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 . In the simulation, tripling lowered the total by about 40%. This is why 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
curve = sqrt), = 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). is a testnet estimate: it gives a 24-month attention half-life if blocks close every 10 minutes with an average , and may be adjusted as the testnet runs. The pool factor 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
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 and loudness 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
| Layer | Where it runs | What it does |
|---|---|---|
| Stream indexer | Off-chain | Pulls matching posts and records a reading at each checkpoint |
| Block builder | Off-chain, run by the Buzzchain team | Applies Proof of Engagement. The rules are public, so anyone with the same data can replay it and compare |
| Checkpoint contract | Ethereum | Stores block hashes at regular intervals, posted by the Buzzchain team |
| $BUZZ and rewards | Ethereum | Token, 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
| Component | Trust | Why |
|---|---|---|
| X | Trusted for ordering and availability | It can censor posts or cut access |
| Buzzchain team | Trusted to build blocks and post checkpoints | Its output can be replayed by anyone with the same data, so a wrong checkpoint can be shown |
| Ethereum | Trusted for integrity | Makes 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, chainedparentHash, 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
settletransaction 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.
| Component | State before BGE |
|---|---|
| Stream indexer | Live. Collects qualifying posts and records a reading at each checkpoint |
| Post weights | Live. Same formula that will be used after BGE |
| Blocks | Live. Built with the real Proof of Engagement rule and published, but not rewarded |
| Virtual supply | Live. The $BUZZ blocks would have minted, computed with the real reward formula. Nothing is minted |
| Explorer | Live. Shows the accumulator, blocks and block rate |
| Checkpoints on Ethereum | Test only |
| $BUZZ emission | Off |
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
- The parameters. The baseline rate , the mean weight and the weight spread are measured, and is set from them.
- The model. Measured block-time noise is compared with the prediction .
- Determinism. Independent replays of the same data must produce identical blocks.
- Loudness. The real engagement per block is measured and projected forward. That fixes the base emission rate for a 24-month half-life.
- Data quality. The share of weight coming from accounts that look inauthentic is tracked, and the filters are tuned.
| Parameter | Symbol | Value |
|---|---|---|
| Stream query | $BUZZ plus a project reference, original posts only | |
| Length of the phase | To be set | |
| Engagement checkpoints | 15 minutes, 2 hours and 24 hours after posting | |
| Target block time at baseline | 10 minutes | |
| Threshold | Calibrated during this phase | |
| Heartbeat interval | 6 hours | |
| Account weight cap | 4 |
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.
- Seats. Validator seats are offered at BGE, with a cap on how many one wallet can buy. The terms will be announced before BGE.
- 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.
- Block 0. and are fixed from the pre-BGE measurements, the accumulator is reset to zero, and the first live block is produced.
| Before BGE | From block 0 | |
|---|---|---|
| Blocks | Published without rewards | Live blocks, checkpointed on Ethereum |
| Emission | Virtual only | Set by each block’s loudness, drawn from a capped pool |
| Supply | None | 92,400,000 at BGE, capped at 280,000,000 |
| Validators | None | Staked seats receive the $BUZZ minted in every block |
| Reward for posting | None | None |
| Parameter | Symbol | Value |
|---|---|---|
| Validator seats | To be announced before BGE | |
| Purchase cap per wallet | To be announced before BGE | |
| Threshold at block 0 | From pre-BGE calibration | |
| Base emission rate | Fixed at BGE for a 24-month half-life | |
| Liquidity pool | 56,000,000 $BUZZ | |
| Builders and team | 22,400,000 and 14,000,000 $BUZZ, locked | |
| Maximum supply | 280,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 be the engagement in epoch , and suppose a fraction of it is caused by the previous epoch's activity.
- For the loop settles, amplifying the organic baseline by . Only a fraction of blocks reflects outside interest.
- For 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 .
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:
| Option | How it works | Trade-off |
|---|---|---|
| Vote | $BUZZ holders stake and vote on the next topic each epoch | One topic at a time. Needs governance |
| Topic tokens | Anyone opens a topic by committing $BUZZ. The topic emits its own token, settled in $BUZZ | Many 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 set by its loudness. It is split equally among the staked seats:
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.
| Parameter | Value |
|---|---|
| Reward split | Equal per staked seat |
| Reward per block | Set by loudness, see Block rewards |
| Transfers | Allowed |
| Number of seats | To be announced before BGE |
| Purchase cap per wallet at BGE | To 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
| Parameter | Value |
|---|---|
| Ticker | $BUZZ |
| Maximum supply | 280,000,000 |
| Block rewards | 187,600,000 (67%) |
| Liquidity pool | 56,000,000 (20%) |
| Builders | 22,400,000 (8%), locked at BGE |
| Team | 14,000,000 (5%), locked at BGE |
| Supply at BGE, circulating plus locked | 92,400,000 |
| Target half-life | 24 months |
| Speed limit | The 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 | Share | $BUZZ | Terms |
|---|---|---|---|
| Block rewards | 67% | 187,600,000 | Minted only as blocks are produced. Paid to staked validator seats |
| Liquidity pool | 20% | 56,000,000 | Minted at BGE to seed the liquidity pool |
| Builders | 8% | 22,400,000 | For people who build on Buzzchain: new streams, tools, applications. Locked at BGE |
| Team | 5% | 14,000,000 | Locked 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 has a loudness , the raw engagement of the readings it contains, and its reward follows it:
| Symbol | Meaning |
|---|---|
| $BUZZ minted in block | |
| Loudness of block | |
| Base emission rate, fixed at BGE | |
| $BUZZ already emitted as block rewards | |
| The block reward pool, |
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
- 20.00
- SAME BLOCK, 4X LOUDER
- 40.00 (2.00x)
- POOL LEFT
- 187.6M
- DAILY SPEED LIMIT
- 356,440 BUZZ
is fixed at BGE, so rewards are shown in units of . The speed limit is 0.19% of the remaining pool per day, and , which is why the pool can never halve faster than once a year. The design uses the square root, .
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:
Each block mints 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 grows by the attention half-life :
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 is set once, at BGE, so that 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.
| Years after BGE | Total supply, target pace | Total supply, fastest pace |
|---|---|---|
| 0 (BGE) | 92,400,000 | 92,400,000 |
| 1 | 147,300,000 | 186,200,000 |
| 2 | 186,200,000 | 233,100,000 |
| 3 | 213,700,000 | 256,600,000 |
| 4 | 233,100,000 | 268,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 , 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
BlockSealedandBatchSettledevents; every block's leaves are in thesettlecalldata. - Validator tooling
- Stake Buzz Validator NFTs, track pending rewards, claim.
| Piece | Where | Use it for |
|---|---|---|
| Contract ABIs | Contract reference | JSON ABIs with NatSpec, ready for viem, ethers or any Ethereum library |
| Contracts | Sepolia addresses | Read views, index events, stake and claim |
| Public API | /api/* | Read-only JSON: blocks, posts with proofs, stats, series, params |
| Encodings | Encodings | Rebuild 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
| Contract | Role | Address |
|---|---|---|
| BuzzchainSequencer | Settlement, proofs, params (proxy) | 0x44e6c7bC1146259Ff63a9b514B42C86F272631a2 |
| BuzzToken | $BUZZ ERC-20 | 0xc8bdca3cFD13BcB2b1E5C4Aa3bc35C7196009e2b |
| BuzzchainValidator | Validator NFT (ERC-721) | 0xb5aAdd62fbC1e42bbEF02dDbBbcef053ff2acdf9 |
| BuzzchainValidatorVault | Staking & rewards (proxy) | 0x5263121Df28F91EC3c2773814a7c798c0849E148 |
| BuzzchainValidatorFaucet | Testnet validator faucet | 0x0419ecE34c8124Ec121495C9E5f4956620DC6b28 |
| BuzzchainSequencer impl. | UUPS implementation | 0xA6BB84310E5e4964D03d49A7CE2919FA9D70a5C3 |
| BuzzchainValidatorVault impl. | UUPS implementation | 0xB70388371EC3D715AB0F89623d9E67A73e647fEe |
| Relayer EOA | Holds SEQUENCER_ROLE | 0x19047640CC347F6B8626cD8DE76A7A7a672880f0 |
Genesis (block 0): hash 0xd4b3ee09f13380bcab2dfdc57e18d4bd5922748e40a02fad77054486b880cc3e, timestamp 1795093152, deployed at L1 block 12168560.
Endpoints
| Environment | Relayer API | Notes |
|---|---|---|
| Sepolia testnet | https://api.testnet.buzzchain.xyz | Read-only /api/*; settles to the Sepolia sequencer above |
Quickstart
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.
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:
- Find the batch:
batchOf(blockNumber), then itsBatchSettledlog and transaction. - Decode the transaction input as
settle(headers, postData)with the sequencer ABI. - For each header, check
keccak256(postData[i]) == dataHash, splitpostData[i]into 17-byte leaves (Encodings), and rebuildpostsRootwith@openzeppelin/merkle-tree(StandardMerkleTree.of(leaves, ['uint64', 'uint8', 'uint64'])). - Rebuild
headersRootfrom the block hashes and compare it withbatch(i).headersRoot. Leaf counts must matchnewPosts/maturedPosts, and leaf loudness must sum toheader.loudness.
Read the chain & block rate
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.
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);
},
});| Event | Indexed | Payload |
|---|---|---|
BlockSealed | number, blockHash | postsRoot, loudness, emission (wei), kind (0 FULL, 1 TIMEOUT) |
BatchSettled | batchIndex | firstBlock, lastBlock, headersRoot, totalEmission |
ParamsUpdated | — | blockSize, maxBlockTime, maxEmissionPerBlock |
RewardNotified (vault) | — | amount, distributed, queued |
Staked / Unstaked / Claimed (vault) | owner, tokenId | amount |
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.
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), withkind0 = 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 OpenZeppelinStandardMerkleTreeconvention. Pairs are hashed sorted, so proofs work withMerkleProof.verifyand@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 rebuildpostsRootfrom L1 alone.- Block hash
keccak256(abi.encode(header))over the 352-byte ABI encoding ofBlockHeader.- 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.
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).
| Route | Returns | Cache |
|---|---|---|
GET /api/blocks?cursor=&limit= | Blocks, newest first, cursor-paginated (limit 1–100) | Head 5 s; all-settled pages 1 day |
GET /api/blocks/:n | A block: header, leaves (loudness only), postData, batch. :n may be latest | Settled: 1 day; otherwise 5 s |
GET /api/posts/:id | Status, total loudness and every inclusion with both proofs | Matured & settled: 1 day; expired: 1 h; otherwise 5 s |
GET /api/stats | Totals, heads and the active (pending) block | 15 s |
GET /api/live?limit= | Stats plus the newest blocks (max 30), in one request | 5 s |
GET /api/series?interval=hour|day | Dense time buckets: blocks, posts, loudness, emission, supply | 15 s |
GET /api/params[/:version] | The params behind any header's paramsVersion | 15 s |
| Value | JSON type |
|---|---|
| Post IDs, loudness, emission, supply | Decimal string (uint64 / uint128) |
| Block numbers, batch indices, counts, timestamps | Number |
| Hashes, roots, proofs, postData, tx hashes | Lowercase 0x hex |
| Block status | sealed (soft confirmation) or settled (on L1) |
| Errors | { "error": string } with HTTP 400 or 404; unknown or repeated query parameters are a 400 |
Roles & permissions
| Contract | Role | Held by | Allows |
|---|---|---|---|
| BuzzchainSequencer | SEQUENCER_ROLE | Relayer EOA | settle |
| BuzzchainSequencer | PARAMS_ROLE | Admin | setParams |
| BuzzchainSequencer | PAUSER_ROLE | Admin | pause / unpause (views keep working) |
| Sequencer, Vault | UPGRADER_ROLE | Admin | UUPS upgrades |
| BuzzToken | MINTER_ROLE | Sequencer proxy | mint |
| BuzzchainValidatorVault | REWARDER_ROLE | Sequencer proxy | notifyReward |
| BuzzchainValidator | MINTER_ROLE | Admin, faucet | mint |
| All | DEFAULT_ADMIN_ROLE | The Buzzchain team | Grant 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, callssettle;PARAMS_ROLE:setParams;PAUSER_ROLE:pause/unpause(pausing blockssettleonly; views keep working);UPGRADER_ROLE: upgrades the implementation.
Functions (18)
batch
VIEW0x0eaa75fefunction 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
VIEW0x06f13056function batchCount() external view returns (uint256)Number of settled batches.
RETURNS
- [0] uint256
- —
batchOf
VIEW0x859f69adfunction 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
VIEW0x07e2da96function 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
VIEW0xcff0ab96function 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
VIEW0x4fc62042function PARAMS_ROLE() external view returns (bytes32)Role allowed to call setParams.
RETURNS
- [0] bytes32
- —
paused
VIEW0x5c975abbfunction paused() external view returns (bool)Whether settlement is paused.
RETURNS
- [0] bool
- —
PAUSER_ROLE
VIEW0xe63ab1e9function PAUSER_ROLE() external view returns (bytes32)Role allowed to pause and unpause settlement.
RETURNS
- [0] bytes32
- —
SEQUENCER_ROLE
VIEW0x4842855cfunction SEQUENCER_ROLE() external view returns (bytes32)Role allowed to call settle (the relayer).
RETURNS
- [0] bytes32
- —
token
VIEW0xfc0c546afunction token() external view returns (BuzzToken)The BUZZ token.
RETURNS
- [0] BuzzToken
- —
UPGRADER_ROLE
VIEW0xf72c0d8bfunction UPGRADER_ROLE() external view returns (bytes32)Role allowed to upgrade the implementation.
RETURNS
- [0] bytes32
- —
vault
VIEW0xfbfa77cffunction vault() external view returns (IBuzzchainValidatorVault)The validator vault.
RETURNS
- [0] IBuzzchainValidatorVault
- —
verifyPost
VIEW0xea5796aafunction 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'sheadersRoot.- 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
WRITE0x5780ad9bfunction initialize(address admin, BuzzToken token_, IBuzzchainValidatorVault vault_, uint64 genesisTimestamp, uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock) externalInitializes 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_ROLEandUPGRADER_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_ROLE0x8456cb59function pause() externalPauses settlement. Restricted to PAUSER_ROLE.
setParams
WRITEPARAMS_ROLE0x3b0057a0function setParams(uint32 blockSize, uint32 maxBlockTime, uint128 maxEmissionPerBlock) externalUpdates 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_ROLE0x93037ea3function settle(BlockHeader[] headers, bytes[] postData) externalSettles 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 + 1andparentHash == previous blockHash;previous.timestamp <= timestamp <= block.timestamp(equal timestamps are allowed);kindis FULL or TIMEOUT; TIMEOUT ⇒emission == 0; FULL ⇒newPosts == blockSize;emission <= maxEmissionPerBlock;postData[i].length == 17 * (newPosts + maturedPosts)andkeccak256(postData[i]) == dataHash;postsRoot == 0exactly when the block has no posts. It then stores oneBatch, moves the latest-block pointer, emitsBlockSealedper block and oneBatchSettled, and, if the total emission is non-zero, mints it to the vault and callsnotifyRewardonce.
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;
0xfor an empty block).
unpause
WRITEPAUSER_ROLE0x3f4ba83afunction unpause() externalUnpauses settlement. Restricted to PAUSER_ROLE.
Events (5)
BatchSettled
EVENTevent 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
EVENTevent 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
EVENTevent 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
EVENTevent Paused(address account)Settlement was paused by account.
FIELDS
- account address
- —
Unpaused
EVENTevent Unpaused(address account)Settlement was unpaused by account.
FIELDS
- account address
- —
Errors (19)
BlockNotSettled
ERRORerror BlockNotSettled(uint64 number)The block number is not part of any settled batch (genesis, or not settled yet).
PARAMETERS
- number uint64
- —
DataHashMismatch
ERRORerror DataHashMismatch(uint64 number)A block's post data does not hash to its dataHash.
PARAMETERS
- number uint64
- —
EmissionTooHigh
ERRORerror EmissionTooHigh(uint64 number, uint128 emission, uint128 max)A block's emission is above maxEmissionPerBlock.
PARAMETERS
- number uint64
- —
- emission uint128
- —
- max uint128
- —
EmptyBatch
ERRORerror EmptyBatch()settle was called with no headers.
EnforcedPause
ERRORerror EnforcedPause()Settlement is paused.
ExpectedPause
ERRORerror ExpectedPause()Settlement is not paused.
FullBlockSize
ERRORerror 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
ERRORerror InvalidKind(uint64 number, uint8 kind)A header's kind is neither FULL (0) nor TIMEOUT (1).
PARAMETERS
- number uint64
- —
- kind uint8
- —
InvalidParams
ERRORerror InvalidParams()A parameter value is out of range.
LengthMismatch
ERRORerror LengthMismatch(uint256 headers, uint256 postData)headers and postData have different lengths.
PARAMETERS
- headers uint256
- —
- postData uint256
- —
NonContiguousBlock
ERRORerror NonContiguousBlock(uint64 expected, uint64 actual)A header's number is not the previous number + 1.
PARAMETERS
- expected uint64
- —
- actual uint64
- —
ParentHashMismatch
ERRORerror 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
ERRORerror 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
ERRORerror PostsRootMismatch(uint64 number)A block's postsRoot is zero while it has posts, or non-zero while it has none.
PARAMETERS
- number uint64
- —
TimeoutEmission
ERRORerror TimeoutEmission(uint64 number)A TIMEOUT block declares a non-zero emission.
PARAMETERS
- number uint64
- —
TimestampDecreasing
ERRORerror 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
ERRORerror TimestampInFuture(uint64 number, uint64 timestamp)A header's timestamp is later than the settling L1 block.
PARAMETERS
- number uint64
- —
- timestamp uint64
- —
UnknownBatch
ERRORerror UnknownBatch(uint256 index)No batch exists at this index.
PARAMETERS
- index uint256
- —
ZeroAddress
ERRORerror ZeroAddress()A zero address was passed where a contract is required.
Inherited (OpenZeppelin AccessControl, UUPS) (25)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddffunction DEFAULT_ADMIN_ROLE() external view returns (bytes32)RETURNS
- [0] bytes32
- —
UPGRADE_INTERFACE_VERSION
VIEW0xad3cb1ccfunction UPGRADE_INTERFACE_VERSION() external view returns (string)RETURNS
- [0] string
- —
getRoleAdmin
VIEW0x248a9ca3function 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
WRITE0x2f2ff15dfunction grantRole(bytes32 role, address account) externalGrants 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
VIEW0x91d14854function 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
VIEW0x52d1902dfunction 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
WRITE0x36568abefunction renounceRole(bytes32 role, address callerConfirmation) externalRevokes 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
WRITE0xd547741ffunction revokeRole(bytes32 role, address account) externalRevokes 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
VIEW0x01ffc9a7function 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
WRITE0x4f1ef286function upgradeToAndCall(address newImplementation, bytes data) external payableUpgrade 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
EVENTevent Initialized(uint64 version)Triggered when the contract has been initialized or reinitialized.
FIELDS
- version uint64
- —
RoleAdminChanged
EVENTevent 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
EVENTevent 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
EVENTevent 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
EVENTevent Upgraded(address indexed implementation)Emitted when the implementation is upgraded.
FIELDS
- implementation address · indexed
- —
AccessControlBadConfirmation
ERRORerror AccessControlBadConfirmation()The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
AccessControlUnauthorizedAccount
ERRORerror AccessControlUnauthorizedAccount(address account, bytes32 neededRole)The account is missing a role.
PARAMETERS
- account address
- —
- neededRole bytes32
- —
AddressEmptyCode
ERRORerror AddressEmptyCode(address target)There's no code at target (it is not a contract).
PARAMETERS
- target address
- —
ERC1967InvalidImplementation
ERRORerror ERC1967InvalidImplementation(address implementation)The implementation of the proxy is invalid.
PARAMETERS
- implementation address
- —
ERC1967NonPayable
ERRORerror ERC1967NonPayable()An upgrade function sees msg.value > 0 that may be lost.
FailedCall
ERRORerror FailedCall()A call to an address target failed. The target may have reverted.
InvalidInitialization
ERRORerror InvalidInitialization()The contract is already initialized.
NotInitializing
ERRORerror NotInitializing()The contract is not initializing.
UUPSUnauthorizedCallContext
ERRORerror UUPSUnauthorizedCallContext()The call is from an unauthorized context.
UUPSUnsupportedProxiableUUID
ERRORerror UUPSUnsupportedProxiableUUID(bytes32 slot)The storage slot is unsupported as a UUID.
PARAMETERS
- slot bytes32
- —
JSON ABI (68 entries)
[
{
"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
VIEW0xdd62ed3efunction 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
VIEW0x70a08231function balanceOf(address account) external view returns (uint256)Returns the value of tokens owned by account.
PARAMETERS
- account address
- —
RETURNS
- [0] uint256
- —
cap
VIEW0x355274eafunction cap() external view returns (uint256)Returns the cap on the token's total supply.
RETURNS
- [0] uint256
- —
decimals
VIEW0x313ce567function 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
VIEW0x32cb6b0cfunction MAX_SUPPLY() external view returns (uint256)Hard cap on the total supply: 280,000,000 BUZZ.
RETURNS
- [0] uint256
- —
MINTER_ROLE
VIEW0xd5391393function MINTER_ROLE() external view returns (bytes32)Role allowed to mint. Granted to the BuzzchainSequencer proxy.
RETURNS
- [0] bytes32
- —
name
VIEW0x06fdde03function name() external view returns (string)Returns the name of the token.
RETURNS
- [0] string
- —
symbol
VIEW0x95d89b41function symbol() external view returns (string)Returns the symbol of the token, usually a shorter version of the name.
RETURNS
- [0] string
- —
totalSupply
VIEW0x18160dddfunction totalSupply() external view returns (uint256)Returns the value of tokens in existence.
RETURNS
- [0] uint256
- —
approve
WRITE0x095ea7b3function 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_ROLE0x40c10f19function mint(address to, uint256 amount) externalMints amount to to.
Restricted to MINTER_ROLE. Reverts with ERC20ExceededCap past MAX_SUPPLY.
PARAMETERS
- to address
- —
- amount uint256
- —
transfer
WRITE0xa9059cbbfunction 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
WRITE0x23b872ddfunction 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
EVENTevent 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
EVENTevent 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
ERRORerror ERC20ExceededCap(uint256 increasedSupply, uint256 cap)Total supply cap has been exceeded.
PARAMETERS
- increasedSupply uint256
- —
- cap uint256
- —
ERC20InsufficientAllowance
ERRORerror 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
spenderis allowed to operate with.- needed uint256
Minimum amount required to perform a transfer.
ERC20InsufficientBalance
ERRORerror 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
ERRORerror 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
ERRORerror ERC20InvalidCap(uint256 cap)The supplied cap is not a valid cap.
PARAMETERS
- cap uint256
- —
ERC20InvalidReceiver
ERRORerror ERC20InvalidReceiver(address receiver)Indicates a failure with the token receiver. Used in transfers.
PARAMETERS
- receiver address
Address to which tokens are being transferred.
ERC20InvalidSender
ERRORerror ERC20InvalidSender(address sender)Indicates a failure with the token sender. Used in transfers.
PARAMETERS
- sender address
Address whose tokens are being transferred.
ERC20InvalidSpender
ERRORerror 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
VIEW0xa217fddffunction DEFAULT_ADMIN_ROLE() external view returns (bytes32)RETURNS
- [0] bytes32
- —
getRoleAdmin
VIEW0x248a9ca3function 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
WRITE0x2f2ff15dfunction grantRole(bytes32 role, address account) externalGrants 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
VIEW0x91d14854function 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
WRITE0x36568abefunction renounceRole(bytes32 role, address callerConfirmation) externalRevokes 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
WRITE0xd547741ffunction revokeRole(bytes32 role, address account) externalRevokes 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
VIEW0x01ffc9a7function 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
EVENTevent 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
EVENTevent 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
EVENTevent 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
ERRORerror AccessControlBadConfirmation()The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
AccessControlUnauthorizedAccount
ERRORerror AccessControlUnauthorizedAccount(address account, bytes32 neededRole)The account is missing a role.
PARAMETERS
- account address
- —
- neededRole bytes32
- —
JSON ABI (36 entries)
[
{
"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
VIEW0x70a08231function balanceOf(address owner) external view returns (uint256)Returns the number of tokens in `owner`'s account.
PARAMETERS
- owner address
- —
RETURNS
- [0] uint256
- —
getApproved
VIEW0x081812fcfunction 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
VIEW0xe985e9c5function 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
VIEW0x32cb6b0cfunction MAX_SUPPLY() external view returns (uint256)Hard cap on the collection size; 0 means uncapped.
RETURNS
- [0] uint256
- —
MINTER_ROLE
VIEW0xd5391393function MINTER_ROLE() external view returns (bytes32)Role allowed to mint.
RETURNS
- [0] bytes32
- —
name
VIEW0x06fdde03function name() external view returns (string)Returns the token collection name.
RETURNS
- [0] string
- —
ownerOf
VIEW0x6352211efunction 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
VIEW0x95d89b41function symbol() external view returns (string)Returns the token collection symbol.
RETURNS
- [0] string
- —
tokenURI
VIEW0xc87b56ddfunction tokenURI(uint256 tokenId) external view returns (string)Returns the Uniform Resource Identifier (URI) for tokenId token.
PARAMETERS
- tokenId uint256
- —
RETURNS
- [0] string
- —
totalSupply
VIEW0x18160dddfunction totalSupply() external view returns (uint256)Number of tokens minted so far (also the last minted ID).
RETURNS
- [0] uint256
- —
approve
WRITE0x095ea7b3function approve(address to, uint256 tokenId) externalGives 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_ROLE0x40c10f19function 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
WRITE0x42842e0efunction safeTransferFrom(address from, address to, uint256 tokenId) externalSafely 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
WRITE0xb88d4fdefunction safeTransferFrom(address from, address to, uint256 tokenId, bytes data) externalSafely 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
WRITE0xa22cb465function setApprovalForAll(address operator, bool approved) externalApprove 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_ROLE0x55f804b3function setBaseURI(string baseURI) externalSets the metadata base URI (tokenURI = baseURI ‖ tokenId).
Restricted to DEFAULT_ADMIN_ROLE.
PARAMETERS
- baseURI string
- —
transferFrom
WRITE0x23b872ddfunction transferFrom(address from, address to, uint256 tokenId) externalTransfers 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
EVENTevent 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
EVENTevent 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
EVENTevent BaseURIUpdated(string baseURI)The base URI changed.
FIELDS
- baseURI string
- —
Transfer
EVENTevent 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
ERRORerror 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
ERRORerror 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
ERRORerror 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
ERRORerror 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
ERRORerror 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
ERRORerror ERC721InvalidReceiver(address receiver)Indicates a failure with the token receiver. Used in transfers.
PARAMETERS
- receiver address
Address to which tokens are being transferred.
ERC721InvalidSender
ERRORerror ERC721InvalidSender(address sender)Indicates a failure with the token sender. Used in transfers.
PARAMETERS
- sender address
Address whose tokens are being transferred.
ERC721NonexistentToken
ERRORerror ERC721NonexistentToken(uint256 tokenId)Indicates a tokenId whose owner is the zero address.
PARAMETERS
- tokenId uint256
Identifier number of a token.
MaxSupplyExceeded
ERRORerror MaxSupplyExceeded(uint256 requested, uint256 remaining)Minting count more would exceed MAX_SUPPLY.
PARAMETERS
- requested uint256
- —
- remaining uint256
- —
Inherited (OpenZeppelin AccessControl) (12)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddffunction DEFAULT_ADMIN_ROLE() external view returns (bytes32)RETURNS
- [0] bytes32
- —
getRoleAdmin
VIEW0x248a9ca3function 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
WRITE0x2f2ff15dfunction grantRole(bytes32 role, address account) externalGrants 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
VIEW0x91d14854function 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
WRITE0x36568abefunction renounceRole(bytes32 role, address callerConfirmation) externalRevokes 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
WRITE0xd547741ffunction revokeRole(bytes32 role, address account) externalRevokes 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
VIEW0x01ffc9a7function 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
EVENTevent 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
EVENTevent 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
EVENTevent 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
ERRORerror AccessControlBadConfirmation()The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
AccessControlUnauthorizedAccount
ERRORerror AccessControlUnauthorizedAccount(address account, bytes32 neededRole)The account is missing a role.
PARAMETERS
- account address
- —
- neededRole bytes32
- —
JSON ABI (43 entries)
[
{
"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
VIEW0x8718a7bcfunction accRewardPerSeat() external view returns (uint256)Cumulative rewards per seat since deployment (wei).
RETURNS
- [0] uint256
- —
nft
VIEW0x47ccca02function nft() external view returns (IERC721)The Buzz Validator collection.
RETURNS
- [0] IERC721
- —
pendingRewards
VIEW0x7dcb2abffunction 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
VIEW0x63d38c3bfunction queuedRewards() external view returns (uint256)Rewards waiting for the next distribution (wei).
RETURNS
- [0] uint256
- —
REWARDER_ROLE
VIEW0x8580cf76function REWARDER_ROLE() external view returns (bytes32)Role allowed to call notifyReward. Granted to the BuzzchainSequencer proxy.
RETURNS
- [0] bytes32
- —
stakerOf
VIEW0xac86e186function stakerOf(uint256 tokenId) external view returns (address)Who staked the NFT (address(0) if not staked).
PARAMETERS
- tokenId uint256
- —
RETURNS
- [0] address
- —
token
VIEW0xfc0c546afunction token() external view returns (IERC20)The BUZZ token.
RETURNS
- [0] IERC20
- —
totalStaked
VIEW0x817b1cd2function totalStaked() external view returns (uint256)Number of staked NFTs (seats).
RETURNS
- [0] uint256
- —
UPGRADER_ROLE
VIEW0xf72c0d8bfunction UPGRADER_ROLE() external view returns (bytes32)Role allowed to upgrade the implementation.
RETURNS
- [0] bytes32
- —
claim
WRITE0x6ba4c138function 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
WRITE0xc0c53b8bfunction initialize(address admin, IERC20 token_, IERC721 nft_) externalInitializes the proxy.
PARAMETERS
- admin address
Receives
DEFAULT_ADMIN_ROLEandUPGRADER_ROLE.- token_ IERC20
The BUZZ token.
- nft_ IERC721
The Buzz Validator collection.
notifyReward
WRITE0x60993b5bfunction notifyReward(uint256 amount) externalCredits 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
WRITE0x150b7a02function 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
WRITE0x0fbf0a93function stake(uint256[] tokenIds) externalStakes NFTs the caller owns (requires approval of the vault).
PARAMETERS
- tokenIds uint256[]
- —
unstake
WRITE0xe449f341function unstake(uint256[] tokenIds) externalPays the pending rewards of the caller's staked NFTs, then returns them to the caller.
PARAMETERS
- tokenIds uint256[]
- —
Events (4)
Claimed
EVENTevent 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
EVENTevent 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
EVENTevent Staked(address indexed owner, uint256 indexed tokenId)A validator NFT was staked.
FIELDS
- owner address · indexed
- —
- tokenId uint256 · indexed
- —
Unstaked
EVENTevent 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
ERRORerror NotStaked(uint256 tokenId)The NFT is not staked in the vault.
PARAMETERS
- tokenId uint256
- —
NotStaker
ERRORerror NotStaker(uint256 tokenId, address caller)The caller is not the staker of the NFT.
PARAMETERS
- tokenId uint256
- —
- caller address
- —
SafeCastOverflowedUintDowncast
ERRORerror SafeCastOverflowedUintDowncast(uint8 bits, uint256 value)Value doesn't fit in a uint of bits size.
PARAMETERS
- bits uint8
- —
- value uint256
- —
SafeERC20FailedOperation
ERRORerror SafeERC20FailedOperation(address token)An operation with an ERC-20 token failed.
PARAMETERS
- token address
- —
WrongCollection
ERRORerror WrongCollection(address collection)The vault only accepts the configured validator collection.
PARAMETERS
- collection address
- —
ZeroAddress
ERRORerror ZeroAddress()A zero address was passed where a contract is required.
Inherited (OpenZeppelin AccessControl, UUPS) (25)
DEFAULT_ADMIN_ROLE
VIEW0xa217fddffunction DEFAULT_ADMIN_ROLE() external view returns (bytes32)RETURNS
- [0] bytes32
- —
UPGRADE_INTERFACE_VERSION
VIEW0xad3cb1ccfunction UPGRADE_INTERFACE_VERSION() external view returns (string)RETURNS
- [0] string
- —
getRoleAdmin
VIEW0x248a9ca3function 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
WRITE0x2f2ff15dfunction grantRole(bytes32 role, address account) externalGrants 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
VIEW0x91d14854function 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
VIEW0x52d1902dfunction 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
WRITE0x36568abefunction renounceRole(bytes32 role, address callerConfirmation) externalRevokes 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
WRITE0xd547741ffunction revokeRole(bytes32 role, address account) externalRevokes 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
VIEW0x01ffc9a7function 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
WRITE0x4f1ef286function upgradeToAndCall(address newImplementation, bytes data) external payableUpgrade 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
EVENTevent Initialized(uint64 version)Triggered when the contract has been initialized or reinitialized.
FIELDS
- version uint64
- —
RoleAdminChanged
EVENTevent 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
EVENTevent 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
EVENTevent 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
EVENTevent Upgraded(address indexed implementation)Emitted when the implementation is upgraded.
FIELDS
- implementation address · indexed
- —
AccessControlBadConfirmation
ERRORerror AccessControlBadConfirmation()The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
AccessControlUnauthorizedAccount
ERRORerror AccessControlUnauthorizedAccount(address account, bytes32 neededRole)The account is missing a role.
PARAMETERS
- account address
- —
- neededRole bytes32
- —
AddressEmptyCode
ERRORerror AddressEmptyCode(address target)There's no code at target (it is not a contract).
PARAMETERS
- target address
- —
ERC1967InvalidImplementation
ERRORerror ERC1967InvalidImplementation(address implementation)The implementation of the proxy is invalid.
PARAMETERS
- implementation address
- —
ERC1967NonPayable
ERRORerror ERC1967NonPayable()An upgrade function sees msg.value > 0 that may be lost.
FailedCall
ERRORerror FailedCall()A call to an address target failed. The target may have reverted.
InvalidInitialization
ERRORerror InvalidInitialization()The contract is already initialized.
NotInitializing
ERRORerror NotInitializing()The contract is not initializing.
UUPSUnauthorizedCallContext
ERRORerror UUPSUnauthorizedCallContext()The call is from an unauthorized context.
UUPSUnsupportedProxiableUUID
ERRORerror UUPSUnsupportedProxiableUUID(bytes32 slot)The storage slot is unsupported as a UUID.
PARAMETERS
- slot bytes32
- —
JSON ABI (51 entries)
[
{
"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
VIEW0x290c3852function AMOUNT_PER_CLAIM() external view returns (uint256)Number of validators minted per claim.
RETURNS
- [0] uint256
- —
hasClaimed
VIEW0x73b2e80efunction hasClaimed(address account) external view returns (bool)Whether an address has already claimed.
PARAMETERS
- account address
- —
RETURNS
- [0] bool
- —
NFT
VIEW0x7c0b8de2function NFT() external view returns (BuzzchainValidator)The Buzz Validator collection.
RETURNS
- [0] BuzzchainValidator
- —
PRICE
VIEW0x8d859f3efunction PRICE() external view returns (uint256)Exact msg.value (wei) required by claim.
RETURNS
- [0] uint256
- —
RECIPIENT
VIEW0x0d9019e1function RECIPIENT() external view returns (address)Receives every claim payment.
RETURNS
- [0] address
- —
claim
WRITE0x4e71d92dfunction 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
EVENTevent 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
ERRORerror AlreadyClaimed(address account)The caller has already claimed.
PARAMETERS
- account address
- —
IncorrectPayment
ERRORerror IncorrectPayment(uint256 expected, uint256 actual)msg.value is not exactly PRICE.
PARAMETERS
- expected uint256
- —
- actual uint256
- —
InvalidConfig
ERRORerror InvalidConfig()A zero address or a zero amount was passed to the constructor.
PaymentFailed
ERRORerror PaymentFailed()Forwarding the payment to RECIPIENT failed.
JSON ABI (12 entries)
[
{
"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.
- The threshold: units of weight needed to close one block.
- Block rate
- Blocks per unit of time. It follows engagement: .
- 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 () 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, . The clock of emission.
- Attention half-life
- The cumulative attention 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 .
- 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.
- X developer policy and InfoFi. Decrypt, “Elon Musk's X Bans Access to ‘InfoFi’ Crypto Projects Amid ‘AI Slop’ Backlash”; The Block, “X users celebrate crackdown on ‘plague’ of AI-led reply spam as InfoFi platforms seek alternatives”; BlockEden, “Kaito After YAPS”.
- Kaito and Loudio. Bankless, “Crypto Gets Loud: The New Attention Market Paying Kaito Yappers”; Backpack Learn, “What is Loudio”; TokenRadar, “Loudio (LOUD)”.