Canonical ETR Transaction Specification¶
This draft defines a canonical interaction model for OpenETR transactions.
For a simplified visual companion, see CANONICAL_ETR_TRANSACTION_INFOGRAPHIC.md.
It focuses on control-relevant actions and the minimum attestable structure required for an OpenETR scheme to express:
- issuance
- transfer
- attestation
- encumbrance
- discharge
- termination
- revocation of incomplete actions
The purpose of this note is not to prescribe one legal implementation for all use cases. It is to define a canonical transaction grammar that can be:
- independently attested
- independently recognized
- evaluated under explicit policy
- aligned with MLETR-style reliability requirements without relying on platform trust
Status¶
Draft.
Purpose¶
OpenETR treats legal effect as the result of attested actions rather than as the product of a platform or registry asserting state.
That means the canonical question is not:
What does the system say happened?
It is:
Which actions were declared, accepted where required, attested by accountable parties, and recognized under policy?
This specification defines the minimal matrix for answering that question.
Core Principle¶
All control-relevant actions in the strong canonical model are independently attested.
The model is designed to support recognition of effect where all required actions are:
- performed
- attested
- recognized
In this model, attestation applies to each action, not merely to the final outcome.
At the same time, OpenETR does not require that every event be separately attested in every implementation profile.
An attestor may instead attest a later event, including a termination event, provided that the attestation reflects validation of the prior control chain necessary to recognize that later event.
This means OpenETR can support both:
- event-level attestation, where each control-relevant action is attested as it occurs
- chain-level attestation, where a later event is attested after the relevant prior chain has been validated
The decisive question is therefore not only whether an event was directly attested, but what the attestor is claiming to have validated and recognized.
This canonical model is intentionally more formal and evidence-based than the minimum profile that may be sufficient among a small trusted group of counterparties.
In some limited operational contexts involving a small and otherwise trusted set of counterparties, the parties may choose to recognize the effect of a transfer without separate third-party attestation.
In that case, recognition arises from the parties' own agreed policy and trust relationship rather than from the fuller OpenETR attestation model.
In such a simplified local-recognition profile, ordinary transfer steps may be recognized without separate attestation, although a specific attestation may still be used where the parties want to attach additional meaning, instruction, endorsement, or indorsement to a particular event.
Such a profile may be operationally sufficient for that narrower context, but it provides a weaker basis for independent verification, portability, and later dispute resolution.
As the model scales beyond a small trusted group, the participating parties may increasingly require attestation in order to rely on events generated by others without direct trust relationships.
In some contexts, attestation may also be required not only for commercial confidence, but for legal effect, institutional acceptance, or official recognition.
Accordingly, OpenETR should be understood as supporting a spectrum:
- simplified local recognition with little or no separate attestation for ordinary transfers
- selective attestation where additional instruction or endorsement-like meaning is required
- fuller attestation models where events, chains, or both are attested for broader reliance and recognition
Canonical Interaction Matrix¶
| Lifecycle | Declare (Initiator) | Accept (Counterparty) |
|---|---|---|
| Issue | Declare Issue -> Attest(Declare) | — |
| Transfer | Declare Transfer -> Attest(Declare) | Accept Transfer -> Attest(Accept) |
| Encumber | Declare Encumbrance -> Attest(Declare) | Accept Encumbrance -> Attest(Accept) |
| Discharge | Declare Discharge -> Attest(Declare) | Accept Discharge -> Attest(Accept) |
| Terminate | Declare Termination (Release / Cancel / Substitute) -> Attest(Declare) | — |
In this matrix:
declaremeans to publish the substantive control action or assertion being madeacceptmeans to publish the counterparty's acceptance where the lifecycle requires it
Attestation¶
In this specification, attest means for an identifiable attestor to publish accountable recognition, witness, validation, or policy-backed support for the relevant declared or accepted action.
Attestation is an authenticated assertion relating to the object or to a control-relevant event in its lifecycle.
Examples may include:
- custody
- inspection
- quality
- quantity
- certification
- endorsement-like or indorsement-like instruction
Required actions:
- declare attestation
- attest the declaration
No counterparty acceptance is required in the canonical model, although an application profile may add additional conditions for recognition.
Attestation does not by itself change the current controller.
In this specification, attestation is discussed separately from lifecycle actions because it operates as an associated evidence, witness, and recognition layer that may attach to relevant events rather than as a lifecycle transition in its own right.
Mandate and Effect¶
OpenETR does not itself provide a mandate or effect.
Instead, the canonical model defines the action sets and evidence structures that may support recognition of mandate or effect under the applicable framework.
Therefore:
- Issue requires
Declare + Attest - Transfer requires
Declare + Accept + Attest(Declare) + Attest(Accept) - Encumber requires
Declare + Accept + Attest(Declare) + Attest(Accept) - Discharge requires
Declare + Accept + Attest(Declare) + Attest(Accept) - Terminate requires
Declare + Attest
Recognition is external to raw event publication. An event may exist on relays and still lack effect if the required action set has not been completed or if the attestors are not recognized under policy.
Terms¶
Object¶
The electronic transferable record or the canonical object identifier to which a transaction applies.
Controller¶
The party capable of exercising control over the object at a given moment.
Initiator¶
The party that publishes the substantive control-relevant action or assertion.
Counterparty¶
The party whose acceptance is required for the action to become effective.
Attestor¶
An identifiable signing party whose attestation anchors accountable recognition, witness, validation, or policy-backed support for a specific declared or accepted action.
Recognition¶
The policy act of treating an attested action set as effective for the relevant legal or operational context.
Endorsement and Indorsement¶
OpenETR does not treat endorsement or indorsement as a standalone universal protocol primitive.
Instead, where relevant, OpenETR expresses endorsement or indorsement as an attestation associated with an underlying OpenETR event, with its legal or commercial characterization determined by the applicable recognition framework.
At the Protocol Layer, the relevant questions are:
- who signed
- what was declared
- which object was referenced
- whether control changed
- what assertions were made
- whether the resulting chain is recognized under policy
In the revised model:
- actions that change control are typically modeled as
TRANSFER - actions that add authenticated meaning, approval, instruction, limitation, or related assertions without themselves changing control are typically modeled as
ATTEST
Whether a particular combination of TRANSFER, ATTEST, and related recognized events constitutes an endorsement or indorsement for legal or commercial purposes is determined by the applicable Recognition Layer.
Event Validity and Recognition¶
Because OpenETR operates in an open environment, the protocol must distinguish between:
- event validity
- recognition
These are related, but they are not the same thing.
Event Validity¶
Event validity concerns cryptographic and structural correctness.
Examples include:
- whether the event signature is valid
- whether the event id is valid
- whether the object identifier is well formed
- whether required tags are present
- whether referenced prior events exist
- whether the event chain is structurally traversable
These checks answer questions such as:
- Did this event occur in the claimed form?
- Is it well formed?
- Is it authentically attributable?
They do not determine whether the event should be treated as effective.
Recognition¶
Recognition concerns the policy conditions under which an event or chain is treated as effective.
Examples include:
- whether the relevant controller was entitled to perform the action
- whether a transfer requires a corresponding accept event
- whether an encumbrance or discharge requires additional supporting conditions under policy
- whether a signer is recognized as a legitimate actor for the claimed role
- whether an attestation or chain is sufficient under the applicable policy
These checks answer questions such as:
- Should this event be treated as effective?
- Does this event satisfy the conditions for recognition?
Consequence¶
An event may therefore be:
- valid but not recognized
- recognized only under a particular policy profile
- invalid and therefore incapable of recognition
This distinction is essential in OpenETR because anyone may publish an event, but not every published event deserves recognition as effective.
A useful way to express this distinction is to separate hard guards from soft guards.
- hard guards protect validity
- soft guards govern recognition
Hard guards prevent a transition because the event fails minimum validity requirements.
Soft guards do not necessarily prevent publication. Instead, they operate as policy conditions on the state transition model. They may:
- emit a warning at declaration time
- require confirmation by an operator or workflow
- lead a later evaluator to refuse recognition
In this sense, policy operates as a soft guard on state transitions. It does not necessarily prevent a declaration from being made, but it influences whether the resulting transition is later recognized as effective.
Determination of Legal Effect and Recognition¶
In OpenETR, the determination of legal effect or operational recognition does not arise from a platform simply asserting state.
Instead, it arises from evaluation of the signed evidence chain.
That evidence chain may include:
- the Anchor Event
- later evidence events
- any accept or terminate events
- any event-level or chain-level attestations
- any actor legitimacy attestations relevant to the participants
The determining party may therefore ask:
Does the full signed chain satisfy the applicable validation rules and cryptographic checks for recognition?
Signed Evidence Chain¶
The full control history exists as linked signed events.
Those events can be evaluated for:
- cryptographic correctness
- continuity of references
- consistency of object identity
- role and signer legitimacy
- compliance with the applicable guards or policy rules
This evidence does not need to remain inside any one platform, database, registry, or single operational system.
Because OpenETR is built on the Nostr protocol, the signed events can exist across multiple independent relays while remaining portable, attributable, and verifiable.
That is a fundamental difference from models in which the authoritative record is inseparable from one database, one registry operator, or one blockchain environment.
In OpenETR, the evidence chain can persist outside and independently of any one system because the relevant unit is the signed event itself rather than the custody of a single data store.
OpenETR now applies the same general design direction to its CLI administration layer as well: operational configuration is increasingly represented by relay-backed signed records rather than being treated as machine-local state alone.
Recognition Basis¶
Legal effect or operational recognition may therefore be based on whether:
- the relevant events are cryptographically valid
- the event chain is coherent and complete enough for the use case
- the participants are recognized as legitimate actors where policy requires that
- the applicable guards or rules have been satisfied
- the relevant attestation claims, if any, are themselves valid and recognized
Consequence¶
OpenETR therefore provides a basis for recognition by making the relevant chain available as inspectable, signed evidence.
The protocol does not itself declare final effect.
It enables the determining party to validate the chain according to:
- cryptographic correctness
- explicit guards and rules
- attestation policy
- recognition policy
This means OpenETR should not be understood as saying:
Publication equals effect.
It should instead be understood as saying:
Publication provides evidence. Recognition determines effect.
Actor Legitimacy Attestation¶
OpenETR may also require a distinct form of attestation concerning the legitimacy of the participating actors themselves.
This is different from attestation of a transaction event or of a control chain.
It addresses questions such as:
- who this signer is
- whether the signer is a legitimate actor for the role being claimed
- whether the signer is recognized for purposes such as issuance, transfer, custody, attestation, encumbrance, discharge, redemption, or termination
This creates a useful distinction between:
- actor legitimacy attestation
- transaction attestation
- chain-level attestation
Purpose¶
An event chain may be structurally valid and cryptographically well-formed while still depending on whether the participants are recognized as legitimate actors for the relevant role.
Examples may include:
- whether an issuer is recognized as a legitimate carrier
- whether a controller is recognized as the entitled party
- whether an attestor is recognized as an accepted validator under policy
Consequence¶
Recognition of an evidence event may therefore depend not only on the event chain itself, but also on whether the relevant signers have been independently attested as legitimate actors for the roles they claim to perform.
Working Interpretation¶
In a fuller OpenETR model, actor legitimacy attestation may bind an npub to one or more recognized identities, roles, or organizational attributes, such as:
- legal name
- role
- jurisdiction
- LEI
- policy reference
- attestation period or validity interval
This is a separate layer from attesting whether a given transaction event or control chain should be recognized.
Canonical Lifecycle Action Types¶
1. Issue¶
Issue is the initial declaration that an object is being brought into effective circulation under the scheme.
Required actions:
- declare issue
- attest the declaration
No counterparty acceptance is required for issue in the canonical model.
Issue provides a basis for recognized effect only when the declaration is both:
- attested
- recognized
2. Transfer¶
Transfer is the movement of control from one controller to another.
Required actions:
- declare transfer by the initiating side
- accept transfer by the receiving side
- attest the declaration
- attest the acceptance
Transfer provides a basis for recognized effect only when all four action components are recognized.
3. Encumber¶
Encumbrance is an authenticated declaration that the object is subject to a claimed restriction, pledge, lien, security right, or similar burden relevant to recognition.
Required actions:
- declare encumbrance
- accept encumbrance by the affected counterparty where the stronger canonical profile requires bilateral acknowledgment
- attest the declaration
- attest the acceptance
In the stronger canonical model, counterparty acceptance is part of the full action set for recognized encumbrance.
A unilateral encumbrance declaration may still be published in an open system and may still be relevant as evidence that a claim was asserted.
However, in most recognition settings, publication alone should not be enough to treat the encumbrance as recognized.
Some simplified or policy-specific profiles may nonetheless recognize a unilateral encumbrance declaration, but that is a weaker recognition pattern than the bilateral canonical model.
Encumbrance does not by itself change the current controller.
4. Discharge¶
Discharge is an authenticated declaration that a previously claimed encumbrance has been released, satisfied, or otherwise brought to an end.
Required actions:
- declare discharge
- accept discharge by the relevant counterparty where the stronger canonical profile requires bilateral acknowledgment
- attest the declaration
- attest the acceptance
In the stronger canonical model, counterparty acceptance is part of the full action set for recognized discharge.
A unilateral discharge declaration may still be published in an open system and may still be relevant as evidence that release or satisfaction was asserted.
However, in most recognition settings, publication alone should not be enough to treat the discharge as recognized.
Some simplified or policy-specific profiles may nonetheless recognize a unilateral discharge declaration, but that is a weaker recognition pattern than the bilateral canonical model.
Discharge does not by itself change the current controller.
5. Terminate¶
Termination ends or supersedes the current effective state of an object within the scheme.
Canonical termination forms include:
- release
- cancel
- substitute
Required actions:
- declare termination
- attest the declaration
No counterparty acceptance is required in the canonical model, although an application profile may impose one.
Working Event Kind Allocation¶
For the current OpenETR reference direction, canonical transaction families are split across distinct event kinds.
The working registry for these assignments is maintained in EVENT_KIND_REGISTRY.md.
Working allocation:
1415= Anchor Event1416= evidence-event family
Anchor Event¶
The Anchor Event is the event by which an object first enters the OpenETR scheme.
It is intended to represent:
- initial issuance
- initial declaration of the object within the scheme
- the first effective control-relevant state for that object
In the current working model, Anchor Events are published as:
kind = 1415
Evidence Event Family¶
The Evidence Event family carries signed evidence of later actions after the Anchor Event. Some actions are control-relevant; others contribute different evidence to the Evidence Graph.
It is intended to represent:
- transfer of control from one controller to another
- later control transitions in the object lifecycle
- later control-relevant assertions, limitations, discharges, and presentation actions
In the current working model, evidence events are published as:
kind = 1416
Working 1416 Action Family¶
Within the current working model, kind 1416 is treated as an Evidence Event
family rather than as a single undifferentiated action.
The action distinction is currently expressed through the action tag:
action=initiateaction=acceptaction=terminateaction=attestaction=encumberaction=dischargeaction=redeem
This means that:
- transfer initiation
- transfer acceptance
- termination
- attestation
- encumbrance
- discharge
- redemption
are presently modeled as distinct actions within the same 1416 event family rather than as separate event kinds.
The current reference implementation exposes these actions through the CLI commands documented in OPENETR_CLI_IMPLEMENTATION_WALKTHROUGH.md. The minimum event shapes are specified in CONTROL_EVENT_MINIMUM_SHAPES.md, and the wire-level tag grammar is specified in OPENETR_NOSTR_WIRE_FORMAT_SPEC.md.
This is a working design choice, not yet a final registry decision.
Working Tag Conventions¶
The current regular-event model uses:
oas the Digital Artifact identifier carried across the Evidence Graph;eas the exact prior-event link for graph traversal;actionas the semantic subtype for a1416Evidence Event; and- action-specific tags such as
p,enc,type, andrefwhere required.
The d tag is not part of the current Evidence Graph grammar. It shall not be used
as the basis for graph reconstruction.
Event Kind Split Rationale¶
This split is useful because it distinguishes:
- the event that brings an object into the scheme
- the events that subsequently move control over that object
That separation improves:
- query clarity
- lifecycle reasoning
- validation logic
- traversal of control history
It also allows an implementation to identify the initial OpenETR record without inferring it only from timestamps or event ordering within a single mixed event family.
Current Scope¶
This specification currently treats the following as the working minimum:
- anchoring or issuance mapped to
1415 - later consequential actions mapped to
1416and distinguished byaction
Substitution, cancellation, and revocation may later receive their own event kinds or remain subtyped within broader event families depending on implementation experience. Attestation, termination, encumbrance, discharge, and redemption are currently implemented as subtyped 1416 actions.
This allocation should therefore be treated as:
- current working convention
- not yet a final permanent registry decision
Query Implications¶
Under this split-kind model:
- initial-record discovery should query Anchor Events
- control-history traversal should query evidence events
- full object-state evaluation will typically need both event families
In practice that means an implementation may need to:
- query the object's Anchor Event using
kind = 1415 - query subsequent evidence events using
kind = 1416 - validate the Evidence Graph and apply defined state transition rules
In the current reference flow, object-history evaluation is therefore object-centric first.
That is, implementations commonly:
- determine the object identifier
- query Anchor Events and later Evidence Events by the object's
otag - derive candidate control chains from linked
ereferences - apply local policy to determine which chain, if any, is recognized
This helps support:
- current-controller determination
- termination guards
- ambiguity detection where more than one candidate control chain exists for the same object
This is consistent with the broader OpenETR design goal of making lifecycle semantics explicit rather than collapsing all control-relevant actions into one undifferentiated event stream.
Regular Events, Persistence, and Attestation¶
Anchor Events and Evidence Events are regular Nostr events. Exact event ids form the graph edges, so a graph node shall not be represented as an addressable or replaceable event.
Relay retention is still not the source of Consequential State or external effect. Relays transport, index, and preserve signed evidence. Implementations should use relay diversity, archives, exports, or local stores appropriate to their availability and retention requirements.
Attestation is one possible form of Evidence Graph records. An attestation may identify an accountable actor that witnessed, evaluated, certified, or recognized another record. Whether an attestation is required, sufficient, or effective is determined by the identified verifier policy and the applicable recognition framework.
Consequential State is derived from validated Evidence Graph records under defined rules. No attestor, relay, or platform is the universal trust anchor for every OpenETR record.
Revocation¶
Revocation is not a lifecycle transition in the same sense as issue, transfer, attest, or terminate.
Revocation applies only to actions that are:
- declared
- optionally accepted
- not yet fully attested
That means revocation is a control on incomplete action sets.
Revocation itself must be:
- declared
- attested
Revocation must not be used to unwind a transaction that has already become effective under the canonical rule unless a separate correction, dispute, rescission, or termination policy expressly permits it.
Action Completion Model¶
A transaction is not evaluated as a monolithic event. It is evaluated as an action set.
The minimum evaluation steps are:
- Identify the intended lifecycle action.
- Determine the required action components for that lifecycle.
- Determine whether each required component exists.
- Determine whether each required component is attested.
- Determine whether the attestors are recognized under policy.
- Determine whether the action set is internally consistent and refers to the same object and transaction context.
- Conclude effect only if the complete required set is present, attested, and recognized.
Reliable Method Under MLETR¶
MLETR requires a reliable method to:
- identify the record
- preserve integrity
- establish exclusive control
- identify the person in control
MLETR deliberately does not prescribe one implementation.
OpenETR therefore does not claim that attestation is required by MLETR as such.
Instead, OpenETR uses attestation as the mechanism by which reliability is achieved and evidenced.
OpenETR formulation¶
OpenETR satisfies the reliable-method requirement by making reliability attributable to identifiable attestors (npubs) who apply defined policies, rather than to a platform or system as a whole.
Consequences¶
This means:
- identifiability is anchored in public keys
- accountability is anchored in signatures attributable to specific attestors
- integrity is anchored in the event and attestation chain
- exclusive control is expressed by recognizing only properly attested control transitions as effective
Actor-Based Reliability¶
This specification rejects platform-based reliability as the canonical trust model.
It does not assume:
- the platform is reliable because it is certified
- the registry is reliable because it is centralized
- the application is reliable because it controls the database
Instead, it adopts actor-based reliability:
- each control-relevant action is attributable
- each attestor is identifiable
- each attestor is accountable for the application of policy
- each attestation can be independently reviewed
Canonical rule¶
Every control-relevant action must be attested by an identifiable party whose public key anchors accountability for the application of policy.
Strength Compared With Platform Trust¶
1. Granular accountability¶
The relevant question becomes:
Who attested this specific action?
instead of:
Which system was supposed to manage it?
2. Composability¶
Different policies and attestors may coexist.
The scheme can support:
- multiple attestors
- different recognition rules
- layered validation
- selective acceptance by different relying parties
3. Auditability¶
Each attestation is:
- signed
- attributable
- reviewable
- separable from platform claims
4. Legal alignment¶
Legal systems ultimately hold actors and entities accountable, not software abstractions.
This model aligns the technical structure with that practical legal reality.
Transaction Recognition¶
Recognition is out of scope for the raw event layer and in scope for policy.
An implementation profile must specify:
- which attestors are recognized
- which policies they are expected to apply
- whether one or multiple attestations are required for a given action
- how conflicts are resolved
- how disputes, rescissions, and substitutions are handled
This specification only defines the canonical minimum:
- no effect without a fully attested required action set
Minimum Data Expectations¶
This specification does not yet define a final wire format, but each canonical transaction should be able to express at least:
- the object identifier
- the lifecycle type
- the action type
- the initiating party
- the counterparty where applicable
- the attestor identity
- the policy context or policy reference
- the relationship to prior actions where applicable
- the signature covering the action
Canonical Validation Rules¶
An OpenETR transaction action should be considered canonically valid only if:
- the object is clearly identified
- the action type is clearly identified
- the signer is identifiable
- the attestation is cryptographically valid
- the action is internally consistent with its referenced object and counterpart actions
- the action satisfies the lifecycle’s required interaction pattern
An OpenETR transaction becomes canonically effective only if:
- all required actions are present
- all required actions are attested
- the relevant attestors are recognized
Transaction Families¶
This specification is intended to support transaction families such as:
- canonical issue transactions
- canonical transfer transactions
- canonical attestation transactions
- canonical encumbrance transactions
- canonical discharge transactions
- canonical termination transactions
- canonical revocation transactions for incomplete action sets
Future companion specifications may define:
- a canonical event schema
- a canonical attestor schema
- policy reference formats
- dispute and rescission handling
- transaction grouping and correlation identifiers
Non-Goals¶
This draft does not yet define:
- a complete JSON schema
- a final Nostr event-kind assignment
- jurisdiction-specific legal effect rules
- substantive commercial law rules for title, negotiability, or legal effect
- a universal recognition policy
Alignment with Existing Legal Frameworks¶
This specification is intended to align with, and reinforce, existing and emerging legal frameworks for electronic records, control, and digital assets.
It does not claim that OpenETR by itself satisfies every legal requirement of any given jurisdiction.
Instead, the intended relationship is that OpenETR provides a structured evidence model that can support compliance, recognition, and analysis under the applicable framework.
UCC Article 12¶
At a high level, this model is consistent with the UCC Article 12 emphasis on control-oriented treatment of electronic records and related digital rights.
In particular, OpenETR reinforces the practical importance of:
- identifying the relevant electronic record
- identifying the person in control or the recognized claimant
- preserving a coherent chain of signed actions
- making transfer and related assertions inspectable and attributable
This is intended as a high-level alignment statement, not a claim that every OpenETR event automatically constitutes a controllable electronic record or has Article 12 effect without the applicable legal conditions being met.
UNCITRAL MLETR¶
The canonical OpenETR model closely tracks the MLETR focus on reliable methods, control, integrity, and identification of the person in control.
OpenETR is designed to support those concerns by providing:
- a durable object identifier
- a signed event chain
- explicit control-relevant actions
- explicit identification of the acting participant
- an evidence structure that can be evaluated for reliability
In this sense, OpenETR is intended to reinforce the MLETR logic that legal recognition should depend on reliable identification, control, and integrity rather than on paper possession alone.
UNCITRAL-UNIDROIT MLWR¶
The model also aligns naturally with the MLWR focus on issuance, transfer, and dealings in electronic and paper-based warehouse receipts.
OpenETR does not replace the substantive warehouse-receipt rules of the MLWR.
It can, however, reinforce them by providing:
- a control history for the receipt
- attributable transfer-related events
- evidence relevant to warehouse-receipt transfer, protected-holder analysis, and related security-right questions
This makes OpenETR a potentially useful evidentiary and operational layer for systems implementing electronic warehouse receipts under the MLWR approach.
UNIDROIT DAPL Principles¶
The model is also broadly consistent with the DAPL Principles emphasis on control, transfer, custody, security rights, and the proprietary treatment of digital assets.
OpenETR does not attempt to restate the DAPL Principles.
However, it reinforces a number of the same structural ideas by:
- treating the relevant record as an electronically identifiable object
- emphasizing control and attributable action rather than platform assertion
- supporting transfer, encumbrance, discharge, custody-style attestation, and related evidence chains
This makes OpenETR a useful practical complement where digital-asset-style control and private-law analysis intersect with transferable records.
English Law Commission on Digital Assets¶
The model is also broadly aligned with the English Law Commission's digital-assets work to the extent that it treats digitally native or digitally managed records through functional concepts such as control, attribution, transfer, and evidence rather than through older paper-bound categories alone.
OpenETR reinforces that direction by providing a protocol-neutral control and evidence structure capable of supporting legal analysis without making legal effect depend on any single platform, registry, or database.
Overall Relationship¶
Taken together, these frameworks point toward a common direction:
- electronic records can be legally significant
- control matters
- integrity matters
- attributable actions matter
- legal effect depends on the applicable framework rather than on technical publication alone
OpenETR is designed to reinforce that direction by supplying signed, portable, inspectable evidence of control-relevant events.
Its role is therefore complementary:
- not to replace the applicable law
- not to override the governing legal framework
- but to provide a stronger technical and evidentiary basis on which those frameworks may operate
Summary¶
The central move in this specification is simple:
Reliability is not treated as a property of systems. It is treated as a property of accountable actors applying policy.
OpenETR makes that accountability explicit through attestation.
That allows the scheme to express control-relevant transactions in a way that is:
- independently verifiable
- policy-aware
- portable across infrastructures
- aligned with the technology-neutral logic of MLETR
Illustrative Examples¶
These examples are illustrative only.
They are intended to show how the canonical model may be applied across different recognition profiles.
1. Fully Attested Transfer in a Broad-Reliance Profile¶
A carrier issues an electronic bill of lading into OpenETR.
The current controller later declares a transfer to a buyer.
The buyer accepts the transfer.
An attestor validates:
- the object identity
- the transfer declaration
- the acceptance
- the signer legitimacy required by policy
In this example, the resulting evidence set provides a strong basis for later independent reliance because the action set is declared, accepted, attested, and recognized.
2. Simplified Transfer Among Trusted Counterparties¶
Three known trading parties use OpenETR within a closed operational relationship.
One party declares a transfer and the receiving party accepts it.
The parties agree by prior policy that, within their own relationship, this is enough to recognize the transfer without separate third-party attestation.
In this example, OpenETR still records the relevant action set, but recognition arises from the parties' own trust relationship and local policy rather than from the fuller attestation model.
This may be operationally efficient, but it provides a weaker basis for outside reliance, independent verification, and later dispute resolution.
3. Transfer with an Indorsement-Like Instruction¶
A transfer is declared and accepted in the ordinary way.
Later, an ATTEST event is associated with the relevant underlying event and carries additional meaning or instruction, such as presenter-entitled redemption or another endorsement-like instruction.
In this example, the endorsement or indorsement is not a standalone evidence-event primitive.
Instead, it is expressed as an attestation associated with the underlying OpenETR event, with its legal or commercial characterization determined by the applicable recognition framework.
4. Encumbrance Without Change of Controller¶
The current controller declares that the Digital Artifact is subject to a security interest in favor of another party.
That declaration is attested under the applicable policy.
In this example, the event may support recognition of an encumbrance affecting the object, but it does not by itself change the Current Controller.
The legal validity, perfection, and priority of the claimed encumbrance remain recognition-layer questions.
5. MLWR-Style Pledge Bond¶
A warehouse operator issues a negotiable warehouse receipt covering stored goods.
Under an MLWR-style dual receipt system, a related pledge bond is granted to a lender and gives that lender a security right in the goods covered by the warehouse receipt.
In OpenETR terms, the warehouse receipt remains the Digital Artifact, while the pledge-related claim may be expressed through an ENCUMBER action set associated with that receipt and identifying the secured party or pledge bond holder.
If the stronger canonical model is used, the encumbrance is declared, accepted, and attested as the basis for recognized encumbrance effect.
Later, once the secured obligation is satisfied or the pledge bond is otherwise released, a corresponding DISCHARGE action set may be recorded against the same Digital Artifact.
In this example, OpenETR does not itself create the pledge or determine its legal validity, perfection, priority, or enforceability.
It provides the signed evidence structure through which an MLWR-style security right may be declared, recognized, and later discharged.
6. Bearer-Style Presentation Profile¶
A PDF is issued into OpenETR as a Digital Artifact.
An attestation is associated with the object or a relevant event stating, under the applicable recognition framework, that redemption is available to a valid presenter of the recognized evidence chain.
The redeemer later recognizes the first valid redemption presented for that object id and records redemption or termination against the same object.
In this example, OpenETR supplies the evidence structure for a bearer-like or presenter-entitled profile, but whether that profile has legal or operational effect remains a question for the relevant recognition framework.
7. Warehouse Receipts for an Impending Export Shipment¶
An exporter holds electronic warehouse receipts issued by multiple warehouse operators covering goods that must be assembled for an impending export shipment.
Each receipt exists as a PDF or similar electronic record and has been issued into OpenETR as a Digital Artifact with its own object id and control history.
To prepare the shipment, the exporter sends the relevant receipt PDFs to the warehouse operators by email and requests redemption or release of the goods for export.
Each warehouse operator has only basic internet access and does not need to run a specialized private platform.
Instead, the warehouse operator may use a public verification tool, such as a web-based application like OpenETR.org, to:
- compute or confirm the object digest from the received PDF
- retrieve the corresponding OpenETR event history
- verify the issuance and transfer chain
- inspect any attestation, endorsement-like instruction, encumbrance, discharge, redeem, or terminate events relevant to the receipt
- determine whether the presenter has shown a recognized basis for release
Once satisfied, the warehouse operator may release the covered goods or recognize redemption for that receipt and then record the corresponding redeem or terminate event against the same object id.
In this example, OpenETR allows multiple warehouse receipts from different issuers to be verified through the same open evidence model, while still leaving the final decision to release goods to the warehouse operator's governing policy, contract, and applicable law.
8. Non-Transferable Club Membership¶
A club issues a digital membership record as a Digital Artifact.
The membership is intended to be personal to the named member and not transferable to others.
An associated restriction or ENCUMBER action set provides that only the identified member, or a person expressly authorized under the club's rules, may present or use the membership and that it may not be transferred in the ordinary course.
In this example, the restriction does not itself transfer control.
Instead, it provides signed evidence supporting recognition of an exclusive presentation and non-transfer condition attached to the membership record.
If the membership later expires, is cancelled, or is revoked, a corresponding termination event may be recorded.