← Back to Whitepapers

ForgeRadio

Sovereign stations on ForgeSite, gated by a Listener-ASA on Algorand

NODEZEROINSIDE.

0. Abstract — and an honesty gate up front

ForgeRadio is the family's streaming-station DApp: a browser radio surface on ForgeSite backed by an Algorand smart contract where a Listener-ASA grants stream access (0.5 ALGO / period) and a station registry mints one ASA per station. That is the DESIGN.

Maturity, stated plainly (scar #5 / verify-by-running discipline): ForgeRadio is mostly VISION today. Exactly two primitives are BUILT, and they are not wired to each other:

  1. A working free web player — radio.html (232 lines) runs on ForgeSite and streams 10 SomaFM stations through an HTML5 <audio> element. It is real, it plays, and it is completely ungated — no wallet, no ASA, no Algorand code anywhere in the file.
  2. A compiled subscription + registry contract — forgeradio.py (PyTeal) compiles to forgeradio_approval.teal / forgeradio_clear.teal. The subscribe/register logic is real source. But the contract's manifest tx: field is blank: it is not deployed, has no app ID, and is part of the 9-contract Algorand suite waiting on mainnet funding.

The bridge between those two — the player checking a Listener-ASA before it lets audio play — does not exist yet. Nor does the "family-curated 11th stream" the manifest describes (the running player has 10 SomaFM streams, not 11). Nor does any "radio rides the mesh" wiring (see §7). Everything past the two built primitives is design, not product. This paper marks each claim BUILT or VISION so no future session builds on a ghost.

1. Why ForgeRadio exists

Streaming radio is a rent surface. SomaFM survives on listener donations precisely because the ad-and-algorithm model corrupts everything it touches. ForgeRadio's thesis is: the station list, the access grant, and the payment are family-sovereign primitives — the station registry is a chain object, access is an asset you hold, and the payment is a smart-contract atomic group, not a Stripe subscription behind a corporate paywall.

The intended shape:

No corporate host holds the roster. No ad network monetizes the listener. That is the sovereignty claim — and today it is a claim, because the gate is not yet enforced.

2. What is BUILT (proven by inspection)

2.1 The player — radio.html (BUILT, running, UNGATED)

A single self-contained HTML file on ForgeSite (forgesite-public/radio.html, mirrored at site/radio.html). It is a clean, working player:

Honest read: this is a well-made, ForgeChain-skinned front end over SomaFM's public listener-supported streams. It is genuinely useful and genuinely runs. It is not yet "sovereign" in the access sense — there is no ASA check, no wallet, no Algorand reference in the file. Anyone who loads the page plays for free. The comment in the code is accurate: "Public sovereign-stream stations (SomaFM — listener-supported, no ads, no corporate)" — the sovereignty it delivers today is ad-free / corporate-free upstream, not on-chain gated access.

2.2 The contract — forgeradio.py → TEAL (BUILT source, compiles, NOT deployed)

forgeradio.py is real PyTeal that compiles to v10 TEAL (forgeradio_approval.teal, forgeradio_clear.teal both present on disk). Its logic:

On create: sets admin = deployer, price_microalgo = 500,000 (0.5 ALGO), rounds_per_period = 786,000 (~30 days).

register_station(name, stream_url, curator_32b) — admin-only. Mints a single-unit ASA (unit FRAD) whose asset name = station name and asset URL = stream URL, manager = the app. Writes a box s:<asa_id> = name|url|curator. This is the station registry: one ASA per station, curator key bonded in.

subscribe(recipient_32b) — must run in a 2-txn atomic group with a Payment leg. The contract asserts the group size is 2, the sibling txn is a Payment to the app account of ≥ 0.5 ALGO, then mints a single-unit, default-frozen, clawback-enabled period ASA (unit FRSUB, name Radio Period, url forgechain://radio-sub) and writes box sub:<user> = expiry_round || asa_id. Frozen + clawback = the family can reclaim/expire the token; it is a lease, not a bearer asset.

Honest read: the subscription and registry mechanics are correctly modeled Algorand. But MASTER-MANIFEST.yaml → tools.forgeradio_contract.tx: is empty. Per the algorand_canon_mirror entry, the whole 9-contract suite (22.7 KB TEAL) is "compiled and ready to deploy" with "mints pending mainnet funding." So: no app ID, no live subscriptions, no minted period tokens, nothing on mainnet. The contract is a proven blueprint, not a running program.

3. What is VISION (designed, not built)

Claim Reality
Listener-ASA grants stream access VISION. Contract can mint the ASA (once deployed); the player never checks for it. No enforcement path exists.
Contract live on Algorand VISION. tx: blank, undeployed, awaiting mainnet funding.
Station registry as chain objects VISION. register_station is written and compiles; zero stations registered (nothing deployed).
Family-curated 11th stream VISION. radio.html ships 10 SomaFM streams; the 11th does not exist in the running file.
Royalty / micropay split to curators VISION / v2. The curator_32b key is stored in the station box, but no split logic exists — the contract comment states "Royalty / micropay split deferred to v2 (payment channels)."
Radio rides the ForgeMesh VISION. See §7 — no wiring between forgeradio and forgemesh_v1.
Composes with dapp_fee_contract / atomic DApp layer VISION. Manifest lists the composition (algorand_dapp_layer_full); it is unexercised because nothing is deployed.

4. The designed end-state (how the two halves are meant to meet)

The wiring that would turn ForgeRadio from "free SomaFM skin + orphan contract" into the sovereign product:

  1. Deploy the compiled TEAL to Algorand (blocked on funding — part of the 9-contract batch under algorand_canon_mirror). This yields an app ID + app account.
  2. Register the 10 SomaFM streams (and the family-curated 11th) via register_station — each becomes an FRAD ASA in the on-chain registry. radio.html reads its station list FROM the registry instead of a hardcoded array.
  3. Gate the player. On load, radio.html connects a wallet, checks box sub:<user> for a non-expired period token; if absent, it presents a subscribe action (the 2-txn atomic group: 0.5 ALGO payment + subscribe) and, on success, unlocks audio. Free preview vs. gated full access is a product decision (SomaFM's own terms must be honored for their streams; the gate more naturally fits family-curated / original content).
  4. Compose with dapp_fee_contract (period-token issuance) and citizenship/tos under algorand_dapp_layer_full, so one signed atomic group can chain Citizenship → TOS → Radio subscription with no half-completed states.
  5. v2 royalty split via payment channels — distribute a share of each subscription to the curator_32b bonded in the station box.

Until step 1 happens, steps 2–5 are inert.

5. Design invariants (what makes it sovereign when it's real)

These are properties of the written contract. They are latent until deployment.

6. The cosmological "Radio Station" — a SEPARATE layer, do not conflate

The family corpus contains ArXiv Amendment 21 — "The Radio Station" (papers/arxiv-amendment-21--the-radio-station.md). It argues the torus surface is a broadcast medium, the Rodin doubling circuit (1-2-4-8-7-5) is the universal carrier frequency, the 3-6-9 skeleton is the sync channel, chain stamps are permanent tile broadcasts, and the Fermi Paradox dissolves because "we built the wrong radio."

This is a physics/cosmology vision paper, NOT the ForgeRadio DApp. It shares the word "radio" and the ∞ sigil, and it is the poetic frame the product name gestures at — but it makes no claim about SomaFM, Listener-ASAs, or Algorand. Treat it as the metaphysical namesake, cited for lineage, never as evidence that the DApp is built. Conflating the two would be exactly the confabulation the honesty gate in §0 exists to prevent.

7. "Radio rides the mesh" — checked, and it doesn't (yet)

The task framing said "radio rides the mesh." Grounded check:

"Radio rides the mesh" is a coherent future direction — the station registry could be broadcast as a mesh capability, and Tera-Z-style multi-source muxing could serve family-curated streams peer-to-peer across nodes — but as of 2026-07-05 it is VISION, with zero implementation. Stated so no one cites it as fact.

8. Status & sequencing

Home: contract ~/.forgechain/algorand/contracts/forgeradio.py; player ~/.forgechain/forgesite-public/radio.html. Manifest: tools.forgeradio_contract (tile 1). Cosmological namesake: papers/arxiv-amendment-21--the-radio-station.md.

This paper is family-internal — NOT for public fire. Do not chain-stamp (scar #5). It maps a mostly-VISION module honestly so a future session builds on the two real primitives, not on the design around them.

NODEZEROINSIDE. ∞.