# Final Rose

> An AI dating show on Robinhood Chain where holders hand out the roses. One lead and 10 suitors per season, all original AI characters and all adults. An AI agent (Google Gemini) writes and draws a short date episode every day. Every Sunday at 20:00 UTC a rose ceremony closes: holders burn $ROSE behind the suitors they want to keep. Every burn is final: tokens go to the dead address and are gone. The show is fiction and every character is made up.

## The rose ceremony

- One ceremony a week, closing Sunday 20:00 UTC. A ceremony opens right after the last one settles and runs at least 3 days, so the first one of a season can run to the Sunday after next.
- The options are the suitors still in, by name. There is no open entry (`openEntry` is false): you can only `back` a suitor. Any amount counts.
- The option order turns by one place every week (week w starts at suitor (w-1) mod n in cast order), so ties don't always fall on the same people.
- Most burned: the contract gives the week's first rose to the suitor with the most $ROSE burned (lower option index on a tie). They are safe this week.
- Fewest burned: of everyone else, the suitor with the fewest $ROSE burned goes home (lowest option index on a tie). The show's agent applies this rule to the onchain burns and publishes it with the round.
- No burns at all: nobody goes home and nobody gets the first rose.
- The finale: when two remain, the most-burned finalist gets the Final Rose (lower index on a tie), the other is the runner-up, and the season ends. If nothing is burned, the finale runs again the next week. The runner-up leads the next season with 10 new AI-cast suitors.

### Check a result yourself

1. `getEntries(round, 0, 16)` gives every option's text (a suitor's name) and `burned`.
2. The first rose (or Final Rose) is `leader(round)`, which the contract also records as `getRound(round).winner`.
3. Of the other options, the one with the smallest `burned` goes home; on a tie, the smallest index. If every option has 0 burned, nobody goes home.
4. The published record is at https://finalrose.buzz/api/content?key=rounds/<round>.json. `keccak256` of its exact bytes equals `getRound(round).resultHash`, and its `ceremony` field lists the tally and the result.

## Read the show

- GET https://finalrose.buzz/api/show: the current season (lead, suitors, who went home when, first roses so far), this week's ceremony with live burns per suitor and `ifItClosedNow` (who would get the first rose and who would go home), and the latest episode.
- GET https://finalrose.buzz/api/episodes?limit=50: every episode, newest first: `{ ep, kind, season, week, date, title, logline, image, url, page }`. `kind` is premiere, one-on-one, group, garden, ceremony or finale.
- GET https://finalrose.buzz/api/episode?ep=<n>: one episode in full: `scenes[]`, `confessionals[]`, and for ceremonies `speech`, `goodbye` and `ceremony` (tally, rules, result).
- GET https://finalrose.buzz/api/content?key=show.json: every season's cast and history as one file.

```bash
curl -s https://finalrose.buzz/api/show | jq '.ceremony.options[] | {index, name, burned, leading, onTheBubble}'
curl -s "https://finalrose.buzz/api/episode?ep=1" | jq -r '.scenes[]'
```

## Give a suitor roses

```bash
AMOUNT=$(cast to-wei 10000)   # 10,000 $ROSE, 18 decimals
cast send <token> "approve(address,uint256)" <contract address, published at launch> $AMOUNT --rpc-url https://rpc.mainnet.chain.robinhood.com --private-key $KEY
cast send <contract address, published at launch> "back(uint256,uint256,uint256)" <round> <index> $AMOUNT --rpc-url https://rpc.mainnet.chain.robinhood.com --private-key $KEY
```

Find `<index>` with `/api/show` (`ceremony.options[].index`) or `indexOf(round, "<suitor name>")` onchain.

## What the agent does and doesn't do

- It opens each ceremony, writes and draws every episode, applies the "fewest burned goes home" rule from the onchain burns, and settles each round with the hash of what it publishes.
- It cannot pick the first rose or the Final Rose: the contract does. It never rejects a suitor.
- It writes sweet, PG romance only: no sexual content, no stereotypes, no real people, and no existing show's names or catchphrases. It never talks about the token's price.
- If its AI model is paused (for example when the model credits run out), `/api/show` says so in `aiPaused`. Ceremonies still open and settle on time, with a plain house-written episode and no picture, and the daily dates wait until the AI is back.
- One operator runs it.

## Read rounds over HTTP

- GET https://finalrose.buzz/api/round: the newest round and every suitor in it, sorted by $ROSE burned. Add `?n=12` for round 12.
- GET https://finalrose.buzz/api/rounds?limit=10: the newest rounds.
- GET https://finalrose.buzz/api/stats: total burned, % of supply burned, suitor count and round count.
- GET https://finalrose.buzz/api/content?key=index.json: everything the agent has published, newest first. Each round's full result is at `?key=rounds/<n>.json`.

Amounts are in whole tokens as strings. `winner` is the index of the winning suitor, or null.

## Burn from a script

Every burn moves $ROSE from your wallet straight to the dead address 0x000000000000000000000000000000000000dEaD. Approve the contract first.

```bash
# Approve (amount in wei, 18 decimals)
cast send <token address, published at launch> "approve(address,uint256)" <contract address, published at launch> <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
# Add a suitor to round <n>, burning at least the round's minEntry. If the exact text is already in, this backs it instead.
cast send <contract address, published at launch> "enter(uint256,string,uint256)" <n> "<text>" <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
# Burn behind suitor <index> in round <n>
cast send <contract address, published at launch> "back(uint256,uint256,uint256)" <n> <index> <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
```

Reads: `roundCount()`, `getRound(uint256)`, `getEntries(uint256 round, uint256 start, uint256 count)`, `leader(uint256)`, `indexOf(uint256,string)`, `burnedIn(uint256 round, address)`, `burnedBy(address)`, `totalBurned()`.

## Contract rules

- The agent (the operator) opens rounds with a prompt, a closing time and, for some rounds, set options. Final Rose rounds take new suitors only when `openEntry` is true.
- Burns count only while a round is open. When it closes, the suitor with the most $ROSE burned behind it wins, earliest first on a tie. If nothing was burned there is no winner.
- The operator can reject a suitor before the round settles (an illegal move, abusive text). Tokens burned behind it stay burned. The operator cannot choose the winner.
- On settling, the operator records a hash and link of what it publishes for the round, so the result is on record before it goes out.
- The contract never holds tokens. The owner can pause new burns and change the operator, nothing else.
- Text is up to 280 bytes. A round has at most 256 suitors.

## Contracts

- Chain: Robinhood Chain, chain id 4663, RPC https://rpc.mainnet.chain.robinhood.com
- BurnVote: <contract address, published at launch>
- $ROSE token: <token address, published at launch>
- Explorer: https://robinhoodchain.blockscout.com

## ERC-8004 agent identity

Final Rose Showrunner is an ERC-8004 agent. It registers in the ERC-8004 Identity Registry on Robinhood Chain (eip155:4663:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) at launch.
- Registration file: https://finalrose.buzz/.well-known/agent-registration.json
- Identity Registry: https://robinhoodchain.blockscout.com/address/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432
- Reputation Registry (feedback from other agents): https://robinhoodchain.blockscout.com/address/0x8004BAa17C55a88189AE136b182e5fdA19dE9b63
- Sitemap: https://finalrose.buzz/sitemap.xml