Field Tables

The family (opens in a new tab) and opcode select one exact layout. An operation stores ordered 64-bit words, ordered byte strings and, where permitted, an appeal deadline (opens in a new tab). Names in this view explain positions; field names are not transmitted as part of an operand.

The view below is taken from the repository's machine-readable operation table. Its layout and decoder checks are described in Wire Format. Product acceptance still requires the authentication and authority checks in Validation.

Every table on this page is generated from one file, spec/operations.json, by scripts/render-operations.py. The script expands each field of an operation entry into rows: a group use becomes the fields of that group, and an optional field becomes a presence row followed by its own fields.

def expand(self, fields, where, prefix="", condition=None, groups=()):    rows = []    for field in fields:        kind = field["kind"]        if kind == "use":            group = field["group"]            if group not in self.data["groups"]:                fail(f"{where}: unknown group {group!r}")            if group in groups:                fail(f"{where}: group {group!r} uses itself")            rows += self.expand(self.data["groups"][group]["fields"], where, prefix,                                condition, groups + (group,))            continue        path = prefix + field["name"]        note = field.get("description", "")        once = "1" if condition is None else f"1 if `{condition}` is 1"        many = "N" if condition is None else f"N if `{condition}` is 1"        if kind == "word":            text = " ".join(part for part in [note, self.accepted(field, where)                                              if field["type"] == "code" else ""] if part)            rows.append(dict(path=path, count=once, type=self.word_type(field, where), text=text,                             word=field))        elif kind == "optional":            rows.append(dict(path=path, count=once, type="presence",                             text=" ".join(part for part in ["0 absent, 1 present.", note] if part)))            rows += self.expand(field["fields"], where, path + ".", path, groups)        elif kind == "counted_set":            item = field["item"]            accepted = self.accepted(item, where) if item["type"] == "code" else ""            rows.append(dict(path=path, count=once, type="count",                             text=" ".join(part for part in ["Number of items N.", note] if part)))            rows.append(dict(path=path + "[]", count=many, type=self.word_type(item, where),                             text=" ".join(part for part in ["Strictly ascending.", accepted] if part)))        elif kind == "counted_pairs":            first, second = field["first"], field["second"]            rows.append(dict(path=path, count=once, type="count", text=" ".join(                part for part in [f"Number of entries N. Each entry is `{first['name']}` then "                                  f"`{second['name']}`.", note] if part)))            for member, text in [(first, "Strictly ascending."), (second, "")]:                accepted = self.accepted(member, where) if member["type"] == "code" else ""                rows.append(dict(path=f"{path}[].{member['name']}", count=many,                                 type=self.word_type(member, where),                                 text=" ".join(part for part in [text, accepted] if part)))        elif kind == "tagged":            values = self.enum(field["enum"])            codes = [case["code"] for case in field["cases"]]            if sorted(codes) != codes or set(codes) != set(values):                fail(f"{where}: cases of {path} must list every {field['enum']} code in order")            cases = [(case["code"], values[case["code"]],                      self.expand(case["fields"], where, path + ".", condition, groups))                     for case in field["cases"]]            rows.append(dict(path=path, count=once, type=f"`{field['enum']}` code", cases=cases,                             text=" ".join(part for part in [                                 "Selects a case; the words of that case end the layout.", note] if part)))        else:            fail(f"{where}: unknown field kind {kind!r}")    return rows

Positional operand layout of every OIP (opens in a new tab) v0.6 operation. The Core family and the operation opcode select exactly one layout of ordered words, ordered blobs and a deadline mode. Field names document the layout and never appear on the wire.

The table is operations.json (opens in a new tab) and its format is operations.schema.json (opens in a new tab). This name view is generated from the table by python scripts/render-operations.py; edit the table, not this file. The specification name of an operation is its name in the family table of wire-conformance.md (opens in a new tab).

Layout rules#

NormativeBytes, test vectors and proofs

• The family and the opcode select exactly one layout. A decoder MUST reject an opcode outside 1 through the operation count of its family with INVALID_FORMAT.
• Words are read in table order and a layout MUST consume every word. A missing word or a trailing word is INVALID_FORMAT.
• An optional field starts with a presence word that MUST be 0 or 1. Its fields follow only when the presence word is 1.
• A counted set starts with a count word followed by that many items in strictly ascending order, so it has no duplicates.
• A counted pair list starts with a count word followed by that many pairs whose first members are strictly ascending.
• A tagged field is the last field of its layout. Its tag word selects one case, and that case fixes the exact number of remaining words.
• Blobs are matched by position and the blob count MUST equal the layout's blob count.
• An enumerated word MUST hold an accepted code. A word whose accepted codes are any takes every value; the enum only names the known codes.
• A decoder runs with a nesting limit, the number of Core levels it may decode counting the outer Core. A canonical_core blob is decoded with that limit reduced by one, and a decoder MUST reject a Core it reaches with a limit of zero with INVALID_FORMAT.
• A layout fault is INVALID_FORMAT. A failed check returns the error listed with that check. A nested canonical Core returns the error of its own decode.
• A v0.6 decoder MUST reject an Operation field that operation_record does not list with INVALID_FORMAT.

Both reference decoders read the words through one cursor that applies the word rules above. A presence word above 1, a set that is not strictly ascending and a word left over at the end all fail with INVALID_FORMAT.

struct Words<'a>(&'a [u64]);impl Words<'_> {    fn word(&mut self) -> Result<u64> {        let (word, remaining) = self.0.split_first().ok_or(BAD)?;        self.0 = remaining;        Ok(*word)    }    fn size(&mut self) -> Result<usize> {        usize::try_from(self.word()?).map_err(|_| BAD)    }    fn origin(&mut self) -> Result<OriginKey> {        Ok(OriginKey {            domain: self.word()?,            event: self.word()?,        })    }    fn present(&mut self) -> Result<bool> {        match self.word()? {            0 => Ok(false),            1 => Ok(true),            _ => Err(BAD),        }    }    fn optional_origin(&mut self) -> Result<Option<OriginKey>> {        if self.present()? {            Ok(Some(self.origin()?))        } else {            Ok(None)        }    }    fn optional_word(&mut self) -> Result<Option<u64>> {        if self.present()? {            Ok(Some(self.word()?))        } else {            Ok(None)        }    }    fn take(&mut self, count: usize) -> Result<&[u64]> {        let (items, remaining) = self.0.split_at_checked(count).ok_or(BAD)?;        self.0 = remaining;        Ok(items)    }    fn set(&mut self) -> Result<BTreeSet<u64>> {        let count = self.size()?;        let items = self.take(count)?;        if items.windows(2).any(|pair| pair[0] >= pair[1]) {            return Err(BAD);        }        Ok(items.iter().copied().collect())    }    fn end(&self) -> Result<()> {        if self.0.is_empty() { Ok(()) } else { Err(BAD) }    }}

type words struct{ items []uint64 }func (w *words) word() (uint64, error) {	if len(w.items) == 0 {		return 0, ErrFormat	}	value := w.items[0]	w.items = w.items[1:]	return value, nil}func (w *words) read(targets ...*uint64) error {	for _, target := range targets {		value, err := w.word()		if err != nil {			return err		}		*target = value	}	return nil}func (w *words) take(count uint64) ([]uint64, error) {	if count > uint64(len(w.items)) {		return nil, ErrFormat	}	result := w.items[:count]	w.items = w.items[count:]	return result, nil}func (w *words) present() (bool, error) {	value, err := w.word()	if err != nil || value > 1 {		return false, ErrFormat	}	return value == 1, nil}func (w *words) set() error {	count, err := w.word()	if err != nil {		return err	}	values, err := w.take(count)	if err != nil || !strictlySorted(values) {		return ErrFormat	}	return nil}func (w *words) optional(count uint64) error {	present, err := w.present()	if err == nil && present {		_, err = w.take(count)	}	return err}func (w *words) end() error {	if len(w.items) != 0 {		return ErrFormat	}	return nil}

The Go decoders read counted sets and optional fields through valueSet and valueOptional, which apply the same cursor checks and also return the typed value. The legal order decoder of family 2 calls both.

func (w *words) valueSet() ([]uint64,error) {    count,err:=w.word();if err!=nil {return nil,err}    values,err:=w.take(count);if err!=nil || !strictlySorted(values) {return nil,ErrFormat}    return values,nil}func (w *words) valueOptional(count uint64) ([]uint64,error) {    present,err:=w.present();if err!=nil {return nil,err};if !present {return valueNone(),nil}    values,err:=w.take(count);if err!=nil {return nil,err}    switch count {case 1:return valueSome(valueScalar(values[0])),nil;case 2:return valueSome(valuePair(values[0],values[1])),nil;default:panic("unsupported semantic optional field")}}

Operation record#

NormativeBytes, test vectors and proofs

Fields appear in ascending tag order: the opcode, then every word, then every blob, then at most one appeal deadline alternative.

The schema's Operation message declares these five fields, and its comment names spec/operations.json as the table that gives each position its meaning.

// An operation carries positional operands. The family of the enclosing body// member and the opcode fix the meaning and order of every entry in words and// blobs. The field-meaning table spec/operations.json lists, for each family// and opcode, the positions, enumerations and whether the reference// configuration accepts the operation.message Operation {  optional uint64 opcode = 1;  repeated fixed64 words = 2 [packed = false];  repeated bytes blobs = 3;  // The appeal deadline of a regulatory action (family 2). Operations of  // other families reject both members. In this version an absent member and  // appeal_deadline_indefinite both mean that no appeal deadline applies.  oneof appeal_deadline {    // Only the value true is canonical.    bool appeal_deadline_indefinite = 4;    // Unix time in UTC seconds.    fixed64 appeal_deadline_utc_seconds = 5;  }}

Deadline modes#

NormativeBytes, test vectors and proofs

Operations#

NormativeBytes, test vectors and proofs

31 operations. Families 1 through 7 have 6, 3, 8, 8, 2, 2, 2 operations in opcode order.

Reference configuration#

NormativeBytes, test vectors and proofs

The Ed25519 (opens in a new tab) reference configuration accepts only the operations whose reference_accepts value is true. It refuses every other operation with UNSUPPORTED_VERSION before admission (opens in a new tab), because that operation is outside the selected version profile, which is the version together with its accepted operation set.

Accepted: 25 of 31 operations. Refused with UNSUPPORTED_VERSION: Write, Timeout, CorrelatedResponse, Capabilities, Liveness, InstallEpoch.

Both reference implementations write the accepted set as opcode ranges per family, and every other family or opcode returns false. Rust checks the configured operation set in the authority entry paths, including response generation and exact Debit resolution. The generic Rust transport decoder has no configuration-specific operation set. Go exposes the configured check through ReceiveAccepting; its generic Receive path does not select that set. Where the check runs, a false answer refuses the frame with UNSUPPORTED_VERSION.

fn supported_frame(core: &Core) -> bool {    match core.body.as_ref() {        Some(Body::StateSync(op)) => matches!(op.opcode, Some(1..=6)),        Some(Body::RegulatoryAction(op)) => matches!(op.opcode, Some(1..=3)),        Some(Body::Ack(op)) => op.opcode == Some(1),        Some(Body::Query(op)) => matches!(op.opcode, Some(1..=8)),        Some(Body::LockManagement(op)) => matches!(op.opcode, Some(1..=6)),        Some(Body::Governance(op)) => op.opcode == Some(1),        _ => false,    }}

// ReferenceAccepts reports whether the reference configuration executes the// operation of a decoded Core. It accepts 25 of the 31 operations of version// 6 and refuses Write, Timeout, CorrelatedResponse, Capabilities, Liveness// and InstallEpoch.func ReferenceAccepts(core *wirepb.Core) bool {	family, op := Body(core)	opcode := op.GetOpcode()	switch family {	case 1, 3:		return opcode >= 1 && opcode <= 6	case 2:		return opcode >= 1 && opcode <= 3	case 4:		return opcode >= 1 && opcode <= 8	case 5, 7:		return opcode == 1	default:		return false	}}

Responses#

NormativeBytes, test vectors and proofs

A call carries a caller-qualified call identifier (opens in a new tab): the Core principal with the call_sequence word. Only calls have a correlated response.

Every delivery and refusal code applies to every call. The recorded codes of each call are listed with the operation.

Family 1 STATE_SYNC#

NormativeBytes, test vectors and proofs

Core body field state_sync (tag 16). 6 operations.

Each operation is one entry of the operations array in spec/operations.json, and the tables under its heading expand that entry. Debit, opcode 1, starts with the shared groups call_prefix, credential and version_vector and adds one generation word.

{  "family": 1, "opcode": 1, "name": "Debit", "title": "debit",  "summary": "Source debit for the bound transfer.",  "reference_accepts": true,  "words": [    {"kind": "use", "group": "call_prefix"},    {"kind": "use", "group": "credential"},    {"kind": "use", "group": "version_vector"},    {"kind": "word", "name": "generation", "type": "generation"}  ],  "blobs": [    {"name": "amount", "type": "amount_u256"}  ],  "deadline": "absent",  "target_domain": "origin_domain",  "call": true,  "recorded_codes": [1, 2, 3, 4, 12]},

Debit#

Family 1 STATE_SYNC (opens in a new tab), opcode 1, specification name "debit". Source debit for the bound transfer.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 4 ORIGINAL_REJECTED, 12 DEBITED. Delivery and refusal codes also apply.

Words:

Blobs:

RecordTerminal#

Family 1 STATE_SYNC, opcode 2, specification name "record terminal evidence". Records the terminal decision of the source for the binding.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 16 RECORDED, 21 EVIDENCE_REFRESHED, 23 DUPLICATE_DECISION. Delivery and refusal codes also apply.

Words:

Blobs:

DeliverCredit#

Family 1 STATE_SYNC, opcode 3, specification name "deliver credit". Settles a confirmed decision at the destination.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal destination, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 17 CREDITED, 24 DUPLICATE_CONFIRMED. Delivery and refusal codes also apply.

Words:

Blobs:

Refund#

Family 1 STATE_SYNC, opcode 4, specification name "refund". Settles a reversed decision at the source.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 19 REFUNDED, 25 DUPLICATE_REVERSED. Delivery and refusal codes also apply.

Words:

Blobs:

PublishPrimary#

Family 1 STATE_SYNC, opcode 5, specification name "publish primary". Publishes the primary outcome of the binding.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 22 PUBLISHED. Delivery and refusal codes also apply.

Words:

Blobs:

OrdinarySpend#

Family 1 STATE_SYNC, opcode 6, specification name "ordinary spend". Ordinary spend from the root binding.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal destination, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 28 SPEND_EXECUTED. Delivery and refusal codes also apply.

Words:

Blobs:

Family 2 REGULATORY_ACTION#

NormativeBytes, test vectors and proofs

Core body field regulatory_action (tag 17). 3 operations.

EmitLegalOrder, opcode 1, follows call_prefix with the order words, allows an appeal deadline and lists one decode check.

{  "family": 2, "opcode": 1, "name": "EmitLegalOrder", "title": "emit legal order",  "summary": "Legal order at the source emission stage.",  "reference_accepts": true,  "words": [    {"kind": "use", "group": "call_prefix"},    {"kind": "word", "name": "action", "type": "code", "enum": "legal_action", "accepted": "all"},    {"kind": "word", "name": "officer", "type": "principal_id"},    {"kind": "word", "name": "jurisdiction", "type": "u64", "description": "Jurisdiction code of the order."},    {"kind": "word", "name": "legal_basis", "type": "u64", "description": "Legal basis code of the order."},    {"kind": "word", "name": "issuance_epoch", "type": "epoch"},    {"kind": "counted_set", "name": "scope", "item": {"type": "asset_id"}},    {"kind": "optional", "name": "predecessor", "description": "Origin of the preceding order.", "fields": [      {"kind": "word", "name": "domain", "type": "domain_id"},      {"kind": "word", "name": "event", "type": "event_id"}    ]},    {"kind": "optional", "name": "confiscation_destination", "fields": [      {"kind": "word", "name": "principal", "type": "principal_id"}    ]}  ],  "blobs": [    {"name": "amount", "type": "amount_u256"},    {"name": "order_authorization", "type": "proof", "description": "Officer authorization of the exact order, verified by the configured legal adapter."}  ],  "deadline": "appeal",  "target_domain": "origin_domain",  "checks": [    {"when": "decode", "rule": "issuance_epoch equals origin_epoch.", "error": "INVALID_SOURCE"}  ],  "call": true,  "recorded_codes": [1, 2, 3, 26, 30, 31, 32, 33, 34, 35, 36, 37, 38]},

Both reference decoders read the words of EmitLegalOrder and CommitLegalOrder in table order, refuse leftover words and then check the target domain and the issuance epoch (opens in a new tab), which fail with INVALID_SOURCE.

fn legal(core: &Core, op: &Operation) -> Result<Operands> {    let (id, p, mut words) = native(core, op)?;    let [_, proof] = op.blobs.as_slice() else {        return Err(BAD);    };    if proof.is_empty() {        return Err(BAD);    }    let stage = match op.opcode {        Some(1) => LegalStage::SourceEmission,        Some(2) => LegalStage::ReceivingCommit,        _ => return Err(BAD),    };    let action = match words.word()? {        1 => LegalAction::Freeze,        2 => LegalAction::Restrict,        3 => LegalAction::Seize,        4 => LegalAction::Confiscate,        5 => LegalAction::Unfreeze,        6 => LegalAction::Unrestrict,        7 => LegalAction::Release,        _ => return Err(BAD),    };    let order = Order {        binding: p.binding,        action,        officer: words.word()?,        jurisdiction: words.word()?,        legal_basis: words.word()?,        issuance_epoch: words.word()?,        scope: words.set()?,        predecessor: words.optional_origin()?,        destination: words.optional_word()?,        appeal_deadline: deadline(op),    };    words.end()?;    let target = match stage {        LegalStage::SourceEmission => p.binding.origin.domain,        LegalStage::ReceivingCommit => p.binding.destination,    };    if p.endpoint != target || order.issuance_epoch != p.origin_epoch {        return Err(WireError::InvalidSource);    }

func legal(core *wirepb.Core, op *wirepb.Operation) (*Native,error) {    n,w,err:=native(core,op);if err!=nil {return nil,err}    opcode:=op.GetOpcode()    if len(op.Blobs)!=2 || len(op.Blobs[1])==0 || (opcode!=1 && opcode!=2) {return nil,ErrFormat}    var action,issuance,officer,jurisdiction,basis uint64    if err:=w.read(&action);err!=nil || action<1 || action>7 {return nil,ErrFormat}    if err:=w.read(&officer,&jurisdiction,&basis);err!=nil {return nil,err}    if err:=w.read(&issuance);err!=nil {return nil,err}    scope,err:=w.valueSet();if err!=nil {return nil,err}    predecessor,err:=w.valueOptional(2);if err!=nil {return nil,err}    destination,err:=w.valueOptional(1);if err!=nil {return nil,err}    if err:=w.end();err!=nil {return nil,err}    target:=n.Binding.Origin.Domain;if opcode==2 {target=n.Binding.Destination}    if target!=core.GetTargetDomain() || issuance!=n.OriginEpoch {return nil,ErrSource}    fields:=valueNode(102,valueScalar(action),valueScalar(officer),valueScalar(jurisdiction),valueScalar(basis),valueScalar(issuance),valueScalars(scope),predecessor,destination,valueDeadline(op))    n.Summary=valueNode(11,valueNative(n,core.GetAuthorityEpoch()),valueScalar(opcode-1),fields,valueBytes(op.Blobs[1]))    return n,nil}

EmitLegalOrder#

Family 2 REGULATORY_ACTION (opens in a new tab), opcode 1, specification name "emit legal order". Legal order at the source emission stage.

• Reference configuration: accepted.
• Deadline: appeal. Absent, indefinite or finite. The finite form is the appeal deadline in UTC seconds. In this version the product treats absent and indefinite alike as no appeal deadline.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 26 LEGAL_EMITTED, 30 LEGAL_INVALID_AUTHORITY, 31 LEGAL_INVALID_STATE, 32 LEGAL_INVALID_BINDING, 33 LEGAL_MISSING_PRIOR_FREEZE, 34 LEGAL_MISSING_PRIOR_SEIZURE, 35 LEGAL_APPEAL_STILL_OPEN, 36 LEGAL_APPEAL_DEADLINE_MISMATCH, 37 LEGAL_MISSING_DESTINATION, 38 LEGAL_CONFLICTING_ORDER. Delivery and refusal codes also apply.

Words:

Blobs:

Checks:

• decode: issuance_epoch equals origin_epoch. Otherwise INVALID_SOURCE.

CommitLegalOrder#

Family 2 REGULATORY_ACTION, opcode 2, specification name "commit legal order". Legal order at the receiving commit stage.

• Reference configuration: accepted.
• Deadline: appeal. Absent, indefinite or finite. The finite form is the appeal deadline in UTC seconds. In this version the product treats absent and indefinite alike as no appeal deadline.
• Target: the Core target_domain MUST equal destination, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 27 LEGAL_APPLIED, 30 LEGAL_INVALID_AUTHORITY, 31 LEGAL_INVALID_STATE, 32 LEGAL_INVALID_BINDING, 33 LEGAL_MISSING_PRIOR_FREEZE, 34 LEGAL_MISSING_PRIOR_SEIZURE, 35 LEGAL_APPEAL_STILL_OPEN, 36 LEGAL_APPEAL_DEADLINE_MISMATCH, 37 LEGAL_MISSING_DESTINATION, 38 LEGAL_CONFLICTING_ORDER. Delivery and refusal codes also apply.

Words:

Blobs:

Checks:

• decode: issuance_epoch equals origin_epoch. Otherwise INVALID_SOURCE.

EnforcementSpend#

Family 2 REGULATORY_ACTION, opcode 3, specification name "enforcement spend". Spend under an enforcement order.

• Reference configuration: accepted.
• Deadline: appeal. Absent, indefinite or finite. The finite form is the appeal deadline in UTC seconds. In this version the product treats absent and indefinite alike as no appeal deadline.
• Target: the Core target_domain MUST equal destination, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 28 SPEND_EXECUTED. Delivery and refusal codes also apply.

Words:

Blobs:

Family 3 LOCK_MANAGEMENT#

NormativeBytes, test vectors and proofs

Core body field lock_management (tag 18). 8 operations.

Reserve, opcode 1, uses the same three groups as Debit and ends with a duration word of type clock_interval.

{  "family": 3, "opcode": 1, "name": "Reserve", "title": "reserve",  "summary": "Reserves the lock footprint of the binding.",  "reference_accepts": true,  "words": [    {"kind": "use", "group": "call_prefix"},    {"kind": "use", "group": "credential"},    {"kind": "use", "group": "version_vector"},    {"kind": "word", "name": "duration", "type": "clock_interval"}  ],  "blobs": [    {"name": "amount", "type": "amount_u256"}  ],  "deadline": "absent",  "target_domain": "origin_domain",  "call": true,  "recorded_codes": [1, 2, 3, 10]},

Reserve#

Family 3 LOCK_MANAGEMENT (opens in a new tab), opcode 1, specification name "reserve". Reserves the lock footprint of the binding.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 10 RESERVED. Delivery and refusal codes also apply.

Words:

Blobs:

Dispatch#

Family 3 LOCK_MANAGEMENT, opcode 2, specification name "dispatch". Dispatches a held lock.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 11 SOURCE_DISPATCHED. Delivery and refusal codes also apply.

Words:

Blobs:

Cancel#

Family 3 LOCK_MANAGEMENT, opcode 3, specification name "cancel". Closes a held lock.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 13 CLOSED. Delivery and refusal codes also apply.

Words:

Blobs:

Fence#

Family 3 LOCK_MANAGEMENT, opcode 4, specification name "fence". Closes a dispatched lock.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 13 CLOSED. Delivery and refusal codes also apply.

Words:

Blobs:

Preempt#

Family 3 LOCK_MANAGEMENT, opcode 5, specification name "preempt". Takes over an expired lock with the next generation.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 14 PREEMPTED. Delivery and refusal codes also apply.

Words:

Blobs:

Reconcile#

Family 3 LOCK_MANAGEMENT, opcode 6, specification name "reconcile". Reconciles a credited lock against confirmed evidence.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 18 RECONCILED. Delivery and refusal codes also apply.

Words:

Blobs:

Write#

Family 3 LOCK_MANAGEMENT, opcode 7, specification name "write". Writes a permitted data value for the asset.

• Reference configuration: not accepted; refused with UNSUPPORTED_VERSION.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 20 DATA_UPDATED. Delivery and refusal codes also apply.

Words:

Blobs:

Timeout#

Family 3 LOCK_MANAGEMENT, opcode 8, specification name "timeout". Advances the ledger clock.

• Reference configuration: not accepted; refused with UNSUPPORTED_VERSION.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Target: the Core target_domain MUST equal origin_domain, otherwise INVALID_SOURCE.
• Call: yes. Recorded codes: 1 REJECTED, 2 BUSY, 3 UNAVAILABLE, 15 TIME_OBSERVED. Delivery and refusal codes also apply.

Words:

Blobs:

Family 4 QUERY#

NormativeBytes, test vectors and proofs

Core body field query (tag 19). 8 operations.

CurrentRead, opcode 1, is not a call: a session word and a revision word come before the shared query group, and the entry has no blobs.

{  "family": 4, "opcode": 1, "name": "CurrentRead", "title": "current",  "summary": "Current read at the expected cut.",  "reference_accepts": true,  "words": [    {"kind": "word", "name": "session", "type": "session_id"},    {"kind": "word", "name": "revision", "type": "revision", "description": "Revision of the expected cut."},    {"kind": "use", "group": "query"}  ],  "blobs": [],  "deadline": "absent",  "call": false},

CurrentRead#

Family 4 QUERY (opens in a new tab), opcode 1, specification name "current". Current read at the expected cut.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Call: no. It has no correlated response.

Words:

Cases of query:

Blobs: none.

HistoricalRead#

Family 4 QUERY, opcode 2, specification name "historical". Read at a retained historical revision.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Call: no. It has no correlated response.

Words:

Cases of query:

Blobs: none.

RawRead#

Family 4 QUERY, opcode 3, specification name "raw". Raw data read.

• Reference configuration: accepted.
• Deadline: absent. Neither appeal deadline field is present. A present deadline is INVALID_FORMAT.
• Call: no. It has no correlated response.