Whitepaper · Draft 0.1 · November 2026

The VaultStamp Protocol

An open format for signed proof about creative work: that a file existed, who holds which rights in a work, who agreed to what, who may act for whom, and what a payment bought. Anyone can issue it, check it or keep a log of it, without asking VaultStamp.

Contents

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.

A consent, as signed
{
  "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:

RelationFrom → to
supersedesA newer version → the version it replaces
claimA composition → a party's own claim it relies on
assetA composition or license → a stamp of a file belonging to the work
ingredientA composition → another work it incorporates (a sample, an interpolation)
consents-toA consent → the composition it answers
disputesA dispute → the composition it contests
resolvesA resolution → the dispute it settles
licensesA license → the composition or stamp it grants rights in
delegated-byAnything made under a delegation → that delegation
withdrawsA 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:

AssuranceMeaning
selfThe principal holds the signing key. The statement is exactly as strong as that key.
custodialA 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.
paymentThe 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.

TypeWhat it says
vsp.stamp/1A file with this digest existed, and the principal stamped it, with what they said about it.
vsp.claim/1The principal holds a share of a right in a work, optionally for a territory and term.
vsp.composition/1A proposed description of a work: its parties, who holds which share of which right, and how they agree.
vsp.consent/1The principal accepts or rejects one exact composition.
vsp.delegation/1The principal lets a delegate make certain statements for it, on stated terms.
vsp.dispute/1The principal contests one part of a composition, with a reason and optionally a proposal.
vsp.resolution/1The arbiter named in a composition's policy settles a dispute.
vsp.license/1The principal grants a right in a work, optionally for a recorded payment.
vsp.withdraw/1The principal withdraws one of its own earlier statements. History is kept.
vsp.attest/1A 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.

A song's composition body
"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:

  1. 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.
  2. Rejected if a party whose consent is required rejects it. Each party's latest answer counts.
  3. Effective once every required consent is an acceptance. It takes effect at the registration time of the last one.
  4. Superseded once a newer version that supersedes it becomes effective. It stays effective for the time it was.
  5. Otherwise proposed, with the list of consents still missing.
Statements about one songVersion 2 of the song's composition supersedes version 1 and cites Ben's claim. Ana's consent and a consent made by Ben's publisher both point at version 2; the publisher's consent also points at Ben's delegation.Composition, version 2Ana 60%, Ben 40% of the songpolicy: shareholdersComposition, version 1Ana 70%, Ben 30%supersedesBen's claim40% of the songclaimAna: acceptsigned for Anaconsents-toBen: acceptmade by Ben's publisherconsents-toDelegationBen → publisherdelegated-by
Statements about one song. Each arrow is a reference by digest, from a statement to the one it names. With both required consents present, version 2 is effective and version 1 is superseded.

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.

For music: The music profile treats a song and each recording as separate lineages, with the recording naming the song as an 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.
Where a receipt carries its inclusion proof (COSE unprotected header)
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 equivalent Link header. 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.

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:

  1. Decodes the envelope and checks its tag, algorithm and content type, and that the CWT issuer and subject match the payload.
  2. Resolves the issuer's key by its id and checks the signature.
  3. Re-canonicalizes the payload and checks the bytes are identical.
  4. 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.
  5. 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.