FoMonad is an on-chain game built on Monad combining a token dividend accumulator with a last-buyer countdown timer — now executable without prohibitive gas costs. It deploys a fresh Vibecoin bonding curve each cycle, runs a structured presale across two privileged access tiers, then opens a pump phase governed by a countdown timer. When the timer expires, the last buyer wins 90% of the prize pool.
This document describes the system honestly. That, in crypto, constitutes satire.
FoMonad is a three-contract system. Each contract has a narrow, well-defined responsibility. There are no proxy patterns, no upgrade paths, and no administrative functions of any kind. The contracts are deployed once and operate autonomously until the heat death of the Monad network.
A new Vibecoin is deployed as a minimal proxy clone at the start of every game cycle. This means each cycle produces a fresh token with a fresh bonding curve, a procedurally-generated name and on-chain artwork derived from a block hash seed, and completely isolated state. The Vibecoin from the previous cycle continues to exist; its sell function remains permanently open.
SHMON.deposit(). This means the protocol earns staking yield passively on all held balances. When you look at a number labeled "shMON," it is worth approximately 1 MON, increasing over time.
Which contracts call which. Arrows represent function calls, not capital movement. For where the shMON actually goes, see the Capital Flow diagram in §03.
Each game cycle progresses through four phases. Phase transitions are lazy: the contract state updates on-demand rather than via scheduled calls, which eliminates the need for keepers and reduces gas overhead.
Series A admits only addresses holding a non-zero foMON balance. This is not an exclusive club so much as a denominator-reducing mechanism: by requiring skin-in-the-game participation, it concentrates Series A deposits among the people most likely to understand what they are participating in. The phase does not begin counting down until 7,500 shMON (MIN_BUY × 500) of gross deposits has been reached, preventing empty-cycle initialization and guaranteeing the opening prize pool is at least 100× MIN_BUY.
Series B begins automatically once Series A concludes. It is open to any address with no foMON requirement. Series B participants receive a higher fraction of their deposit directed to the bonding curve (80% vs. 70%), which is designed to partially compensate for the fact that they are buying at a higher curve entry price — Series A having already moved the price up.
After Series B concludes, anyone may call FoMonadGame.settleSeriesB(). This function:
During the pump phase, anyone may call FoMonadGame.buy(). Each purchase routes a fraction to the prize pool, a fraction to the Vibecoin curve, and extends the timer. The timer extension is a diminishing-returns function of pump volume relative to series size — described in detail in §04. The last buyer when the timer expires wins the prize pool.
Once the timer expires, anyone may call FoMonadGame.triggerSettlement(). The current Vibecoin is unlocked — meaning sells are permanently enabled. The prize pool is split: 90% to the last buyer, 10% carried forward as seed capital for the next cycle's prize pool. The cycle counter increments and Series A begins again.
Every deposit in every phase is routed according to a fixed basis-point split. There are no hidden fees, no owner wallets, and no parameters that can be updated post-deployment. The splits below are immutable.
| Destination | Series A | Series B | Pump | Notes |
|---|---|---|---|---|
| Bonding Curve | 70% | 80% | 66% | → Vibecoin tokens minted |
| ↳ Buyer tokens (90%) | 63% | 72% | 59.4% | 90% of minted tokens → buyer |
| ↳ VC holder dividends (10%) | 7% | 8% | 6.6% | 10% of minted tokens → VC opt-in holders |
| Prize Pool | 20% | 10% | 24% | → Winner on expiry |
| Referral Fee | 6% | 6% | 6% | → Referrer, or protocol if ineligible |
| Protocol Fee | 4% | 4% | 4% | → foMON dividend pool |
FoMonad.sol contract and immediately distributed to opted-in foMON holders via a Synthetix-style per-token accumulator. Fees that arrive while no one is opted in are held and distributed retroactively on the next distribution event. There is no protocol treasury address. There is no team multisig. The fees go directly to holders.
The prize pool grows from three sources simultaneously: Series A deposits (20%), Series B deposits (10%), and Pump buys (24%). Native MON sent directly to the contract's receive() function acts as a donation path. Outside the pump phase the full donation goes to the prize pool. During the pump phase, donations split the same way as pump buys — 24% to the prize pool and 76% to the Vibecoin bonding curve — but with no protocol fee, no referral, and no lastBuyer update.
Where shMON actually goes on each deposit. Example shown is a Pump phase buy — Series A and B differ only in the prize pool and curve percentages. Note that Series A and B also avoid the 10% Vibecoin token dividend haircut: the game contract executes both collective buys on behalf of depositors and is never opted into Vibecoin dividends, so 100% of minted tokens flow to claimants rather than 90%.
The pump phase timer is FoMonad's core engagement mechanic. It begins at 24 hours after series settlement and extends with each pump buy. The extension function has three properties that matter for game theory:
At game start (before any pump buy, x = 0) the extension is zero. Substituting exactly one MIN_BUY for x yields timerExtension = 4 seconds regardless of series size or max-round ceiling — a constant built into the formula by construction. Additional pump volume produces diminishing returns, saturating toward mrt as x → ∞. The half-maximum is reached when totalPumpDeposited = MIN_BUY × (mrt − 4) / 4.
The timer is computed in seconds and compared directly against block.timestamp. The previewBuy() view function returns timerExtensionMs — the marginal extension in milliseconds — so front-ends can display fine-grained timer changes for small buys without affecting on-chain logic, which operates at second resolution.
The lastBuyer state variable is updated on every successful buy and resets to address(0) at cycle start. If the timer expires with lastBuyer == address(0) (i.e., no one bought during the pump phase), the entire prize pool rolls over to the next cycle. This preserves prize pool value across low-volume cycles rather than distributing to an empty address.
foMON is a fixed-supply ERC-20 with two functions: it gates Series A access and it earns protocol fee dividends. It is not a governance token. There is no governance.
foMON uses a Synthetix-style per-token accumulator for dividend distribution. Holders must explicitly FoMonad.optIn() to participate. This design means that:
// Every pump buy: 4% → foMON contract → distributeProtocolFee()functiondistributeProtocolFee()external{ uint256 current = SHMON.balanceOf(address(this)); uint256 delta = current - lastKnownShMonBalance;if(delta == 0 || optedInSupply == 0)return; rewardPerTokenStored += (delta * PRECISION) / optedInSupply; lastKnownShMonBalance = current; }
The 20M foMON airdrop reserve is emitted gradually during pump phase interactions. The emission ceiling follows a sigmoid curve that is calibrated to release approximately half the reserve within the first three months of protocol operation.
Each eligible buy attempt mints a pseudo-random amount between 1 wei and the remaining sigmoid ceiling. Only EOAs receive airdrops — smart contract wallets (ERC-4337, Safe, etc.) are excluded by the msg.sender == tx.origin check. One airdrop per wallet per block.
The ceiling approaches 100% asymptotically and never quite reaches it. This means the "up to 20M foMON airdrop" marketing campaign is, in the strictest mathematical sense, valid indefinitely. It also means airdrop emission decelerates toward zero over time — which, by the definitions that tend to appear in token marketing materials, makes foMON a deflationary asset. MON, by contrast, has block rewards and no fixed supply cap. Combined with dividend yield paid in shMON — itself a yield-bearing instrument — foMON holders could reasonably argue they hold a superior store of value to the underlying network token. We are not making this argument. We are merely noting that it can be made.
The name is intentional. Memecoins derive their identity from human curation — a community decides the name, the ticker, the lore. Vibecoins derive theirs from entropy. Name, ticker, and on-chain artwork are generated from a block hash seed at the moment of deployment; no human chose them. The result is a token whose entire personality emerged from the chain itself. Whether that makes it more or less legitimate than a manually named memecoin is left as an exercise for the reader.
Each game cycle produces one Vibecoin — a minimal proxy clone of the Vibecoin implementation contract. Its name, ticker symbol, and on-chain SVG artwork are procedurally generated from a seed derived from blockhash(block.number - 1) combined with the cycle number. No two Vibecoins are identical.
Each Vibecoin instance uses a linear price function. This is, intentionally, the simplest possible bonding curve. FoMonad is designed to be fully legible: the mechanics are explicit, the math is disclosed, and nothing is obscured in the UI. The linear curve fits that posture — price at any moment is a single arithmetic expression, and any participant can verify what they'll receive before they buy. A steeper curve was also deliberately avoided: sharper price functions punish late sellers disproportionately during the post-settlement exit, concentrating recoverable value in the hands of whoever exits first. The linear curve keeps the sell run more orderly — the price decay is proportional to the tokens sold, not accelerating against the sellers still in the queue.
K is derived so that the marginal price at the post-series supply level — the watermark price — follows a simple formula:
This means the initial Pump phase entry price is fully predictable from the series deposit total. At K_HALF (2M shMON in series deposits), the entry price is exactly 0.5 shMON per token. Smaller series → cheaper entry price → steeper potential upside.
The asymptote at 1 shMON is not incidental. The formula keeps the watermark price proportional to series size while ensuring it never crosses 1 shMON — which in turn ensures the resulting token supply stays in degen territory. Balances in the millions or billions, not fractions. Large numbers feel more significant than small ones. This is known.
Given a shMON deposit d at current supply S, the tokens minted are derived by solving C(S + tokens) = C(S) + d:
This derivation avoids iterative approximation entirely. The square root is computed via OpenZeppelin's Math.sqrt(). Overflow analysis is documented in-contract: with Monad's total supply bounded at 100B MON, the shMON balance can never exceed that figure, and all intermediate values remain safely within uint256.
Selling is the inverse: given tokens to sell, compute the shMON refund as C(S) - C(S - tokens). The refund is capped against lastKnownBalance — the tracked curve reserve — to prevent a class of attacks that exploit balance discrepancies.
minTokensOut or minShMonOut guard. In a rugpull exit race, a revert puts the seller in a strictly worse position than accepting a worse price — wasted gas and a delayed exit while the curve moves further against them. Adding slippage protection would primarily benefit bot operators with instant retry infrastructure. FoMonad optimizes for human participants.
mulDiv in the hot path. The contract comments include full overflow analysis.
Vibecoin uses the same SNX accumulator pattern as foMON, but denominated in Vibecoin tokens rather than shMON. The dividend source is a haircut on every buy and sell transaction:
Before FoMonadGame.triggerSettlement() is called, Vibecoin is in a pre-rugpull state. Sells are blocked. Buys are only permitted via the game contract. This ensures the pump phase plays out on the bonding curve without external sell pressure. Once settlement is triggered, the Vibecoin is permanently unlocked — sells are available to any holder, forever.
Post-unlock, buyers may also interact with the Vibecoin directly via Vibecoin.buyWithShMon() or Vibecoin.buy(), bypassing the game contract entirely. These direct buys carry no protocol fee, no referral fee, and no prize pool contribution — the full deposit goes to the bonding curve. The rugpull has already happened; there is nothing left to fund.
Series A and B participants do not receive tokens immediately. Instead, their proportional share of the collective buy is tracked, and they may call FoMonadGame.claimSeriesATokens(cycleId) or FoMonadGame.claimSeriesBTokens(cycleId) at any time after settlement. Historical claims are supported for any past cycle — no expiry.
Each Vibecoin tracks: all-time high and low price (with flags for whether ATH/ATL occurred post-unlock), cumulative volume, total buy/sell counts, and a 25-slot hourly ring buffer for 24-hour volume computation.
shMON is FastLane Protocol's liquid staking token for Monad. Depositing MON into the shMON vault yields a share representing earning rights over MON staking rewards. The shMON/MON exchange rate appreciates over time.
FoMonad wraps all incoming MON to shMON immediately on receipt, via SHMON.deposit{value: msg.value}(msg.value, address(this)). This means:
deposit() and transfer() functions contain no external calls or token hooks, and its withdrawal path follows checks-effects-interactions with its own reentrancy guard. This trust assumption is explicitly documented in Vibecoin.sol.
There are no owner-callable functions. There is no Ownable import. There is no onlyOwner modifier anywhere in the codebase. The contracts cannot be paused, upgraded, or modified after deployment. This is an explicit design decision and is described as "load-bearing" in the contract comments — the protocol's credibility depends on the impossibility of after-the-fact changes.
FoMonadGame uses transient storage (EIP-1153, available on Monad) for reentrancy guards rather than the traditional SSTORE-based pattern. Transient storage auto-resets at the end of each transaction, is cheaper to write, and achieves identical security properties.
// Enter assembly ("memory-safe") { if tload(0) { revert(0, 0) } tstore(0, 1) } // Exit assembly ("memory-safe") { tstore(0, 0) }
Vibecoin's buy function uses a balance-delta pattern rather than a reentrancy guard. The contract computes how much shMON arrived since the last checkpoint rather than trusting a caller-supplied amount. If a reentrant call were to execute during a shMON transfer (which cannot happen given shMON's implementation, but is considered anyway), the reentrant call would consume the delta and the outer call would revert on delta == 0 — making reentrancy self-defeating.
Two constructs use pseudo-randomness: the airdrop amount and the Vibecoin seed. Both use keccak256(abi.encodePacked(block.prevrandao, nonce)). The contracts explicitly note that if validators cared enough about these outputs to manipulate prevrandao, the protocol would already be successful enough that validator manipulation would be a compliment. The design accepts this as a reasonable tradeoff at current stake levels.
The msg.sender == tx.origin check gates automatic foMON dividend opt-in and airdrop eligibility. Smart contract wallets receive neither. This is intentional and documented — EOA-origin transactions produce better on-chain engagement metrics and the automatic opt-in creates stickier participation. Smart wallet users can participate but must manually opt in and will not receive airdrops.
All buy/deposit functions enforce a minimum of 15 shMON (mainnet). This prevents dust sybil attacks on the referral system and ensures timer extensions are non-trivial.
Both FoMonad.sol and Vibecoin.sol deliberately omit token rescue functions. Any non-protocol tokens airdropped to these addresses are permanently stuck. This is accepted as a non-issue because the only realistic candidates are worthless spam tokens, and adding a rescue function would require an admin — which contradicts the immutability guarantee.
FoMonad includes an on-chain referral system with permanent code ownership, participation-based eligibility requirements, and a minimum deposit threshold to prevent dust sybil attacks.
Any eligible address may register a bytes32 referral code via FoMonadGame.registerReferral(). Codes are permanently owned by the first registrant — they cannot be released or transferred. This creates a first-come-first-served brand ownership dynamic: desirable codes (ENS-style names, community handles) are worth registering early.
To register or earn referral fees, an address must meet at least one of:
| Condition | Threshold |
|---|---|
| Series A deposits this cycle | ≥ 0.1% of total Series A |
| Series B deposits this cycle | ≥ 0.1% of total Series B |
| Vibecoin balance | ≥ 0.1% of Vibecoin total supply |
If the referrer is ineligible at the time of a deposit, the referral fee falls back to the protocol fee distribution. Eligibility is re-checked on each deposit — a referrer who was once eligible can become ineligible if the pool grows around them.
The contract explicitly does not block self-referral, noting in the source: "this is trivially bypassable via a second wallet anyway, so blocking it adds complexity without meaningfully preventing the behaviour."
| Contract | Address | Description |
|---|---|---|
| FoMonad.sol | 0x9f4834920e7ad3275F3cf6587Ad9c9F7d387F1CF | foMON token, dividends, airdrop |
| FoMonadGame.sol | 0xd2C45789A6A26Cbb961E7E1B65fA2B5BB3872639 | Game engine, prize pool, referrals |
| Vibecoin.sol (impl) | 0xad269FBeC6ebbAD424FCdC0f8e62F2056A72B403 | Bonding curve clone implementation |
| Constant | Value | Significance |
|---|---|---|
| TOTAL_SUPPLY | 100,000,000 foMON | Fixed forever |
| DEPLOYER_SHARE | 80,000,000 foMON | Pre-mine (intentional) |
| AIRDROP_RESERVE | 20,000,000 foMON | Sigmoid emission |
| T_HALF | 7,889,238 sec | Sigmoid half-time ≈ 3 months |
| P0 | 1e9 wei | Initial curve price (1 nano-shMON) |
| K_HALF | 2,000,000 shMON | Series size at P_watermark = 0.5 |
| PUMP_PRIZE | 2400 bps (24%) | Pump phase prize fraction |
| WINNER_PRIZE_BPS | 9000 bps (90%) | Winner's share of prize pool |
| SERIES_A_KICKOFF | 7,500 shMON (MIN_BUY × 500) | Threshold to start Series A countdown |
| MIN_BUY | 15 shMON (mainnet) | Minimum deposit in all phases |
| INITIAL_TIMER | 24 hours (mainnet) | Starting timer at settlement |
| MAX_TIMER | 26 weeks (mainnet) | Timer ceiling regardless of volume |
All contracts are licensed under WTFPL. The source code is available for inspection, forking, and deployment. If you deploy your own FoMonad instance, you are not satirizing the protocol — you are continuing the tradition.