Check the channel

Every package on this channel was packed by wai-pack, and its receipt was signed with the channel's key. This page lists each package in the loop with its receipt and its components, checks each receipt here in your browser, says what the player checks while you watch, and gives the command that checks a whole package on your own machine.

What the player checks in your browser

The player runs open WAI's composing sink, compiled to WebAssembly from the same Rust that packed the packages. For each package, before any of it is shown:

  1. The receipt's Ed25519 signature verifies, and the key it names is the channel's, shown below.
  2. Each component's stage index is the one the receipt binds: its digest, its stage root and the counts.

Then for every piece of every component, before that piece is shown:

  1. Each object the piece needs is the one its signed index entry names: its length, its SHA-256 and its envelope. One that is not is refused, and the player says so; the "Flip one byte" control under the player shows it.
  2. Each decoded output that has a signed digest is held to it: the graphics, drawn here, frame by frame; the captions; the sound decoded here from FLAC, or the idents' scores synthesised here, sample by sample; and the ticker's state, replayed here from its signed updates to the piece's seal, each piece starting from the state the one before it sealed.

The picture and, where your browser's decoder is chosen, the sound are decoded by your browser's own decoder; no digest states what such a decoder puts out, so the player counts the frames it gives and checks nothing more of them. The panel under the player says which component your device runs where, and why.

The channel's key

signer_id
did:key:z6MkvLrP4ufTqRqLT7LXmy235dQVUkMQSVNKWNYrxVHpuXv2
Ed25519 public key
ec16bfb02353f42ce81c31e015dc0e9f32f4c22aeffb8d96c79beab66fe5a9cb

The packages in the loop

Each piece cut from openly licensed or public-domain footage also links its provenance record: where its source file came from and that file's SHA-256, the licence evidence kept for it, and how it was cut. Beside the link is the SHA-256 the programme's manifest gives the record; this tab fetches the record and compares. Who made each piece and its licence are on the credits page.

Loading the list of packages…

    Check a package on your machine

    Install the WAI command line on macOS or Linux with its published installer. It puts it in ~/.wai, the archive checked against the SHA-256 the release states, and wai-pack is part of it: 

    curl -fsSL https://wai.transaction.science/install.sh | sh
export PATH="$HOME/.wai/bin:$PATH"

    Then fetch one package, every file its LISTING names, and verify it. The first line names the first package in the list above; put any other directory from the list in its place to check that one: 

    p=<package directory>
base=https://tv.transaction.science/channel/$p
mkdir -p "$p" && curl -fsSL "$base/LISTING" -o "$p/LISTING"
while read -r sum path; do
  mkdir -p "$p/$(dirname "$path")" && curl -fsSL "$base/$path" -o "$p/$path"
done < "$p/LISTING"
wai-pack verify "$p"
grep -o '"signer_pubkey":"[^"]*"' "$p/package.receipt.json"

    wai-pack verify prints ok and the receipt hash when the package checks: the signature, every index and every object. The last line prints the key the receipt names, to compare with the channel's key above.

    The lineup

    What airs, the strip under the player and the guide come from one signed lineup, in the form of open WAI's channel lineup. It is sealed in windows of a day from 00:00 UTC (or of whole hours, where a day of the loop holds more programmes than one window takes), ahead of the times it covers. Each window is three files, signed with the channel's key above:

    • channel.json: the day's channel receipt, its schedule of programmes, and the receipt hash of the day before;
    • lineup.wlu: the lineup, which describes each programme by the title its package has, and binds the schedule by its root;
    • guide.xml: the XMLTV guide that wai channel guide renders from the two.

    Before the channel's server starts, it checks every window: the receipt's and the lineup's signatures, that the lineup describes the receipt's schedule and that the guide is the one they render, that the key is the channel's, that the windows follow one another day by day, each receipt naming the one before it, and that the programmes are the loop of the packages above, each with its package's title. It refuses to start otherwise. The order the packages air in is the lineup's. For each request, /api/now computes what is on now and next from the window that holds that instant.

    Loading today's window…

    wai channel verify checks a window on your machine. It is part of the same WAI command line, which this installs (once is enough for both checks on this page): 

    curl -fsSL https://wai.transaction.science/install.sh | sh
export PATH="$HOME/.wai/bin:$PATH"

    Then fetch today's window and verify it. The first line names today's directory; any other day's works the same way:

    d=https://tv.transaction.science/channel/lineup/<YYYY-MM-DD>
curl -fsSL -O "$d/channel.json" -O "$d/lineup.wlu" -O "$d/guide.xml"
wai channel verify --receipt channel.json --lineup lineup.wlu --guide guide.xml

    It prints verified, the receipt hash and the lineup digest, then each programme of the guide. It marks the programmes inside the receipt's window as aired in the window: the receipt was sealed before its day, so that is what the schedule placed in the day, not a record of what was shown. Nothing on this channel records what was shown.