A celestial sphere, rolled by the block that mines it.

How far the roll has reached

0 of 5,000 minted

Each mint brings two spheres through a Binance agent wallet, and the first of the two is free. One mint per wallet, so a wallet that has taken its pair cannot come back for another. The figure above is read straight from the contract every twenty seconds, never typed in by hand.

Rolled by the block

Nothing about a piece is known when the transaction is signed. The seed mixes the previous block hash, the block randomness, the sender, the token number and the block itself, and the contract stores the result. Read that seed and run the same four hashes, and the grade, the rings, the weave and the core come out the same every time. The picture is therefore not a promise from us, it is a proof you can run yourself.

The shape is permanent. There is no re-roll and no second chance to buy, so nobody is ever asked to pay twice for the same piece. What a piece rolls is what it keeps, and the market is where a holder trades it if the roll is not to their taste.

Built for agents

The full brief is written for software agents holding a Binance Agentic Wallet: the contract, the gate, the price formula, the runbook, the functions an agent may call, every error selector, the trait table, and the rules of engagement. It can be copied whole and handed to an agent as it stands.

MERIDIAN, AGENT BRIEF
A complete operating guide for software agents holding a Binance Agentic Wallet that want to mint, read, verify, or trade Meridian. There is no re-roll of any kind: a piece is rolled once and keeps its shape. Written to be followed literally. Every number, address, and selector below was read from BNB Smart Chain and can be re-read at any time.

SECTION 1. WHAT THIS COLLECTION IS
Meridian is a fixed set of 5,000 celestial spheres on BNB Smart Chain. Each piece is a photograph-grade render of a crystal globe held inside a metal armillary sphere, standing on a dark plinth. There is no text inside the artwork.
The shape of a piece is not decided by its token number. It is decided by block randomness at the moment the minting transaction is mined, and that randomness is written into the contract as a seed. Because the seed is stored on chain, every trait of every piece can be recomputed by anyone, without trusting the site or the indexer. Two reads of the same token always give the same answer.

SECTION 2. NETWORK AND ADDRESSES
Chain: BNB Smart Chain, chain id 56, native token BNB.
Collection contract: 0xFaaa800C44eFE7f46F9b07a76Cc119E76575524c
Agent ID registry: 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F
Price feed, Chainlink BNB/USD, eight decimals: 0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE
Metadata host: https://meridiannft.pages.dev/metadata/<token id>.json
Art host: https://meridiannft.pages.dev/art/<token id>.jpg
Site: https://meridiannft.pages.dev
Explorer page: https://bscscan.com/address/0xFaaa800C44eFE7f46F9b07a76Cc119E76575524c
If an address in this brief disagrees with the site, trust the site, then re-read the chain. A redeployment changes the collection address and nothing else.

SECTION 3. THE MINT RULES, IN ONE PARAGRAPH
Minting sends exactly two pieces in a single transaction. Sending one piece is refused. A wallet may mint once in its lifetime, so the same wallet cannot come back for another pair. The first piece of the pair is free, the second costs 0,20 USD paid in BNB at the rate the Chainlink feed reports at that moment. The wallet that signs must hold a Binance Agent ID, checked on chain during the mint. Supply stops at 5,000 pieces, and the contract refunds any excess value in the same transaction.

SECTION 4. PRICE MECHANICS
The contract computes the amount itself, in wei, with this expression: paid_price_usd_8 * paid_pieces * 1e18 / bnb_usd_8, where paid_price_usd_8 is 20000000 and bnb_usd_8 is the feed answer carrying eight decimals. For a first mint, paid_pieces is one, because one of the two pieces is free.
Worked example. If the feed reports 750.00000000 USD, then bnb_usd_8 is 75000000000 and the amount is 20000000 * 1 * 1e18 / 75000000000, which is about 0,000267 BNB. If BNB trades at 1500 USD the same pair costs about 0,000133 BNB.
Never hardcode this number. Call cost(2) from your own address and send exactly what it returns. The contract refuses to price a mint when the feed answers zero or less and reverts with BadFeed, so retry rather than guess.

SECTION 5. THE AGENT ID GATE
Minting is closed to plain wallets. The contract asks the registry for the handle of the calling address, hashes that handle with keccak256, and asks the registry who owns the resulting id. The call is allowed only when the owner is the calling address. A wallet with no handle, or one whose handle is owned by somebody else, fails the check. The gate reads the address that signs the transaction, so no agent can mint for another address and no agent can bypass the gate by relaying through a helper contract.

SECTION 6. THE SEED, AND HOW TO VERIFY A PIECE
At mint, the contract writes seedOf[tokenId] as keccak256 over: the previous block hash, block.prevrandao, the minter address, the token id, the block number, and the contract address. None of those values is known when the transaction is signed, which is the point.
Every trait is then derived from that seed, all of it on chain:
grade roll is keccak256(seed, uint8 1) modulo 10000. Below 6000 is Steel, below 8500 is Cyan, below 9700 is Violet, anything above is Gold.
rings, which the metadata calls Rings, are the grade number plus two, plus keccak256(seed, uint8 2) modulo 2. So two to five.
weave is keccak256(seed, uint8 3) modulo 6.
core is keccak256(seed, uint8 4) modulo 4.
The metadata file names those numbers, in order: weave is open, soft, even, dense, tight, braided. Core is faint, warm, bright, blazing. Grade is Steel, Cyan, Violet, Gold.
Anyone can confirm a piece from the chain alone: read seedOf, run the same four hashes, and compare with tierOf, veinsOf, weaveOf, coreOf and with the metadata. If they ever disagree, the chain is right and the metadata must be rebuilt.

SECTION 7. HOW THE PICTURE IS PICKED
There are 24 finished renders, six for each grade, all the same object family: steel, cyan, violet and gold. The seed chooses which of the six within its grade a piece receives, with keccak256(seed, uint8 30) modulo 6. A piece therefore always shows the render that matches its grade, and always the same one. The render is copied to the pieces own file at /art/<id>.jpg when its metadata is built, so nothing shared can change under it.

SECTION 8. THE SHAPE IS PERMANENT
There is no re-roll, no recut, and no way to buy a second chance. A piece is rolled once, at the moment its mint is mined, and it keeps that shape for as long as it exists. The owner of the project removed the paid re-roll on purpose, so no holder is ever asked to pay twice for the same piece. If a holder dislikes the roll it received, the market is the answer: pieces can be sold or bought like any other token, and that costs nobody an extra fee at the contract.

SECTION 9. RUNBOOK FOR MINTING
Step 1. Confirm the collection address against the site. Never mint against an address you have not confirmed in this session.
Step 2. Read mintOpen() and paused(). Both must be open. If either is closed, stop and report the state instead of sending anything.
Step 3. Read PIECES_PER_MINT(), MAX_MINTS_PER_WALLET(), MAX_PER_WALLET() and remaining(). The quantity is fixed at two, so there is nothing to decide.
Step 4. Read mintedBy(your address). If it is not zero, this wallet has already minted and the contract will refuse a second mint. Do not try.
Step 5. Read hasAgentId(your address). If it is false, the wallet cannot mint no matter what else is true. Report and stop.
Step 6. Call cost(2) from your own address. Read the answer every time, it moves with the market.
Step 7. Send mint(2) with exactly that value, in one transaction, from the wallet that owns the Agent ID. Do not split it, and do not send a rounded-up amount far above the cost.
Step 8. After one confirmation, read totalSupply() and call ownerOf on the two new ids to confirm they landed in your wallet. Read seedOf for both, then the four trait views, and report those values rather than your own description of the picture. The shape you report is final, there is no later re-roll to mention.
Step 9. Report the token ids, the amount actually paid, the transaction hash, and the block number.

SECTION 10. FUNCTION REFERENCE
There are three levels of rights in this contract. Anyone holding an Agent ID may mint. A holder may list its own piece for sale on a market. The owner wallet runs the mint itself, and nothing else. Only the first two concern an agent, so the owner functions are left out of this brief on purpose.
Read functions with their four byte selectors.
name() 0x06fdde03, returns Meridian. symbol() 0x95d89b41, returns MRDN.
MAX_SUPPLY() 0x32cb6b0c returns 5000. MAX_PER_WALLET() 0x0f2cdd6c returns 2. MAX_MINTS_PER_WALLET() 0xe78fba22 returns 1. PIECES_PER_MINT() 0x3d3adfb6 returns 2. PAID_PRICE_USD() 0x69b69a32 returns 20000000. ROYALTY_BPS() 0x49c657db returns 500.
totalSupply() 0x18160ddd. totalMinted() 0xa2309ff8. remaining() 0x55234ec0.
mintOpen() 0x24bbd049. paused() 0x5c975abb. owner() 0x8da5cb5b. baseURI() 0x6c0360eb.
cost(uint256) 0x9097548d, price in wei for a quantity read as the caller. This is the only price the contract asks for.
mintedBy(address) 0x3cef28d2. hasAgentId(address) 0x4eab3ef2. balanceOf(address) 0x70a08231. tokensOfOwner(address) 0x8462151c.
ownerOf(uint256) 0x6352211e. tokenURI(uint256) 0xc87b56dd. seedOf(uint256) 0x82829f74. tierOf(uint256) 0x53f96df2. veinsOf(uint256) 0x04b0a4fe. weaveOf(uint256) 0x2d31bf61. coreOf(uint256) 0xabce47e2. royaltyInfo(uint256,uint256) 0x2a55205a.
Write functions that concern an agent.
mint(uint256) 0xa0712d68, payable, quantity must be two. There is no other payable function.
approve(address,uint256) 0x095ea7b3 and setApprovalForAll(address,bool) 0xa22cb465, used only when listing a piece for sale.
Functions reserved for the owner wallet do exist: opening and closing the mint, pausing the contract, changing the metadata prefix, withdrawing the proceeds and moving ownership. They revert for every other caller, they are read by the project and not by agents, and they are deliberately left out of this brief. An agent never needs them, and calling one costs gas and buys nothing.

SECTION 11. ERROR REFERENCE
TwoOnly() 0x2261ff77. The quantity was not two. Send two.
WalletLimit() 0x5426a580. This wallet has already minted. One mint per wallet, ever.
QtyLimit() 0x3802e3e8. The quantity was zero or above the per transaction limit.
NoAgentId() 0xf947691f. The signing wallet does not own a Binance Agent ID.
MintClosed() 0x589ed34b. The owner has not opened minting. Read mintOpen() first.
IsPaused() 0x1309a563. The owner has stopped the contract. Read paused() first.
SoldOut() 0x52df9fe5. Fewer than two pieces remain. Read remaining() first.
Underpaid(uint256) 0xa5cc3e35. The value sent was below the required amount, which the error carries in wei. Re-read cost(2), it moves with the market, then retry.
BadFeed() 0xb0171a5d. The price feed answered zero or less, so the contract refused to price the mint. Wait, then retry.
NotOwner() 0x30cd7471 and NotAuthorized() 0xea8e4eb5 mean the caller tried something outside its rights, either an owner function or a token it does not hold. ZeroAddress() 0xd92e233d means an address was empty. None of the three is retried with different values.
A failed mint spends gas and changes nothing else. Nothing is taken from the wallet beyond gas.

SECTION 12. WHAT A PIECE CONTAINS
Metadata is one JSON file per token at the metadata host, holding the name, a one line description, the image address, the external address, and five attributes: Grade, Rings, Weave, Core, and Seed. The Seed attribute is the exact seed written by the contract, and it is what makes the piece checkable: read seedOf on chain, compare, and the piece is proven.
The image is a JPEG, one thousand by one thousand pixels, no background plate beyond the render itself.

SECTION 13. TRADING
Secondary trading is expected to run on Element, and the collection charges five percent royalty through ERC-2981, paid to the owner wallet of the contract. Listing is per piece: the seller connects a browser wallet, approves that single token, sets a price, and lists it. A blanket approval for the whole collection is neither required nor recommended.
Royalty on a sale of one BNB is 0,05 BNB. On a sale of 0,25 BNB it is 0,0125 BNB.

SECTION 14. READING THE CHAIN WITHOUT AN INDEXER
There is no private indexer. Every figure can be read with eth_call against a public BNB Smart Chain node. Use at least three endpoints in fallback order, because public nodes occasionally answer execution reverted for every call in one moment and behave again the next. Sensible endpoints include bsc-dataseed1.bnbchain.org, bsc-dataseed.binance.org, bsc-dataseed1.defibit.io and bsc-dataseed2.defibit.io.
Two pitfalls. First, a reply of Free API access is not supported for this chain from an explorer API means the plan does not cover that endpoint, not that the data is missing; read the node directly. Second, selectors must come from keccak256, never sha256. A wrong selector answers execution reverted with empty data, which looks exactly like a dead contract.
The contract emits Minted(address indexed to, uint256 indexed tokenId, uint256 seed) for each piece, so a mint can be followed from the receipt alone.

SECTION 15. RULES OF ENGAGEMENT FOR AGENTS
Do not mint unless the signing wallet owns a Binance Agent ID.
Do not send more than cost(2), and do not split a pair across two transactions. A one piece mint is refused by design.
Do not mint on behalf of another address. The gate reads the signer.
Do not publish prices, traits, grades, supply or addresses that you have not read from the chain in this session.
Do not describe the artwork beyond what the chain and metadata state. Read the grade, rings, weave and core, and quote those.
Do not promise rarity. Which two ids you receive depends only on how many pieces exist when your transaction is mined, and the seed is rolled after that, once and for all.
Do not attempt to move funds out of the contract. Only the owner wallet can, and that is not your role.

SECTION 16. CHECKLIST BEFORE AND AFTER A MINT
Before: address confirmed, mintOpen true, paused false, remaining at least two, mintedBy zero, hasAgentId true, cost(2) read in this session.
After: totalSupply rose by exactly two, ownerOf returns the signing wallet for both new ids, seedOf is non zero for both, the four trait views answer, the metadata for each id loads, and the paid amount equals the value you computed. Report all of it with the transaction hash and the block number.

SECTION 17. WHOSE PIECE IS IT
The wallet that signs owns the pieces. An agent acting for a user mints into that users wallet, and the pieces belong to that user from the moment of the mint. An agent must not sell or transfer anything without an explicit instruction from the owner of the wallet, and must not treat a mint as a position it may trade on its own initiative.

SECTION 18. IF SOMETHING LOOKS WRONG
If the site and the chain disagree, the chain wins. If the contract address here does not match the address on the site, this brief is out of date: use the site and re-read the brief there.
If a call fails with an error not listed in section eleven, quote the raw revert data and stop. Do not invent a cause and do not retry with a larger value hoping it passes.
If the feed is unreadable the contract refuses to price with BadFeed. Waiting is cheaper than a wrong price.
Every figure in this brief can be re-read from the chain with the selectors in section ten. Nothing here needs to be taken on trust.