# live-conformance/prices — what delivering a rung costs, and which option a comparer takes

The corpus of [`extensions/rung-price.md`](../../extensions/rung-price.md) §9: `vectors.json`.

**Provenance.** Generated here by `wai_rung_price_vectors gen` (`wai-rs`, feature `rung_price`),
from Ed25519 keys on fixed 32-byte seeds and constant instants; no input from outside this
repository. Every signature is deterministic (RFC 8032) but one: `same_body_two_signatures` signs
unicast_tiers's body a second time under a fixed, different nonce prefix, which is still a valid
signature of the same body under the same key.

`keys` names every key by its role, as 64 lowercase hexadecimal digits: `seller_unicast` (A,
two-way delivery and rooms), `seller_broadcast` (B, transmissions), `seller_c` and `seller_d` (the
sellers the limit and ranking cases add), `seller_contribution` (uplink), `seller_other_currency`
(the one list in EUR), five holders (`holder_a` to `holder_e`) that price their bytes as peers, of
which `holder_d`'s list lapses a minute after issue and `holder_e`'s prices only `XA`, `seller_e`
(a second calibrated relay), `seller_f` (a relay that prices from a model), `seller_g` (a seller
whose class its records do not bear out), `room_authority` (signs the two room descriptors), and
`small_order`, the identity point.

Instants are microseconds. Lists are issued at 1,793,664,000,000,000 (2026-11-03T00:00:00Z) and
expire a day later unless a case says otherwise; comparisons are made an hour after issue. The
currency is `USD`. Every region is an ISO 3166-1 user-assigned code (`XA`, `XB`, `XC`) or a
subdivision of one (`XA-1`, `XB-1`), and names no place. The footprint of 8,192 codes is the
subdivisions `000` to `511` of each of `XA` to `XP`, in byte order; the one of 8,193 adds `XQ-000`.

The per-hop records are of two rooms, both signed by `room_authority`. R1's `t0` is a day before
issue (1,793,577,600,000,000), and R0's thirty days before it (1,791,072,000,000,000). Each record
covers its room's first hour, so a record of R1 has the instant 1,793,581,199,999,999 and one of R0
the instant 1,791,075,599,999,999. Each record is signed by its hop's key, one of `seller_c`,
`seller_d`, `seller_e`, `seller_f` and `seller_g`; `seller_g` also names `seller_c`'s and
`seller_d`'s records, which it did not sign, and `seller_c` names one of `seller_g`'s. One of
`seller_c`'s records counts media bytes it received beside those it sent. `rc2` and R1 are each also
given once with their last byte changed, a copy whose signature fails. The base request confirms
`seller_c` and `seller_e` for `CalibratedInstrument`, `seller_d` for `OnChipCounter` and `seller_f`
for `ModelBased`, and relies on records up to seven days old; a case that confirms another key or
class, or relies on records up to a day old, says so.

- `lists` (§4) are each a list's `text` and its `outcome`: `read`, with its `digest`, `seller` and
  count of `entries`; or `refuse` and its `reason`.
- `verdicts` (§5) are each `texts` and an instant `at_us`; `outcome.lists` gives each text's
  verdict, in order: `stands`, `superseded`, `set-aside reason=…` or `reject reason=…`.
- `comparisons` (§6) are each `texts`, an instant `at_us`, a `request` text and `evidence`, the
  texts given as evidence, as lowercase hexadecimal, in ascending order of the digest each names,
  and of their bytes for one digest; `outcome` is `refuse` and its `reason`, or the plan of §6.6:
  `request` (its digest), `at_us`, `lists` (each `verdict` and `digest`), `evidence` (the digests
  of the records and rooms those texts give, a damaged copy giving none), `audience`, `candidates`
  (each with its `energy_ppm`, `evidence` and `energy_rank`), `order` and `decision`.

The comparisons use A's 8,000,000 tier, `bytes` at 20,000,000 per 10⁹, and B's unidirectional
8,000,000 tier, `bytes_sent` at 100,000,000 per 10⁹. Most requests ask for 500,000,000 `bytes` per
receiver and 500,000,000,000 `bytes_sent` per transmission, for a rung of 3,000,000 and passes of
6,000,000 bits per second, to `XB`: a cost per receiver of 10,000,000 against *T* = 50,000,000,000,
and a break-even audience of 5,000. A's and B's figures are estimates.

Everything is synthetic: keys attest nothing, and prices and figures are chosen for their
arithmetic. Each case states the outcome it was written to have, declared in the generator, never
copied from a verifier: the removals, the order, the decision, the break-even and each candidate's
evidence of each comparison are written out case by case, and its costs, energies and energy ranks
are §6.3's and §6.4's arithmetic over the entries and the declared evidence. No vector carries the
bounds of a list of 1,048,577 bytes, a list of 1,025 entries, a request of 65,537 bytes or an
evidence text of 1,048,577 bytes; both implementations check them themselves.

`wai_rung_price_vectors verify` and `tests/rung_price.rs` check that the file regenerates byte for
byte and that `wai-rs` reaches every stated outcome. `../rung_price_verify.py` is the second
implementation, written from the extension's text, which also mutates copies of the corpus and
drops each of its own checks in turn and requires each to be caught.