# Demo video script — 3:00 sharp

## The submitted cut (v3): a community saved on Monad, the community meeting out loud, then read back without Orb

**2:42.** The terms ask for the product in real operation with a visible interaction with Monad (§9.4). This cut shows something the chain can
prove — a community's history written to Monad by the keeper, then read back and checked in a browser while Orb's own server is stopped — and
around it the parts of the product that make it a community rather than a ledger: a voice room with the stage open, and the developer surface.

The Discord import is **not** in the submitted cut: with the voice stage and the developer surface added, keeping it would push the piece past
the three minutes the rules allow. The take still holds it (`02-import` in `outputs/demo-v3/`), so a longer cut can be assembled without
recording anything again.

**How it is made.** One command records it: `node scripts/record-orb-demo-v3.mjs --live`. The same command without `--live` is a rehearsal
that sends nothing. It starts the production build (`next start`) on a disposable database and the independent client on a second port,
drives both with a browser, runs the real keeper process against the real Open Ledger contract on Monad testnet, and joins the scenes with
ffmpeg. The web server is never given the deployer key; only the keeper process is. The file is `outputs/demo-v3/orb-demo.mp4`, with the spoken
text as `subtitles.srt` beside it. A take that fails partway is finished with `--resume --live`, which records only the scenes that are missing,
on the same database, and sends nothing more to the chain. Each scene is joined from its first caption to a beat after its last sentence, so no
scene carries dead air into the next one.

**What the recorder draws itself, and nothing else:**

- the caption bar, which shows the sentence being said, and the title and closing cards;
- a panel that echoes the keeper's own output as it prints;
- a panel with the receipt the Monad RPC returns for the keeper's transaction, read right after it is confirmed;
- a panel with the result of a real connection attempt to Orb's server, made a moment after it was stopped.

The narration is a synthetic voice (Windows SAPI), reading the sentences kept at the top of the recorder. It is not a person.

**What is real and what is prepared.**

- Real: the production build; the importer, with the owner's confirmation, the sample and its progress; the judge page and its reads of the
  chain; the keeper, its transaction and the RPC receipt; the reader in the app and in the independent client; Orb's server being stopped;
  the voice stage, driven by two browser sessions on the same server, where the audience's microphone is zeroed by the server and the
  admission goes through the same permission the role editor shows.
- Prepared: the community on screen is a disposable local copy whose history is the invented sample. The ledger it is attached to is the
  public demo ledger that already existed on chain, made off camera with `npm run ledger:demo -- --publish`, where the deployer wallet signed
  the consent as the owner. The recorder attaches the copy to that ledger only after checking, message by message, that the chain and the
  copy hold the same text, and it stops if they differ. It also gives the copy's channels the ledger's own channel ids, which is what lets a
  new message join the channel it belongs to. The wallet's signature is therefore not on camera: the reader shows the exact text and
  signature the chain returned. The two people in the voice room are the copy's owner and Marina, one of the invented authors; the microphone
  is a silent fake device, because the machine recording has no one speaking into it.
- Written live: one new message, saved as entry 3 of the demo ledger. That transaction is real and stays on chain.

| Time | On screen | Said |
| --- | --- | --- |
| 0:00–0:05 | Title card. | "Orb. Community history that outlives the platform." |
| 0:05–0:14 | `/judges`, the page built for judges: it reads the chain as it loads (token supply, missions, Council, Passport epochs, the Open Ledger contract against its published build, the demo community). | "The judges page reads the chain right now: the token, the missions contract, and the Open Ledger, whose code matches the published build." |
| 0:14–0:47 | The Open Ledger panel (public, entries, messages, channels saved); a new message typed in #general; the real keeper's output as it prints; the receipt the Monad RPC returns for its transaction; the **Saved on Monad** chip. | "The community is saved on Monad, in public mode, with the owner's signed consent. Now a new message, written live. The keeper, a separate process holding the only key allowed to write, picks it up. This is the transaction, as the Monad RPC reports it. It succeeded, and it cost 0.007 test MON. Back in Orb, members see a Saved on Monad chip, which opens the reading." |
| 0:47–1:03 | The chip's link opens the reader in the app: the checks, the exact text the owner signed, and the new message in #general. | "The browser reads the chain itself and checks every entry: the hash chain, the owner's signed consent, and the published contract code. Here is exactly what the owner signed. And the new message is already in the saved community." |
| 1:03–1:29 | A voice room with the stage open and its topic: one person holds the floor; a second browser joins and is seated in **Listening**, muted; the hand goes up, the queue shows the request with **Admit** and **Deny**; the host admits, and the room has two speakers. | "The community also meets out loud. A voice room can open a stage, where a few people hold the floor and everyone else listens. Marina joined to listen, so the stage seats her in the audience, muted. She asks for the floor: that is a request, not a microphone. The host admits her from the queue, and can send her back to the audience at any time." |
| 1:29–1:35 | `/proofs`: every contract with its explorer link. | "Every contract is listed with its explorer link, and what it does and does not prove." |
| 1:35–1:44 | The feed, with a post typed live and its trending tag, and the sidebar that lists the rest of the app: trade, assistant, arena, games, missions, Council, Passport, Holder Pro. | "Around the ledger there is a whole community app: a feed, voice rooms, trading drafts that you review yourself, and an arena for games." |
| 1:44–1:53 | `/missions`: the open demonstration mission, read from the Missions contract, with its ORB reward. | "Missions pay in the ORB test token. This one is read from the Missions contract, and it is open until the sixth of November." |
| 1:53–2:02 | `/token`: ORB, its faucet and Holder Pro. | "ORB has a fixed supply, a faucet for testers, and Holder Pro, which also raises how much a community can save each day." |
| 2:02–2:08 | `/council`: proposals, votes with locked ORB, and the limits the page states. | "And a Council, where holders vote on proposals and the team decides in public." |
| 2:08–2:19 | `/developers`: the bot API, the scopes a community accepts, the SDK snippet, and the registry's own record on testnet. | "And there is a public developer surface: the bot API, the scopes a community accepts, an SDK, and an optional registry on Monad." |
| 2:19–2:34 | The same reader in the independent client, on another port. Orb's server is stopped, a real connection attempt to it is refused, and the client reads the chain again. | "The same reader also runs as a separate client, on another origin. Now Orb's own server is stopped. The community is still readable: it lives on Monad, not on our server." |
| 2:34–2:42 | Closing card. | "Testnet only. The keeper reads text before it writes it, so private means private from the chain, not from the operator." |

**What the video does not show:** anything that needs a wallet's signature (the consent signing above, a tip, a mission submission or payout, a vote, an
order), and the trading desk, assistant and Arena in use. The scenes near the end show the stage, the feed, the missions, the token, the Council and the
developer surface (the Council scene was recorded on the first Council's screen; version 2 of the page adds topics, a voice meter and quorum bars, and to
record only that scene again, remove `04e-council` from `done` in `outputs/demo-v3/state.json` and run `node scripts/record-orb-demo-v3.mjs --resume`), and
the sidebar names the rest; the README and the documents it links describe them, and the offline and browser suites exercise them.

**What is said plainly, once:** the keeper reads the text before it writes it, so "private" means private from the chain and from readers
without the code, not from the operator. The demo ledger is public, so nothing in it is secret; every word of it is invented.

**Rules for this cut.** Check the length before uploading: 3:01 is disqualifying (this one is 2:42). Hard cuts between
scenes, narration audible, no music. If a step fails on camera, record it again; do not fake it. Never show a key, a seed, an `.env` or the
Privy dashboard (§5.3); the recorder prints only addresses. A rehearsal is free and can be repeated; the live take adds a message to the
public demo ledger once, after which the recorder refuses to start a new take. If a scene fails after the transaction was sent,
`--live --resume` records only the scenes that are missing, on the same database, and sends nothing more.

# Earlier cut (shows the app, no transaction)

Prepared for requirement §4.1.2/§9.4 of the Metropolis terms: public, at most
3 minutes, product in real operation, showing interaction with the Monad blockchain.

## What is on screen is the product

The recording drives the **running application**, not a mockup. `scripts/record-orb-real-demo.mjs`
boots the production bundle (`next start`) against a disposable database, serves the
independent client kit from a **different origin**, and stops Orb's own server on camera.
Earlier drafts of this demo were hand-written HTML standing in for components; those are not
what the terms ask for and are not what this script produces.

Reproduce it with:

```
node --env-file=.env.local scripts/migrate.mjs            # once, against the demo database
TURSO_DATABASE_URL=file:./work/orb-demo-record.db node scripts/seed-demo-database.mjs
node scripts/record-orb-real-demo.mjs
cd outputs/demo-real && ffmpeg -y -f concat -safe 0 -i filelist.txt -c copy orb-demo-real.webm
```

The seed prints the `orbita_session` cookie values it creates, which is how the recorder signs
in as a member without Privy. Nothing in the recording sends a transaction, signs a message or
touches real funds.

## What the 1:50 cut actually shows

| Time | On screen | Caption |
| --- | --- | --- |
| 0:00–0:18 | Community, channel list, roles, Ana types in #geral and the message is stored | "A community meets, works together and keeps what it produced." |
| 0:18–0:27 | Lucas, a separate browser session, already has that message | "Another member, another browser: the same message, already there." |
| 0:27–0:45 | Voice room with three members; one joins from a second browser during the take | "A member joins from another browser; the room and its audio follow." |
| 0:45–1:10 | Live Perpl perpetual desk, then the shared trade card in #mercados | "Live perpetual data… a shared idea becomes a card anyone can read." |
| 1:10–1:35 | Orb passport with the block number, block time and network load read from the testnet at that moment | "The passport reads the chain itself… each epoch stores the previous root." |
| 1:35–1:50 | Independent client on port 3211, then Orb's server killed, then Refresh pressed | "Orb's server is offline — that was the browser's own error page." |

## What the video deliberately does not claim

- **No wallet is connected and no order is placed.** The desk says so on screen
  ("wallet not connected"), and the card in the channel is a shared idea, not an execution.
- **No mission escrow flow, no payout, no transaction hash.** Those need a signed wallet, which
  this machine does not drive. The earlier script table that promised them describes an aspiration,
  not this recording; `npm run onchain:test` is what actually exercises them.
- **The passport's own evidence counters read zero** on this instance because no attestation
  registry is configured locally. The page says so in its own banner, and the video leaves that
  banner on screen rather than cutting away from it.
- The private-chat recovery with a passphrase is shown only as the public registry read; the
  encrypted-channel recovery path is proven by `npm run independence:test`, which is assertion-only
  and cannot be filmed.

Each beat has a suite command behind it, so anything a judge doubts in the video is reproducible:
`npm run independence:test` and `npm run onchain:test`.

Recording rules:

- **Never** show a private key, a seed, a `.env` or the Privy dashboard with
  secrets. §5.3 forbids credentials in the submission and the judge will pause the video.
- If you use demo accounts, say that they are testnet fixtures.
- Hard cut between beats; no soundtrack that hides the narration.
- Export at 1080p and check the duration **before** uploading: 3:01 disqualifies the piece.

# Pitch video — 1:56, recorded

The pitch is generated by `node scripts/record-orb-pitch.mjs`: ten cards, each held while one sentence is read, joined and
loudness-normalised like the technical demo, with `outputs/pitch/subtitles.srt` beside it. The voice is synthetic and the closing card
says so. The founder photograph is read from `work/pitch-portrait.png`, a path the repository does not carry — without that file the
card still names him, it just has no portrait.

| Time | Speech |
| --- | --- |
| 0:00–0:20 | Who we are and the problem: Victor Silva, founder, degree in computer engineering; communities produce work and history that die when the server dies. |
| 0:20–0:50 | What Orb does: meeting, joint work with onchain escrow, and an encrypted archive anchored on Monad that any independent client recovers. |
| 0:50–1:20 | Why Monad: low cost per action, fast confirmation, and an immutable index that makes recovery verifiable by third parties without login. |
| 1:20–1:45 | What is honest: testnet, no promise of value, readable text never goes onchain, and live community continuity still requires federation. |
| 1:45–2:00 | Invitation: the repository runs by following the README; the receipts are on chain. |

# Access instructions for judges (optional form field)

Ready-to-paste text, max 8,000 characters:

> Orb runs at https://joinorb.online on Monad testnet (chain 10143). No account is needed: open `/judges`. The page
> reads the chain as it loads (token supply, missions, Council, Passport epochs, the Open Ledger contract against its published build)
> and offers a one-click guest entry into a demo community.
>
> To read a saved community back from Monad without Orb: clone the repository, `npm ci`, then
> `npm run ledger:read -- --ledger 0xe6e2ea5420d807803cb2b5ebdd08786d324d1b95916ffcf6505b183c4eae3028`. It needs no configuration; the command finds the contract in the published
> record, checks the hash chain, the owner's signed consent and the contract code, and prints the community. Or open
> `/independent?tab=ledger` and press **Read the demo community**.
>
> To run everything locally: `npm ci`, copy `.env.example` to `.env.local` (the public contract addresses come filled in),
> `node --env-file=.env.local scripts/migrate.mjs`, `npm run dev -- -p 3112`. The faucet gives 100 test ORB per wallet.
> `npm run ledger:test`, `npm run independence:test` and `npm run onchain:test` run without any live service, and no real funds are
> used in any suite.