Demo guide

Cold load — auto-seed

On first load the demo seeds a small live book against Canton DevNet with zero clicks: an A–B bilateral trade (which Participant A discloses to her home regulator) and a separate B–C trade. It shows an honest seeding line while the real transactions land (~15–30 s), then every party role has real content to show. The seed's party ids are persisted per-tab so a reload repopulates instantly; if the stored ids no longer validate against the ledger (for example after a DevNet reset), the demo silently re-seeds.

Party selection

Choosing a party opens a view scoped by that party's own Ledger API projection. Available roles: Participant A, Participant B, Participant C, Operator, and Regulator (A). Nothing about which party you act as changes what the interface shows you — it only changes which party's own projection is being read. The header shows the real allocated party id, with a copy control.

Compression Console

The result KPIs lead with what the cycle accomplished — trades torn up, the compression ratio (e.g. 3 → 0 legs, 100%), and positions seen by the operator: 0 — rather than a wall of zeros.

The main action, Run compression cycle, drives the real off-ledger client against the live ledger and stages the run as a live step timeline: each step appears as its real ledger operation completes — allocating parties, writing three encrypted trades, the real matching result, the operator opening the cycle, each participant verifying its own post-cycle risk within tolerance, the atomic execute, and the settled after-state. The DevNet latency becomes the proof that every step is a real transaction, not dead air. When it finishes, a prompt jumps you straight to the operator's view — the operator coordinated the whole cycle; see what it saw, and try to read a book yourself.

A second action, Run operator-blindness check, re-runs the seed — the persistent A–B and B–C trades the privacy matrix, the blotter, and the "try to cheat" control read from.

Trade blotter

The acting party's own bilateral trades, read from its live projection: trade ref, counterparty, terms, commitment, status. Where this session holds the party's key, the terms cell shows the real decrypted economics (instrument and notional); where it does not, it shows the real on-ledger ciphertext, truncated and labeled as such — never a simulated redaction. The operator's blotter is empty: it holds no book, the honest message. A gross-notional figure is shown only over trades this session can actually decrypt.

Compression ring

A native before/after diagram of the fixture ring: three nodes (A, B, C) with the gross ring edges before the cycle, and the replacement topology after — for this fixture, zero legs, i.e. three bilateral trades fully compressed. The three-node shape is fixed (the fixture is deterministic), but the edge counts come from the real matching result, not constants.

Ledger / X-ray

The acting party's own ledger activity feed, loaded automatically: every CREATE and ARCHIVE event in that party's projection, in order, with a contract-detail drawer and an "N events · Live" badge of the real event count. Every economic field renders exactly as it exists on-ledger — ciphertext, never a simulated redaction.

"Try to cheat"

Available when acting as the Operator (on the Ledger tab, and one click from the cycle's finale prompt). This genuinely attempts, as the operator, to read and decrypt a participant's trade from the operator's own ledger view. It reads the operator's real projection — empty by construction — and reports the real outcome: the attempt fails because there is no trade in the operator's own view to open.

Privacy matrix

Fills in cell by cell as each underlying live projection read resolves. Each cell is computed from a real read of that party's own active-contract set — the same table published in the privacy modelpage, made runnable and falsifiable. Because the seed discloses A–B to the regulator but leaves B–C undisclosed, the regulator column is a measured result: it sees A's terms (scoped) and genuinely does not see B's separate B–C trade.

Live counter

"Positions seen by the operator" and each counterparty's own trade count, read live rather than asserted as zero.