Build the cage Script from config bytes.

Build the per-cage request Script from config bytes.

Compute the ScriptHash from raw script bytes.

The three leaf states the registry admits (#157 three-state-leaf-codec). Requests carry an edge, not a value, so these are no longer something a builder chooses: they are the bytes each edge's trie move reads and writes, and walkEdge below is the one place that pairs them with their edge.

The three leaf states the registry admits (#157 three-state-leaf-codec). Requests carry an edge, not a value, so these are no longer something a builder chooses: they are the bytes each edge's trie move reads and writes, and walkEdge below is the one place that pairs them with their edge.

The three leaf states the registry admits (#157 three-state-leaf-codec). Requests carry an edge, not a value, so these are no longer something a builder chooses: they are the bytes each edge's trie move reads and writes, and walkEdge below is the one place that pairs them with their edge.

Walk one request's edge through a speculative trie and return the proof steps the fold states for it (#183).

The edge names the move and its leaf bytes, from the table `types.ak` publishes. The proof is the one the cage verifies at this request's own position in the batch, so it is read BEFORE a replacement and AFTER an insert, exactly as the cage's own walk does.

A tag outside the table names no move: the cage refuses it `edge-inadmissible` before touching the trie, so the builder walks nothing either and states the proof the refusal will be judged against. All five excluded encodings leave the local trie unchanged for refusal fixtures.

One site, so the connected fold and the update builder cannot drift apart about what an edge does to the trie.

The policy id a 28-byte pin names. The four pins the state datum carries are raw script hashes; this is the one place that turns one back into the ledger's own type.

The address a request's binary destination names (#157 request-destination-binding). The bytes are a full Cardano address, network byte and all, so nothing here supplies a network of its own.

What a supported edge owes the mint, as (kind, quantity). Registration mints one active token (kind 1); retirement burns one.

The policy a kind names in this registry's configuration.

The approval binding (#157 approval-asset-binding): the asset name the application policy mints to certify one edge, blake2b_256(edge ‖ key ‖ owner ‖ destination address ‖ destination datum hash). One formula, recomputed by the cage from the request it rides; a builder that computes it differently makes an honest booking refuse loudly at the fold.

A request's destination as approvalName binds it.

The hash an approval binds for the datum a request carries (#419): the BLAKE2b-256 of the datum's serialisation, empty for none — the bytes the request named before it carried the datum, so an approval's name is unchanged for the same tuple.

Compute the cage minting policy ID from config.

Compute the cage script address from config.

Compute the request script address for a token.

Convert a ledger token id to its on-chain token id.

Build a CageDatum for a request at one seven-admitted-edges edge (#183).

A request datum naming where the edge it books delivers (#157 request-destination-binding) and carrying the datum the delivered output must hold (#419). The cage reads the destination for every edge that mints an active or terminal token, and the approval that certifies the edge binds the address and the hash of that datum, so the booking and the fold cannot disagree about where the token goes or what it carries.

Convert a ToData value to Data.

Convert a ToData value to a ledger Data.

Wrap Data as an inline Datum.

Extract a CageDatum from an inline datum in a TxOut.

Convert a ledger TxIn to an on-chain OnChainTxOutRef.

Extract the payment key hash raw bytes from an Addr.

Reconstruct an Addr from raw payment key hash bytes.

Extract a KeyHash 'Witness from raw payment key hash bytes.

Find a UTxO by its TxIn.

Find the state UTxO for a token.

Find all request UTxOs for a token.

Compute the spending index of a TxIn.

Compute the ScriptIntegrityHash.

Evaluate script execution units and balance a transaction.

evaluateAndBalance for a transaction that reads scripts from reference outputs (#300): the resolved outputs are handed to the balancer, which charges the ledger's per-byte tier for every reference-script byte the transaction references, exactly as the node will.

Placeholder execution units used in the initial unbalanced transaction.

Empty MPF root (32 zero bytes).

Get current POSIX time in milliseconds.

Try converting successive POSIX ms values to slots, returning the first that succeeds.

Try converting successive POSIX ms values to slots, rounding down, and return the first that succeeds: an upper validity bound.

trySlots rounds up, which is right for a lower bound but not for an upper one. Rounding down never puts the upper bound later than its chosen POSIX candidate. NOTE030 opens the pinned final era, preserving this rounding rule and the caller's candidate windows. Synchronous conversion failures still try the next candidate; cancellation escapes.

Run an action, returning its synchronous failure; an asynchronous exception — a cancellation, a timeout — is rethrown, never taken for a conversion that failed and so never answered by a fallback.

Extract the owner key hash bytes from a request TxOut.

Compute a rejected row's refund output (NOTE-014 item A2, delegated routing): exactly `input lovelace − tip`, floored at min-UTxO with the top-up funded visibly. No fee share is deducted here and none is invented (fees ride funding inputs; the validator pins per-owner floors and exact lock accumulation instead of an aggregate envelope). THE shared helper for every rejected-refund emission — Reject and manual paths call it; processed rows emit no refunds at all (their bond locks).

The consumer pin as a ledger ScriptHash. Loud on bad width (the mint gate enforces 28 bytes on chain; this mirrors it builder-side so a misconfigured pin fails at build, not on ledger).

The withdrawal account for the pinned consumer: the exact script credential from the pin, on the cage's network.

A key-hash withdrawal account (exhibit controls only): lets a row point a withdrawal at an ordinary key, where no script executes and only the cage's own credential check can refuse. Loud on bad width, like the pin helper above.

The bound exhibit consumer, unparameterized (NOTE-021): no operator key, no appointed processor — the consumer authenticates batches from transaction evidence alone. One derivation, used for boot pinning, builder witnesses, and identity checks — never separate computations that could disagree.

Build the bound consumer Script from config bytes (mirror of mkCageScript). Builders attach this as the hook withdrawal witness.

Parse the node's named failed-witness field (The script hash is:ScriptHash HEX) and return the hash — the FIRST occurrence, which names the failing script (later occurrences repeat the same failure's context). Anchored on the opening quote (hash letters also occur in ScriptHash itself, so a hex scan from the marker misfires). Length-checked to 56 hex chars (a 28-byte script hash) so partial garbage never matches. Nothing when the reason carries no named field (non-script failures: extraneous witnesses, unregistered withdrawals, balance errors).

Parse a builder-EVALUATION failure's named script field (pwcScriptHash = ScriptHash HEX, first occurrence) and return the hash. NOTE-018 bind: fork-occupied assertions match THIS field against the derived applied identity — never a hex substring of the full ErrorCall show (transaction data, values and parameterized script bytes can all contain the state policy). Same 56-hex rule.

True when the refusal is budget exhaustion rather than a semantic predicate failure. Kept to the OBSERVED node wording (overspending the budget); unknown budget wordings fail closed elsewhere (no named semantic match), never silently accepted.