How R&H 500 works

R&H 500 is an on-chain index token on Robinhood Chain. It is a fixed-supply ERC-20 whose treasury holds a basket of real tokenized stocks. Every trade pays a fee; most of that fee buys more stock for the basket. Because supply is fixed and the basket only grows, each token is backed by an ever-larger, redeemable slice of real equities.

The name echoes a broad market index. Robinhood Chain lists a growing set of tokenized equities, so the “500” is the index level (base 500 at inception), not a literal count of holdings. The basket expands as more names list on-chain.

The whole system is one repeating cycle:

1. 01A trader buys or sells R&H 500 on Pons. Every swap routes creator rewards to the project wallet.
2. 02A keeper claims the rewards and swaps 75% into the basket of tokenized stocks through on-chain pools once they clear a batching threshold.
3. 03The stocks settle in the treasury contract. NAV rises; with fixed supply, the redeemable floor per token rises with it.
4. 04A visibly rising floor and real equity backing attract the next trade. The wheel turns again.

There is no manager and no discretionary desk. The swaps are programmatic and every one is an on-chain transaction you can audit. Fees are batched so a single tiny trade doesn't waste gas swapping dust; once the buffer crosses a threshold, the buy fires.

R&H 500 launches on the Pons launchpad, so the token itself is a standard bonding-curve ERC-20 with no custom transfer tax. Funding instead comes from creator rewards: Pons routes a share of its trade fee to the project on every swap. A keeper claims those rewards and splits them two ways:

• 75% to the basket. Swapped into tokenized stocks and locked in the treasury. This is the backing behind your floor.
• 25% to protocol. Kept as stables to run the keeper, cover gas, and fund the team. Visible on-chain and tunable as volume scales.

The keeper claims and recycles in one call:

// Claim creator rewards from Pons, split, and buy the basket.
function recycle() external {
    uint256 rewards = pons.claimCreatorRewards();     // ETH in
    uint256 toStocks = (rewards * SPLIT_STOCKS) / 100; // 75%
    protocol.transfer(rewards - toStocks);             // 25% to ops

    // buy each basket member pro-rata to its target weight
    for (uint256 i; i < basket.length; ++i) {
        uint256 amt = (toStocks * weight[basket[i]]) / TOTAL_WEIGHT;
        dex.swapExactETHForTokens(amt, basket[i], address(this));
    }
    emit Recycled(rewards, toStocks);
}

The floor is not a promise, it is the basket sitting in the contract. To redeem you deposit RH500 into the vault; once it has vested you burn the deposit and receive a pro-rata slice of every stock in the treasury, priced at NAV. The deposit-to-vault model is what lets vesting work with a plain Pons token (no custom transfer hook needed).

In normal conditions the market price sits above the floor, so redemption is a backstop rather than a daily action. Its two real jobs:

• It pins the price. If the market ever dips to the floor, redeeming is free profit, so arbitrage buys the token back up.
• It converts the meme into a real portfolio. Don't want the token? Crack it open into a diversified basket of tokenized equities, on-chain, no KYC.

// Burn vested tokens, send caller their pro-rata slice of every stock.
function redeem(uint256 amount) external {
    Deposit storage d = deposits[msg.sender];
    uint256 unlocked = (d.amount * maturity(d.since)) / 1e18;
    require(amount <= unlocked, "not vested");

    d.amount -= amount;
    rh500.burn(amount);                       // supply drops
    uint256 share = (amount * 1e18) / rh500.totalSupply();

    for (uint256 i; i < basket.length; ++i) {
        uint256 out = (IERC20(basket[i]).balanceOf(address(this)) * share) / 1e18;
        IERC20(basket[i]).transfer(msg.sender, out);
    }
    emit Redeemed(msg.sender, amount);
}

Redemption is gated by how long your tokens have sat in the vault, so the floor can't be farmed and dumped. Your vesting clock starts the moment you deposit, and the claimable fraction follows this schedule:

• First 1 hour: 0% redeemable. This lets the treasury fill and blocks launch snipers.
• At 1 hour: a small 5% unlocks.
• 1 hour to 10 days: ramps linearly to 100%.

Redeeming burns the vaulted tokens, so there is nothing to dump after. Tokens you keep in your wallet are never touched. You can sell on the open market at any time, and you can withdraw an un-vested deposit back to your wallet whenever you want. Vesting only gates pulling real stock out of the vault, so no one is ever locked in. Each deposit tracks its own clock; a fresh deposit starts a new one.

// Fraction (1e18 = 100%) of a deposit that is redeemable, by age.
function maturity(uint256 since) public view returns (uint256) {
    uint256 age = block.timestamp - since;
    if (age < LOCK) return 0;                       // 1h cliff
    if (age >= FULL) return 1e18;                   // 10d = 100%
    // 5% at the cliff, linear to 100% at FULL
    uint256 ramp = ((age - LOCK) * (1e18 - BASE)) / (FULL - LOCK);
    return BASE + ramp;                             // BASE = 0.05e18
}

Membership in the basket is not hand-picked. It is decided by on-chain trading volume of the tokenized stocks themselves: the most-traded names are in, laggards are relegated. This is the idea behind a real market index, inclusion by rule rather than by committee, moved fully on-chain.

A keeper reads volume from an indexer, posts the ranking on-chain, and the contract executes the rebalance via swaps. Rebalances happen on a weekly epoch to limit slippage, and swaps are restricted to a whitelist of official Robinhood Chain stock tokens, so the contract physically cannot buy an arbitrary token.

// Keeper posts the volume-ranked list; contract swaps in/out.
// 'incoming' must be whitelisted RH-Chain stock tokens — nothing else.
function applyRebalance(address[] calldata incoming, address[] calldata outgoing)
    external onlyKeeper
{
    require(block.timestamp >= lastEpoch + EPOCH, "too soon");
    for (uint256 i; i < outgoing.length; ++i) {
        _sellToEth(outgoing[i]);                    // relegated → out
        _setWeight(outgoing[i], 0);
    }
    for (uint256 i; i < incoming.length; ++i) {
        require(whitelist[incoming[i]], "not a stock token");
        _addMember(incoming[i]);                    // promoted → in
    }
    lastEpoch = block.timestamp;
    emit Rebalanced(incoming, outgoing);
}

The contract, not our word, is what protects you:

• Source verified and ownership renounced. The rules can't be changed after launch.
• redeem() is permanent and public. The vault only ever empties by burning tokens; we can't freeze or drain it.
• No founder seed. The treasury fills from recycled creator rewards, visible on Blockscout from the first claim.
• The first redemption after the one-hour lock is a permanent on-chain receipt: proof of payment anyone can check.
• Swaps are whitelisted to official stock tokens; the treasury can't be pointed at a rug.

• Cold start: at launch the treasury is near-empty, so the floor starts thin and grows with volume. Early holders are betting on that volume arriving.
• Underlying assets: Robinhood Chain stock tokens are debt instruments with no shareholder rights, and carry the price risk of the equities they track.
• Smart-contract risk: immutability cuts both ways, and a bug can't be patched. Audits and verified source mitigate but don't eliminate this.
• Liquidity: redemption defends the floor, but thin DEX liquidity can still cause slippage on ordinary market exits.
• Regulatory: tokenized equities are a new and evolving area. Rules may change in your jurisdiction.