MERIDIAN, AGENT BRIEF
A complete operating guide for software agents holding a Binance Agentic Wallet that want to mint, read, verify, or trade Meridian. 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: __CONTRACT__
Agent ID registry: 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F
Price feed, Chainlink BNB/USD, eight decimals: 0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE
Metadata host: https://meridian.pages.dev/metadata/<token id>.json
Art host: https://meridian.pages.dev/art/<token id>.jpg
Site: https://meridian.pages.dev
Explorer page: https://bscscan.com/address/__CONTRACT__
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. RECUT, THE ONE REROLL
The holder of a piece may recut its shape once, for 0,10 USD paid in BNB. The call is recut(tokenId), holder only. It writes a new seed from a new block, so the grade, rings, weave, core and render all change, and the old shape is gone for good. Supply does not grow, and nothing is minted. A second attempt reverts with AlreadyRecut. Recut stays available after the mint is closed, and it is the only way a piece changes after it exists.

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.
Step 9. Report the token ids, the amount actually paid, the transaction hash, and the block number.

SECTION 10. FUNCTION REFERENCE
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. RECUT_USD() 0x442d6904 returns 10000000. 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. recutCost() 0x2d41beca, price in wei of a recut.
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. recutDone(uint256) 0xf7d8fd25. royaltyInfo(uint256,uint256) 0x2a55205a.
Write functions.
mint(uint256) 0xa0712d68, payable, quantity must be two. recut(uint256) 0x3e3af7ec, payable, holder only, once per token.
approve(address,uint256) 0x095ea7b3 and setApprovalForAll(address,bool) 0xa22cb465 for trading.
Owner only: setMintOpen(bool) 0xf8004d31, setPaused(bool) 0x16c38b3c, setBaseURI(string) 0x55f804b3, withdraw(address) 0x51cff8d9, transferOwnership(address) 0xf2fde38b.

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.
NotHolder() 0x7623fb52. That wallet does not hold the token, so it may not recut it.
AlreadyRecut() 0xeeb64cae. That piece has already been recut once. A piece is recut once, forever.
NotOwner() 0x30cd7471, NotAuthorized() 0xea8e4eb5, ZeroAddress() 0xd92e233d. The caller is not allowed, or an address was zero.
A failed mint or recut 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 and Recut(uint256 indexed tokenId, address indexed holder, uint256 seed) on a recut, so both can be followed from receipts 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 recut a piece unless its holder asked for it. A recut is irreversible and destroys the previous shape.
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.
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, transfer, or recut 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.