The envelope as proof-of-compute
Every charged compute mints exactly one envelope — and the envelope is, first, a proof: an immutable, signed receipt that a specific compute happened, to a specific precision, at a specific Zeqond. It is the bridge between the proof machinery and the economy: the same object that proves the work also carries its value.
This page covers the proof side — what the receipt contains and how anyone re-verifies it. Its role as the unit of value — how it's owned, transferred, and carried — lives in Envelopes.
The receipt
Each envelope is one immutable row on the machine's tally, carrying everything a verifier needs and nothing it doesn't:
A deterministic hash
An id and hash taken over the machine, the Zeqond, the result digest, and the operator chain — so the same work always names the same envelope, and no two distinct computes collide.
The compute's ZeqProof
The ZeqProof of the compute that minted it, carried as the envelope's proof value — the link back to the exact result.
An Ed25519 signature
Signed by the node key, with the public key resolvable — so the receipt verifies offline, with no call back to the machine that issued it.
A soulbound minter
The machine that did the work, stamped permanently. This is the light proof — it never moves, even if the envelope is later transferred.
Why it's trustworthy
The envelope inherits the framework's whole trust chain. Its hash is deterministic, so it can't be forged for a compute that didn't happen; its signature is checkable offline; and it's written through the entangled-state chain, so it carries the same Proof of Elapsed Zeqonds seal as every other machine event. A holder never has to trust the machine that recorded it — the receipt proves itself.