# Two marketplaces, one rail — verify it yourself

Two companies traded for five minutes on 2026-09-05: a **buyer whose system hands over
Ariba-shaped documents** (cXML vocabulary) and a **seller whose system hands over
Alibaba-shaped documents** (trade-order vocabulary). They ran on different machines and never
exchanged a message. Each sealed every second and sent one 32-byte commitment to the rail.

This folder holds both companies' kits (records of the sampled deals, Merkle paths, snapshots,
door receipts, ledger receipts, witness bundles, public units), our reference verifier and the
code it needs. `run.sh` disables sockets inside the process before verifying: a PASS was
computed from these files and nothing else.

What is recomputed: per kit, every sampled deal from its record → record hash → Merkle path →
snapshot root → 32-byte commitment == door payload → ledger leaf (recomputed from the lane's
subject, the commitment and the request id) → beat root → NEOva2 bundle (two distinct witness
ids, signatures checked against `pinned_qws.json`) → public unit. Across the kits: the same deal
(contract number) names the **same relation** in both books, and both sides reach a witnessed
position.

What the verification relies on: this verifier and its vendored code (ours — read it), the
protocol rules it encodes, the `--member` input, and a witness registry you obtained from a
source you trust. The public unit named HOUR spans 60 seconds in the current epoch. The era seal
is not proven. We are the bookkeeper: this proves what was recorded and witnessed, and when;
not that the documents' business content is true. Deals that one side reached in a second the
other did not are reported as one-sided samples, never as paired.

## Run

```bash
python3 -m venv .venv && . .venv/bin/activate && pip install cryptography
bash run.sh
```

Expected last line: `{"verdict": "PASS", ... "same_relation_both_sides": <n>, "fails": 0}` with
`deals_in_both_kits == same_relation_both_sides`. Python 3.11+.
