Documentation

How Bill works.

Everything the front page leaves out. The mechanics in full, the exact numbers, and the contract functions behind each one. $BILL is two contracts on Robinhood Chain: BILL (the token and all its behaviour) and FlopDistributor (where payout proceeds land and holders claim them).

01Overview

$BILL is a token that periodically sells and burns its own supply, and taxes exits. There is no team treasury, no vesting, no mint function. Once launched, every rule is fixed in the contract and ownership is renounced.

Three things happen, all triggered by ordinary trading:

Contract: contract FSH · contract FlopDistributor

02Supply & allocation

Fixed supply of 1,000,000,000 BILL, minted once in the constructor. Nothing can mint more.

AllocationShareWhere it goes
80%800,000,000Paired with 2.5 ETH into the liquidity pool. LP tokens are locked for 6 months in a third-party locker.
15%150,000,000Bill's stack — held by the contract itself. This is what yells HEY YOU GUYS.
5%50,000,000Dev wallet. Not tax-exempt — the dev sells at the same 20% as anyone.
Contract: constructor() mints totalSupplyCap and splits it 15 / 5 / 80.

Bill's 15% lives at the token contract's own address. There is no function anywhere that lets the owner, the dev, or anyone else withdraw it. It can only leave through a HEY YOU GUYS.

03HEY YOU GUYS

Every buy above a minimum size rolls the dice. On a hit, the contract earmarks a slice of Bill's stack to be sold — but it doesn't sell during your buy. The pair is locked mid-swap, so the sale is queued and fires on the next transaction that isn't a buy.

How a HEY YOU GUYS is triggered

How it fires

The queued slice executes on the next sell or transfer. Whoever makes that transaction pulls the trigger for Bill. The contract market-sells the slice for ETH and sends it straight to the FlopDistributor, where it's split across all holders by share of supply.

// FSH.sol — queued on a qualifying buy
function _rollFlop(address buyer, uint256 amount) internal {
    if (amount < minRollAmount) return;        // dust pulls no triggers
    if (pendingFlop > 0 || fishBundle == 0) return;
    uint256 r = _entropy(buyer, amount, "FLOP");
    if (r % BPS >= flopChanceBps) return;      // 2.5% chance
    // ... earmark 3–8% of fishBundle, set pendingFlop, emit FlopQueued
}
Contract: _rollFlop() queues · _executeFlop() fires on the next transfer · emits FlopQueued then Flopped.

Because sellers keep refilling Bill (see the tax below), his stack never empties. Bill yells HEY YOU GUYS forever.

04Burn yells HEY YOU GUYS

Not every payout is a sale. 1 in 8 yells HEY YOU GUYS (burnFlopOneInN = 8) is a burn payout: instead of selling the slice, the contract sends it to the dead address. Those tokens are gone. Nobody receives anything, and the supply in circulation shrinks.

Note

Burned tokens go to 0x…dEaD. The totalSupply figure on the explorer stays at 1B — standard for burn-to-dead — but those tokens can never move again.

Contract: _executeFlop() branches on pendingBurnFlop; burn path emits BurnFlopped.

05The sell tax

Buys are untaxed. Every sell pays a 20% tax (SELL_TAX_BPS = 2000). The dev wallet is not exempt — it pays the same 20%. After launch the only exempt address is the contract itself, because it needs to route payout sales without taxing itself.

The 20% is split four ways (as fractions of the tax):

CutShare of taxGoes to
50%TAX_BURN_BPSBurned — sent to dead.
35%TAX_FISH_BPSFeeds Bill — reloads his stack so yells HEY YOU GUYS never stop.
10%TAX_BASS_BPSThe Golden Doubloon pot.
5%TAX_DEV_BPSDev wallet, in tokens. No auto-swap.

So a 100 BILL sell: 80 reach the pool, 10 burn, 7 feed Bill, 2 gild the Doubloon, 1 to dev.

Contract: applied in _transfer() when to == pair; splits sent to dead / contract / dev.

06The Golden Doubloon

A token jackpot that fills from 10% of every sell tax and pays out, in full, to one buyer. Every qualifying buy is a cast of the line.

Why the winner doesn't get a bigger slice of a HEY YOU GUYS

Payouts pay every holder by share of supply — one simple rule, no exceptions. The Doubloon is where outsized wins come from: the winner takes the whole pot, which is a far larger, lumpier prize than a pro-rata HEY YOU GUYS share. Keeping them separate keeps both honest and easy to verify.

Contract: _rollBass(), weighted by amount / bassWeightDenom, capped, gated by bassMinPot; emits GoldenBass.

07Claiming payout proceeds

Spill ETH accrues to holders in the FlopDistributor using a standard magnified-dividends model — your share tracks your balance automatically as you trade. It doesn't auto-send; you claim it when you want.

Contract: FlopDistributor.claim() · claimable() · shares synced by the token on every transfer.

08Randomness

Both rolls use on-chain randomness seeded from ArbSys L2 block hashes (Robinhood Chain is an Arbitrum-stack L2; the ordinary blockhash is frozen for ~120 L2 blocks there and unusable).

This is memecoin-grade randomness, and we say so plainly. Both rolls resolve at buy time, so a fast bot could in principle simulate a buy in the current block and only submit winning ones. The minRollAmount gate is the defence: every attempt to grind a roll costs a real buy — which pays holders (a HEY YOU GUYS) or fills the pot (the Doubloon). Grinding Bill funds the people Bill pays.

Contract: _entropy() = keccak(arbBlockHash(n-1), buyer, amount, nonce, salt).

09Trust & renouncement

Contract: renounceTaxExemptions()renounceOwnership(), called in that order at launch.
One caveat we don't hide

The canonical WETH on Robinhood Chain — the other half of the FSH/WETH pair — is a third-party upgradeable proxy, not an immutable contract. That's the chain's infrastructure, not ours, and it's normal for a young network. But on a coin whose whole pitch is "read the contract," you should know that one side of the liquidity pair can be changed by its administrator, and it's outside our control. The FSH contract itself is immutable once ownership is renounced.

10Parameters at a glance

NameValueMeaning
flopChanceBps2502.5% payout chance per qualifying buy
trancheMinBps300Min payout = 3% of Bill's stack
trancheMaxBps800Max payout = 8% of Bill's stack
burnFlopOneInN81 in 8 yells HEY YOU GUYS burns instead
SELL_TAX_BPS200020% sell tax (buys 0%)
bassMaxChanceBps5005% cap on Doubloon odds per buy
bassMinPot1,000,000Pot floor before it can be won
minRollAmount500,000Min buy to roll either mechanic

Every one of these is set once in the constructor and can never change.

11FAQ

Can the dev dump on me?

The dev holds 5% and pays the same 20% tax as everyone to sell it. No auto-swaps, no exemptions — every dev sell is visible on-chain like any other.

Can the team rug the liquidity?

Not for 6 months. The LP tokens are held in a third-party time-locker and cannot be withdrawn before the unlock date. After 6 months the lock creator can reclaim them — the lock, and its unlock date, are public on-chain so you can verify both before buying.

Why will scanners flag this?

High sell tax, a contract that sells itself, and on-chain randomness all trip automated scanners. They're not wrong about what the contract does — that's the point. It's all here, and the source is verified on the explorer.

Does Bill ever run out?

No. 35% of every sell tax feeds his stack, so it refills faster than the occasional payout drains it. Bill yells HEY YOU GUYS forever.

Not financial advice. Assume total loss. Read the verified contract before you buy.