Suliman Mokhtar

Posted on Oct 18 Originally published at xroot.dev

Retium's Testnet, Read Before the Ticker: One Dollar, One Executor, and the Block That Didn't Fit

#retium #layer1 #tokenomics #forensics

Originally published on xroot.dev.

Retium is a new layer 1 from an Australian company with an unusual pitch: blocks laid out by prime-number arithmetic instead of a chain, no mempool, fees fixed in cents, post-quantum signatures from the first block, and a coin with no team or investor allocation. Its public testnet has been opening in stages since August and its Rust SDK shipped this month. On 18 October I read it the way I read every new chain — from its own API, ignoring the announcement posts.

The design is genuinely different, and the whitepaper is more candid than most. But the tokenomics are the story, and it is not the story a ticker will tell. Everything below was read from https://rpc.retium.org/api at 09:43 UTC on 18 October, with the call that produced each figure. The ledger you can query today begins on 7 October — balances may be wiped between testnet stages — and testnet coins have no value, as the whitepaper says, so every dollar figure here tests the plumbing, not a bank balance.

Ground Truth in Five Calls

Reads need no key. The explorer at retium.net is a front end over the same endpoints, so everything it shows can be pulled raw:

API=https://rpc.retium.org/api        # reads are open; writes need an API key

curl -s $API/stats
# -> keepers 10/10 · suits 10/10 · workers 26/26 · rpc 5
#    transactions 1,090,940 · rejected 0 · voided 2 · wallets 890

curl -s $API/tick/current
# -> tick 13 · total_blocks 32,767 · hard_final 5,587 · planned 27,177

curl -s $API/safehouse
# -> total_supply 1,000,000,000 RTM · inventory 999,874,287.09
#    released 124,712.91 · locked_rusd 124,712.91 · unbacked 1,000
#    burned 235.6645 · excess_rusd 235.6645

curl -s https://api.retium.money/api/summary
# -> supply 127,905.85 RTD · bank_cents 12,790,585 · books_match true

curl -s "$API/transactions/histogram?range=7d&tz=0"
# -> 12–16 Oct: 101,131 · 101,524 · 60,641 · 101,164 · 101,111 a day

Chain ID — 3 (public testnet)

Signatures — ML-DSA-44 · 2,420 bytes · 72-char rete… addresses

Contracts — WebAssembly · Rust SDK v0.1.0

Current ledger — since 7 Oct · 1.09M txs · 890 wallets

Read the traffic for what it is. A million transactions from 890 wallets is about 1,200 per wallet. On seven of the ten full days the daily count landed within half a percent of 101,000. The sender of one transfer I sampled was on nonce 10,562, and in the latest 2,000 transactions 615 of the 631 contract calls went to a single token whose own metadata names it RetiumBotToken. That is a load test, which is exactly what a testnet is for. Just don't quote it as adoption.

A Mesh That Doubles, and the Block That Didn't Fit

The structure Retium calls Prime Number Linking Architecture works like this. Every block's identity is a prime or a product of distinct primes, and its parents are the blocks whose primes divide it: block 6 links to 2 and 3, block 105 to 3, 5 and 7. Nobody mines or proposes a block — the arithmetic decides which blocks exist, which is why the paper calls the consensus Proof of Math. Each tick introduces the next prime and plans every block that prime can form with the primes before it. The paper says later ticks "roughly double". The chain says exactly:

Tick 2 · prime 11 — 16 blocks

Tick 7 · prime 29 — 512 blocks

Tick 12 · prime 47 — 16,384 blocks

Tick 13 · prime 53 — 32,767 blocks

Why 32,767 and not 32,768? Tick 13 should hold 53 times every subset of the fifteen primes before it — 2¹⁵ blocks. I pulled the full list from /api/tick/13 and checked every entry. 32,767 are there, every one a multiple of 53. The single identity missing is the product of the first sixteen primes, and it is too big for the integer the chain stores it in:

expected  = 53 × each subset of {2, 3, 5, … , 47}       = 32,768 blocks
listed    = GET /api/tick/13                             = 32,767 blocks

missing   = 2·3·5·7·11·13·17·19·23·29·31·37·41·43·47·53
          = 32,589,158,477,190,044,730
u64::MAX  = 18,446,744,073,709,551,615                   # missing > u64::MAX
largest   = 16,294,579,238,595,022,365                   # = missing ÷ 2, fits

The design's central claim is that the layout follows from arithmetic alone: for a given tick there is, in the paper's words, "exactly one valid set of block identities", which anyone can recompute without trusting a validator. The arithmetic says 32,768. The chain applies one more rule the paper does not state: an identity has to fit in 64 bits. That rule is testable, because the planner works two ticks ahead. It predicts tick 14 drops 53 of its 65,536 blocks. The chain has tick 14 planned already, at 65,483 blocks — every multiple of 59 that fits in 64 bits, and none that doesn't. (Tick 15 is listed too, but its reported size changed between reads, so I leave it out.) Projected forward, the share it drops keeps growing:

Tick 14 · prime 59 · on chain — 53 of 65,536 dropped

Tick 16 · prime 67 — 5,020 of 262,144 · 1.9%

Tick 18 · prime 73 — 107,394 of 1,048,576 · 10.2%

Tick 22 · prime 97 — 8,225,330 of 16,777,216 · 49%

Keep it in proportion. Wider identities fix it, and at testnet traffic the steep part is a long way off, because ticks double in duration as well as size. Tick 11 ran two days and ten hours; tick 12 ran four days and twenty-one hours, ending at 18:47 UTC on 16 October. Thirty-nine hours into tick 13, 5,587 of its 32,767 blocks were final — the same pace, which finishes it in about nine and a half days. A transaction's finality does not wait for its tick. But "the layout is pure arithmetic" is a claim about a rule, and an integer width that changes which blocks exist is part of that rule. It belongs in the paper, and in the pending audit, before mainnet rather than after.

Which Number Is the Block?

The paper gives every block two identifiers: the mesh identity, which the protocol reasons about, and a block number, a plain counter for tools and people. The public API leans on the identity — block_id on a transaction, deployed_at_block on a contract — and identities do not count up across ticks. Tick 12 finished in block 614,889,782,588,491,410, the product of the first fifteen primes. The next transaction landed in block 53.

JSON loses the block. /api/transactions returns block_id as a bare JSON number. Above 2⁵³ a JavaScript client rounds it: 614,889,782,588,491,410 parses as 614,889,782,588,491,400, which is divisible by four and so is not a block at all. 431 of tick 13's identities sit above 2⁵³. Parse ids as strings or BigInt; the /api/tick endpoints already send them as strings.
A height is not obviously a clock. The SDK's contract guide offers env::block_height() or env::block_time_ms() when you need a notion of time. The wire reference documents the host call behind the first as returning the "block id", as an i64. If that is the identity, a vesting cliff or claim window written against height sees time fall from 6×10¹⁷ to 53 at every tick boundary, and two of tick 13's identities do not fit in an i64 at all. If it is the counter, none of that applies. The docs do not settle it; one test deploy would.

Retium's own exchange contract sidesteps the question: its liquidity locks store their expiry as a millisecond timestamp, which is what env::block_time_ms() returns. That is the safe choice whichever way the height question is answered.

No Mempool Is Not No Executor

The paper's abstract compresses ordering into one line — a transaction's position comes from a hash of its own identity, so fees play no part — and chapter 4 adds the half that matters. Transactions are handled in the order they arrive at the pin, the one keeper that holds a short lease to execute. It checks a transaction, executes it, writes the result into an open block and answers in the same request (SoftFinal). The other nine keepers apply its signed packets in order, and once seven of the ten report the same state fingerprint the transaction is HardFinal. The hash of the transaction's id sets its place within a block. There is no tip and no priority fee, and the node does not read one.

So "no mempool" removes the public waiting room, not the party that sees a transaction first. The pin executes everything, in arrival order, and all ten genesis keepers are run by the Retium Foundation. The paper knows it: pin election, where the keepers elect the pin and replace it when they disagree with it, is the first item on its list of work before mainnet.

No fee buys position. Arrival does — and so does your API key. Every write needs an on-chain developer key, which sets a rate tier: free at five requests a second, Pro at twenty and Enterprise at a hundred, bought for a fixed period at 100 and 1,000 RTM. Dropping the key requirement for signed transactions is item seven on the pre-mainnet list. Meanwhile the tokenomics page still offers optional "priority credits" at +10% and +20% for faster routing, which the paper contradicts and the per-transaction gas breakdown the API returns has no line for. Ask which document is current before you design a fair launch around either.

Fees in Cents, Measured

Every action has a weight from one to five and every weight a fixed price in dollars, paid in RTM at a dollar a coin or in RTD at one and a half times that. I pulled the gas breakdown of one transaction of each kind from the latest 400:

RTM transfer · token transfer · approve — $0.01

Token mint · burn · stake · unstake — $0.05

Contract deploy — $0.50

Swap or add liquidity on the chain's DEX — $0.50

The DEX row is the one to notice. A contract declares its own weight when it is deployed, and the exchange contract (DexCore v1.3.1) declares five, so every swap costs fifty cents however small — about ninety times what a Uniswap v4 fee claim cost on Arc the week it launched.

The other rows are the good news for a token team. Distributing a token to 10,000 wallets costs exactly $100 in fees, whatever else the chain is doing, and nobody can outbid you. The limit is throughput: one sender's transactions execute in nonce order, and on a free key 10,000 transfers take at least 2,000 seconds — half an hour. And the fixed price has a seam in the docs. The paper prices an RTM fee at a dollar a coin; the tokenomics page says fees are converted "through the oracle rate". While the Safehouse holds RTM at a dollar those are the same thing. After it empties they are not, and neither document says which wins.

A Dollar Until the Billionth Coin

Here is the design. All 1,000,000,000 RTM, at 18 decimals, were created at genesis inside the Safehouse, a reserve that is part of the protocol itself rather than a contract someone deployed. There is no allocation for the team, investors or an airdrop, and no vesting. RTM leaves one way: send RTD, Retium's dollar token, and receive the same amount of RTM. Send the RTM back and the RTD comes back out. The API's books close to the cent:

inventory     999,874,287.09   RTM still in the Safehouse
released          124,712.91   RTM out, against 124,712.91 RTD locked
unbacked            1,000.00   RTM out, with no RTD behind it
─────────────────────────────
total       1,000,000,000.00

burned                235.6645  ->  excess_rusd 235.6645
circulating       125,477.2455  = released + unbacked − burned

Now follow the mechanism to its consequence. While the Safehouse holds inventory it sells RTM for a dollar and buys it back for a dollar — the paper says a holder can always sell it back at that rate. A coin that anyone can buy for $1 and sell for $1 trades at $1. The paper puts the open market in charge only once the inventory is fully distributed: after the billionth coin is sold, which means after a billion dollars have gone into the reserve. Today about 0.013% of the supply is out, and it is testnet money.

RTM has no price of its own until a billion dollars have arrived. Any RTM quoted above or below a dollar before then is not the Safehouse's price. There is nothing to farm either: every RTM in the design enters at a dollar, the paper rules out an airdrop allocation, and the testnet page says test coins cannot be bought, sold or moved to mainnet. The airdrop guides already ranking for the name are guessing against the documentation.

One line in that ledger is not explained by the paper. The API reports 1,000 RTM outside the Safehouse with no RTD behind them. The tokenomics page mentions "a small reserve used to run the founding nodes", held by the company, locked and never to be sold; the paper says the Foundation holds no RTM at all. A thousand coins on a testnet is a rounding error. The size of that reserve at mainnet is not stated anywhere I could find.

Where the Return Lives

If the coin is a dollar until a billion arrive, where does an early backer make money? The paper answers plainly, and it deserves credit for it: in the company. Investors hold shares in the Retium Foundation — the investor page names the company as CompanyIndexer Pty Ltd, raising through SAFEs or loans, and says investors receive no RTM or any other token. The company's income comes from four places:

The reserve's interest. Every RTD is backed by a dollar in a segregated reserve, and "The interest on that reserve, from short dated government paper, belongs to the Foundation." Every RTM sold locks an RTD — 97.5% of all RTD in existence sits in the Safehouse today — so at full distribution that is a billion-dollar reserve, and each percentage point of yield is $10 million a year. The paper expects it to become the largest income line.
8.5% of every fee. A 5% Foundation share, the 3% keeper share (the Foundation runs every keeper, and the tokenomics page offers no public keeper seat), and the 0.5% treasury, which is the Foundation. The paper lists it as 8.5 percent "in three separate, labelled lines". The API agrees: of 308.61 RTD collected in fees, 26.23185 went to the Foundation.
The burn. One percent of every fee is burned, and the RTD that backed the burned RTM becomes reserve excess that only the Foundation's wallet can withdraw. The API shows the two side by side, equal to the ten-thousandth: 235.6645 burned, 235.6645 excess. While the Safehouse sells at a dollar, the burn does not make anyone's RTM scarcer. It converts 1% of fees into dollars for the issuer — so counted in dollars, the company's cut of an RTM fee is 9.5%.
Fees and services. Conversion fees on the dollar ramps, a fee on on-chain swaps where one applies, and — once licensed — custody, tokenisation and merchant payments.

None of this is hidden; chapters 10 and 11 of the paper set it out. It is a different business from the one a ticker implies: a dollar-float business, a stablecoin issuer with a chain attached, where the equity carries the upside and the coin carries a dollar. "No team allocation" is true. The team's claim on the network is the reserve's interest.

There is a second claim on sale now. An "Early Validator Round" — round 2 — is live on onboarding.retium.org: Worker seats at $200 and Suit seats at $2,000, paid in USDC or USDT on Ethereum, one per wallet, non-refundable, closing on 1 February 2027, with $0 of a $195,000 target raised when I looked. The tokenomics page prices the same seats at $1,000 and $10,000 at mainnet, paid in RTM. Workers split 90% of every fee, and the seat page calls a seat a participation right, "not an investment product". The homepage's "no insider discounts" is about RTM, and RTM has none. But a permanent right to run the role that collects nine-tenths of fees, sold before mainnet at a fifth of its stated mainnet price, is the closest thing this design has to an early round — and it is paid in another chain's dollars, before the audit and before the licence.

Where the Documents Disagree

Retium's pages were plainly written at different times, and they disagree in places that matter to money. The October whitepaper, version 2.0, is the newest and most specific, and where it agrees with the chain I have treated that as the answer. Four disagreements have come up already: the company's RTM, paid priority, the seat price and currency, and how a fee converts to RTM. Here are the other six, as questions to put to the team:

Vesting. The homepage roadmap lists "Private Vesting Round: open now" and an Early Validator Coin Reservation Program; the same page says there is no early-validator supply, and the paper says there is no vesting schedule. The same roadmap still dates the SDK to December 2026; it shipped this month.
Treasury. "5.5% of all transaction fees" in the tokenomics prose; 0.5% in its own table, in the paper and on chain.
The top fee. "Forty-five cents" in the prose; $0.50 in the table and on chain.
Income. "No passive income" on the tokenomics page, which also says the staking token entitles holders to a share of fee revenue.
The dollar's name. RTD in the paper, the contract and the explorer; rUSD on the tokenomics page and in the API's own field names (locked_rusd, rusd_contract_id).
"Audited." Retium Money's Safehouse card says "Audited on chain", meaning the figures are readable. The investor page says the network has not yet completed an independent security audit.

The Dollar, the Licence, and the Pre-Mainnet List

RTD is live on the testnet: contract c1d3…611c, version v1.0.2, 18 decimals. Retium Money's API reports 127,905.85 RTD against a reserve of $127,905.85, with books_match: true and 809 customers. On a testnet those are play dollars, so what matches is the bookkeeping, not a bank account. Real dollars wait on a licence: the investor page says the company has applied to ASIC for an Australian financial services licence, that none has been granted, and that until one is, the company provides no financial service — issuing the dollar token and operating the Safehouse among them.

The token's status call names one address — rete88cb…b63b — as owner, pauser and freezer, the same address that deployed the exchange. Its declared capabilities include freeze, wipe_frozen, pause, pause_mint, rescue and retire. That is the standard toolkit of a regulated dollar token, not a red flag on its own. It does mean RTM's dollar floor is exactly as good as one issuer, one reserve and, today, one key.

Live now: the testnet (chain id 3) in stages, the web wallet and browser extension, the explorer beta, the Whisk exchange, Retium Money, a hosted validator pool, and the Rust SDK v0.1.0 under Apache-2.0.
Before mainnet, in the paper's order: pin election; stake at risk; seats replacing staking, with self-hosted validators and keepers outside the Foundation; software attestation; a fresh signing key per transaction; state proofs and compressed history; signed transactions without an API key; and a security audit of the node, the SDK and the wallets. Plus the licence.
Not stated anywhere: a mainnet date. Testnet balances, NFTs and history may be wiped between stages; the current ledger's first block is dated 7 October.

Nothing in this list is a launch commitment, and the project does not present it as one. A testnet is where a 64-bit ceiling and a stale roadmap are supposed to turn up. The useful question for anyone scouting the chain is which of them are fixed before the first real dollar goes into the reserve.

What to Carry Out of This

The coin is a dollar until a billion arrive. The Safehouse buys and sells at $1 both ways. Any other RTM price before then is not the Safehouse's, and there is nothing to farm.
The upside is in the company and the seats. Reserve interest, 8.5% of fees and the burn's backing go to the Foundation; 90% of fees go to workers, whose seats are on sale now at a fifth of the mainnet price.
One executor, first come, first served. No fee buys position. Arrival at the pin and your API key's rate tier do.
Store time, not block identity. Use block_time_ms for anything that unlocks, and parse block ids as strings.
The arithmetic has a width. Tick 13 is one block short of its own math and tick 14, already planned, is 53 short. Ask how identities grow before you rely on the claim that the layout is arithmetic alone.

Read the Source Yourself

Every on-chain figure above came from the public API at https://rpc.retium.org/api — /stats, /safehouse, /tick/0 to /tick/14, /mesh, /transactions, /transaction/{id} and /contract/{id} — and from Retium Money's /api/summary, read on 18 October 2026 between 09:30 and 10:00 UTC, behind the Retium explorer. Design and economics: the whitepaper, version 2.0 and its explainer What backs RTM?; the tokenomics page, the homepage roadmap, the testnet page and the investor page; the seat round; and the SDK repository, including docs/08-wire-reference.md, docs/04-writing-contracts.md and crates/retium-contract/src/env.rs. The 64-bit projection for ticks 16 to 22 is my arithmetic, not the chain's; it reproduces ticks 13 and 14 exactly. For counting a tick's blocks, prefer /mesh?tick=N over /tick/N, which stopped listing at 40,000 entries for tick 15. Anonymous reads have a smaller allowance than keyed ones, so pace your calls. Re-run every call before relying on any of it — this ledger is eleven days old and may be reset again.

xroot.dev is not affiliated with, endorsed by, or sponsored by the Retium Foundation or CompanyIndexer Pty Ltd. "Retium", "RTM" and "RTD" are used here only to name the network and the assets this article examines. Testnet figures have no monetary value, and nothing here is financial advice.

DEV Community