Proof about creative work is scattered. A timestamp lives in one service, a split sheet in an email thread, an agency agreement in a PDF, and a license in a payment processor's records. Each is in its own format, and each can only be checked by asking whoever holds it.
The VaultStamp Protocol (VSP) puts all of these in one shape: a small JSON document, signed, named by the hash of its signed bytes, and appended to a public, append-only log. Statements refer to each other by those hashes, so a song's ownership, the consents that made it binding, the publisher who signed for a writer and the license someone bought all form one graph that anyone can walk and check.
VSP is a profile of the IETF's SCITT architecture for supply-chain transparency, and is built only from published standards: JSON canonicalization (RFC 8785), COSE signatures (RFC 9052), CWT claims (RFC 9597) and the Certificate Transparency Merkle tree (RFC 9162). The specification, schemas and test vectors are public under Creative Commons Attribution 4.0. VaultStamp runs one issuer and one log; its implementation is the reference the test vectors come from.
A proof is only as useful as the number of people who can check it without trusting the person showing it. Three things follow.
- Proof has to outlive its issuer. If a receipt can only be checked on the website that made it, it disappears with that website. A signed statement in a public format, with public keys and a public log, can be checked by anyone, in any language, decades later.
- Rights are shared. A song has writers, publishers, a label and featured artists, each with a different share of a different right, sometimes per territory. Agreement among them needs to be recorded as precisely as the file itself, and disagreement needs a place too.
- Software now acts and pays. Agents generate work, agencies act for talent, and machines pay each other per request. A proof format has to say who acted, for whom, under what terms, and what was paid, in a form other software can check.
An open format also keeps VaultStamp honest. Anyone can run a second issuer, a second log or an independent verifier, and the moment VaultStamp signs something inconsistent, the log makes it visible.
- Standards, not inventions. Every cryptographic and encoding choice is an existing RFC with existing libraries. A competent developer can verify a statement with general-purpose tools; the specification ships a script that does exactly that.
- Bytes are the identity. A statement is named by the SHA-256 of its signed envelope. References pin exact bytes, so nothing can be edited after the fact without changing its name.
- Append, never edit. A new version supersedes an old one; a withdrawal is itself a statement. History is never rewritten, only added to.
- Say who stands behind it. Every statement says whether its subject holds the key, was authenticated by a platform, or is known only by a payment, so a verifier can show how strong each claim is.
- Small core, typed bodies. The envelope and the rules for checking it are fixed. What a statement says lives in a typed body that can grow without breaking older verifiers.
- No floats, no ambiguity. Shares are integer basis points (10,000 = 100%), money is a decimal string with a currency, times are whole-second UTC. Two implementations must produce the same bytes.
Everything in VSP is a statement: a JSON payload in canonical form, signed in a COSE envelope. In the VaultStamp app a stamped file's statement is what people see as its receipt.
The payload
Every payload has the same top-level members: the protocol version, a registered type with its major version, the issuer that signs, the time it was issued, the principal it speaks for, a typed body, and optionally the subject bytes it is about, the actor that caused it, refs to other statements and namespaced extensions in ext.
{
"vsp": "0.1",
"type": "vsp.consent/1",
"issuer": "did:web:vaultstamp.com",
"issued_at": "2026-11-09T18:14:00Z",
"principal": {
"id": "did:web:vaultstamp.com:org:0193f1c2-…",
"kind": "person",
"name": "Rae Moreno",
"assurance": "custodial"
},
"refs": [{ "rel": "consents-to", "stmt": "sha-256:44d0…" }],
"body": { "decision": "accept" }
}Canonical form
Before signing, the payload is serialized with the JSON Canonicalization Scheme (RFC 8785): keys sorted, no insignificant whitespace, numbers in one spelling. Floating-point numbers are forbidden and integers stay within ±253−1, so every language reproduces the same bytes. A verifier re-serializes the payload and rejects it if the bytes differ.
The envelope
The canonical bytes are signed as a tagged COSE_Sign1 (RFC 9052) with ES256 or Ed25519. The protected header carries the algorithm, the key id, the content type application/vsp+json and CWT claims (RFC 9597) binding iss to the issuer and sub to the principal, so the envelope alone says who signed and for whom.
Names and references
A statement's name is sha-256: followed by the hex SHA-256 of its envelope. Statements refer to one another only by these names, with a registered relation:
| Relation | From → to |
|---|---|
supersedes | A newer version → the version it replaces |
claim | A composition → a party's own claim it relies on |
asset | A composition or license → a stamp of a file belonging to the work |
ingredient | A composition → another work it incorporates (a sample, an interpolation) |
consents-to | A consent → the composition it answers |
disputes | A dispute → the composition it contests |
resolves | A resolution → the dispute it settles |
licenses | A license → the composition or stamp it grants rights in |
delegated-by | Anything made under a delegation → that delegation |
withdraws | A withdrawal → an earlier statement by the same principal |
A reference that can't be resolved makes a statement unverified, not invalid: the statement is still signed, but a verifier can't yet check what it relies on.
The principal is the party a statement speaks for, a person, organization or agent, and its assurance says how the issuer knows it:
| Assurance | Meaning |
|---|---|
self | The principal holds the signing key. The statement is exactly as strong as that key. |
custodial | A platform signed for a principal it authenticated, as VaultStamp does for its accounts. As strong as the platform's sign-in and its validation level, which verifiers should show. |
payment | The issuer authenticated nothing but a payment. Valid only on stamps; it proves a paid request carried this file digest at this time, and verifiers must not present the payer as an identified party. |
Custody is a starting point, not a trap. A party can move to its own keys at any time, and everything signed for it before stays valid. When someone other than the principal caused a statement, such as an agency member or a software agent, the optional actor names them.
Types are versioned independently; a breaking change bumps the type's major version without touching the core.
| Type | What it says |
|---|---|
vsp.stamp/1 | A file with this digest existed, and the principal stamped it, with what they said about it. |
vsp.claim/1 | The principal holds a share of a right in a work, optionally for a territory and term. |
vsp.composition/1 | A proposed description of a work: its parties, who holds which share of which right, and how they agree. |
vsp.consent/1 | The principal accepts or rejects one exact composition. |
vsp.delegation/1 | The principal lets a delegate make certain statements for it, on stated terms. |
vsp.dispute/1 | The principal contests one part of a composition, with a reason and optionally a proposal. |
vsp.resolution/1 | The arbiter named in a composition's policy settles a dispute. |
vsp.license/1 | The principal grants a right in a work, optionally for a recorded payment. |
vsp.withdraw/1 | The principal withdraws one of its own earlier statements. History is kept. |
vsp.attest/1 | A validation authority vouches for an issuer or a principal. |
Rights are drawn from a short list (composition, performance, mechanical, sync, master, likeness, print) with an other: escape. Territories are ISO 3166 country codes or WW for worldwide.
A composition is a proposed record of who owns a work. It lists the parties, their shares of each right, and a policy for how they agree: unanimous (every listed party), shareholders (everyone holding a share) or a weighted threshold of a given right. It can name an arbiter for disputes.
"body": {
"title": "Harbour Lights",
"identifiers": { "iswc": "T-123.456.789-0" },
"parties": [
{ "id": "…:org:ana", "name": "Ana Reyes", "kind": "person" },
{ "id": "…:org:ben", "name": "Ben Okafor", "kind": "person" }
],
"shares": [
{ "party": "…:org:ana", "right": "composition", "share_bp": 6000, "role": "writer" },
{ "party": "…:org:ben", "right": "composition", "share_bp": 4000, "role": "writer",
"claim": "sha-256:9be1…" }
],
"policy": { "consent": "shareholders" }
}From proposal to binding
A composition is never "approved" by a server. Its state is computed by anyone, from the statements that refer to it:
- Invalid if, for any right and territory, the shares don't add up to exactly 10,000, or if a share cites a claim that disagrees with it. A worldwide share counts in every country named alongside it.
- Rejected if a party whose consent is required rejects it. Each party's latest answer counts.
- Effective once every required consent is an acceptance. It takes effect at the registration time of the last one.
- Superseded once a newer version that supersedes it becomes effective. It stays effective for the time it was.
- Otherwise proposed, with the list of consents still missing.
Claims, disputes and merges
A claim lets a party record what they hold before anyone drafts a split. A composition that agrees cites it, and the evaluator checks that the share matches; one that disagrees is shown to its parties as a conflict rather than silently accepted. A dispute points at the exact field it contests with a JSON Pointer. It doesn't change the computed state, but verifiers must show it alongside, until the arbiter's resolution or a new version settles it. A composition that supersedes two branches merges them, and should need consent from every party of both.
ingredient, so samples and interpolations are references too. Split sheets become one composition every writer and publisher signs.Agencies sign for talent, publishers consent for writers, and software agents stamp for their owners. A delegation records that permission as a statement of its own: who the delegate is, which statement types it may make, optionally which works and media, when it starts and ends, and how independent it is:
independent: the delegate acts freely within its scope.notify: it acts, and the principal is told.approve_each: every statement needs the principal's approval first, and carries evidence of it.
Anything made under a delegation references it with delegated-by, and a consent counts for the principal only if that delegation was in force and its scope covers consents and that work. Delegations end at their end date, when superseded, or when withdrawn, and they don't chain: a delegate can't pass its permission on unless the scope explicitly says so. A delegation can point at a stamp of the signed agreement it mirrors.
A signature proves who signed; it doesn't prove when, or that the issuer didn't quietly sign something else as well. VSP statements are therefore appended to a transparency log: an append-only Merkle tree, the same construction Certificate Transparency uses for every TLS certificate on the web (RFC 9162).
- Entries are the 32 raw bytes of each statement's digest, in registration order. The time an entry is appended is the statement's authoritative registration time.
- Checkpoints are signed COSE statements of the tree's root at a given size. A log that signs two different roots for the same size has been caught misbehaving, with its own signatures as proof.
- Receipts prove one statement is in the tree: the checkpoint's signature plus the inclusion path, following the IETF COSE Receipts draft. With a statement, its receipt and the log's public key, anyone can check inclusion offline.
- Consistency proofs show that a later tree contains an earlier one unchanged, so monitors can confirm nothing was removed or rewritten.
396: { -1: [ bstr .cbor [ tree_size, leaf_index, [ hash, … ] ] ] }The log reveals digests only. What a statement says is visible to those who fetch it by its 256-bit name, unless its principal published it.
An issuer publishes its keys at /.well-known/vsp/issuer.json on its own domain, the address its did:web identifier resolves to. The list holds every key that ever signed, marked active, retired (still verifies) or compromised (statements count only if the log shows they were registered before the compromise). It also says which types the issuer makes, whether it signs for others, and where its log is.
Validation authorities vet issuers and principals and sign attestations at three levels: control of a domain or account, a verified legal entity, or a match with rights-registry identifiers such as IPI and ISNI or membership of a collecting society. Which authorities and logs a verifier accepts is its own trust list; nothing in the protocol depends on one operator's list, VaultStamp's included.
VaultStamp's own issuer document is at /.well-known/vsp/issuer.json, and its log's latest checkpoint at /api/vsp/v1/log/checkpoint.
A small HTTP surface makes statements discoverable wherever the content goes:
- Any response whose content is described by a statement can carry
VSP-Statement: sha-256:…; url="…", or the equivalentLinkheader.vsp:sha-256:…names a statement independently of any host. - Files can carry the digest in their own metadata: a C2PA assertion, an XMP property or an ID3 frame. When metadata is stripped, lookup by the file's own hash still finds its stamps.
- A transparency service answers a handful of read endpoints: a statement (as COSE or JSON), its receipt, the latest checkpoint, consistency proofs, the log's leaves for monitors, the statements that refer to one, a composition's computed state, and lookup by file digest.
12
Payments
VSP has a profile for the Machine Payments Protocol (MPP), the open HTTP 402 standard for software paying per request. The two fit together: MPP proves money moved, VSP records what it bought.
Paid stamping
An agent with no account can stamp a file by paying for it. It sends the file's SHA-256 (the file itself never leaves it) and gets 402 Payment Required with a payment challenge per accepted method, each bound to that exact request. Once it pays, it receives a stamp whose principal has payment assurance, recorded in the log, with both MPP's Payment-Receipt and a VSP-Statement header. VaultStamp offers this today with Tempo and Stripe.
Licenses and royalty splits
The profile also defines how a payment for a license is divided: take the work's effective composition, compute each party's share of the right in the currency's smallest unit, pay the largest holder as the recipient and the rest as splits, and mark each split with the composition's digest. A buyer's client can recompute the payees from the public composition and refuse a payment that doesn't match, so a server can't redirect royalties unnoticed. VaultStamp hasn't built this part yet; it's specified so others can.
To verify a statement, a verifier:
- Decodes the envelope and checks its tag, algorithm and content type, and that the CWT issuer and subject match the payload.
- Resolves the issuer's key by its id and checks the signature.
- Re-canonicalizes the payload and checks the bytes are identical.
- Checks the key was valid at the registration time shown by a log receipt, or at the issued time when there is none, and says which.
- Applies the statement type's own rules, such as evaluating a composition.
The specification ships test vectors: canonical JSON cases, an Ed25519-signed statement with every intermediate byte, ten composition graphs with their expected states, and a log with a checkpoint, receipts and a consistency proof. A short Python script re-derives all of them with general-purpose libraries and no VSP code:
git clone https://github.com/vaultstamp/vs-spec cd vs-spec pip install cbor2 cryptography python3 tools/check_vectors.py vectors
An implementation conforms to the core when it produces the same bytes, envelope and digest for the signed vector, and reaches the expected state for every composition scenario.
This is draft 0.1. The envelope and canonical form are intended to be stable, and VaultStamp issues them in production; statement bodies may still change before 1.0, and any breaking change bumps a type's major version. "VSP" is a working name.
- Read it: core, statement types, trust and HTTP, and the payments and music profiles.
- Use it: the text, schemas and vectors are licensed under Creative Commons Attribution 4.0, and the tools under Apache 2.0. Issue, verify or log statements without asking.
- Shape it: issues and pull requests are welcome on GitHub.