Skip to content

MLWR Warehouse Receipt Pilot Boundary Notes

This note captures pilot-design boundaries for using OpenETR with a warehouse receipt system.

It is based on the position that OpenETR is a correctness protocol for portable control evidence, not the reliable system, identity provider, KYC provider, account system, warehouse management system, registry, or federation operator.

Status

Pilot note.

Purpose

A warehouse receipt pilot needs a clean boundary between:

  • the system that operates the warehouse receipt service
  • the legal and operational identity controls around user accounts
  • the OpenETR protocol events that record control-relevant facts
  • the federation arrangements among participating system operators
  • the attestation and recognition policies that give evidence practical effect

The compact model is:

Reliable system:
  accounts, KYC, authorization, custody, document generation,
  operational controls, user experience, federation agreements

OpenETR correctness protocol:
  digest-identified objects, signed Anchor Events and later Evidence Events,
  profile keys, control graphs, linked evidence, verifier output

Recognition layer:
  MLWR-style law, contracts, registry rules, platform rules,
  institutional policy, attestation requirements, relying-party decisions

OpenETR should exist between systems as portable evidence. It should not absorb the duties of those systems.

Reliable System Versus Correctness Protocol

The pilot should distinguish a reliable system from a correctness protocol.

A reliable system is the operational environment that creates, manages, and governs warehouse receipt activity.

It may include:

  • user accounts
  • KYC and legal-identity onboarding
  • role assignment
  • warehouse operator authorization
  • customer onboarding
  • document generation
  • warehouse management integration
  • storage and access control for receipt content
  • audit and compliance controls
  • operational security
  • business workflow
  • support and dispute handling
  • federation agreements with other operators

OpenETR is narrower.

It provides a correctness protocol for signed evidence about a digital artifact.

It can answer:

  • Which receipt artifact or package is identified by digest?
  • Which profile key signed the Anchor Event?
  • Which evidence events refer to the same object?
  • Which prior events are linked into the control graph?
  • Which participant keys are named?
  • Which attestations or linked evidence exist?
  • What candidate control state can be derived under a selected verifier policy?
  • What warnings arise from the graph?

It should not answer by itself:

  • Was the user properly KYC'd?
  • Is this account legally tied to the named person or organization?
  • Is the warehouse operator licensed?
  • Is the signer authorized under the pilot rulebook?
  • Does this receipt satisfy statutory content requirements?
  • Do federation partners recognize this account, key, receipt, or event?
  • Is an attestation legally sufficient?

Those are reliable-system, domain-adapter, federation, and recognition questions.

KYC And Account Boundary

OpenETR should not perform KYC.

KYC belongs to the host warehouse receipt system or to an integrated identity/compliance provider chosen by that system.

For the pilot, the host system should be responsible for:

  • creating a user account
  • tying that account to a legal person or legal entity
  • performing or relying on KYC, KYB, AML, sanctions, or registry checks where required
  • assigning account roles and permissions
  • recording account lifecycle events
  • deciding whether a user may issue, transfer, accept, encumber, discharge, redeem, or terminate a receipt
  • maintaining the business record that links account identity to operational authority

OpenETR only sees the keys and signed events that the system permits to act.

The distinction is:

account identity:
  who the system says the user or organization is

OpenETR key identity:
  which key signed the evidence event

recognition policy:
  whether the account-to-key binding and system controls are sufficient

Account-Controlled Key Creation

In the pilot, account context may provide the secure environment used to generate or protect OpenETR keys.

The system may:

  • create a root admin identity for the account
  • create one or more operational profile keys
  • protect signer material using account security controls
  • store encrypted profile signer material
  • require multi-factor authentication for sensitive actions
  • separate administrative key access from operational signing access
  • maintain logs tying key creation and use to the account

This does not mean OpenETR performs account management.

It means the reliable system creates an accountable operating environment in which OpenETR keys are generated, stored, selected, and used.

OpenETR's root/profile model remains:

root admin identity:
  organizes the OpenETR environment and profile set

profile signer identity:
  signs operational OpenETR events

host account:
  provides the legal, operational, and security context around those keys

Accountability Chain

Ultimate accountability in the pilot depends on linking the OpenETR key material to the host-system account.

The useful chain is:

legal identity
  -> host-system account
  -> account roles and permissions
  -> root admin identity
  -> operational profile key
  -> signed OpenETR event
  -> warehouse receipt control graph

OpenETR can prove that a profile key signed an event.

The host system must be able to prove, or at least evidence under its rulebook, that:

  • the account was tied to a legal identity
  • the account was allowed to control the root or profile
  • the profile key was created, imported, or activated under that account
  • the signing action was authorized under the account's role and workflow
  • any required internal approval, dual control, or attestation was satisfied

This account-to-key accountability record may be private to the host system, exposed through a registry, or provided as linked evidence.

OpenETR should not require private account records to be public. It should allow references, attestations, or verifier-policy hooks that make the relationship auditable when needed.

Profiles And Roles

Pilot systems should avoid treating one account as always equivalent to one OpenETR signer.

A single account may control multiple profiles.

Examples:

  • warehouse operator root
  • facility issuer profile
  • inventory-control profile
  • finance-office profile
  • system automation profile
  • emergency recovery profile

Likewise, one legal entity may operate multiple accounts or facilities.

The pilot should define:

  • which profiles may issue receipts
  • which profiles may transfer control
  • which profiles may attest facts
  • which profiles may declare encumbrances
  • which profiles may discharge encumbrances
  • which profiles may redeem or terminate receipts
  • whether profile use requires human approval or system automation

OpenETR records which key signed. The reliable system records why that key was allowed to sign.

Federation Boundary

Federation is an arrangement among system operators.

OpenETR can provide portable signed control evidence that travels between systems, but it does not automatically create a federation.

Federation may require agreement on:

  • participant onboarding
  • KYC or KYB standards
  • legal identity assurance
  • account-to-key binding requirements
  • profile naming or metadata conventions
  • relay or archive infrastructure
  • receipt document formats
  • accepted domain tags
  • attestation requirements
  • verifier policies
  • dispute resolution
  • suspension, revocation, or emergency handling
  • data sharing and privacy rules

The OpenETR graph can move between participants.

Recognition of that graph is a federation-policy decision.

OpenETR portability:
  another system can inspect the signed object/control graph

Federation recognition:
  another system agrees to rely on that graph under shared rules

The pilot should therefore document federation rules separately from the OpenETR wire format.

Attestation Boundary

Attestation fits naturally in OpenETR.

An attestation can be represented as a signed event or linked evidence about:

  • the warehouse operator
  • the account-to-key binding
  • the receipt artifact
  • goods custody
  • inspection results
  • insurance
  • financing
  • encumbrance status
  • release or discharge
  • registry status
  • legal identity assurance
  • system reliability
  • federation membership

But the responsibility for requiring and evaluating attestations remains outside the OpenETR core.

The host system, federation rulebook, registry, or verifier policy should decide:

  • which attestations are required
  • who may issue them
  • when they must be refreshed
  • whether they are public or private
  • whether missing attestations produce warnings or hard failures
  • whether an attestation changes control or only supports recognition

OpenETR should record and retrieve attestation evidence. It should not decide universal attestation sufficiency.

Pilot Event Responsibilities

The pilot should classify responsibilities this way.

Responsibility Reliable System OpenETR Recognition / Federation
User account creation yes no may set requirements
KYC / KYB yes no may require evidence
Legal identity binding yes no evaluates sufficiency
Root/profile key generation context yes stores/signs through keys evaluates controls
Receipt document creation yes hashes artifact evaluates content
Anchor Event authorizes action signs/publishes event evaluates signer authority
Transfer event authorizes workflow signs/publishes event evaluates legal effect
Encumbrance/discharge authorizes workflow signs/publishes event evaluates priority/effect
Attestation requires and obtains records signed evidence evaluates sufficiency
Federation membership negotiates and enforces provides portable graph recognizes participants
Verifier warnings supplies policy inputs computes graph warnings decides effect

Pilot Design Principles

The pilot should use the following principles.

Keep OpenETR Narrow

OpenETR should be responsible for correctness of the portable control graph:

  • object digest correctness
  • event signature correctness
  • prior-event linkage
  • graph reconstruction
  • candidate state derivation
  • signed evidence retrieval

Keep The Host System Accountable

The host system should remain responsible for:

  • legal identity
  • account security
  • KYC
  • authorization
  • operational controls
  • document content
  • business process
  • private data custody

Make Bindings Explicit

The pilot should explicitly record or reference:

  • account-to-root binding
  • account-to-profile binding
  • profile-to-role binding
  • receipt-to-origin binding
  • transfer-to-prior-event binding
  • attestation-to-object or attestation-to-event binding

These bindings may be public OpenETR events, private host-system records, registry records, or linked evidence, depending on the sensitivity of the data.

Separate Cryptographic Validity From Recognition

A valid OpenETR signature means the key signed the event.

It does not automatically mean:

  • the signer was KYC'd
  • the signer was authorized
  • the warehouse receipt is valid
  • the goods exist
  • the federation must accept the event
  • a court must recognize the transfer

Those conclusions require recognition policy.

Pilot Minimum Viable Architecture

A practical pilot can start with:

warehouse receipt system
  -> account and KYC layer
  -> account-managed OpenETR root/profile keys
  -> receipt artifact or package
  -> OpenETR Anchor Event
  -> OpenETR evidence events
  -> optional attestations and linked evidence
  -> verifier policy for pilot recognition

The first pilot does not need to solve every federation or recognition question.

It should demonstrate that:

  • a warehouse receipt artifact can be digest-identified
  • an account-authorized profile can sign an Anchor Event
  • later evidence events can link to the same object
  • account-to-key accountability can be evidenced by the host system
  • required attestations can attach to the graph
  • another verifier can inspect the graph without being inside the original system
  • recognition decisions remain policy-dependent

Open Questions For The Pilot

  • Which legal identity assurance level is required for warehouse operators?
  • Which account roles may create root keys or profile keys?
  • Should profile signer material be generated client-side, server-side, or in managed custody?
  • How will the host system evidence account-to-key binding?
  • Which profile types are needed for the first pilot?
  • Which attestation types are mandatory for issuance?
  • Which attestation types are mandatory for transfer, encumbrance, discharge, redemption, or termination?
  • Which events must be public, private, or encrypted?
  • Which relays or archives will participating operators use?
  • What federation rulebook, if any, will pilot operators adopt?
  • What happens when a profile key is compromised, rotated, suspended, or retired?
  • What verifier output should distinguish cryptographic validity, reliable-system assurance, attestation sufficiency, and legal recognition?