Consequential State Architecture Design Note¶
Status¶
Draft architectural design note for OpenETR.
This note defines the architectural rule that should govern OpenETR state, events, projections, and application boundaries.
Core Principle¶
Consequential state should be derived from end-verifiable evidence according to defined rules, not merely asserted by applications, databases or blockchains.
Consequential State Architecture (CSA) is an architectural approach in which signed, independently verifiable records form an Evidence Graph spanning an artifact's evidenced lifecycle. Validation checks that evidence, and defined rules derive state affecting control, authority, rights, obligations, restrictions, standing, or permitted actions.
Applications may maintain projections of consequential state, but they are not its sole authority:
Applications derive consequential state; they do not own it.
The corresponding interoperability objective is:
Make the evidence and derivation of consequential results portable, while leaving recognition and effect to the applicable context.
This objective is sometimes shortened to make consequences portable. The short form must not be read as treating Consequential State as a status object copied from one authoritative application to another. OpenETR makes the digest-identified artifact, signed Evidence Graph records, graph relationships, and identified rules basis available so another conforming verifier can reproduce the result.
portable inputs reproduced result contextual decision
artifact + Evidence Graph + rules basis -> Consequential State -> recognition and effect
The identity, delegation, approval, and authorization machinery that produced an event may remain within the host system. A relying system introduces that additional evidence only when its policy requires it. OpenETR therefore does not require two organizations to adopt interoperable internal authority models merely to exchange independently verifiable consequential records.
Digital Artifacts, Evidence Graphs, And Digital Originals¶
A Digital Artifact is persistent digital content having a unique content identity established by a cryptographic digest. It may exist in any number of locations or byte-for-byte copies. Copies with the same protocol-defined digest represent the same Digital Artifact.
An Evidence Graph is a single end-verifiable record or a graph of related end-verifiable records through which consequential state concerning a Digital Artifact can be established and transitioned. An Evidence Graph is the protocol evidence structure, not the file or content that it concerns.
A Digital Original is a Digital Artifact for which consequential state has been established by validating its Evidence Graph under an identified, versioned ruleset.
This is a technical architecture definition. It does not claim that an external institution, community, contract, or jurisdiction must recognize the object or give its state legal or operational effect.
The central proposition is:
Content makes an artifact identifiable. Consequential state makes it an original.
Consequential state may concern:
- current control;
- transfer;
- encumbrance;
- discharge;
- termination;
- delegation or authority;
- standing or another domain-specific status derived under defined rules; or
- another protocol-defined condition affecting what may be done with the object.
Copying content does not copy or alter consequential state. A byte-for-byte copy with the same digest represents the same Digital Artifact, but possession of the copy does not create a new controller or valid state transition.
The canonical relationship is:
DIGITAL ARTIFACT
uniquely identifiable content
|
| referenced by
v
EVIDENCE GRAPH
single record or record graph spanning the evidenced lifecycle
|
| evaluated by
v
STATE TRANSITION RULES
protocol-defined transition rules
|
| derive
v
CONSEQUENTIAL STATE (validation result)
|
| establishes
v
DIGITAL ORIGINAL
Creation, scanning, translation, rendering, or transformation may produce a new Digital Artifact. Novelty alone does not make it a Digital Original:
Creation produces a Digital Artifact. Consequential state makes that artifact a Digital Original.
A creator may make a provenance claim such as “I created this artifact.” An issuer or other authority may make a different claim such as “I certify this artifact as authoritative for purpose X.” OpenETR establishes who signed the claim and which artifact it concerns. Recognition of the signer's standing or authority remains a separate determination.
Evidence Graph¶
An Evidence Graph may consist of:
- one end-verifiable record;
- multiple related records; or
- a directed graph of control, transfer, encumbrance, discharge, provenance, delegation, termination, or related events.
The graph is evidence. Validation checks the Evidence Graph as a whole, and defined state transition rules derive current consequential state from the valid evidence. The Evidence Graph therefore spans the signed evidence lifecycle between content identity and state evaluation; it must not be used as a synonym for the Digital Artifact itself.
Evidence Graph is an OpenETR protocol term. It is not legally synonymous with a Controllable Electronic Record (CER) under UCC Article 12. An Evidence Graph may qualify as a CER, electronic transferable record, negotiable cargo document, or another legally recognized record only where the applicable legal requirements are satisfied.
Evidence Records And Events¶
A consequential state transition MUST be supported by Evidence Records that can be verified independently of the application, platform, registry, or database that produced, stored, transmitted, indexed, or displayed them. In an event binding, those records are Evidence Events.
An Evidence Event must provide sufficient cryptographic and referential evidence to determine:
- which key signed the event;
- which Digital Artifact and, where applicable, prior event it concerns;
- which transition or assertion is being made;
- whether the event is authentic and unaltered;
- which prior state, signatures, guards, or events constrain it; and
- how it participates in policy validation of the Evidence Graph and the resulting consequential state.
The durable primitive is not an application's state row. It is portable, verifiable evidence of a state transition.
Evidence, Disclosure, And Verified Propositions¶
Independent verification does not imply full disclosure. Verifiable evidence must be sufficient to establish the propositions required by the applicable rules. A future evidence profile may establish those propositions through disclosed records or privacy-preserving proofs with explicit assumptions.
A verified proposition is a conceptual result of evidence verification, not a new Evidence Graph event type. Rules define what must be proven; an identified evidence profile defines acceptable mechanisms. Existing cryptographic and structural requirements remain in force. Optional proof support requires further profile design and implementation.
Reproducibility requires the same evidence, rules and versions, evaluation parameters, and verification dependencies. It does not require unique assertions or guarantee a single controller: conflict and insufficient evidence may be the deterministic result. Different evidence subsets can support different conclusions and must be reported with their scope.
See Private Evidence And Verified Propositions for the evidence interface and threat analysis.
State Transition Rules¶
OpenETR uses ordinary state transition rules to determine how valid consequential actions change consequential state.
CURRENT CONSEQUENTIAL STATE
|
| consequential action
| evidenced by signed event
v
TRANSITION RULE
|
v
NEW CONSEQUENTIAL STATE
A consequential action is an action capable of producing a protocol-defined change in consequential state. The generic OpenETR action vocabulary includes:
- Anchor;
- Transfer;
- Encumber;
- Discharge;
- Terminate.
Domain profiles may define additional actions or effect concepts such as relinquishment, surrender, redemption, amendment, cancellation, or replacement. Those profiles should state whether the concept is a state transition, a domain interpretation of one or more transitions, or an external recognition effect.
Consequential actions deserve durable, end-verifiable evidence. A conforming implementation should be able to determine from the Evidence Graph and identified policy:
- the prior consequential state;
- the consequential action asserted by the event;
- whether the signing key was permitted to make that transition;
- whether transition guards were satisfied;
- whether the event links coherently into the relevant Evidence Graph; and
- the new consequential state, if the transition is valid.
Derived State¶
Consequential state is produced by validating the relevant Evidence Graph record or graph under an identified, versioned ruleset. A ruleset defines the validation and state-derivation rules for that evaluation. Recognition policy remains a separate boundary and decides whether to accept the resulting state:
Evidence Graph Record Or Graph + Identified Ruleset
|
| validate and apply state transition rules
v
Consequential State (result)
|
+------+------+
| | |
v v v
App A App B System C
Independent conforming implementations receiving the same relevant valid events and applying the same ruleset SHOULD derive the same Consequential State.
Applications MAY maintain databases, indexes, caches, APIs, snapshots, and materialized views. These are projections of consequential state rather than its ultimate source of authority.
A projection must be reproducible or auditable from the Evidence Graph records and the identified ruleset version used for validation.
Historical State¶
Historical state derivation is a first-class verification capability. Where sufficient evidence is available, an implementation SHOULD be able to derive Consequential State for a candidate Evidence Graph path ending at an identified event.
The result is relative to:
- the supplied evidence set;
- the candidate path or graph cut ending at the identified event;
- the applicable rule identifier and version; and
- the evaluation parameters and retrieval scope.
It is not automatically a statement about globally authoritative state at the event's declared timestamp. Signed event timestamps do not create a trusted total order. The verifier should disclose competing evidence, unresolved links, source divergence, and completeness limitations known from the supplied evidence set.
Conceptually:
derive_state(Evidence Graph records, rules)
derive_state(Evidence Graph records, rules, at_event=E)
The evidence basis and rules used for either result should be exportable so another implementation can reproduce the derivation.
For a future profile accepting privacy-preserving proofs, preserve sufficient proof material, public inputs, commitments, verification parameters, profile versions, and temporal or revocation evidence for historical re-verification. The private witness need not necessarily be disclosed or retained by the verifier. A proof created later does not establish its existence at the event time, and missing dependencies must remain visible as verification limits.
Conflicts And Candidate State¶
End-verifiability does not eliminate conflicting events or incomplete event sets. OpenETR must specify how a verifier handles:
- multiple candidate Anchor Events for the same object;
- competing branches;
- invalid signatures or malformed references;
- transitions made by a key lacking control under the prior derived state;
- unresolved or missing prior events;
- superseded events;
- terminated graphs; and
- events observed in different orders.
Valid signatures do not establish that all observers received one globally consistent Evidence Graph. Relays, repositories, archives, or other evidence sources may return stale, incomplete, or divergent event sets. Source agreement also does not establish that a signed action was intended by an actor whose key may have been compromised.
Chronology alone is not authority. Until the selected ruleset resolves a conflict, a verifier should preserve candidate graphs and describe the state as ambiguous, incomplete, or disputed rather than silently selecting one.
Where observations can be compared, verifier findings should distinguish conflicting evidence, insufficient evidence, history divergence, unresolved candidate state, and unknown evidence completeness.
Recognition And Effect¶
Consequential state, recognition, and effect are distinct:
Consequential State is state derived from end-verifiable events by an identified ruleset that is capable of affecting control, authority, rights, obligations, restrictions, standing, or permitted actions.
Recognition is acceptance of an actor, event, graph, object, or derived state by a person, organization, institution, system, community, jurisdiction, or applicable rule for a stated purpose.
Effect is the consequence produced when recognized state is given force or acted upon.
EVIDENCE GRAPH + DEFINED RULES
|
| validate evidence and derive state
v
CONSEQUENTIAL STATE (result)
|
v
RECOGNITION
|
v
EFFECT
OpenETR can derive consequential state from end-verifiable Evidence Graph records according to defined rules without claiming that every external party or jurisdiction must recognize it or give it a particular legal, institutional, contractual, community, or operational effect.
The term recognized Digital Original may be used when it is important to state that a Digital Original and its consequential state have been accepted under an identified recognition context. The unqualified technical term does not imply universal recognition.
Nostr As An Event Substrate¶
Nostr is a useful substrate for CSA because its primitive is a signed, addressable, referential event. A Nostr event can carry evidence concerning:
- control;
- transfer;
- encumbrance;
- discharge;
- delegation;
- binding;
- termination;
- recognition; or
- another consequential relationship.
Events can reference objects and other events, allowing consequential state to be represented as a verifiable event graph.
Relays transport and preserve evidence. They do not need to determine the meaning or effect of that evidence. OpenETR defines the event grammar, validation rules, and state transition rules.
CONSEQUENTIAL ACTION
|
v
NOSTR EVENT
signed evidence
|
v
NOSTR RELAYS
transport and preserve
|
v
OPENETR RULES
validate and derive state
|
v
CONSEQUENTIAL STATE
Nostr carries the events. OpenETR determines their consequences.
Nostr is the current OpenETR technical binding, not the definition of CSA. Another technical substrate could implement the same architectural rule if it preserved portable end-verifiability and deterministic state derivation.
Application Independence¶
Because consequential state is derived from end-verifiable events rather than a particular application's database, the same state can be reconstructed across applications and systems.
An application may disappear, become unavailable, change operators, or be replaced without necessarily destroying the evidence required to reconstruct state:
System failure need not become state failure.
The Internet analogy is useful but should remain precise:
TCP/IP routes packets around damaged connections.
Nostr can route evidence around damaged systems.
OpenETR lets conforming implementations derive state from that evidence.
State is not copied from one application's private database to another. Events are transmitted and preserved; conforming applications independently derive the applicable consequential state.
OpenETR Layering¶
OpenETR should distinguish:
| Layer | Responsibility |
|---|---|
| Artifact Layer | Establish the unique content identity of persistent digital content. |
| Evidence Graph Layer | Carry the signed, end-verifiable record or record graph concerning the artifact. |
| State Layer | Validate the Evidence Graph under an identified, versioned policy and expose the resulting consequential state. |
| Recognition Layer | Determine which actors, graphs, objects, or states are accepted for a purpose. |
| Effect Layer | Apply legal, institutional, contractual, community, or operational consequences. |
The architecture can be summarized as:
UNIQUE CONTENT
|
v
DIGITAL ARTIFACT
|
| referenced by
v
EVIDENCE GRAPH
|
| validate as a whole under an identified policy
v
CONSEQUENTIAL STATE (validation result)
|
v
DIGITAL ORIGINAL
|
v
RECOGNITION
|
v
EFFECT
OpenETR Design Rule¶
For every state variable proposed for OpenETR, ask:
Is this state consequential?
If it is consequential, the specification SHOULD identify:
- which event or sequence of events establishes it;
- which signing key or keys are permitted to produce those events;
- which prior state, events, signatures, or guards constrain the transition;
- how another implementation independently verifies the transition;
- how conflicting, invalid, superseded, ambiguous, or terminated events are resolved; and
- which consequential state results.
A consequential state field that cannot answer these questions should not be treated as authoritative ruleset-derived state. It may instead be application metadata, a cache, a hint, an unresolved assertion, or recognition-layer input.
The protocol SHOULD NOT make consequential state depend solely upon an application database row, mutable API response, private job status, or operator-controlled projection.
Relationship To C2PA¶
C2PA and OpenETR are complementary.
C2PA binds signed provenance assertions to content and describes creation, transformation, ingredients, and publication history. OpenETR identifies the Digital Artifact and validates its portable Evidence Graph under an applicable policy to produce consequential state. Recognition determines what effect a relying party gives both forms of evidence.
C2PA -> explains the content and its provenance
OpenETR -> explains consequential state and control
Recognition -> explains accepted meaning and effect
A valid C2PA Content Credential does not automatically create OpenETR consequential state. It may be evidence referenced by an OpenETR event or an input to recognition policy. Conversely, a valid OpenETR graph does not prove that C2PA provenance assertions are true or trusted.
Architectural Definition¶
Consequential State Architecture is an architecture in which consequential state is derived from portable, end-verifiable evidence of state transitions, allowing that state to be independently reconstructed and interpreted across applications and systems.
For OpenETR:
A Digital Artifact has uniquely identifiable content. A Digital Original is a Digital Artifact with consequential state.
The governing principle is:
Move the evidence for consequential state out of applications and into end-verifiable events.
The objective is simple:
Digital Originals should outlive applications.
Specification Consequences¶
Future OpenETR specifications and reviews should:
- apply the OpenETR Design Rule to every consequential state field;
- distinguish raw events, valid events, derived state, recognition results, and external effect;
- identify the protocol binding and ruleset versions used to derive a projection;
- preserve conflicting candidate evidence rather than hiding it;
- make application caches and database projections explicitly non-authoritative;
- support export or retrieval of sufficient evidence for independent replay; and
- test that independent implementations derive equivalent state from the same event set.
For every feature, reviewers should also ask:
- What is the Digital Artifact and which digest identifies it?
- What Evidence Graph record or graph establishes the relevant state?
- Who is authorized to produce those records, and what prior state constrains the transition?
- Can another implementation reproduce the same state and trace it to inspectable evidence?
- Is recognition being confused with ruleset-derived Consequential State?
- Would the consequential state survive if the originating application disappeared?