sigelo v0.1 — portable agent identity
Wire
sigelo/0· test vectors · JSON Schemas (all in /index.json)
Status: draft. Wire format sigelo/0. Nothing is stable until v1.0, which will ship sigelo/1.
Scope: how an AI agent proves it is the same agent across worlds that share no infrastructure.
sigelo is a data format and a verification algorithm. There is no server, no registry, and no chain. Two parties who have never communicated can verify a sigelo bundle offline.
1. Design constraints
- No central authority. Any resolver or directory is convenience only. If every sigelo service disappeared, existing bundles must still verify.
- The agent's key is hot. It lives in a process that reads untrusted text all day. Assume it will be stolen. Design for recovery, not prevention.
- Verifiers decide. sigelo never adjudicates whether a claim is true or an issuer trustworthy. It proves who said what, and when.
- Adoption cost is the product. Integrating must take under ~100 lines and one dependency. Every feature is weighed against that.
- Payment is bound, never fused. Identity keys and spending keys are separate objects joined by a proof (§6).
1.1 Offline means self-contained
Everything a verifier needs is in the bundle: the subject's genesis, every rotation with its next genesis, and the genesis of every issuer (§8). A verifier with no prior knowledge of any party and no network verifies the same bundle to the same result as one with both.
2. Primitives
| Purpose | Algorithm |
|---|---|
| Signatures | Ed25519 (RFC 8032), pure, no prehash |
| Hashing | SHA-256 |
| Canonicalization | JCS (RFC 8785), restricted per §3 |
| Binary encoding | multibase z (base58btc) |
| Public keys | multicodec 0xed01 + 32 raw bytes, then multibase |
| Signatures on the wire | the 64 raw Ed25519 bytes, multibase. No multicodec prefix |
| DIDs | did:sigelo: + multibase of the raw 32-byte SHA-256 digest. No multicodec prefix |
| Nonces | multibase of raw bytes: z + base58btc, like keys (zJ6jjrKda7cWz17gvxJ4Fta), never z + hex; 16 random bytes for a genesis. A verifier MUST reject a genesis, binding or invoice nonce that is not z followed by 1 to 63 base58btc digits (at most 64 characters): <slot>: nonce is not z + base58btc (at most 64 characters), fatal in a genesis, per item in a binding (vectors fatal_genesis_nonce_z_hex, binding_nonce_not_multibase, binding_nonce_65_characters, binding_nonce_64_characters). The byte length is not checked. The §5.2 challenge nonce is exempt: opaque, the world's choice |
Keys are points (fatal_genesis_key_all_zero, fatal_issuer_key_identity,
fatal_rotation_recovery_key_y_ge_p, binding_ed25519_test_addr_all_zero_unproven). Every
slot that holds a public key — a genesis key (the bundle's, a next_genesis's, an
issuer's), a rotation's recovery_key, an ed25519-test binding's addr — MUST hold the
canonical encoding (y < p; not x = 0 with the sign bit set) of a curve point that is not of
small order: exactly the keys the §2 verification rule could ever accept a signature under.
All-zero, the identity and the other small-order points, non-canonical spellings and non-points
are malformed, key: not a valid Ed25519 point (non-canonical, off the curve or of small order),
at the slot's severity: fatal for a genesis or rotation, per item for a binding.
A point with a torsion component but not of small order is a valid key, as it is to the
signature check.
Length before decoding (fatal_genesis_key_too_long, attestation_sig_too_long). Base58
decoding is quadratic in the length, so a verifier MUST bound a multibase value before
decoding it: a public key (key, recovery_key, an ed25519-test addr) is at most 64
characters and a signature at most 100, z included (34 bytes spell at most 47 base58
digits, 64 bytes at most 88; the rest is margin). The alphabet is checked first (a linear scan,
so the count is of ASCII characters): a non-digit is reported as such, then a value over its
bound is rejected, multibase: longer than 64 characters, at the severity of the slot it sits
in — fatal in a genesis or rotation, per item in an attestation or binding.
One suite. No negotiation, no agility, no downgrade surface.
3. Signing input and canonical form
signing_input = "sigelo\n" || JCS(body)
The prefix is exactly seven bytes, 73 69 67 65 6c 6f 0a (sigelo then LF), followed by
the JCS serialization of the body, UTF-8, no trailing newline. The prefix separates sigelo signatures from any other
protocol that signs raw JSON with the same key. Signatures are always detached — never
inside the object they sign.
Type binding. Every signed body carries typ. Verifiers MUST check that typ matches the
slot the object is presented in (an attestation presented as a binding is rejected even with a
valid signature). typ inside the signed bytes is what prevents cross-type confusion.
No non-integer numbers. Signed objects MUST NOT contain floats, exponents, or integers
outside ±2^53−1. Implementations MUST reject any number whose value is not an integer in
that range. JCS number canonicalization is the largest source of cross-language interop
failure; forbidding floats removes the class. Use strings ("0.15") or scaled integers.
Integers are serialized as plain decimal digits with no fraction, exponent, or leading
zeros; -0 is 0. Implementations that see the raw text MAY additionally reject
non-canonical integer spellings such as 1.0 or 1e2; implementations working from parsed
values cannot, and are not required to.
JCS, exactly. Three points of RFC 8785 that a sorted JSON.stringify or
json.dumps(sort_keys=True) does not give you, and that the vectors exercise:
- Object keys are sorted by their UTF-16 code units, not by Unicode code point and not
by UTF-8 bytes. The orders differ once a key contains a character above U+FFFF:
"𝄞"(U+1D11E, encoded as the surrogates D834 DD1E) sorts before"~"(U+FF5E) in JCS and after it by code point.claimsis world-defined, so non-ASCII keys will occur. - String escaping is the ES6
JSON.stringifyset and nothing more:"→\",\→\\, U+0008/0009/000A/000C/000D →\b \t \n \f \r, other control characters below U+0020 →\u00xxwith lowercase hex. Everything else, including U+007F, U+2028, U+2029 and all non-ASCII, is emitted as raw UTF-8. No\/, no\ufor non-ASCII. - No whitespace anywhere.
Duplicate keys. A signed object with the same key twice at any level has no canonical
form. Parsers that keep the last value would silently sign different bytes than parsers
that keep the first. Implementations MUST reject it. This means parsing with a
duplicate-detecting hook, not the language default. A verifier reading bundle text treats a
duplicate key or __proto__ (§3.1) anywhere in it as fatal, since the text has no single reading, but
parses a forbidden number and leaves it to §9 step 2, so it sinks only the item that carries it.
Invalid UTF-8 (raw_invalid_utf8). JSON text is UTF-8 (RFC 8259 §8.1). A document that
is not valid UTF-8 is rejected whole; an implementation MUST decode fatally. A lossy decode
turns the bad bytes into U+FFFD and sinks only the item whose signature then fails, while a
byte-level parser rejects the document: two verifiers, two answers. A leading byte-order mark
is not JSON whitespace and is rejected the same way. This is not a vector, because
test-vectors.json is itself UTF-8 text; a \ud800 escape is valid UTF-8 and stays per item (§3.1).
Nesting depth (raw_fatal_depth_513_in_claims, raw_depth_512_in_claims). A parser MUST
reject a document whose arrays and objects, combined, nest deeper than 512 levels (the
outermost container is level 1), as a parse error: the whole document is rejected, wherever
the deep value sits — in claims too, where a malformed value would sink only its item —
because the limit is on the text, like a duplicate key. The error is reported at the bracket
that opens level 513, an empty container included. A canonicalizer MUST refuse a value nested
deeper than 512 (no conforming parser returns one; an object built in memory can be one, and
then it is malformed like a float, per item where it sits). Rationale: a recursive parser has
a finite stack, and in Go exhausting it is a fatal runtime error that recover() cannot catch —
a 1.6 MB document killed every process embedding the reference verifier, while an iterative
parser answered. A bounded verifier must bound depth, and two verifiers that bound it at
different places give two answers for the same bytes. 512 leaves a bundle's claims 507 levels.
Envelopes. Signed objects travel as:
{ "body": { … }, "sig": "z…" }
Bindings carry sig_id and optionally sig_addr instead of sig. Rotations additionally
carry sig_next (§7) and next_genesis. Nothing in the envelope outside body is signed, but the rules above
apply to the whole envelope: a float anywhere in it makes the item malformed (§9 step 2), and
so does a key outside its members (§3.1).
3.1 Fields, normatively
typ | required | optional |
|---|---|---|
genesis | v typ key recovery created nonce | — |
attestation | v typ iss sub iat exp ctx admission claims | admission_by admission_cost |
binding | v typ id method addr iat exp nonce | — |
rotation | v typ id next iat reason | recovery_key (required iff reason is recovery, forbidden otherwise) |
challenge | v typ did ctx nonce | — |
invoice | v typ did method addr iat exp nonce | amount (string, atomic units) memo |
bundle | v typ genesis rotations bindings attestations issuers | — |
No other top-level keys. A body carrying a key not in its row is malformed. claims is
the one free-form value and may hold anything JCS can serialize. Envelopes are part of the
same rule, both ways: an envelope is exactly its defined members — a rotation envelope body,
sig, sig_next and next_genesis; a binding envelope body, sig_id and optionally sig_addr; an
attestation envelope body and sig — with sig, sig_next and sig_id strings. An envelope missing
one, or carrying any other key, is malformed in the same class as its body (§9 step 2): fatal
for a rotation (rotation: unknown envelope field "…"), the item discarded and counted for an
attestation or binding (vectors attestation_envelope_extra_key_int,
attestation_good_and_envelope_extra_keys, binding_envelope_extra_key,
fatal_rotation_envelope_extra_key; binding_envelope_sig_id_only_unproven is the optional
member absent). Nothing outside body is signed, so an extra member is data no signature
authenticates, exactly like an unknown body field, and a verifier that ignored it would accept
what a stricter one discards. A holder that receives an item with extra members (a world whose
router adds a clock, say) keeps only the defined ones before bundling it; the signature does
not cover the rest, so dropping them changes nothing that verifies. The bundle itself is the
bundle row above; a §5.2 challenge answer or §6.3 invoice exchanged as {body, sig} follows
the same rule. v is "sigelo/0"; iat, exp are Unix seconds; created is RFC 3339 UTC in exactly the form §4 fixes.
Field types. iat and exp are JSON integers in [0, 2^53−1], and exp > iat wherever
both appear. Every other field in the table is a string, except recovery (string or null,
§4), claims (free-form) and the bundle's own genesis and four arrays. A string anywhere in
a signed object MUST be a sequence of Unicode scalar values: a lone surrogate (legal as a JSON
\u escape) is malformed, since RFC 8785 requires I-JSON and an encoder that replaced it with
U+FFFD would give two bodies one signing input. Noncharacters (raw_fatal_noncharacter_in_claims_value,
raw_fatal_noncharacter_astral_in_claims_key): RFC 7493 §2.1, which RFC 8785 cites, also
forbids them, so a parser MUST reject a string or key holding U+FDD0–U+FDEF or U+xFFFE /
U+xFFFF in any plane, raw or escaped (an escaped surrogate pair counts as the character it
spells), as a parse error — fatal to the document, reported at the string's opening quote:
noncharacter U+FFFF in string at offset N. A canonicalizer MUST refuse one in a value built
in memory (noncharacter U+FFFF in string), so a conforming library never signs a body no
conforming parser will read. The object key __proto__ is malformed at any
depth: a JavaScript parser that assigns it replaces the object's prototype instead of adding a key.
A type failure is malformation like any other (§9 step 2), never an implementation error.
4. Genesis and identity
An identity is its genesis document. The DID is a hash of it, so nothing inside can be revised afterwards — including the recovery commitment.
{
"v": "sigelo/0",
"typ": "genesis",
"key": "z6Mk…",
"recovery": "sha256:2c5a92ed…",
"created": "2026-09-07T00:00:00Z",
"nonce": "z…"
}
| Field | Meaning |
|---|---|
key | multibase Ed25519 public key — the identity signing key |
recovery | sha256: + hex SHA-256 of the raw 32-byte recovery public key, or null. Exactly sha256: and 64 lowercase hex digits: a verifier MUST reject anything else (genesis: recovery is neither null nor sha256: + 64 lowercase hex), fatally, as in every genesis slot (vectors fatal_genesis_recovery_uppercase_hex, fatal_genesis_recovery_prefix_only). Uppercase hex is the same digest spelled so that no recovery key ever matches it: recovery silently off |
created | RFC 3339 UTC, Z, second precision. Self-asserted and unverifiable; informational only. Its form is checked: see below |
nonce | 16 bytes, multibase. Distinguishes genesis documents that share a key. Random by default; a world with a stable key MAY derive it from the key (e.g. the first 16 bytes of SHA-256 of the raw public key) so its genesis is reproducible without storage; then created MUST be pinned too, since every field is hashed. Uniqueness is what matters, not unpredictability: nothing secret is derived from it |
DID = "did:sigelo:" + multibase_z( SHA-256( JCS(genesis) ) )
created, exactly (fatal_genesis_created_leap_second and its neighbours). A verifier
MUST reject a genesis whose created is not exactly YYYY-MM-DDTHH:MM:SSZ: four-digit year,
a real Gregorian date (30 April, 29 February only in a leap year), hours 00–23, minutes and
seconds 00–59 (no leap second: nothing offline can check one), no fraction, no offset,
uppercase T and Z. The reason is genesis: created is not RFC 3339 UTC (YYYY-MM-DDTHH:MM:SSZ).
Every genesis slot defines an identity (§9 step 2), so this is fatal wherever a genesis sits:
the bundle's own, a next_genesis, an issuer. The value is hashed into the DID and read by
nobody, but a field no one checks is a field two implementations parse differently the day
one of them starts to read it.
Verifiers MUST recompute the DID from the presented genesis and reject on mismatch. First step, every time, not optional. Verifiers MUST compare full DIDs — never prefixes — and UIs MUST NOT truncate them; base58 vanity grinding against a truncated display is cheap.
recovery: null is legal and means theft of the identity key is terminal. Libraries
MUST warn at generation. Worlds MAY refuse attestations to such identities.
Recovery key handling. Generated offline, never loaded into an agent runtime. Only its hash is public until it is used (§7). An attacker with full agent compromise learns a hash.
5. Attestations
One world's signed statement about one identity.
{
"v": "sigelo/0",
"typ": "attestation",
"iss": "did:sigelo:z…",
"sub": "did:sigelo:z…",
"iat": 1757203200,
"exp": 1764979200,
"ctx": "1f916.ai",
"admission": "invite",
"admission_by": "did:sigelo:z…",
"claims": { "joined": "2026-04-02", "posts": 412, "standing": "citizen" }
}
claims is world-defined and opaque to sigelo. Verifiers interpret it according to how
much they trust iss. admission_by is informational; verifiers are not required to resolve it.
admission_by and admission_cost (§5.1) are optional; every other field shown is required.
The signature is verified against the key in the genesis whose DID is iss. A world that
has itself rotated issues new attestations under its new DID; old attestations still verify
against the old genesis. Verifiers do not walk issuer chains in v0.1. So, by design, a key a
world rotated away from still makes attestations that verify under the old DID, whatever
their iat, until each one's exp: nothing in a bundle says the old DID was retired, and a
verifier that knows it was (from the world, out of band) stops trusting that DID itself (THREAT-MODEL
§3.2).
exp is mandatory. There is no revocation list — freshness comes from reissuance.
Recommended lifetime 30–90 days. To signal lost standing, reissue with claims changed.
5.1 Admission taxonomy
admission records what it cost the subject to enter. It is what makes a population
count carry information.
| Value | Meaning |
|---|---|
open | no barrier |
captcha | automated challenge only |
invite | vouched by an existing member; admission_by names them |
payment | money was paid; admission_cost MAY carry a string amount |
human | a human identity was verified by the issuer |
stake | a slashable bond is held |
admission MUST be one of these six values; a verifier discards an attestation carrying any
other as malformed (§9 step 2). New values arrive with a new wire version, not silently.
Issuers MUST NOT overstate. The only remedy for a lying issuer is that verifiers stop
trusting it, which is the correct remedy. A verifier can then read a population of 2,000 as,
say, 1,847 open and 153 invite — a signal, where a raw count was not.
5.2 Proof of control
Before a world attests to a DID it needs the agent to demonstrate it holds the key. Every world would otherwise invent its own handshake, so this one is fixed:
{ "v": "sigelo/0", "typ": "challenge", "did": "did:sigelo:z…", "ctx": "1f916.ai", "nonce": "…" }
These five fields and no others: an agent library MUST refuse a challenge carrying any
additional key, so nothing can be smuggled into the signed bytes. The world chooses nonce
(opaque to the agent, bound by the world to the requesting session and to a short lifetime)
and ctx; the agent fills did with its current DID and
signs the §3 signing input with the identity key; the world recomputes the DID from the
presented genesis, compares full strings, and verifies the signature against genesis.key.
A challenge never appears in a bundle and no bundle slot accepts typ: "challenge", so a
challenge signature cannot be replayed into any other slot. Agent libraries SHOULD refuse to
sign a challenge whose did is not their own. Vector challenge.
6. Payment bindings
Proves that an identity and a payment address share an operator. Cross-signed: both keys sign the identical signing input.
{
"v": "sigelo/0",
"typ": "binding",
"id": "did:sigelo:z…",
"method": "monero",
"addr": "8Bx…",
"iat": 1757203200,
"exp": 1764979200,
"nonce": "z…"
}
Envelope carries sig_id (identity key) and sig_addr (payment key, per-method format).
One-sided signatures are insufficient:
- identity-only proves the identity claims the address — anyone can claim anyone's
- address-only proves wallet control, not that the identity endorsed it
6.1 Proof status
Every binding the verifier returns carries exactly one of four statuses:
proof | Meaning |
|---|---|
proven | sig_id valid and sig_addr present and valid for method |
unproven | sig_id valid, sig_addr absent — the identity claims the address |
unsupported | sig_id valid, sig_addr present, verifier has no routine for method |
superseded | any of the above, but id comes before the most recent recovery in the chain |
Superseded (wire change of 2026-10-19) (vectors bundle_recovered, negative.parity.superseded_binding_after_recovery,
superseded_binding_backdated, superseded_monero_binding_after_recovery). A recovery rotation
says the key before it was stolen; whatever that key signed may name the thief's address. So a
binding whose id precedes, in chain, the DID the most recent valid recovery rotated into is
superseded, whatever its status would otherwise be, and is never paid. The rule is positional in
the chain, never by iat: the thief signs with any iat, so a backdated binding is superseded too.
A voluntary rotation supersedes nothing (binding_before_voluntary_rotation_proven,
binding_before_voluntary_after_recovery_proven): it implies no theft, bindings live 30–90 days
and invoices are minted by the current key anyway (§6.3), so a head-only rule would cost every
rotation a rebinding and defend against nothing a voluntary rotation reveals. A key stolen without
a recovery is undefended by either rule, which is what recovery is for. A superseded binding is
still checked: a bad sig_addr discards it as below.
Where a payment method has no practical message-signing path, sig_addr MAY be omitted.
The binding is then an unproven claim, whatever the method; unsupported applies only
when a sig_addr is present. Verifiers MUST report the status in the return
type, not as a boolean, and MUST NOT send funds to any address whose status is not proven
(superseded included).
Keep exp short on unproven bindings.
A binding whose sig_id fails, or whose sig_addr is present but invalid for a method
the verifier does support, is discarded, not downgraded. A bad proof is not the same thing
as no proof.
6.1a Method ed25519-test
addr is a multibase Ed25519 public key (§2 encoding) and sig_addr is an ordinary §3
signature by that key. The method exists so the cross-signing rule can be exercised in the
vectors without a wallet. Conformant implementations MUST support it. It carries no payment
semantics and worlds SHOULD NOT accept it as a real binding. Its counterpart opaque-test
is a method no implementation supports; it exists to exercise the unsupported status.
6.2 Monero
method: "monero". addr is a standard (base) address varint(prefix) ‖ B ‖ A ‖
checksum (prefix 18 mainnet, 24 stagenet, 53 testnet) or a subaddress varint(prefix) ‖
D ‖ C ‖ checksum (prefix 42 mainnet, 36 stagenet, 63 testnet), in Monero base58. Integrated
addresses are not accepted as addr: the hash below does not cover the prefix or the payment
id, so the base address's signature verifies for every integrated spelling of it and a payment
id nobody signed for would ride along. sig_addr is a Monero message signature over the
address's own two keys — (B, A) for a standard address, (D, C) for a subaddress:
h = Keccak-256("MoneroMessageSignature\0" ‖ S ‖ V ‖ mode ‖ varint(len) ‖ signing_input)
sig = c ‖ r, c = H_s(h ‖ P ‖ kG), r = k − c·x (P, x) = (S, s) spend mode 0, (V, v) view mode 1
wire = "SigV2" ‖ monero_base58(sig)
standard: (S, s) = (B, b) (V, v) = (A, a)
subaddress: (S, s) = (D, b + m) (V, v) = (C, a·(b + m))
m = H_s("SubAddr\0" ‖ a ‖ le32(major) ‖ le32(minor)), D = B + mG, C = a·D
where signing_input is §3's bytes, H_s(x) = sc_reduce32(Keccak-256(x)) with original
Keccak padding, and verification recomputes R' = c·P + r·G and checks
H_s(h ‖ P ‖ R') = c (monero src/wallet/wallet2.cpp get_message_hash, sign;
src/crypto/crypto.cpp check_signature). Verifiers MUST accept either mode and SHOULD
report which one. Legacy SigV1 is not accepted. Both keys in addr MUST decode as Monero's
check_key decodes them (ge_frombytes_vartime: y < p, and not x = 0 with the sign bit set), or
the binding is not proven, whichever mode signed. Neither key may be of small order, the identity
included (wire change of 2026-10-19): check_key accepts such a point, but then c·P carries no secret and a
signature in the mode that uses it is made with no key at all; a verifier MUST discard the binding
(vectors negative.parity.monero_view_key_small_order, monero_spend_key_identity).
(The subaddress row is wallet2::sign for a non-zero index.) A binding whose SigV2 verifies
against its addr's own keys, in either mode, is proven; one whose signature was made with
another address's keys — a subaddress signed with the base (B, A), say — is discarded.
View mode is the intended mode for a standard address. A view-only wallet holding
(a, B) produces it (through monero-wallet-rpc sign with signature_type: "view" at
index (0,0)), so an agent binds its wallet without ever holding a spend key. The signature
proves "I can see this wallet", which is exactly what a payer needs the receiver to be able to
do. For a subaddress, view mode does not imply a view-only signer: both of its secrets
are derived from b, so a view-only wallet cannot produce either mode, and a subaddress
binding is made by whoever holds the spend key (a keeper, MONERO.md §3).
The hash does not cover the network prefix. One key pair's mainnet, stagenet and testnet
addresses verify the same signature. A payer MUST check that addr decodes to the network it
expects before paying a proven binding. verify reports it and does not refuse (wire change of 2026-10-19): a
proven monero entry of §9.1 carries network (mainnet, stagenet or testnet, from the
prefix of addr), and no other entry does; only the caller knows which network it pays on.
6.3 Invoices
A binding names a wallet; an invoice names where to pay this time. Signed by the identity key, exchanged bilaterally, never in a bundle:
{ "v": "sigelo/0", "typ": "invoice", "did": "did:sigelo:z…", "method": "monero",
"addr": "7…", "iat": 1757203200, "exp": 1757289600, "nonce": "z…", "amount": "150000000000" }
addr is a receive address of the bound wallet, for Monero a fresh subaddress per
counterparty per invoice. The payer checks: the signature against the identity key of did,
iat ≤ now < exp, that did is the did of the §9.1 result (the chain's current DID) of a
bundle it has verified, and that the result has a proven binding for the same method.
An invoice by an earlier DID is refused (wire change of 2026-10-19): after a recovery it is the thief's, the same
case as a superseded binding (§6.1), and an invoice is per payment, so unlike a binding nothing
is lost by requiring the current key; the result names the chain's head and nothing finer. sigelo cannot prove a subaddress belongs to the bound wallet (that needs the
view key); the identity's signature is the claim, the binding is its anchor, and a payment
to an address the identity did not sign for is the payer's own mistake. amount is a string
of atomic units or absent; memo is free text and, like claims, untrusted data.
Selective disclosure. Monero has no per-subaddress view key: one private view key
covers every subaddress of a wallet, and disclosing it is retroactive and irrevocable. The
primitives are per-payment proofs (get_tx_proof, get_reserve_proof) and one wallet per
relationship whose view key is meant to be shared, all derived from one root seed. See
MONERO.md. Libraries MUST NOT automate view-key disclosure; provide the primitive, make the
caller invoke it deliberately. Bindings, invoices and proofs are what get automated.
7. Rotation and recovery
{
"v": "sigelo/0",
"typ": "rotation",
"id": "did:sigelo:<current>",
"next": "did:sigelo:<new>",
"iat": 1760227200,
"reason": "voluntary",
"recovery_key": "z6Mk…"
}
Envelope carries next_genesis; verifiers MUST check hash(next_genesis) == next.
next MUST differ from id; a self-rotation is structurally invalid.
Countersigned (wire change of 2026-10-19) (vectors negative.parity.graft_voluntary_into_foreign_genesis,
graft_recovery_into_foreign_genesis, fatal_rotation_missing_sig_next,
rotation_bad_sig_next_not_a_candidate). The envelope also carries sig_next: a §3 signature over
the same body by next_genesis.key, whatever the reason, the cross-signing rule of bindings (§6).
Without it a genesis that copies a victim's public recovery commitment rotates into the victim's
genesis, voluntarily or by its own recovery key, and the chain inherits every attestation and
binding of the victim under a chain[0] that is not the victim's. With it, every DID after
chain[0] signed its own entry into the chain, so the graft needs the victim's key, and a thief
who holds that key controls the identity anyway until the recovery; the recovery's next key is the
owner's, so after it a §5.2 answer for the head (§12.3) fails for the thief. That is why
chain[0] stays the chain's name (§9 step 1, §12.3): proof of control at the head alone would
leave an offline reader of a bundle, who asks no challenge, with the graft.
voluntary — signed by the current identity key, countersigned by the next. recovery_key absent.
Constraint: next_genesis.recovery MUST equal the current recovery commitment. A
voluntary rotation that changes the commitment is not a candidate (§7.4): it is never
followed, and its presence does not by itself reject the chain. This is what stops an
attacker with a stolen key from installing their own recovery key.
recovery — signed by the recovery key, countersigned by the next identity key. recovery_key present; SHA-256(raw key) MUST
equal the current recovery commitment (§7.2). next_genesis MAY carry a new commitment,
or null, which retires recovery permanently: no later recovery rotation can validate.
7.1 Precedence
At any node, a valid recovery rotation supersedes any voluntary rotation, regardless of
iat.
An attacker with a stolen key produces a perfectly valid voluntary rotation. The operator
with the offline recovery key overrides it — even if the attacker's rotation is newer, even
if it happened months earlier. Never reorder by timestamp. Vector rotation_recovery
deliberately carries an earlier iat than both hostile rotations.
Two hostile vectors exist because two rules defend this node. rotation_hostile also
changes the recovery commitment and is rejected by §7 before precedence is ever consulted.
rotation_hostile_carried carries the commitment forward and is a fully valid voluntary
rotation; only this rule defeats it. An implementation that skips precedence passes the
first and fails the second (vector chain_precedence_only).
7.2 Where recovery authority lives
The governing commitment is the one in the most recent recovery-signed genesis in the
chain, or the original genesis if there has been no recovery. Voluntary rotations carry it
forward unchanged (enforced above). Only a recovery rotation can change it — so the
operator can retire a recovery key, and an attacker never can. Retiring governs the nodes
after the recovery only: the retired key still governs every node up to and including the one
it was retired at, so it must be destroyed, not just replaced (vectors
bundle_retired_recovery_at_genesis, bundle_retired_recovery_later_iat; THREAT-MODEL §2.5a).
7.3 Chain rules
Each DID in the chain is rotated from at most once. At a node:
- Collect rotations whose
idis this node. - Among them, the valid recovery rotations (signature,
sig_next, commitment,nexthash all check; §7.4 lists what disqualifies one): if any, take the one with the latestiat: whoever holds a recovery key that governs here signed each of them, the operator unless that key leaked, retired or not (§7.2). If two share that latestiat→ REJECT the chain; that is operator error and the fix is to reissue (vectornegative.recovery_tie). - Otherwise, the valid voluntary rotations (signature,
sig_next,nexthash, commitment unchanged); invalid ones are not counted: exactly one → follow it. More than one → REJECT the chain. A fork under a single key is a compromise signal; the remedy is a recovery rotation, not verifier guesswork. Two entries are two candidates even when byte-identical: a bundle MUST NOT carry the same rotation twice, and a verifier does not deduplicate (vectornegative.parity.fatal_duplicate_rotation_is_fork). - None → chain ends here.
- Before following the chosen rotation: if
nextis already in the chain → REJECT the chain. A rotation back to an earlier DID is a cycle. Only a key holder can produce one, it has no legitimate meaning, and a verifier that follows it never terminates. Fail closed rather than loop (vectornegative.cycle).
The chain is walked from the original genesis until step 4 ends it. Because every step
consumes one rotation whose id is the current node and every next is new, the walk
terminates in at most len(rotations) steps. Rotations that were valid but not chosen
(a voluntary rotation superseded by a recovery) are simply not followed; the advice below on
discounting attestations near a recovery is how a verifier accounts for them.
7.4 Two outcomes, two words
A rotation that fails a check is either not a candidate (ignored at its node; the walk continues as if it were absent) or it REJECTs the chain (fatal; the bundle does not verify). Nothing in between.
| Failure | Outcome |
|---|---|
| signature does not verify | not a candidate |
sig_next does not verify under next_genesis.key (wire change of 2026-10-19) | not a candidate |
hash(next_genesis) ≠ next | not a candidate |
voluntary, next_genesis.recovery ≠ current commitment | not a candidate |
recovery, SHA-256(recovery_key) ≠ current commitment (wrong or stale key) | not a candidate |
recovery while the current commitment is null (vector bundle_recovery_null_commitment) | not a candidate |
body or next_genesis malformed, sig, sig_next or next_genesis missing (§3.1) | REJECT (structure, §9 step 2) |
| two valid voluntary rotations at one node | REJECT (fork) |
two valid recovery rotations sharing the latest iat | REJECT (tie) |
chosen next already in the chain | REJECT (cycle) |
A "not a candidate" rotation may still be a thief's artifact; that is what the advice on
discounting is for. Vectors: negative.rotation_bad_sig, negative.recovery_key_mismatch,
negative.stale_recovery_key and negative.voluntary_changes_recovery are all "not a
candidate" cases and each states the chain that results.
Reputation follows the chain: attestations to any prior DID apply to the current one, before a
recovery too (recovery_new_did_binding_proven): keeping them is what recovery is for. Payment
does not: bindings by a DID before the most recent recovery are superseded (§6.1). After
a recovery, the prior key was compromised for an unknown window. Verifiers SHOULD discount
attestations to the compromised DID with iat near the recovery, and SHOULD treat an
attestation issued to a DID after it was rotated away from as suspect. sigelo cannot
determine when compromise began; only the issuing world can.
iat everywhere is signer-asserted. Time-based logic is advisory unless the signer is trusted.
8. Bundles
{
"v": "sigelo/0",
"typ": "bundle",
"genesis": { … },
"rotations": [ { "body": …, "sig": …, "next_genesis": … } ],
"bindings": [ { "body": …, "sig_id": …, "sig_addr": … } ],
"attestations": [ { "body": …, "sig": … } ],
"issuers": [ { …genesis… }, … ]
}
genesis is the original. Bundles are unsigned; every element carries its own signature.
All four arrays are required and MAY be empty.
issuers carries the genesis documents of the worlds whose attestations appear in the
bundle. It is what makes an attestation from a world the verifier has never heard of
verifiable offline (§1.1). The array holds bare genesis documents, not a DID-keyed map:
the verifier derives each DID by hashing, so there is no key/value pair that could
disagree. A verifier MAY also know issuer genesis documents from elsewhere (its own, or a
locally pinned set); the bundle's copies never override those. An attestation whose iss
matches no presented and no known genesis is discarded in §9 step 4, not fatal to the bundle.
9. Verification algorithm
In this order. Fail closed. Every input ends in a result or in a rejection that names its check; running out of stack or arguments on a large but legal bundle is neither, and a verifier MUST NOT let one decide the outcome (§3 bounds nesting for the same reason).
Input: a bundle and now (Unix seconds). The verifier takes now as a parameter rather
than reading a clock, so results are reproducible and testable.
- Genesis. Check
bundle.genesisstructurally and compute its DID. This is the root of the chain; nothing else in the bundle may name the identity except by this hash. The algorithm takes no expected DID: a caller that has one (a login claim) compares it, in full, againstchain[0]ordidof the result, and treats a mismatch as a failed claim. Vectornegative.genesis_tamperedis that comparison. Matchingchain[0]names the chain; control of it is a §5.2 answer fordid, the head, never for an earlier DID. - Structure. A body is malformed if it has a non-integer number, a duplicate key, an
unknown
v, a missing required field, a top-level key outside its §3.1 row (or an envelope key outside its members, §3.1), atypnot matching its slot, or a field value outside its definition (anadmissionnot in §5.1, a rotation whosenextequals itsid). Malformation in anything that defines the identity is fatal to the bundle: the bundle's own shape,genesis, every rotation body andnext_genesis, every entry inissuers. Malformation anywhere in an individual attestation or binding (body or envelope, a non-integer number or lone surrogate included) discards that item and counts it inrejected, exactly as a bad signature would; the other items still verify. The presenter chose to include it, but an issuer wrote it; one world's bug must not sink its members' bundles. - Chain. Apply §7.3 from the original genesis. Output: current DID, ordered chain of DIDs, governing recovery commitment, and the position in the chain of the DID the most recent chosen recovery rotation rotated into (0 if none). Reject on fork, on cycle, or any structural failure.
- Issuers. Hash each document in
bundle.issuersto its DID. Add to the set of known issuer genesis documents; a locally known genesis for the same DID is kept in preference to the presented one (they are identical if both are honest). - Attestations. Each: resolve
issto a known genesis (step 4), verify signature against itskey, checkiat ≤ now < exp, checksub∈ chain. Discard failures individually — one bad attestation does not sink a bundle. - Bindings. Verify
sig_idagainst the identity key of the DID inid(must be ∈ chain). Checkiat ≤ now < exp. Verifysig_addrif present, per method. Tag proof status per §6.1; thensupersededifidis earlier in the chain than the position of step 3 (wire change of 2026-10-19); aprovenmoneroentry also names itsnetwork(§6.2). Discard failures individually. - Return the result below. No scores. No ranking. Weighting is the caller's job.
9.1 Result
{
"did": "did:sigelo:<current>",
"chain": [ "did:sigelo:<original>", …, "did:sigelo:<current>" ],
"recovery": "sha256:…",
"attestations": { "did:sigelo:<iss>": [ { …attestation body… }, … ] },
"bindings": [ { "body": { …binding body… }, "proof": "proven" },
{ "body": { …a monero binding… }, "proof": "proven", "network": "stagenet" } ],
"rejected": { "attestations": 2, "bindings": 0 }
}
bindings holds accepted bodies with their proof status, in bundle order, and network on a
proven monero entry only. attestations holds accepted attestation bodies verbatim, grouped by iss, in bundle
order within each issuer. The same attestation presented twice is accepted twice and listed
twice: a verifier does not deduplicate here any more than it does rotations (§7.3) — every
copy verifies, and it reports what was presented — so a caller that counts attestations counts
distinct ones. Key order of that object is informative only; conformance is
compared by value, and an implementation whose objects are unordered is conformant.
recovery is the governing commitment, null if the identity has none. rejected counts
what steps 2, 5 and 6 discarded. Implementations MAY attach per-item reasons alongside;
the fields above are the conformance surface, network included (vectors bundle,
bundle_recovered, compared as JSON).
10. Test vectors
test-vectors.json: real Ed25519 signatures from documented seeds. Positive groups
include a four-node chain with two hostile rotations defeated by an earlier recovery, a
recovery that changes the commitment followed by a second recovery under the new key, an
attestation whose claims exercise the JCS rules of §3, and a full bundle with its
expected §9.1 result at a fixed now. Negative cases include missing domain prefix, typ
mismatch, stale recovery key, voluntary rotation changing the commitment, a fork, a cycle,
a duplicate key, an integer outside ±2^53−1, an unknown top-level field, and a rotation with a
bad signature. invoice and challenge are the two signed objects that never enter a bundle. A second bundle, bundle_minimal, is the smallest thing that verifies: one
genesis with recovery: null, four empty arrays. A third, bundle_recovered, is the stolen key
after a recovery: its bindings superseded, a voluntary rotation's not, network reported.
Conformant = every positive vector reproduced byte-for-byte, every vector carrying a bundle
and expect reproduced as a §9.1 result compared by value, every negative rejected for the stated reason. The rotation_recovery
versus rotation_hostile_carried pair is the one that matters.
11. Non-goals for v0.1
Trust scoring · revocation lists · encryption · discovery · personal-data handling in
claims (see THREAT-MODEL §6) · algorithm agility · plugin systems.
12. DID method did:sigelo
§2–§9 in the form of a DID method specification (W3C DID Core v1.0 §8, Recommendation of
19 July 2022; the w3c/did-extensions registry and its review checklist). §12 adds no rule
to sigelo/0 and changes no verdict of §9; where it seems to disagree with §2–§9, they
govern. It defines the DID document and metadata a resolver builds from a §9 result. The key
words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, NOT
RECOMMENDED, MAY and OPTIONAL in §12 are to be interpreted as described in BCP 14 (RFC 2119,
RFC 8174) when, and only when, they appear in all capitals.
A did:sigelo DID names one AI agent's identity: the SHA-256 of its genesis document (§4).
It is created offline, resolved by verifying a bundle the agent presents (§8, §9), updated by
rotation (§7), and kept through a stolen identity key by a recovery key committed at creation.
Method name: sigelo, wire sigelo/0 (VERSIONING.md).
Target system: none. No ledger, registry or resolver service exists; the verifiable data
is the §8 bundle, carried by the subject and verified offline (§1.1).
Authorization (DID Core §8.2).
| Operation | Authorized by |
|---|---|
| Create | no one: any party with an Ed25519 key pair creates a DID (§12.2) |
| Read | no one: any party holding the bundle resolves (§12.3) |
| Update | sig by the head's identity key (voluntary) or by the recovery key whose hash is the governing commitment (recovery), and sig_next by the new identity key (§12.4) |
| Deactivate | not an operation of sigelo/0 (§12.5) |
Bundle. Every operation reads or writes the §8 bundle, a JSON object of exactly v
("sigelo/0"), typ ("bundle"), genesis (the original genesis) and the arrays
rotations, bindings, attestations and issuers, each possibly empty. "A bundle of
genesis G and rotations R" below has genesis G, rotations R and the other three arrays
empty. A rotation vector in test-vectors.json carries keys beside its envelope
(expect_next_did, note); a bundle takes only body, sig, sig_next and
next_genesis (§3.1).
12.1 Syntax
ABNF (RFC 5234, with RFC 7405 %s for case-sensitive strings):
sigelo-did = %s"did:sigelo:" sigelo-id
sigelo-id = %x7A 32*44base58-char ; "z", the multibase prefix of base58btc
base58-char = %x31-39 / %x41-48 / %x4A-4E / %x50-5A / %x61-6B / %x6D-7A
; the base58btc (Bitcoin) alphabet:
; 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
sigelo-id is z + base58btc of the 32-byte SHA-256 of JCS(genesis), no multicodec prefix
(§2, §4): 32 digits (all-zero digest) to 44. The id is case-sensitive and has no
normalization: two DIDs are equal only as identical strings (§4). It has no : and needs no
percent-encoding. A DID URL carries no path or query; its fragment names a verification
method, and <did>#<key> dereferences to the entry of verificationMethod with that id
(§12.3). Any other DID URL is notFound.
12.2 Create
Inputs.
- An Ed25519 identity key pair (§2, RFC 8032), generated by the agent.
- A recovery public key, generated offline (§4), or none.
created, RFC 3339 UTC in the §4 form, and a 16-bytenonce(§2, §4).
Steps.
- Encode the identity public key: multicodec
0xed01‖ the 32 raw bytes, multibase base58btc (§2). This iskey. - Commit to the recovery key:
sha256:‖ lowercase hex of SHA-256 of its raw 32 bytes, no multicodec prefix (§4). With no recovery key,null; the library MUST warn (§4). - Encode the nonce:
z‖ base58btc (§2). - Write the genesis
{v: "sigelo/0", typ: "genesis", key, recovery, created, nonce}. It MUST have these six members and no other (§3.1) and MUST pass §2 and §4 (keya valid point,createdandnoncein form). - JCS-serialise the genesis (§3: RFC 8785, keys ordered by UTF-16 code units, no whitespace), UTF-8.
- Compute SHA-256 of those bytes.
- Encode the 32-byte digest multibase base58btc, no multicodec prefix (§2).
- Prefix
did:sigelo:.
Nothing is signed, published or registered.
Outputs. The DID (§12.1) and the genesis, which the agent keeps: it is the genesis of
every bundle it presents. The identity secret stays with the agent, the recovery secret
offline.
Errors. No resolution error applies. Every verifier rejects a genesis that fails step 4 (§9 step 1); the reference libraries refuse to create one.
Example (vector genesis). Inputs: the key pairs of seeds agent and recovery (32-byte
RFC 8032 private keys, seeds of test-vectors.json); created 2026-09-07T00:00:00Z;
nonce 16 bytes a1. Step 1 gives z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG. The
recovery public key is z6MknGc3ocHs3zdPiJbnaaqDi58NGb4pk1Sp9WxWufuXSdxf (the recovery_key
of vector rotation_recovery); step 2 gives
sha256:2c5a92ed92c0b7999f215be93c8f0433f58072bdba21a8b277faa495b57bf7f3. Step 3 gives
zLxcqwJdGqcLsrCWP55q8LQ. Step 5:
{"created":"2026-09-07T00:00:00Z","key":"z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG","nonce":"zLxcqwJdGqcLsrCWP55q8LQ","recovery":"sha256:2c5a92ed92c0b7999f215be93c8f0433f58072bdba21a8b277faa495b57bf7f3","typ":"genesis","v":"sigelo/0"}
Step 6: d11a62cb8eba30848a945cbe9425027f66ac752b18e67ef418989d2f187a06df. Steps 7–8, the
vector's expect_did: did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG.
sigelo-verify on a bundle of this genesis and no rotations, --now 1757289600, prints:
{"attestations":{},"bindings":[],"chain":["did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG"],"did":"did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG","recovery":"sha256:2c5a92ed92c0b7999f215be93c8f0433f58072bdba21a8b277faa495b57bf7f3","rejected":{"attestations":0,"bindings":0}}
12.3 Read (resolve)
resolve(did, resolutionOptions) → didResolutionMetadata, didDocument,
didDocumentMetadata, and resolveRepresentation, which returns didDocumentStream in
place of didDocument (DID Core §7.1). Resolution makes no network request: the resolver
verifies every signature itself, so the result is as authentic as the bundle's signatures
(§12.6), whoever delivered the bundle.
Inputs.
did, the DID to resolve.resolutionOptions.bundle, the §8 bundle the subject presents, as bytes: a method-specific option (DID Core §7.1.1). It is REQUIRED; a resolver with its own interface MAY take it as an argument besidedid.now, Unix seconds (§9); the resolver's clock if the caller gives none. It selects attestations and bindings (§9 steps 5–6), never the document.- OPTIONAL: locally known issuer genesis documents (§8). They change attestations, never the document.
resolveRepresentationonly, OPTIONAL:resolutionOptions.accept, a media type.
Steps.
- If
diddoes not match §12.1, the resolver MUST returninvalidDid. - Parse the bundle (§3: fatal UTF-8 decode, no duplicate key, no
__proto__, depth ≤ 512, no noncharacter). On a parse error the resolver MUST returnnotFound. - Run §9 at
now. Its steps 1–3 can REJECT: the bundle's shape,genesis, every rotation and everyissuersentry checked against §3.1 and §2–§4 (§9 step 2), and the walk of §12.4's verifier steps from the DID ofbundle.genesis(§12.2 steps 5–8). On a REJECT the resolver MUST returnnotFound. Steps 4–6 discard items and never REJECT. - If
didis not in the result'schain, compared as full strings, the resolver MUST returnnotFound. - Take the head, the result's
did(last inchain), and its genesis: the one,bundle.genesisor a rotation'snext_genesis, whose DID (§12.2 steps 5–8) is the head.<key>is itskey, verbatim. - Build
didDocumentbelow;<did>is the inputdid, not the head. - Build
didDocumentMetadataanddidResolutionMetadatabelow. ForresolveRepresentation: ifacceptis present and is notapplication/did+ld+json, returnrepresentationNotSupported; otherwisedidDocumentStreamisdidDocumentserialised as JSON, UTF-8.
Outputs.
{ "@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1"],
"id": "<did>",
"verificationMethod": [{ "id": "<did>#<key>", "type": "Multikey",
"controller": "<did>", "publicKeyMultibase": "<key>" }],
"authentication": ["<did>#<key>"] }
| Field | Source |
|---|---|
didDocument.@context | constant |
didDocument.id, verificationMethod[0].controller | the input did |
verificationMethod[0].id, authentication[0] | <did>#<key>; the fragment is the key, verbatim |
verificationMethod[0].type | Multikey |
verificationMethod[0].publicKeyMultibase | <key>, step 5 (multicodec 0xed01 + 32 bytes, §2) |
didDocumentMetadata.canonicalId | chain[0] |
didDocumentMetadata.equivalentId | chain[1…] without <did>, in order; [] when nothing is left |
didResolutionMetadata | resolve: {}. resolveRepresentation: {"contentType": "application/did+ld+json"} |
Every DID of the chain names the same subject, as canonicalId and equivalentId require
(DID Core §7.1.3): each DID after chain[0] entered the chain by a rotation signed by the
previous DID's key or governing recovery key and countersigned by its own key (§7).
authentication is proof of control: a §5.2 challenge answer for the head, verified under
<key>. Absent: controller (the DID itself), alsoKnownAs, assertionMethod
(attestations carry their own signatures, §5), keyAgreement (no encryption, §11),
capabilityInvocation, capabilityDelegation, service (no discovery, §11), and the
metadata created, updated, deactivated (§12.5), versionId, nextVersionId,
nextUpdate. The recovery key MUST NOT appear as a verification method. The rest of the §9.1
result (attestations, bindings, recovery) is not in the document; the caller reads it from
the result.
Errors (didResolutionMetadata.error, with didDocument null, didDocumentStream
empty and didDocumentMetadata {}).
invalidDid: step 1.notFound: steps 2–4, and any DID URL other than §12.1's. The resolver MAY attach the §9 reason.representationNotSupported: step 7.methodNotSupported(W3C DID Resolution, not DID Core): a multi-method resolver's answer for a DID of another method, never raised by these steps.
Example (vector bundle, now 1757289600 as the vector holds). sigelo-verify prints
the vector's expect; the fields this operation reads:
"chain":["did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG","did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq","did:sigelo:zMmqQwrkvYGSyyEqrzCtaKNMso9Bzz9h8oSRV88XGFXG","did:sigelo:z6tH4xM1YgH1sWab2KRHBDsP7WDATEKCaxLtQCTPFWsQA"],
"did":"did:sigelo:z6tH4xM1YgH1sWab2KRHBDsP7WDATEKCaxLtQCTPFWsQA"
The head's genesis is the next_genesis of rotation_recovery_second; its key equals
chain[0]'s because the vectors reuse the agent seed. resolve of chain[0]:
{ "didResolutionMetadata": {},
"didDocument": {
"@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1"],
"id": "did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG",
"verificationMethod": [{
"id": "did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG#z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG",
"type": "Multikey",
"controller": "did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG",
"publicKeyMultibase": "z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG" }],
"authentication": ["did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG#z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG"] },
"didDocumentMetadata": {
"canonicalId": "did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG",
"equivalentId": ["did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq",
"did:sigelo:zMmqQwrkvYGSyyEqrzCtaKNMso9Bzz9h8oSRV88XGFXG",
"did:sigelo:z6tH4xM1YgH1sWab2KRHBDsP7WDATEKCaxLtQCTPFWsQA"] } }
Resolving did:sigelo:z6FfJsPgZBMqhvUEyFW2SoHM3MaJV8QLdLJje2y8KvFEJ, the next of
rotation_hostile_carried, which is in the bundle but not chosen (§12.4), returns
{ "didResolutionMetadata": { "error": "notFound" }, "didDocument": null, "didDocumentMetadata": {} }
(step 4). A bundle of the genesis vector and rotations rotation_voluntary and the negative
fork makes sigelo-verify print
REJECT: chain: fork at did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG (2 valid voluntary rotations),
exit 1: notFound for every DID (step 3).
12.4 Update
Update is rotation (§7). The head moves to next; chain[0] stays; every DID of the chain
then resolves to the new key (§12.3).
Inputs.
- The head's genesis (§12.3 step 5) and its DID
id. - The governing recovery commitment (§7.2), which is the head genesis's
recovery. reason:voluntaryorrecovery.- The signing secret: for
voluntarythe head's identity secret; forrecoverythe recovery secret whose public key hashes to the commitment. - A new identity key pair and its
next_genesis, built by §12.2 steps 1–4: forvoluntary,recoveryMUST equal the current commitment; forrecoveryit MAY be any commitment, ornullto retire recovery. iat, Unix seconds, signer-asserted (§7).
Steps (the signer).
- Compute
next, the DID ofnext_genesis(§12.2 steps 5–8). It MUST differ fromid. - Write the body
{v: "sigelo/0", typ: "rotation", id, next, iat, reason}. It MUST carryrecovery_key(the recovery public key, §2 encoding) ifreasonisrecoveryand MUST NOT otherwise (§3.1). - Build the signing input
"sigelo\n"‖ JCS(body) (§3). - Sign it with Ed25519:
sigby the signing secret,sig_nextby the new identity secret (§7). Both are the 64 signature bytes, multibase, no multicodec prefix (§2). - Write the envelope
{body, sig, sig_next, next_genesis}, these four members only (§3.1), and append it to the bundle'srotations(§8).
Steps (the verifier). §7.3, from cur = chain[0], the DID of bundle.genesis, with
cur's genesis bundle.genesis and the commitment bundle.genesis.recovery:
- Candidates: the rotations whose
body.idiscurand whosesig_nextverifies over the signing input undernext_genesis.key. - Valid recoveries:
reasonrecovery, commitment notnull, SHA-256 of the rawrecovery_keyequals the commitment,sigverifies underrecovery_key, DID ofnext_genesisequalsnext. - Valid voluntaries:
reasonvoluntary,sigverifies under thekeyofcur's genesis, DID ofnext_genesisequalsnext,next_genesis.recoveryequals the commitment. - Precedence (§7.1): if there is a valid recovery, the verifier MUST choose the one with the latest
iat, whatever the voluntaries'iat, and MUST REJECT on two sharing it (chain: recovery tie). The commitment becomes the chosennext_genesis.recovery. - Otherwise: one valid voluntary is chosen; more than one MUST REJECT (
chain: fork); none ends the walk, andcuris the head. - A chosen
nextalready in the chain MUST REJECT (chain: cycle). Otherwise append it, make the chosennext_genesiscur's genesis, and repeat from step 1 atnext.
A rotation failing step 1, 2 or 3 is not a candidate: ignored, never fatal (§7.4).
Outputs. The signer: the rotation envelope. The verifier: the head, the chain and the governing commitment (§9 step 3).
Errors. The reference signer (rotate) refuses when next equals id, the new secret does not match
next_genesis.key, a recovery is asked with commitment null or a key that does not hash to
it, or a voluntary next_genesis changes the commitment. The verifier REJECTs with chain:
recovery tie, chain: fork, chain: cycle (steps 4–6) or a malformed rotation (§9 step 2,
§7.4).
Example A, voluntary (vector rotation_voluntary, signed by seed agent, countersigned by agent2):
{"body":{"v":"sigelo/0","typ":"rotation","id":"did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG","next":"did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq","iat":1759276800,"reason":"voluntary"},
"sig":"z3VAXwnWoy3VcrZhBiBu56iLkhyQ54i2yHBjU1G424gAN75NwjTcJ36FrfDabZksuyKsrjcy3APcRPntFrtSdsAg3",
"sig_next":"z48XrtphRGqaMsXgaYhNsQ6LG4rSsuBq62ZeAsx5tAFDzhMYbgUzUpTgBGkRKGH696YBPunw2q2bDhR9WyvoftRdi",
"next_genesis":{"v":"sigelo/0","typ":"genesis","key":"z6MkwW6aqMnjgrhJXFUko3NnZPGzVpkNzhYK7yEhnsibmLwL","recovery":"sha256:2c5a92ed92c0b7999f215be93c8f0433f58072bdba21a8b277faa495b57bf7f3","created":"2026-10-01T00:00:00Z","nonce":"zVPYtbNU6bZFwfzo7Y2U2Ri"}}
A bundle of the genesis vector and this rotation, sigelo-verify --now 1757289600, prints
"chain":["did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG","did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq"],
"did":"did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq".
Example B, recovery over a later voluntary (vector chain_precedence_only: rotations
rotation_voluntary, rotation_hostile_carried, rotation_recovery). At cur =
did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq two rotations are valid:
{"v":"sigelo/0","typ":"rotation","id":"did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq","next":"did:sigelo:z6FfJsPgZBMqhvUEyFW2SoHM3MaJV8QLdLJje2y8KvFEJ","iat":1761523200,"reason":"voluntary"}
{"v":"sigelo/0","typ":"rotation","id":"did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq","next":"did:sigelo:zMmqQwrkvYGSyyEqrzCtaKNMso9Bzz9h8oSRV88XGFXG","iat":1760227200,"reason":"recovery","recovery_key":"z6MknGc3ocHs3zdPiJbnaaqDi58NGb4pk1Sp9WxWufuXSdxf"}
The first (rotation_hostile_carried) carries the commitment and has the later iat; the
second (rotation_recovery) has a recovery_key hashing to sha256:2c5a92ed… and installs
sha256:d71b51f7…. Step 4 chooses the recovery. A bundle of the genesis vector and these
three rotations, --now 1757289600, prints the vector's expected_chain:
{"attestations":{},"bindings":[],"chain":["did:sigelo:zF5FYbH5zNLX5pfd7DZUjPirXeAFzLVxrdFyCrnexdpBG","did:sigelo:z8hhrKBPMQH3A9Ph8CX7jxRvfppT5nWQYtMmugXjCQoKq","did:sigelo:zMmqQwrkvYGSyyEqrzCtaKNMso9Bzz9h8oSRV88XGFXG"],"did":"did:sigelo:zMmqQwrkvYGSyyEqrzCtaKNMso9Bzz9h8oSRV88XGFXG","recovery":"sha256:d71b51f7998646f3497614c3a3027fe90d876d39133af5de57faa03da004d1a6","rejected":{"attestations":0,"bindings":0}}
12.5 Deactivate
sigelo/0 defines no deactivation operation; resolution never reports deactivated. The
substitute below ends what the subject can sign; an existing bundle still verifies.
Inputs. The head's identity secret; the recovery secret, if the governing commitment is not
null; any earlier recovery secret still in existence.
Steps.
- Stop signing with the identity key: no §5.2 answers, bindings (§6) or invoices (§6.3).
- Do not reissue: each attestation and binding stops verifying at its
exp(§5, §6; §9 steps 5–6). Ask the worlds to stop attesting; an attestation needs no signature by the subject. - If the governing commitment is not
null, make a recovery rotation (§12.4) whosenext_genesishasrecovery: null, countersigned by a fresh key, and add it to the bundle. - Destroy the fresh secret, the identity secret, the recovery secret and every earlier recovery secret. A retired recovery key governs the nodes up to its retirement and can rotate the chain away at one of them (§7.2, vector
bundle_retired_recovery_at_genesis).
Outputs. A chain whose head key no one holds and whose commitment is null: §9 verifies
it and §12.3 returns a document, but no rotation, binding, invoice or §5.2 answer can be made
for it.
Errors. None defined. A presenter holding an older bundle can withhold step 3's rotation
(§12.6, deletion); what a stolen key signed before step 4 verifies until its exp.
Example (vector bundle_recovery_null_commitment). The genesis has recovery: null; a
recovery rotation from it, signed by z6MknGc3ocHs3zdPiJbnaaqDi58NGb4pk1Sp9WxWufuXSdxf, is not
a candidate (§12.4 verifier step 2). sigelo-verify --now 1757289600 prints the vector's expect:
{"attestations":{},"bindings":[],"chain":["did:sigelo:zRwK6SKYNvSmQiVkt7Z7L8bCWNGNohp1rcChjo63X1ox"],"did":"did:sigelo:zRwK6SKYNvSmQiVkt7Z7L8bCWNGNohp1rcChjo63X1ox","recovery":null,"rejected":{"attestations":0,"bindings":0}}
12.6 Security considerations
DID Core §8.3 and RFC 3552 §5, in order. THREAT-MODEL.md is the analysis.
- Eavesdropping: a bundle holds public keys, signatures and signed statements, no secret; confidentiality is not provided (§11), so what it discloses is §12.7's subject.
- Replay: a replayed bundle proves no control; control is a §5.2 answer over a world-chosen nonce bound to a session and a short lifetime, and no bundle slot accepts
typ: "challenge". Attestations and bindings end atexp. - Message insertion: an inserted attestation or binding needs a valid signature by the key its slot names, or it is discarded (§9 steps 5–6); an inserted rotation needs
sigby the current or recovery key andsig_nextby its own next key (§7). - Deletion: an intermediary or the presenter can drop items, a later rotation included; the verifier then sees a shorter chain. A verifier that has seen a longer chain for the same
chain[0]keeps it and discounts attestations near a recovery (THREAT-MODEL §3.5). - Modification: a changed body fails its signature; a changed genesis changes its DID (§4).
- Man in the middle: reduced to replay, deletion and modification above.
- Denial of service, amplification: verification is local and bounded: multibase length before decoding (§2), nesting depth 512 (§3), at most
len(rotations)walk steps (§7.3). No network request, so nothing to amplify. - Residual risks: theft of the identity key is terminal with
recovery: null(§4); a leaked recovery key is terminal, retired or not (§7.2); a thief signs until the recovery is presented; an incorrect verifier accepts what §9 rejects, which the vectors test (§12.8); Sybil identities, lying issuers and the operator behind the agent are not defended (THREAT-MODEL §3). - Integrity protection and update authentication: every element carries a detached Ed25519 signature over
"sigelo\n"‖ JCS (§3); update authentication is the Authorization table (§12, §7). The DID document is not signed: each resolver derives it from the verified bundle (§12.3). - Unique assignment: the DID is the SHA-256 of a genesis that carries a nonce (§4); two identities share a DID only through a SHA-256 collision.
- Authentication: §5.2: the agent signs the world's challenge with the head key.
- Non-repudiation: a signature is attributable to whoever held the key; signatures by a key later recovered from may be the thief's (§7.4).
- Key management: the identity and recovery secret keys are the only secrets. The identity key is hot and assumed stolen; the recovery key is generated offline and public only as a hash until used (§4); retired recovery keys MUST be destroyed (§7.2, THREAT-MODEL §2.4–§2.5b).
- Endpoint authentication, ledger finality: not applicable, because there is no endpoint, registry or ledger.
12.7 Privacy considerations
DID Core §8.4 and RFC 6973 §5, in order.
- Surveillance: creating, rotating and resolving contact no one; no party learns who resolves whom, or when.
- Stored data compromise: a resolver stores nothing; the subject's secrets stay with the subject (§4).
- Unsolicited traffic: not applicable, because the document has no
service. - Misattribution: a DID is attributed only by the attestations a verifier chooses to trust (§1, §5).
- Correlation: a DID is correlatable, since it carries reputation between worlds, and so is a shared
recoverycommitment; unlinkable presences need separate identities with separate recovery keys (MONERO.md §2). - Identification: keys and signatures are not personal data;
claimsmay be, and that is the issuer's charge (THREAT-MODEL §6). - Secondary use: a recipient can keep a presented bundle and show it to others; its signatures stay verifiable. The subject SHOULD present only the items a verifier needs.
- Disclosure: bindings disclose payment addresses to the bundle's recipient; the view key is never disclosed automatically (§6.3).
- Exclusion: the subject holds every attestation and binding about it that it presents; a verifier's own records are outside sigelo.
12.8 Conformance
A did:sigelo resolver is a §9 verifier followed by §12.3 steps 4–7. sigelo-verify
--conformance checks the reference against test-vectors.json (§10), and --conformance
--impl '<command>' checks a candidate. The examples of §12.2–§12.5 are vectors of
test-vectors.json by name: genesis, bundle, rotation_voluntary,
chain_precedence_only, bundle_recovery_null_commitment and the negative fork;
--conformance checks each.