Ledger Replication Messages
The Vultron SYNC substrate copies the case event log to all active participants. This keeps each participant's local DataLayer consistent with the canonical log that the CASE_MANAGER holds. ADR-0077 describes the mechanism.
These messages are infrastructure, not protocol messages in the 28-shorthand sense. They carry other protocol messages as ledger entries, and are not a Vultron protocol step themselves (see ADR-0083).
Faults and Acknowledgments gives the acknowledgment semantics.
How replication works
- The CASE_MANAGER commits a new log entry and sends it to each participant as
Add(CaseLedgerEntry). TheAddadds the entry to the case's ledger,<case>/ledger, which is itstarget; itscontextis the case (ADR-0204, SYNC-02-006). The ledger is an ordered collection whose items are the case's entries inlogIndexorder, and its id is an identity only: no route serves it. TheAddnames the act the entry commits ininReplyTo, so it is also that act's positive acknowledgment to its sender, and it carries noresult(SYNC-02-007, SYNC-02-009, MSM-05-009). - A participant first recomputes the entry's hash from its content.
An entry that does not reproduce its
entry_hashis refused and logged, with noReject(SYNC-03-012, CLP-04-008). The participant sends the CASE_MANAGER aCreate(ProcessingFault)with failure classLedgerEntryRefused/HashMismatchinstead (SYNC-03-007). The CASE_MANAGER sends nothing back for it, because a replay would resend the same content (SYNC-03-008). - A participant whose local
prev_log_hashmatches the incoming entry'sprev_log_hashaccepts it and sends nothing. An unbroken hash chain is the implied positive acknowledgment (MSM-05-002). - A participant whose hashes do not match sends
Reject(CaseLedgerEntry)whoseledgerPositionis its ledger tail, the last entry it accepted. From that position, the CASE_MANAGER can replay the gap (SYNC-03-001, SYNC-03-002). ItsinReplyTonames theAdd(CaseLedgerEntry)that carried the entry (RF-08-004). - A participant that wants to check its ledger is current states its position:
Read(<case>/ledger), aReadof the case's ledger whoseledgerPositionis the last entry it applied, or index -1 when it holds none. The CASE_MANAGER records that position and replays every entry after it (SYNC-17-001, SYNC-17-004).
Every case message a participant or the CASE_MANAGER sends also states how far its sender's ledger had got.
The sender puts its ledger tail in the activity's ledgerPosition, the same property and shape a case copy carries (SYNC-18-001, SYNC-16-005).
The position is the tail when the sender built the message, and a resend keeps it (SYNC-18-002, SYNC-18-009).
A receiver refuses a case message that carries no position or one that does not parse (SYNC-18-015).
The position is part of the received body, so the ledger entry for the message records it (SYNC-18-006).
Add(CaseLedgerEntry) and Announce(VulnerabilityCase) carry none, because the entry and the case state their own positions.
Create(ProcessingFault) carries none either: any receiver sends one, about an activity it could not process.
A participant also numbers each case message it sends the CASE_MANAGER that carries a ledgerPosition, in the activity's senderSequence (SYNC-21-001, ADR-0178).
The number is 1 for its first message on the case and one more than the last for each next one (SYNC-21-002).
A resend keeps its number, as it keeps its position (SYNC-21-003).
Read(<case>/ledger) and Reject(CaseLedgerEntry) carry no number, because they ask about the ledger rather than state a case event, and the CASE_MANAGER numbers none of its own messages.
A participant that lost its count resumes past the highest of its own numbers in the ledger it holds (SYNC-21-006).
A refusal notice that names an expectedSenderSequence moves the participant's count up, so its next message for the case is numbered no lower (SYNC-21-007).
The CASE_MANAGER judges each sender's numbered messages in number order (SYNC-21-008).
For each sender and case it keeps the next number it expects: one more than the highest it judged or skipped.
Before it has judged any, that is one more than the highest of the sender's numbers in its ledger, or 1 (SYNC-21-009).
A message refused on its merits still counts as judged.
A message numbered past a gap is held, as the body that arrived, until the missing numbers arrive (SYNC-21-010).
It is then judged as a delivery of its own.
The hold ends when its wait has passed, whether or not anything else arrives, or when the sender has 16 messages held for the case (SYNC-21-011, SYNC-21-012).
The CASE_MANAGER then skips the missing numbers, logging each at WARNING, and judges the held messages in number order (SYNC-21-013, SYNC-21-022).
The wait is ledger.sender_sequence_hold_seconds (120 seconds by default), and the cap is ledger.sender_sequence_hold_cap (SYNC-21-021).
A message numbered below the next expected one, one that reuses the number of a held message, and one that carries no valid number are refused with the refusal notice, which names the next expected number as expectedSenderSequence (SYNC-21-014, SYNC-21-015, SYNC-21-017).
A refused message changes no case state and is never inserted into the ledger's history (SYNC-21-024).
A repeat of a held or judged message is found by its id first and gets no notice (SYNC-21-018).
Before the CASE_MANAGER role passes to another actor, the outgoing CASE_MANAGER judges every message it holds for the case, skipping the gaps (SYNC-21-025).
The CASE_MANAGER reads the position on every case message it receives.
Apart from a reply to the full-case Invite, which must not be behind the Invite's own position (CM-11-012), the position never changes how it judges the message.
A position behind its ledger tail is normal while entries are still on their way, so the CASE_MANAGER logs the lag at DEBUG and applies or refuses the message on its own merits (SYNC-18-004, SYNC-18-010).
A position at or behind the tail is also the sender's statement of how far it has got, so the CASE_MANAGER answers it as it answers a Read(<case>/ledger).
It records the position as the sender's acknowledged position and, when the position lags, replays every entry after it under the same rate bound and outbox de-duplication (SYNC-18-007).
A position that names an entry the CASE_MANAGER's ledger holds with a different hash, or an index past its tail, means the sender's chain has split from the canonical ledger.
The CASE_MANAGER logs the split at ERROR and sends the sender Announce(VulnerabilityCase) of its current case, at most once per re-seed cooldown (SYNC-18-011, SYNC-18-012, SYNC-16-004).
It answers only an active participant: a removed or unconsented participant's position is not recorded, and nothing is replayed or re-seeded to it (CM-10-004).
A held position from any participant still on the roster also has the CASE_MANAGER resend each Invite that participant owes an answer to, as Resending unanswered Invites describes (SYNC-20-001).
A participant's replica of the case is the replay of its ledger. It is the case as it stood when the replica was seeded, plus every ledger entry since, applied in ledger order (ADR-0124, CM-23-016). A replica applies an entry by copying the objects it carries. Applying an entry mints no id, reads no clock or local policy, and runs no lifecycle logic. So two replicas at the same ledger position hold identical case files.
Each entry records one activity with its object. An embargo act's entry carries its whole step on the embargo register. A termination's entry also cancels every open proposal. An activation's entry also supersedes the embargo it replaces.
When an act causes the CASE_MANAGER to change a consent row, that change is its own entry after the act's entry.
That entry is a CASE_MANAGER Create(EmbargoConsent) or Update(EmbargoConsent).
A replica copies that row and does not decide the change itself (CLP-07-013, EP-09-007).
The same holds for participants.
Some acts move a participant's RM state, such as a report verdict, an engagement decision or a Leave.
Such an act is followed by an add_participant_status_to_participant entry for each status the CASE_MANAGER wrote.
A record the CASE_MANAGER creates is its own Create(CaseParticipant) entry.
A replica copies each of these, ids and times included (CLP-07-013, CM-23-016).
The replica does not patch over an embargo or consent entry whose starting state does not match the replica's case.
It holds the Add that carried that entry as a HeldLedgerAnnounce.
When that entry extends the replica's chain and the case is not already past it, the replica's case has diverged.
The replica then sends the CASE_MANAGER a Create(ProcessingFault) with failure class LedgerEntryRefused/CaseDiverged (SYNC-16-001).
From an active participant, the CASE_MANAGER answers that fault with Announce(VulnerabilityCase) of its current case, which names its ledger position, so the replica can replace its case and store the held entry (SYNC-16-003).
It re-seeds one peer at most once per cooldown, so a replica that refuses several entries in a row gets one copy, and a later fault still gets another (SYNC-16-004).
Neither fault is committed to a case ledger, by the replica or by the CASE_MANAGER (SYNC-16-002).
Occasions
| When… | Send | Send to | Sent by | Distinguished by | Details |
|---|---|---|---|---|---|
| the CASE_MANAGER has committed a case event to the case ledger | Add(CaseLedgerEntry) |
a participant | the CASE_MANAGER | — | Add case ledger entry |
| a received ledger entry does not chain onto the Participant's own ledger | Reject(CaseLedgerEntry) |
the CASE_MANAGER | an active participant, including one that has left the case | — | Reject case ledger entry |
| a Participant checks that its ledger is current, such as after a restart, or holds a case but none of its entries | Read(OrderedCollection)[context=VulnerabilityCase] |
the CASE_MANAGER | a participant | — | Read case ledger |
Add case ledger entry
Fans out the newly committed ledger entry to each active participant, as an Add to the case's ledger that names the committed act in inReplyTo: the positive acknowledgment of that act.
- When… the CASE_MANAGER has committed a case event to the case ledger
- Send:
Add(CaseLedgerEntry) - Send to: a participant
- Sent by: the CASE_MANAGER
- Mapping status: none
{
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "Add",
"id": "urn:uuid:705101bd-584d-43c1-aad6-5b5e4cf9c0f1",
"name": "https://vultron.example/case-actors/vendorco-case-actor Add urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/log/0 to urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/ledger",
"context": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a",
"inReplyTo": "https://vultron.example/activities/00000000-0000-0000-0000-000000000001",
"published": "2026-06-01T19:12:00.000000+00:00",
"updated": "2026-06-01T19:12:00.000000+00:00",
"actor": "https://vultron.example/case-actors/vendorco-case-actor",
"target": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/ledger",
"object": {
"id": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/log/0",
"type": "CaseLedgerEntry",
"published": "2024-01-01T12:00:00.000000+00:00",
"caseId": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a",
"logIndex": 0,
"logObjectId": "https://vultron.example/activities/00000000-0000-0000-0000-000000000001",
"semanticType": "create_case",
"payloadSnapshot": {
"id": "https://vultron.example/activities/00000000-0000-0000-0000-000000000001"
},
"prevLogHash": "41ebcb1d996477859b8fec00382f75af72401ede0814022bab3f0d54f1b25e0d",
"entryHash": "f09b79ec9013551751a903a361bf0358df5739b769a2f5e908a4d98bd51ed483",
"receivedAt": "2024-01-01T12:00:00.000000+00:00"
},
"proof": {
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"verificationMethod": "https://vultron.example/case-actors/vendorco-case-actor#main-key",
"proofPurpose": "assertionMethod",
"created": "2026-06-01T19:12:00.000000+00:00",
"proofValue": "z35V28iTq3H6PMTwB7GWvKYVwRMSejdAd8xhJAhBnSnhHMBnZQxV8XDaYc6KyrTC9gBj9i2mvJkHsEGxZn4t2CcUV"
}
}
- Triggering transition: triggered internally after any event is recorded to the log — not a protocol shorthand.
- Spec: SYNC-09-002.
- Pattern:
AddLogEntryToLedgerPatterninvultron/wire/as2/extractor/_instances.py. - Factory:
add_log_entry_activityinvultron/wire/as2/factories/sync.py. - Example artifact: add_case_ledger_entry.json.
Each entry carries a content hash and the hash of its predecessor, forming a chain.
A participant checks the chain when an entry arrives.
It holds the Add of any entry that arrives before its predecessor as a HeldLedgerAnnounce.
It replays that Add when the predecessor arrives (ADR-0037, SYNC-14-009).
Reject case ledger entry
Tells the CASE_MANAGER that the entry's previous hash does not match the sender's ledger tail, and the CASE_MANAGER replays every entry after the last accepted hash. This negative acknowledgment serves the purpose of the formal EK and CK messages.
- When… a received ledger entry does not chain onto the Participant's own ledger
- Send:
Reject(CaseLedgerEntry) - Send to: the CASE_MANAGER
- Sent by: an active participant, including one that has left the case
- Mapping status: evolved
{
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "Reject",
"id": "urn:uuid:1cfe2007-c672-488f-a2e4-c437d085199b",
"name": "https://vultron.example/organizations/vendorco Reject urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/log/2",
"context": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a",
"inReplyTo": "urn:uuid:fbc07321-bab2-436c-a6a8-835721b664bf",
"published": "2026-06-01T19:12:00.000000+00:00",
"updated": "2026-06-01T19:12:00.000000+00:00",
"actor": "https://vultron.example/organizations/vendorco",
"ledgerPosition": {
"logIndex": 0,
"entryHash": "f09b79ec9013551751a903a361bf0358df5739b769a2f5e908a4d98bd51ed483"
},
"object": {
"id": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/log/2",
"type": "CaseLedgerEntry",
"published": "2024-01-01T12:00:00.000000+00:00",
"caseId": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a",
"logIndex": 2,
"logObjectId": "https://vultron.example/activities/00000000-0000-0000-0000-000000000003",
"semanticType": "engage_case",
"payloadSnapshot": {
"id": "https://vultron.example/activities/00000000-0000-0000-0000-000000000003"
},
"prevLogHash": "6d51c69e0b6e2ce33c464ece5ff0ec4b486b29f62734ba6123dead2a3f577633",
"entryHash": "d2c075a87b6930e11d5a09e41ded4d9c318a5e48797f5d3824b82d4ea8aade95",
"receivedAt": "2024-01-01T12:00:00.000000+00:00"
},
"proof": {
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"verificationMethod": "https://vultron.example/organizations/vendorco#main-key",
"proofPurpose": "assertionMethod",
"created": "2026-06-01T19:12:00.000000+00:00",
"proofValue": "z4LUnv6NnR2VuYREsbVUzwhEzzkZxUZy3tdwF2sebVgthGN86qNmtm1puBdibAyuaUY2MzkFissJ1WxFN4jpq75zx"
}
}
- Context: the case.
ledgerPosition: the participant's ledger tail, thelogIndexandentryHashof the last entry it accepted, so the CASE_MANAGER can determine which entries to replay (SYNC-03-002, SYNC-18-001). A participant that does not hold the case yet has no tail, sends noledgerPosition, and is answered with the case and a replay from genesis (SYNC-15-015), unless the last replay from genesis already sent the rejected entry, in which case the CASE_MANAGER may send nothing (SYNC-15-019).- Triggering transition: triggered by hash-chain mismatch detection — not a protocol shorthand.
- Spec: SYNC-03-001, SYNC-03-002, SYNC-03-005.
- Pattern:
RejectLogEntryPatterninvultron/wire/as2/extractor/_instances.py. - Factory:
reject_log_entry_activityinvultron/wire/as2/factories/sync.py. - Example artifact: reject_case_ledger_entry.json.
A participant that holds no entry has none to reject.
If its case is replaced by a copy ahead of its chain, it states its position instead, with Read(<case>/ledger) at logIndex -1, which asks for every entry (SYNC-16-027, SYNC-16-029).
Every Reject names an object: one that names none is refused when it is parsed (SYNC-16-028, ADR-0204).
Buffering takes priority over rejection (ADR-0037).
A participant sends a Reject only for an entry that is really missing from the chain, never for one that is only out of order.
So an out-of-order delivery does not start a reject-and-replay cycle.
The CASE_MANAGER acts on a Reject(CaseLedgerEntry) only when its sender is an active participant in the case (SYNC-03-005, CM-10-004).
From any other sender it reports REFUSED, records no replication state, and replays no entry and announces no case to that sender.
The check runs before any write, so a stranger cannot obtain case content by sending a Reject that states no position.
Read case ledger
States the sender's position in the case's ledger: its last entry, or index -1 when it holds none. The CASE_MANAGER resends every Invite the sender has not answered and, for an active participant, records the position as the sender's acknowledged position and replays every entry after it, the whole ledger for index -1.
- When… a Participant checks that its ledger is current, such as after a restart, or holds a case but none of its entries
- Send:
Read(OrderedCollection)[context=VulnerabilityCase] - Send to: the CASE_MANAGER
- Sent by: a participant
- Mapping status: none
{
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "Read",
"id": "urn:uuid:a825bad4-89cc-4d3b-bff2-f727dc12f21a",
"name": "https://vultron.example/organizations/vendorco Read urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/ledger",
"context": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a",
"published": "2026-06-01T19:12:00.000000+00:00",
"updated": "2026-06-01T19:12:00.000000+00:00",
"to": [
"https://vultron.example/case-actors/vendorco-case-actor"
],
"actor": "https://vultron.example/organizations/vendorco",
"ledgerPosition": {
"logIndex": 1,
"entryHash": "6d51c69e0b6e2ce33c464ece5ff0ec4b486b29f62734ba6123dead2a3f577633"
},
"object": {
"id": "urn:uuid:e54656f1-e9c8-4ec5-9a69-6cbf725e510a/ledger",
"type": "OrderedCollection"
},
"proof": {
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://certcc.github.io/Vultron/ns/context.jsonld",
"https://w3id.org/security/data-integrity/v2"
],
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"verificationMethod": "https://vultron.example/organizations/vendorco#main-key",
"proofPurpose": "assertionMethod",
"created": "2026-06-01T19:12:00.000000+00:00",
"proofValue": "z3hpLmw8SCTV5wNcr9yN4fJ6Q85cBG2qFsnffDurk4jBTmzLFcEmgboGf63dftWzBYZob3Yeii6s7AGguYEotikbv"
}
}
- Object: the case's ledger,
<case>/ledger, anOrderedCollectiongiven by itsidandtypealone: the ledger is an identity, and no route serves it (ADR-0204). - Context: the case.
ledgerPosition: the participant's tail, thelogIndexandentryHashof the last entry it applied, so the CASE_MANAGER can tell a lag from a position its ledger does not hold (SYNC-17-001). A participant that holds no entry stateslogIndex-1 with the case's genesis hash. This is the sameledgerPositionevery case activity carries (SYNC-18-001).- Triggering transition: a case copy seeding the participant's replica (SYNC-17-008), and otherwise the participant's own policy, not a protocol shorthand. The reference participant also sends one for each case it holds after every restart, and on
ledger.position_statement_interval_secondswhen that is set, which is off by default (SYNC-17-007). - Spec: SYNC-17-001 through SYNC-17-008; the Invite resend, SYNC-20-001 through SYNC-20-008.
- Pattern:
ReadLedgerPatterninvultron/wire/as2/extractor/_instances.py. - Factory:
read_ledger_position_activity, orread_ledger_at_entry_activityfor the position of an entry the sender holds, invultron/wire/as2/factories/sync.py. - Example artifact: read_case_ledger.json.
Read(<case>/ledger) is the participant's position statement, in one form for every position (ADR-0204).
Read states how far the sender has read the ledger, so it claims no refusal, where a Reject would.
The CASE_MANAGER replays what follows the stated position, so a position behind its tail asks for a replay, and one at index -1 asks for the whole ledger.
It covers the case the Reject loop cannot: when the last Add(CaseLedgerEntry) before a quiet period is lost, no later entry arrives with a gap, and no Reject is ever sent (ADR-0155).
A participant whose case is still at the empty ledger's position states index -1:
{
"type": "Read",
"object": {"id": "<case>/ledger", "type": "OrderedCollection"},
"context": "<case>",
"ledgerPosition": {"logIndex": -1, "entryHash": "<the case's genesis hash>"}
}
A participant also states its position once Announce(VulnerabilityCase) seeds its replica of a case (SYNC-17-008).
Its chain stores no entry yet, but the seeded case reflects every entry up to the copy's position, so the Read states that position.
The statement tells the CASE_MANAGER that the replica is ready, so the CASE_MANAGER can resend an Invite the participant dropped before the copy arrived (ADR-0163).
A copy that replaces a case the participant already holds sends no Read.
If that send fails after the seed, the reference participant's next restart statement states the same position while its chain still stores no entry, because such a replica states its case's position (SYNC-17-007).
The CASE_MANAGER's answer is the one it gives a Reject.
It records the stated position's hash as the sender's acknowledged position (SYNC-17-003).
When that position is behind its ledger tail, it sends the sender every entry after it, in log order, as Add(CaseLedgerEntry), under the same replay rate bound and outbox de-duplication as a Reject-triggered replay (SYNC-17-004).
At index -1 that is every entry (SYNC-16-029).
At the tail it sends nothing.
It answers only an active participant (SYNC-17-002, CM-10-004).
A removed, unconsented or closed participant's Read is REFUSED, with no replication state recorded and no entry replayed.
An unconsented participant that is still on the roster is still resent the Invites it owes an answer to (SYNC-20-001).
A position the CASE_MANAGER's ledger does not hold, an index at which its entry has a different hash, or index -1 with a hash other than the case's genesis hash, is logged at WARNING and answered with nothing (SYNC-17-005).
A Read and its answer are never ledgered: stating a position changes nothing in the case file (SYNC-17-006).
Resending unanswered Invites
A position statement tells the CASE_MANAGER that the participant's replica holds the case, so the participant can now answer an Invite it lost.
An Invite that reached a joiner before its case copy waits in the joiner's pre-bootstrap queue, and is dropped when the queue's window ends (CBT-03-003).
Any Invite can also be lost in delivery.
So when a participant states a position the CASE_MANAGER's ledger holds, in Read(<case>/ledger) or as any case activity's ledgerPosition, the CASE_MANAGER resends each Invite that participant owes an answer to (ADR-0163, SYNC-20-001).
The resend runs apart from the active-participant check.
Any participant still on the roster is resent its Invites, even an inert one that has not consented to the embargo in force, because an Invite is how it is asked to consent.
A resent Invite is one the participant was already sent, so it carries no withheld case content (CM-10-009).
A removed participant is asked nothing (CM-31-013), and a closed one is sent nothing (SYNC-20-008).
For an inert sender the rest of the answer is unchanged: nothing is replayed, no replication state is recorded, and its Read is still REFUSED (SYNC-17-002, SYNC-17-009).
An Invite is owed while its answer can still count (SYNC-20-002):
- an
Invite(EmbargoEvent)whose embargo is still a proposal or is the embargo in force, whose consent row for the participant isINVITED, and whose RSVP deadline has not passed; - the full-case Invite, until the CASE_MANAGER's ledger records the participant's reply to it (CM-11-010).
The Invite that the stating activity itself answers is not owed, and of several Invites for one embargo only the last one sent is owed.
A resend is the Invite as first sent: the same id, ledgerPosition and RSVP deadline, from the body sealed when it was first sent (SYNC-20-003, SYNC-18-009).
A receiver that already handled it treats it as a redelivery and does nothing, and a receiver that dropped it handles it as new.
A resend never extends a deadline, and the full-case Invite's ledger floor is unchanged, so a reply at or beyond it is still accepted (CM-11-035).
Resends are rate-bounded per Invite and participant.
The CASE_MANAGER does not resend an Invite whose earlier send is still pending in its outbox (SYNC-20-004).
Each consecutive resend of one Invite to one participant doubles the cooldown before the next, from ledger.invite_resend_cooldown_seconds (30 seconds by default) up to ledger.invite_resend_max_cooldown_seconds (600 seconds by default) (SYNC-20-005, SYNC-20-006).
A resend commits no ledger entry, because the Invite's emission was ledgered when it was first sent, and it does not change the outcome of the activity that stated the position (SYNC-20-007).
Case seeding
A participant whose replica starts for the first time receives Announce(VulnerabilityCase), not a ledger entry.
This happens after it accepts an Invite, or after a Create(CaseProposal) is accepted.
The participant holds any Add(CaseLedgerEntry) that arrives before the seed as a HeldLedgerAnnounce, keyed by prev_log_hash.
It replays that Add when it can compute the genesis hash from the seeded case (ADR-0059).
While it waits, it sends the CASE_MANAGER one Reject(CaseLedgerEntry) with an empty last_accepted_hash per case, not one per held entry, and another, under a new id, only for an entry that arrives once 600 seconds have passed (SYNC-15-016, SYNC-15-017).
It records the time of the last one as a GenesisRejectRecord and deletes that record when it seeds the case (SYNC-15-021, SYNC-15-023).
A report submitter's replica is seeded by the report receiver's Create(VulnerabilityCase) instead (CBT-01-001), and that seed replays the held Add the same way (SYNC-15-005).
The report receiver's own seed, the CASE_MANAGER's Create(VulnerabilityCase), replays held entries the same way too.
The receiver and the CASE_MANAGER are separate senders, so the CASE_MANAGER's entries often arrive before that Create.
After an Announce(VulnerabilityCase) seed, the participant states its position in the seeded case with Read(<case>/ledger) (Read case ledger, SYNC-17-008).
A Create(VulnerabilityCase) seed sends no such statement, because SYNC-17-008 covers only the Announce(VulnerabilityCase) seed.
- Pattern:
AnnounceVulnerabilityCasePatterninvultron/wire/as2/extractor/_instances.py. - Factory:
announce_vulnerability_case_activityinvultron/wire/as2/factories/case/content.py. - Spec: SYNC-09-001.
Each Announce(VulnerabilityCase) carries the case with its ledgerPosition: the logIndex and entryHash of the last ledger entry its case file reflects (SYNC-16-005).
A participant that already holds the case judges the copy by that position.
The participant skips a copy it is already past.
It refuses a copy that names a different entry at an index the participant holds.
Any other copy replaces the case, position included (SYNC-16-022).
After a replacement whose position is ahead of its chain, the participant sends Reject(CaseLedgerEntry) naming its own tail.
Its inReplyTo names the Announce(VulnerabilityCase) that carried the copy (RF-08-004).
It stores each entry the copy already reflects as a no-op, and does not move its case's position back (SYNC-16-023, SYNC-16-024).
The activity and its rendered example are documented under Announce vulnerability case.
See also
- Case Ledger Synchronization — why the ledger is ordered this way and what the buffering guarantees
- ADR-0037 — Buffer Out-of-Order Ledger Entries
- ADR-0059 — Buffer Pre-Genesis Ledger Entries
- Spec:
specs/sync-ledger-replication.yaml(SYNC-09, SYNC-10, SYNC-14, SYNC-15, SYNC-17)