Resources, Kinds and the Completeness Invariant
A virtual machine for resources, not for value
Ethereum's virtual machine guarantees that one contract cannot write another's storage. It does not guarantee that a token's balances sum to its total supply — that is the token contract's job, and when a contract gets it wrong the EVM does not notice. The separation is deliberate, and it is why one machine can host assets it was never designed for.
The vault makes the same split. Its proof layer enforces structure: that a resource is consumed at most once, that nothing is dropped along the way, that a record is well-formed. It never looks inside a value. What "one unit" means, and what conserving it requires, belongs to the kind — the vault's analogue of a contract.
A kind's identity is a hash of its own logic. Nothing is blessed at genesis, so there is no privileged asset and no registry to petition. The consequence is honest and worth stating: which kind is the "real" one is a social fact, published as a list, exactly as "real" USDC on Ethereum is a social fact rather than a property the chain enforces.
What a resource is
A resource is a record with seven fields, none derivable from the others: the kind that governs it, a label, an opaque value reference, the account that owns it, a salt, a uniqueness nonce, and randomness. Two things follow from that shape.
The value reference is opaque to the proof layer — it is interpreted only by the kind that owns it, the way the EVM never parses a contract's storage. And ephemerality is structural: whether a resource is a persistent balance or a transient intermediate is a question of which set of an action it appears in, never a flag on the record. A flag could be set wrongly; a position cannot.
The invariant that replaces value-summing
If the proof layer cannot check that balances balance, what universal rule is left? This one:
Every resource in an action belongs to exactly one kind's partition, and every kind was shown its complete partition.
That single statement does the work. A kind cannot enforce conservation over resources it never saw, so completeness is what makes each kind's own rule meaningful. Conversely, a kind that saw everything and conserves correctly cannot leak value, because value changes only through declared boundary flows.
It is enforced as one algebraic identity — a signed sum over a lookup argument that comes out zero if and only if the partitions are a disjoint cover of the action. Not one check per kind: that weaker shape is precisely the bug class that has drained bridges, where a verifier authenticates every item it was given and never asks whether it was given everything. The 2026 Hyperbridge exploit minted a billion bridged tokens from a single missing bounds check of that flavour. Here there is no per-partition path to skip, because there is only one identity to satisfy.
The same identity carries authority: for every resource being consumed, the assertion that its owning account approved is on the same bus, domain-separated from the value lane. One check covers both "all the value is accounted for" and "everything that moved was authorised".
What this costs
Two things, stated plainly. Every kind is an independently audited circuit, so the audit surface grows with the number of kinds in use — Ethereum pays this per contract. And the completeness identity is a concentrated risk: a bug in it breaks the one universal guarantee, which is why it is the first thing to be machine-checked and the last thing to be changed.