Current epoch
—
currentEpoch() — emission contract
Live on Robinhood Chain · chain ID 4663
Supply is e. Emission is 1/n!.
An ERC-20 whose issuance schedule is not a team decision but the partial sums of a series. Total supply equals the number e to 18 decimal places. Emission decays factorially and terminates on its own: not on a roadmap date, but at the epoch where the next term of the series first falls below one base unit of the token.
Why “Maclaurin”. A Maclaurin series is a Taylor series expanded at zero. The expansion ex = Σ xn/n! used here is built around the point x = 0 and taken at x = 1, which yields e = Σ 1/n!. The expansion point is not arbitrary, it is zero — so this is a Maclaurin series, and the project name describes the mechanism literally rather than by analogy.
- Total supply
- 2 718 281 828.459045235360287471
- = floor(e × 1027) base units, 18 decimals
- Epoch n reward
- 1027 / n!
- an epoch is 7 days; emission runs from n = 2 through n = 26
- End of emission
- n = 27
- 1027/27! = 0 under integer division
01 — On-chain
On-chain data
Everything below is read straight from the contracts with eth_call against a public Robinhood Chain RPC endpoint when the page loads. None of these numbers live in the markup — markup can be forged, a node's answer cannot. Next to every number is a link to the same call in the explorer and the exact command that reproduces it. Several endpoints are configured: if the first one does not answer, the page silently moves to the next, after checking its chain ID first.
Current epoch reward
—
epochAmount(n) — exactly 1027/n! base units
End of emission
—
emissionEnd() — the moment after which issuance is impossible
Total supply
—
totalSupply() — fixed at deployment
Sold by the curve
—
sold() / INVENTORY()
Spot price
—
spotPrice() — price of one whole token
Curve reserve
—
reserve() — backing for buy-backs
Total staking weight
—
totalWeight() — the reward divisor; totalStaked() — deposit principal
Name and ticker in the contract
—
name(), symbol(), decimals() — as written in the bytecode
Proxy slot (EIP-1967)
—
eth_getStorageAt on the implementation slot: zero means there is no proxy behind the contract
The “explorer” link opens the Read contract tab, where the same call runs in your own browser. The “reproduce this call” block expands into a ready-made curl command and its cast equivalent: the node's answer depends neither on this page nor on its author.
02 — Mechanics
The mechanics, no maths background required
1. The supply is a number, not a round figure
Supply is normally chosen: a billion, because a billion looks good. Here it is the base of the natural logarithm scaled by 1027:
2 718 281 828.459045235360287471 MACLRN
The series e = 1/0! + 1/1! + 1/2! + 1/3! + … converges. Converging means that no matter how many terms you add, the sum never exceeds e. The supply is bounded by a property of the series, not by a promise to issue no more than some amount.
The first two terms (1/0! + 1/1! = 2) are 2 000 000 000 tokens, 73.576% of supply. They exist from block zero and cannot be farmed. The remaining 26.424% (718 281 828.459045235360287471 tokens) sit in the emission contract and are handed out epoch by epoch.
2. Emission decays factorially
An epoch lasts 7 days. Epoch n issues exactly 1027/n! base units: epoch 2 issues one half, epoch 3 one sixth, epoch 4 one twenty-fourth. Each portion is smaller than the previous one not by percentage points but by whole factors, and the gap keeps widening.
The practical consequence: the first five epochs release 99.97% of the emission pool. The tail is not cut off — it continues, it simply becomes negligible very quickly. This is the opposite of halving, where every step divides the reward exactly in two, forever.
Full epoch table (constants hardcoded in the contract)
| n | n! | base units | tokens | % of supply |
|---|---|---|---|---|
| 2 | 2 | 500000000000000000000000000 | 500 000 000 | 18.394% |
| 3 | 6 | 166666666666666666666666666 | 166 666 666.67 | 6.131% |
| 4 | 24 | 41666666666666666666666666 | 41 666 666.67 | 1.533% |
| 5 | 120 | 8333333333333333333333333 | 8 333 333.33 | 0.3066% |
| 6 | 720 | 1388888888888888888888888 | 1 388 888.89 | 0.0511% |
| 7 | 5040 | 198412698412698412698412 | 198 412.70 | 0.0073% |
| 8 | 40320 | 24801587301587301587301 | 24 801.59 | 0.0009% |
| 9 | 362880 | 2755731922398589065255 | 2 755.73 | — |
| 10 | 3628800 | 275573192239858906525 | 275.57 | — |
| 11 | 39916800 | 25052108385441718775 | 25.05 | — |
| 12 | 479001600 | 2087675698786809897 | 2.088 | — |
| 13 | 6227020800 | 160590438368216145 | 0.1606 | — |
| 14 | 87178291200 | 11470745597729724 | 0.01147 | — |
| 15 | 1307674368000 | 764716373181981 | 0.000765 | — |
| 16 | 20922789888000 | 47794773323873 | 0.0000478 | — |
| 17 | 355687428096000 | 2811457254345 | 0.00000281 | — |
| 18 | 6402373705728000 | 156192069685 | 0.000000156 | — |
| 19 | 121645100408832000 | 8220635246 | 0.00000000822 | — |
| 20 | 2432902008176640000 | 411031762 | — | — |
| 21 | 51090942171709440000 | 19572941 | — | — |
| 22 | 1124000727777607680000 | 889679 | — | — |
| 23 | 25852016738884976640000 | 38681 | — | — |
| 24 | 620448401733239439360000 | 1611 | — | — |
| 25 | 15511210043330985984000000 | 64 | — | — |
| 26 | 403291461126605635584000000 | 2 | — | — |
| 27 | 10888869450418352160768000000 | 0 — emission complete | — | — |
Epochs 2…26 sum to 718 281 828 459 045 235 360 287 457 base units. The floor-rounding remainder — 14 units — stays in the emission contract forever. That is not a loss but a buffer: paying out more than exists is arithmetically impossible, without a single check in the code.
3. Emission terminates on its own
At epoch 27 the term of the series is 1027/27!. 27! is roughly 1.089 × 1028, which is larger than the numerator. EVM arithmetic is integer-only, with no fractions: the division yields zero. Not “rounded to zero for display” — it is zero.
The end of emission is a property of uint256 arithmetic, not a multisig decision. Nobody votes to stop issuance and nobody can extend it: no function capable of doing so exists in the contract.
4. Staking: radius of convergence
Every series converges only inside its own radius. A staker picks a radius R — the number of epochs the position is locked for. The reward multiplier is the partial sum of that same series up to the R-th term.
| R | Lock | Multiplier | Increment over previous |
|---|---|---|---|
| 1 | 7 days | 1.000000 | — |
| 2 | 14 days | 2.000000 | +1/1! |
| 3 | 21 days | 2.500000 | +1/2! |
| 4 | 28 days | 2.666666… | +1/3! |
| 5 | 35 days | 2.708333… | +1/4! |
| 6 | 42 days | 2.716666… | +1/5! |
| 7 | 49 days | 2.718055… | +1/6! |
| ∞ | — | e = 2.718281828459045235 | unreachable |
The ceiling is the number e itself, and it is unreachable by construction: a partial sum of the series is strictly less than the sum of the series. This is not a marketing cap that a vote could lift, but a property of a convergent series with positive terms. The constant E_FIXED sits in the contract precisely so that this unreachability can be checked on-chain.
Rewards are split by weight rather than by deposit size: weight = staked × multiplier(R). The deposit principal is tracked by a separate counter and plays no part in the multiplier.
5. What is locked and what is not
-
claim()is closed until the lock expires. Before unlockTime the call reverts withStillLocked. Otherwise the multiplier would be drained as rewards every epoch, and by the time somebody exited early there would be nothing left to take back. -
unstake()is always open, including during an active lock. The deposit principal comes back in full, down to the last base unit. The rule “never touch the principal, under any circumstances” is not broken. - Exiting early forfeits the reward. Everything accrued is zeroed and goes to the remainder-term treasury — in full, even on a partial exit. Proportional forfeiture would look fairer, but it would let somebody withdraw 99.99% of the principal and sit out the rest of the lock with a speck of dust, keeping the reward earned on the full principal.
- No keepers, no oracles. The only external input to the emission contract is block.timestamp. There is no price fed from outside, no bot that payouts depend on, no signature without which nothing works.
03 — Immutability
Why nobody can print tokens here
The most common way to rug a token is not an exploit but a perfectly
legitimate mint(address,uint256) onlyOwner. The owner prints
themselves a trillion tokens and sells. An audit passes a contract like that:
there is no vulnerability in it, there is a documented privilege. The only
defence against it is for the function not to be in the bytecode at all.
- There is no
mintfunction in the bytecode. The entire supply was issued once, in the token constructor. After the constructor there is no function in the contract that changes supply. - There is no owner.
Ownableis not used in any of the contracts — there is no ownership to renounce, and no need to. Noowner(), no roles, no privileged multisig. - There is no proxy. An upgradeable token is the same
mint, only hidden behind a proxy. The EIP-1967 implementation slot is read on this very page: it is zero. - No pause, no blacklist, no transfer tax, no hooks. A plain OpenZeppelin ERC-20 with nothing bolted on.
- The deployer has no access to the curve reserve. No function that would move
reserveanywhere other than to a seller exists in the contract; the fee lives in a separate counter and never mixes with the reserve.
Check it yourself, without trusting this site
Below are commands that search the deployed bytecode for the selectors of privileged functions. Empty grep output means the function is not in the contract. Addresses are substituted automatically from this page's configuration, but they are worth checking against the link to the verified source.
—
40c10f19 = mint(address,uint256),
8da5cb5b = owner(),
f2fde38b = transferOwnership(address),
3659cfe6 = upgradeTo(address),
8456cb59 = pause().
Selectors are the first 4 bytes of the keccak256 hash of the signature — you
can derive them yourself with cast sig.
04 — Buy
Buying through the bonding curve
There is no liquidity pool: a pool needs capital the project does not have, and at shallow depth a few dollars of buying moves the price by tens of percent. In its place is a curve contract that holds an inventory of 1 000 000 000 tokens (half of genesis, laid out along the geometric series 2 = 1 + 1/2 + 1/4 + …) and sells them at a linearly rising price.
Last trade price
—
- The price rises linearly, so the cost of a purchase is the area of a trapezoid. Integer multiplication and division only, no exponential approximations. The formula can be recomputed on paper.
- From the first token to the last, the price rises by exactly a factor of e: from 2 gwei to 5.436563656918090470 gwei per whole token. The ratio can be verified on-chain with a single division, because the arithmetic is integer.
- A flat 1% fee in ETH — a constant, not a variable. It is taken before the reserve is credited on a buy, and out of the already-reduced amount on a sell, so the reserve never funds the fee.
- The curve is not an exchange: you can only sell back to it what you bought from it. The purchase right is tied to the address (
boughtOf(address)) and does not travel with an ordinary transfer. Otherwise a holder of free genesis tokens or staking rewards would walk off with the buyers' ETH. Tokens acquired anywhere other than the curve are sold on a secondary market, not here. - Nothing in the sell path depends on anyone's decision: only your balance, your own slippage protection and a deadline that has not expired. No pauses, no lists, no cooldown.
- The anti-snipe window has already expired. It capped purchases at 10 000 000 tokens per address for the first hour after the curve was deployed (
antiSnipeEnd()— check it on-chain). That hour is over and no purchase was made during it, so the cap applies to nothing: right now a single transaction can buy the entire remaining inventory. The cap was a mitigation rather than a defence in any case — several wallets bypass it trivially.
Curve contract address
Check it against the address shown in your wallet before you confirm the transaction. No other address is the sale contract.
0x0000000000000000000000000000000000000000
Connect a wallet to see how much the curve owes you a buy-back for.
Selling takes two transactions: an allowance for exactly the amount being sold, then the sale itself. The page never asks for an unlimited approve.
What the wallet actually signs
The call is buy(uint256 minTokensOut, uint256 deadline), with
the amount passed as the transaction's value.
minTokensOut is derived from the
previewBuy(ethIn) quote minus the slippage you set: if the price
moves further than that between quoting and execution, the transaction
reverts instead of filling at a worse price. Overpaying beyond the remaining
inventory is not refunded as change — it reverts — which is why
maxEthIn() exists, the exact upper bound at this moment.
—How to sell back to the curve
The Sell tab above does this for you, but the site is not required for it:
the same two calls are available in the explorer, and the allowance is for
exactly the amount being sold — never an unlimited approve.
The order is:
approve(curve address, amount)on the token contract — grant an allowance for exactly the amount being sold;sell(amount, minEthOut, deadline)on the curve contract.
Both calls are available in the explorer's Write contract tab, which
also shows the function body. boughtOf(your address) shows how
many tokens the curve is obliged to buy back.
No wallet in this browser
The page found no wallet: neither an EIP-6963 announcement nor window.ethereum. That means no wallet extension is installed or it is disabled for this site. What you can do:
- install any EVM wallet that supports custom networks (MetaMask or Rabby, for example) from your browser's official extension store;
- add the network by hand: Chain ID 4663, RPC , explorer ;
- fund the address with a little of the network's gas token and come back — the connect button will appear on its own.
Mobile browsers usually do not support extensions: there you need to open this page inside your wallet's built-in browser. A purchase can equally be made by hand from the explorer's Write contract tab — this site is not required for it.
05 — Contracts
Contract addresses
All four contracts are deployed and verified. Copy an address from here and compare it with the one your wallet shows before you sign anything.
Verification means the explorer matched the deployed bytecode against the source. An unverified contract is an unchecked contract, whatever a website says about it.
06 — Risks
Risks. Read this before buying
- Liquidity is thin and the price is volatile. Selling the entire inventory collects roughly 3.72 ETH into the reserve — that is the order of magnitude of the whole mechanism, not the size of a market. Any sizeable trade moves the price noticeably in either direction. This is a working demonstration of a full cycle, not a deep market.
- The curve is not an exchange. It buys back only what was bought from it, and only from the address that bought it. Tokens obtained by any other route cannot be sold to the curve. There may be no secondary market at all.
-
The curve buys back at its current price, not at the price you
paid. The reserve always covers every outstanding buy-back, so
sell()can never fail for lack of funds — but the amount of ETH it returns depends on how much has been sold at that moment, not on your entry. If other buyers exit before you do, the price falls back along the curve and you receive less than you put in — in the worst case (you bought at the top of the inventory, everyone else sold first) about 63% less, which is the factor e the price spans. This is a first-in-best-out mechanism, not a refund. - The whole inventory costs about 3.76 ETH, and one address can take all of it. That is small enough that a single actor can buy the entire billion-token inventory in one transaction, stake it, collect essentially the whole 718 281 828-token emission pool — rewards are split by weight, and their weight would be the divisor — then sell the inventory back to the curve at the same average price and recover the ETH. The round trip costs only the two 1% fees. Nothing in the contracts prevents this, and staking alongside such a position yields a proportionally negligible share.
- The project is experimental. The contracts are immutable: a bug cannot be patched and there is no upgrade path. That is at once the principal guarantee and the principal risk.
- An audit is not insurance. Tests, static analysis and independent review lower the probability of a bug but do not prove its absence. Only some of the properties are formally proven.
- The token has no yield and owes you nothing. Staking rewards are a redistribution of a pre-issued emission pool, not profit from any activity. Nobody promises price appreciation and nobody can deliver it.
- The network is new. Robinhood Chain, its public RPC endpoints and its explorer are external infrastructure the project does not control. If they become unavailable, so does this page and any work with the contracts from a browser.
- The legal status is unsettled. A token with a reward-distribution mechanism may qualify as a security in a number of jurisdictions. A direct sale from a website by the asset's author is not the same thing as providing liquidity on a DEX. This is not legal advice; compliance with your local law is your responsibility.
- Buy only an amount you are prepared to lose in full. Nothing on this page is investment advice.
07 — Verify
Verify
Contract links point to verified sources in the explorer: that is where the bytecode is matched and where you read the same code that sits in the repository. Treat an unverified contract as unchecked, whatever a website says about it.