Theme
Read this as an inventory rather than an explanation. What the rules mean for your money is on the pages before it; this is the list of things those rules run inside. On NEAR an address is a name, so each one gets its name, a sentence, and a link to its page on the public explorer.
The code behind every token is fixed. A token cannot be upgraded, replaced or pointed at different code, by us or by anyone, because the account that holds it has no key and no method that deploys code. The one exception closes on its own: a token made on v2.5 before 6 October 2026 at 16:14 UTC takes new code from the factory, which only its owner can send, until that moment. Until then new code could change anything that token does. Each change is public, and after that moment it is fixed.
Ours
Three of these hold contract code: the factory, the code every token runs, and the burn contract. The rest are plain accounts that hold a key.
- The parent owns the factory and holds no code of its own. It is the only account that can publish new launch code, move the treasury, move the takeover key, name the operator and the guardian, set a pair's figures to any value, and name where a pair's burn share goes. None of that reaches a token that already exists. It also owns the burn contract, where it can change only the buying limits, and only within the limits compiled into it.
- The factory makes every token and keeps the register of them and of the pairs a new token can be launched in. It takes the 0.5 NEAR creation fee, gives the token its own account, and puts the published launch code on it. It holds two things and no more: a creator's own first buy while their token is being made, which a failed creation hands back, and the part of each creation fee the new token's storage did not need, which only the treasury can collect. It never holds a trader's money.
- The treasury receives the platform's share of the tax, and that leftover part of a creation fee. On a coin made since pairs arrived that share is 10% of every tax, paid in the coin's pair; on an older coin it is 20%, in NEAR. It has to ask for both, and both are paid to it and nowhere else: no caller, the owner included, can name a different destination.
- The takeover key is the one key that can re-point a token's future creator fees. It can do nothing else at all, and it cannot point them at itself or at the treasury.
- The keeper signs the background jobs: opening a pool when a curve sells out, running a buyback the creator funded, adding liquidity the creator funded, collecting pool fees into the split, sending each coin's burn share on, and paying dividends to people who have not claimed. Every one of those calls is open to anyone. It holds gas and nothing else, and none of its calls chooses where money goes. The same account is also the guardian: it can switch a pair off for new coins, and nothing more.
- The operator is the day-to-day key for the pairs. It can add and check a pair, remove one that was never switched on, move a pair's figures for future coins by at most 50% once an hour, and switch a pair on, which takes effect only after 15 minutes. It cannot name where a pair's burn share goes, and nothing it does reaches a coin already made.
- Each token is a contract of its own, a sub-account of the factory, numbered in the order tokens are created: the first is
l000000, the secondl000001, and so on. It is the token's ledger, its curve, its pool, its taxes and its dividends in a single account. A token that graduates into a Rhea pool keeps all of that except the pool, which is on Rhea's exchange.
| Name | On chain | |
|---|---|---|
| Parent and owner | shardsmarket.near | Explorer |
| Factory | factory.shardsmarket.near | Explorer |
| Treasury | treasury.shardsmarket.near | Explorer |
| Takeover key | cto.shardsmarket.near | Explorer |
| Keeper and guardian | keeper.shardsmarket.near | Explorer |
| Operator | operator.shardsmarket.near | Explorer |
| Each token | l000000.factory.shardsmarket.near and up | On the token's own page |
The code every token runs
The launch code is published once, as a NEAR global contract. Every token points at one published copy by its code hash instead of carrying a copy of its own. Two things follow, and both can be checked rather than taken on trust: every token made from the same version runs exactly the same bytes, and no token can be made to run different ones.
The factory keys its launch code by a version string and refuses to publish the same version twice, so a version names one set of bytes and goes on naming it.
Coins made since v2.5 (29 September 2026) run a v2.5 version: the one that was current when they were made, or a newer v2.5 version given to them before their upgrade window closed. The factory names the current one to anyone who asks (get_current_template), and each token's account page on the explorer shows the code hash it runs. That version is the one that offers a Shards pool or a Rhea pool.
Coins made since pairs arrived, before v2.5, run this code:
| Launch code version | 0.2.0+2nD3b7Y9 |
| Launch code hash | 2nD3b7Y9eVLHPrNJHPZF3v3LKTyxGUPXqah2uaAANNLm |
| Published at block | 217,082,715 |
| From this block, coins launched with this code | 217,082,815 |
| Factory code hash when pairs arrived | E3UZD9GmAEF6GMvY4ZbpAp81yfWVr1XkK12LwyzftGQX |
The factory has been given new code since, for v2.5. Its explorer page shows the hash it runs today.
Coins made before that block keep the code and the terms they were made with:
| Launch code version | 0.1.0+BqWmwKZ5 |
| Launch code hash | BqWmwKZ5H95Hjtrn5dfZb17K8xi7HSriStdTbiNYYLVo |
| Published | 2026-09-22 |
| First block that can carry a Shards transaction | 216,709,121 |
Pairs and the SHARDS burn
- The burn contract receives the SHARDS-burn share from every NEAR and SHARDS coin. It buys SHARDS in the SHARDS pool and burns it, or burns SHARDS it already holds. Anyone can make it do either. It can send money nowhere else. Its limits are on SHARDS.
- The burn wallet is a platform wallet. Zcash, Quantus and stock coins pay their burn share there, because the burn contract takes only NEAR and SHARDS. It converts what it receives and sends it on to the burn contract.
- SHARDS is the platform's own coin, the factory's first token.
| Name | On chain | |
|---|---|---|
| Burn contract | burn.shardsmarket.near | Explorer |
| Burn contract code hash | HW74imqsrHuqquHxp9efWomeFQgjb1Z7UmbN6KCx24s3 | |
| Burn wallet | burnwallet.shardsmarket.near | Explorer |
| SHARDS | l000000.factory.shardsmarket.near | Explorer |
The pairs a new coin can be launched in, as the factory reports them. A NEAR or SHARDS coin pays its burn share to the burn contract; a Zcash, Quantus or stock coin pays it to the burn wallet. Each coin's destination is fixed when it is made.
What a pair means for a buyer, and what each one graduates at, is on Pay in what you hold.
Not ours
These contracts are on this page because money passes through them. We did not write any of them, and we do not control them.
wrap.nearis the NEAR ecosystem's own contract and has been on chain for years. A NEAR coin's buy reaches it through this contract and a payout leaves through it, so the NEAR you send and the NEAR you get back are ordinary NEAR either way. It holds a balance only while a trade or a refund is in flight.zec.omft.near,qtc.omft.nearand the twentybnb-….omdep.nearstock tokens are the Zcash, Quantus and Ondo tokens coins can be paired with. They are issued on NEAR by the bridges that carry them, which can pause or freeze them. Their accounts are in the pairs table above.- NEAR Intents (
intents.near, and its 1Click swap service) turns NEAR into Zcash or a stock and back when you pay or get paid in NEAR on those coins, and runs the RWA page and the Swap page. - Rhea's exchange (
dclv2.ref-labs.near) is where a Rhea-pool token's pool opens when it graduates. Rhea runs it. The token's own positions there hold its liquidity, and nothing can remove them, but the exchange itself is Rhea's code, not ours. - RHEA (
token.rhealab.near) is Rhea Finance's own token, and a pair a coin can launch in.
| Name | On chain | |
|---|---|---|
| The NEAR contract | wrap.near | Explorer |
| NEAR Intents | intents.near | Explorer |
| Rhea's exchange | dclv2.ref-labs.near | Explorer |
| RHEA | token.rhealab.near | Explorer |
How to check any of this
Every row above with a link opens that account's page on the public explorer, where its code hash, what it holds and every transaction it has taken part in are visible to anyone, with no account and no permission from us.
The factory answers get_current_template to whoever asks it, and that answer is the code hash every new token runs. Each token's own account page reports the hash it runs. A coin made before v2.5 matches one of the tables above; a coin made since matches a v2.5 version the factory published. Anything else means something is wrong.
Every contract here also answers read-only questions from anyone, free: a token tells you its taxes, its split, its pair, its state, your balance and what you are owed; the factory tells you every token it made and the terms of each pair. The contracts carry their own method list inside the WASM, so an explorer can list what they accept without being told.
What is fixed, and what is not
A token is fixed. Its code, its supply, its buy tax, its sell tax, how the tax is divided and the platform's share were all written when it was made, and there is no method anywhere that changes any of them afterwards. A coin made since pairs arrived also fixes its pair, its curve's reserve (and so its graduation size and market cap), its minimum buy, where its burn share goes, and the even split of the platform's share between the treasury and the burn. The exception is a token made in the first week of v2.5, until its deadline: the owner can give it new code, and new code could change any of these.
The factory is not. Its account keeps a full-access key, so it can be given new code, and new code would change what happens to tokens made after that. What even a rewritten factory could reach on a token that already exists, outside a v2.5 token's upgrade window, is two things and only two: re-pointing future creator fees, which is a community takeover, and sending the platform's own share of the tax somewhere other than the treasury. It cannot reach a balance, a dividend, a sell credit, the burn share or the pool. Apart from opening a new token's market once, while the factory is making it, those are the only two calls such a token accepts from the factory at all. A token made in the first week of v2.5 accepts a third until its deadline: new code, which could reach anything.
Who can do what
| Who | What it may do | What it cannot reach |
|---|---|---|
| The owner | On the factory: publish new launch code for future tokens, name the treasury, the takeover key, the operator and the guardian, add, set, switch and remove pairs and name where a pair's burn share goes, and return a failed creation nobody claimed for 90 days. For v2.5, set the upgrade deadline (once) and give a v2.5 token new code before it. On the burn contract: its buying limits, within its compiled limits | No supply, tax, split, pair, liquidity or balance on any live token, except by replacing the code of a token made in the first week of v2.5, until its deadline. After it, nothing on any token, ever. No money in the burn contract |
| The operator | Add and recheck a pair, remove one never switched on, move a pair's figures by at most 50% once an hour, switch a pair on (after 15 minutes) or off (at once) | Where a pair's burn share goes, any coin already made |
| The guardian | Switch a pair off, nothing else | Switching a pair on, and everything else |
| The treasury | Collect the platform's share and the leftover part of each creation fee | Anything but its own accrued share, and it can only pay it to itself |
| The takeover key | Re-point one token's future creator fees (takeover) | Everything else. It cannot name itself, the treasury, the token, the factory or any pair's token as the new recipient |
| The keeper | Nothing that is not open to everyone, apart from being the guardian | It chooses no recipient and holds no credit |
| A creator | On their own creation: skip their first buy, and take back a first buy or a creation fee owed back to them | Their own token's taxes, split, pair and supply, once it is live |
| Anyone | On a token: pay creator fees, dividends, older creator fees and the burn share to where they belong, open a Shards pool, collect pool fees into the split. On the burn contract: buy SHARDS and burn it | Where any of it is paid: each pays the destination the contract already holds |
| The creator, the fee wallet or the platform | On a Rhea-pool token whose pool Rhea has not opened after 7 days and 3 tries: start its move to a Shards pool | Anything else about the token |
The narrowest of the owner's powers is the one over failed creations: a creation that failed and was never claimed goes to the owner 90 days later, once, and its record closes.
Nobody can change a token's tax or pair, mint more of a token, or move the principal of a graduated pool. Those are not permissions anyone is trusted with: there is no such method to call. Nobody can upgrade a token either, except the factory's owner on a token made in the first week of v2.5, and only until that token's deadline. Until then that one guarantee is the owner's word, not the code: new code could add any of those methods. Every upgrade is public, and after the deadline it is the code again.
Standards
Every token implements the NEAR token standards and nothing beyond them.
- NEP-141, the fungible token: balances, transfers, and
ft_transfer_call, which is how a buy arrives. - NEP-145, storage management: a trader pays 0.005 NEAR once, before their first receipt, and that covers everything the token stores about them.
- NEP-148, metadata: name, ticker, decimals, and a reference to the off-chain document. There is no setter. Metadata is written when the token is made.
- NEP-297, events: every trade, payout, burn and takeover is emitted as a standard event log, which is what the indexer and any other reader follow.
The source
The contracts are Rust, built to WASM. The code hash is the thing to compare: it is what the factory published, what every token account reports, and what the tables above print.
The code itself is not published, so what a reader can check today is the hash rather than the lines behind it. It is enough to show which code every token runs and that none of them has changed.
Nothing on this page says any of it is safe. What can go wrong is the honest list.