@rootzero/contracts 1.8.0 → 1.10.0

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 Until the protocol reaches integration-stable status, minor versions may include
 breaking API changes. Breaking changes are called out explicitly.
 
+## Unreleased
+
+## 1.10.0
+
+### Breaking Changes
+
+- Moved `RecoverHook` from `Portal.sol` to `commands/Recover.sol`.
+- Moved `RoutePayableHook` from `Portal.sol` to `commands/Relay.sol`.
+- Renamed Portal helpers to `forward` / `retry`; hosts now explicitly bridge
+  the `RecoverPayable` hook to Portal retry behavior.
+- Renamed the generic `Resolved` event to `Recovered`.
+- Portal no longer emits `Recovered` when retrying an undelivered witness.
+- Renamed `Cursors.exit` to `ensureAt` and renamed its position argument to
+  `pos`.
+- Removed the redundant `next` return value from both `Cursors.init` overloads;
+  callers should use the returned cursor's `len` as the run boundary.
+- Changed `Cursors.list` to require the expected current cursor position as
+  `pos` before entering the LIST block.
+
+## 1.9.0
+
+### Breaking Changes
+
+- Renamed relay and dispatch routing fields from `chain` to `portal` across
+  schemas, cursor helpers, dispatch hooks, and dispatch/route events.
+- Replaced the context-specific `RecoverContextPayable` / `#contextRecovery`
+  surface with generic `RecoverPayable` / `#recover` using byte witnesses.
+- Renamed the `Dispatch` event correlation field from `ref` to `key`.
+- Replaced `DispatchPayableHook.dispatch` with `RoutePayableHook.route` in the
+  portal core layer.
+- Added `status` to `Route(uint indexed host, uint portal, uint status)`
+  so routes can be removed by emitting zero status.
+- Added `Undelivered(uint indexed host, bytes32 key, bytes32 digest)` for portal
+  messages that could not be delivered to their handler port.
+- Added `Recovered(uint indexed host, bytes32 key)` as the
+  matching event for resolved undelivered digests.
+- Removed the generic `Commitments` core mixin and `Commitment` event in favor
+  of domain-specific events such as `Undelivered` and `Recovered`.
+
 ## 1.8.0
 
 ### Breaking Changes

package/Core.sol

@@ -6,13 +6,14 @@ pragma solidity ^0.8.33;
 
 import { AccessControl } from "./core/Access.sol";
 import { Balances, InsufficientFunds } from "./core/Balances.sol";
-import { Commitments } from "./core/Commitments.sol";
 import { Escrows, InsufficientEscrow } from "./core/Escrows.sol";
 import { NativeAsset, Runtime } from "./core/Runtime.sol";
 import { Host, IHostIntroduction } from "./core/Host.sol";
 import { CommandCalls, FailedCall, NodeCalls, PortCalls } from "./core/Calls.sol";
 import { Payable } from "./core/Payable.sol";
 import { Pipeline } from "./core/Pipeline.sol";
+import { Portal } from "./core/Portal.sol";
+import { RecoverHook } from "./commands/Recover.sol";
 import { AssetAmount, AccountAsset, AccountAmount, HostAmount, HostAccountAsset, HostAccountAmount, Tx } from "./core/Types.sol";
 import { Validator } from "./core/Validator.sol";
 

package/Endpoints.sol

@@ -16,8 +16,8 @@ import { DebitAccount, DebitAccountHook } from "./commands/Debit.sol";
 import { Deposit, DepositHook, DepositPayable, DepositPayableHook } from "./commands/Deposit.sol";
 import { Payout, PayoutHook } from "./commands/Payout.sol";
 import { Provision, ProvisionHook, ProvisionPayable, ProvisionPayableHook } from "./commands/Provision.sol";
-import { RecoverContextPayable, RecoverContextPayableHook } from "./commands/Recover.sol";
-import { RelayPayable, DispatchPayableHook } from "./commands/Relay.sol";
+import { RecoverHook, RecoverPayable } from "./commands/Recover.sol";
+import { RelayPayable, RoutePayableHook } from "./commands/Relay.sol";
 import { Withdraw, WithdrawHook } from "./commands/Withdraw.sol";
 
 // Admin commands

package/Events.sol

@@ -10,10 +10,10 @@ import { Actions } from "./utils/Actions.sol";
 import { BalanceEvent } from "./events/Balance.sol";
 import { CommanderEvent } from "./events/Commander.sol";
 import { CommandEvent } from "./events/Command.sol";
-import { CommitmentEvent } from "./events/Commitment.sol";
 import { DispatchEvent } from "./events/Dispatch.sol";
 import { PositionEvent } from "./events/Position.sol";
 import { ReceivedEvent } from "./events/Received.sol";
+import { RecoveredEvent } from "./events/Recovered.sol";
 import { EventEmitter } from "./events/Emitter.sol";
 import { GuardEvent } from "./events/Guard.sol";
 import { GuardianEvent } from "./events/Guardian.sol";
@@ -26,6 +26,7 @@ import { QueryEvent } from "./events/Query.sol";
 import { RootedEvent } from "./events/Rooted.sol";
 import { RouteEvent } from "./events/Route.sol";
 import { SpentEvent } from "./events/Spent.sol";
+import { UndeliveredEvent } from "./events/Undelivered.sol";
 import { UnlockedEvent } from "./events/Unlocked.sol";
 
 

package/README.md

@@ -2,7 +2,7 @@
 
 rootzero is a protocol for building **hosts**: contracts that expose a uniform
 set of endpoints over accounts and assets — commands that change state,
-queries that read it, and peer links that connect hosts to each other, on the
+queries that read it, and port links that connect hosts to each other, on the
 same chain or across chains.
 
 This repository is `@rootzero/contracts`, the Solidity library for the EVM port
@@ -160,7 +160,7 @@ structured ID announces what it is (an account, an asset, a node) and which
 chain it lives on, and the payload usually embeds the underlying address. User
 accounts are chain-agnostic; admin and guardian accounts are chain-local.
 Assets are unique IDs in the same single-word form as accounts and nodes.
-Nodes are hosts, commands, peers, queries, and guards.
+Nodes are hosts, commands, ports, queries, and guards.
 
 Opaque asset declarations use `Asset(host, asset, preimage)`. The preimage
 starts with a one-byte format/hash tag, letting offchain indexers or witnesses
@@ -220,7 +220,7 @@ the batch, call the hook, write the output run:
 
 ```solidity
 function deposit(CommandContext calldata c) external onlyCommand returns (bytes memory) {
-    (Cur memory request, uint groups, ) = Cursors.init(c.request, 1);
+    (Cur memory request, uint groups) = Cursors.init(c.request, 1);
     Writer memory writer = Writers.allocBalances(groups);
 
     while (request.i < request.len) {
@@ -258,7 +258,7 @@ The standard commands cover the common ledger movements: `deposit` and
 `depositPayable` (external funds in), `withdraw` and `burn` (funds out),
 `debitAccount` and `creditAccount` (internal movements), `payout` (deliver
 state to other accounts), `provision` (allocate custody on another host), and
-`relayPayable` (hand a pipeline to another chain).
+`relayPayable` (hand a pipeline to another portal).
 
 ## Pipelines
 
@@ -285,9 +285,9 @@ if (state.length != 0) revert UnexpectedState();
 A transfer, for instance, is a two-step pipeline: `debitAccount` turns an
 `#amount` request into `#balance` state, and `payout` consumes that state
 toward a recipient. Because a pipeline is just blocks, it is also the unit of
-command batching — and `resources` is a chain-typed word (on EVM, the low 128
-bits are native value in wei, drawn from a shared budget), so the same pipeline
-bytes are meaningful to every port.
+command batching — and `resources` is a chain-specific word interpreted by the
+portal adapter (on EVM, the low 128 bits are native value in wei, drawn from a
+shared budget), so the same pipeline bytes are meaningful to every port.
 
 ## Queries
 
@@ -314,10 +314,11 @@ central ones are batches all the way down:
   block — how two hosts record settlement between their ledgers.
 - `portPipePayable` consumes `#context` blocks, each carrying an account, an
   initial state, and a run of steps — a complete pipeline delivered by another
-  host, executed locally against the peer call's shared value budget.
+  host, executed locally against the port call's shared value budget.
 
-This is also the cross-chain mechanism. `relayPayable` (or `portDispatchPayable`)
-wraps a pipe and addresses it to a chain; a bridge adapter moves the **raw
+This is also the cross-portal mechanism. `relayPayable` (or `portDispatchPayable`)
+wraps a pipe and addresses it to a portal, commonly the destination host ID;
+a bridge adapter moves the **raw
 bytes**; the destination host parses them with the same cursor rules and runs
 the same pipeline loop. Nothing in the payload is EVM-specific — step targets
 are destination-local node IDs, and only the adapter boundary (native
@@ -350,8 +351,8 @@ names, access sets, balances — from logs alone, with no artifact files.
 Import from the package entry points rather than deep paths:
 
 - `@rootzero/contracts/Core.sol` — `Host`, access control, `Balances`,
-  `Pipeline`, validator
-- `@rootzero/contracts/Endpoints.sol` — command, admin, peer, guard, and query
+  `Pipeline`, `Portal`, validator
+- `@rootzero/contracts/Endpoints.sol` — command, admin, port, guard, and query
   mixins and their hooks
 - `@rootzero/contracts/Cursors.sol` — `Cur` cursor reader, `Writers`, `Schemas`,
   `Keys`
@@ -363,7 +364,7 @@ Repo layout:
 
 - `contracts/core` — host, access control, balances, pipeline, validation
 - `contracts/commands` — standard commands and admin commands
-- `contracts/ports` — peer surfaces for inter-host and cross-chain flows
+- `contracts/ports` — port surfaces for inter-host and cross-portal flows
 - `contracts/guards` — guardian direct actions
 - `contracts/queries` — read-only query endpoints
 - `contracts/blocks` — block schema, cursor parsing, writers

package/blocks/Cursors.sol

@@ -76,16 +76,14 @@ library Cursors {
     /// @param group Expected block group size (e.g. 1 for single, 2 for paired).
     /// @return cur Cursor with `len` truncated to the end of the first run in `source`.
     /// @return groups Number of block groups in the run (`block count / group`).
-    /// @return next Byte offset immediately after the run, relative to `source`.
     function init(
         bytes calldata source,
         uint group
-    ) internal pure returns (Cur memory cur, uint groups, uint next) {
+    ) internal pure returns (Cur memory cur, uint groups) {
         cur = open(source);
         if (cur.i == cur.len) revert ZeroCursor();
         (bytes4 key, ) = cur.peek(cur.i);
         groups = cur.run(key, group);
-        next = cur.len;
     }
 
     /// @notice Create a cursor over `source`, restrict it to its first grouped run, and require an exact group count.
@@ -93,14 +91,13 @@ library Cursors {
     /// @param group Expected block group size (e.g. 1 for single, 2 for paired).
     /// @param expectedGroups Required number of groups in the run.
     /// @return cur Cursor with `len` truncated to the end of the first run in `source`.
-    /// @return next Byte offset immediately after the run, relative to `source`.
     function init(
         bytes calldata source,
         uint group,
         uint expectedGroups
-    ) internal pure returns (Cur memory cur, uint next) {
+    ) internal pure returns (Cur memory cur) {
         uint groups;
-        (cur, groups, next) = init(source, group);
+        (cur, groups) = init(source, group);
         if (groups != expectedGroups) revert BadRatio();
     }
 
@@ -333,13 +330,16 @@ library Cursors {
         return find(cur, cur.i, key);
     }
 
-    /// @notice Enter a List block at the current position and return the next offset.
+    /// @notice Enter a LIST block at the expected current position and return its next offset.
+    /// Reverts with `IncompleteCursor` if `cur.i` is not exactly `pos`.
     /// Advances `cur.i` past the list header so the list members can be parsed
     /// directly from the same cursor. The returned `next` is the byte offset
     /// immediately after the list payload, relative to the current cursor region.
-    /// @param cur Cursor positioned at a list block; advanced past the 8-byte header.
+    /// @param cur Cursor expected to be positioned at a list block; advanced past the 8-byte header.
+    /// @param pos Expected current cursor position, relative to the cursor region.
     /// @return next Byte offset immediately after the list payload.
-    function list(Cur memory cur) internal pure returns (uint next) {
+    function list(Cur memory cur, uint pos) internal pure returns (uint next) {
+        cur.ensureAt(pos);
         next = enter(cur, Keys.List, 0, 0);
     }
 
@@ -387,13 +387,13 @@ library Cursors {
         return maybeTake(cur, Keys.Data);
     }
 
-    /// @notice Exit a nested region at an exact boundary.
-    /// Reverts with `IncompleteCursor` if `end` exceeds the cursor region length
-    /// or `cur.i != end`.
+    /// @notice Ensure the cursor is at an exact position.
+    /// Reverts with `IncompleteCursor` if `pos` exceeds the cursor region length
+    /// or `cur.i != pos`.
     /// @param cur Cursor to check.
-    /// @param end Relative end offset of the nested region.
-    function exit(Cur memory cur, uint end) internal pure {
-        if (end > cur.len || cur.i != end) revert IncompleteCursor();
+    /// @param pos Relative byte offset the cursor must be positioned at.
+    function ensureAt(Cur memory cur, uint pos) internal pure {
+        if (pos > cur.len || cur.i != pos) revert IncompleteCursor();
     }
 
     /// @notice Assert that the cursor has consumed its entire source region.
@@ -519,7 +519,7 @@ library Cursors {
 
     /// @notice Encode a STEP block.
     /// @param target Command target identifier.
-    /// @param resources Chain resources assigned to the step.
+    /// @param resources Packed resources assigned to the step.
     /// @param request Raw nested request payload.
     /// @return Encoded STEP block bytes.
     function toStepBlock(uint target, uint resources, bytes memory request) internal pure returns (bytes memory) {
@@ -528,7 +528,7 @@ library Cursors {
 
     /// @notice Encode a CALL block.
     /// @param target Target node identifier.
-    /// @param resources Chain resources assigned to the call.
+    /// @param resources Packed resources assigned to the call.
     /// @param data Raw calldata payload for the target.
     /// @return Encoded CALL block bytes.
     function toCallBlock(uint target, uint resources, bytes memory data) internal pure returns (bytes memory) {
@@ -549,21 +549,21 @@ library Cursors {
     }
 
     /// @notice Encode a RELAY block.
-    /// @param chain Destination chain node ID.
-    /// @param resources Chain-adapter-specific resources for the destination context.
+    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param resources Chain-specific resources for the destination context.
     /// @param request Nested request block stream.
     /// @return Encoded RELAY block bytes.
-    function toRelayBlock(uint chain, uint resources, bytes memory request) internal pure returns (bytes memory) {
-        return createBlock(Keys.Relay, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(request)));
+    function toRelayBlock(uint portal, uint resources, bytes memory request) internal pure returns (bytes memory) {
+        return createBlock(Keys.Relay, bytes.concat(bytes32(portal), bytes32(resources), toBytesBlock(request)));
     }
 
     /// @notice Encode a DISPATCH block.
-    /// @param chain Destination chain node ID.
-    /// @param resources Chain-adapter-specific resources for the destination dispatch.
-    /// @param payload Encoded cross-chain payload.
+    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param resources Chain-specific resources for the destination dispatch.
+    /// @param payload Encoded payload.
     /// @return Encoded DISPATCH block bytes.
-    function toDispatchBlock(uint chain, uint resources, bytes memory payload) internal pure returns (bytes memory) {
-        return createBlock(Keys.Dispatch, bytes.concat(bytes32(chain), bytes32(resources), toBytesBlock(payload)));
+    function toDispatchBlock(uint portal, uint resources, bytes memory payload) internal pure returns (bytes memory) {
+        return createBlock(Keys.Dispatch, bytes.concat(bytes32(portal), bytes32(resources), toBytesBlock(payload)));
     }
 
     // -------------------------------------------------------------------------
@@ -747,7 +747,7 @@ library Cursors {
         id = cur.readUint();
         namespace = cur.read32();
         name = cur.unpackString();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
     /// @notice Consume a dynamic block with a single bytes32 payload.
@@ -1100,28 +1100,28 @@ library Cursors {
     /// The `req` slice is the raw payload of the block's required BYTES child.
     /// @param cur Cursor; advanced past the block.
     /// @return target Destination node ID for the sub-command.
-    /// @return resources Chain resources assigned to the step.
+    /// @return resources Packed resources assigned to the step.
     /// @return req Embedded request bytes for the sub-command.
     function unpackStep(Cur memory cur) internal pure returns (uint target, uint resources, bytes calldata req) {
         uint end = cur.enter(Keys.Step, 64 + Sizes.Header, 0);
         target = uint(cur.read32());
         resources = uint(cur.read32());
         req = cur.unpackBytes();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
     /// @notice Consume a CALL block and return its target invocation fields.
     /// The `data` slice is the raw payload of the block's required BYTES child.
     /// @param cur Cursor; advanced past the block.
     /// @return target Target node ID to call.
-    /// @return resources Chain resources assigned to the call.
+    /// @return resources Packed resources assigned to the call.
     /// @return data Raw calldata payload for the target.
     function unpackCall(Cur memory cur) internal pure returns (uint target, uint resources, bytes calldata data) {
         uint end = cur.enter(Keys.Call, 64 + Sizes.Header, 0);
         target = uint(cur.read32());
         resources = uint(cur.read32());
         data = cur.unpackBytes();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
     /// @notice Consume a CONTEXT block and return its command context fields.
@@ -1137,54 +1137,54 @@ library Cursors {
         account = cur.read32();
         state = cur.unpackBytes();
         request = cur.unpackBytes();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
-    /// @notice Consume a RELAY block and return its destination chain, resources, and request stream.
+    /// @notice Consume a RELAY block and return its destination portal, resources, and request stream.
     /// @param cur Cursor; advanced past the block.
-    /// @return chain Destination chain node ID.
-    /// @return resources Chain-adapter-specific resources for the destination context.
+    /// @return portal Destination portal identifier, often the destination host ID.
+    /// @return resources Chain-specific resources for the destination context.
     /// @return request Embedded request block stream.
     function unpackRelay(
         Cur memory cur
-    ) internal pure returns (uint chain, uint resources, bytes calldata request) {
+    ) internal pure returns (uint portal, uint resources, bytes calldata request) {
         uint end = cur.enter(Keys.Relay, 64 + Sizes.Header, 0);
-        chain = cur.readUint();
+        portal = cur.readUint();
         resources = cur.readUint();
         request = cur.unpackBytes();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
-    /// @notice Consume a DISPATCH block and return its destination chain, resources, and payload.
+    /// @notice Consume a DISPATCH block and return its destination portal, resources, and payload.
     /// @param cur Cursor; advanced past the block.
-    /// @return chain Destination chain node ID.
-    /// @return resources Chain-adapter-specific resources for the destination dispatch.
-    /// @return payload Encoded cross-chain payload.
+    /// @return portal Destination portal identifier, often the destination host ID.
+    /// @return resources Chain-specific resources for the destination dispatch.
+    /// @return payload Encoded payload.
     function unpackDispatch(
         Cur memory cur
-    ) internal pure returns (uint chain, uint resources, bytes calldata payload) {
+    ) internal pure returns (uint portal, uint resources, bytes calldata payload) {
         uint end = cur.enter(Keys.Dispatch, 64 + Sizes.Header, 0);
-        chain = cur.readUint();
+        portal = cur.readUint();
         resources = cur.readUint();
         payload = cur.unpackBytes();
-        cur.exit(end);
+        cur.ensureAt(end);
     }
 
-    /// @notice Consume a CONTEXT_RECOVERY block and return its port, key, resources, and embedded context cursor.
+    /// @notice Consume a RECOVER block and return its handler, resources, key, and witness bytes.
     /// @param cur Cursor; advanced past the block.
-    /// @return port Recovery handler port node ID.
-    /// @return key Commitment or recovery lookup key.
-    /// @return resources Chain resources assigned to the recovery attempt.
-    /// @return context Cursor scoped to the embedded CONTEXT witness block.
-    function unpackContextRecovery(
+    /// @return handler Recovery handler port node ID.
+    /// @return resources Packed resources assigned to the recovery attempt.
+    /// @return key Recovery lookup key.
+    /// @return witness Witness bytes used by the recovery handler.
+    function unpackRecover(
         Cur memory cur
-    ) internal pure returns (uint port, bytes32 key, uint resources, Cur memory context) {
-        uint end = cur.enter(Keys.ContextRecovery, 96 + Sizes.Header, 0);
-        port = cur.readUint();
-        key = cur.read32();
+    ) internal pure returns (uint handler, uint resources, bytes32 key, bytes calldata witness) {
+        uint end = cur.enter(Keys.Recover, 96 + Sizes.Header, 0);
+        handler = cur.readUint();
         resources = cur.readUint();
-        context = cur.take(Keys.Context);
-        cur.exit(end);
+        key = cur.read32();
+        witness = cur.unpackBytes();
+        cur.ensureAt(end);
     }
 
     // Type-specific validators
@@ -1379,16 +1379,16 @@ library Cursors {
     /// @param cur Cursor; advanced past the RELAY block.
     /// @param account Account identifier to embed in the destination context.
     /// @param state State block stream to embed in the destination context.
-    /// @return chain Destination chain node ID.
-    /// @return resources Chain resources assigned to the destination context.
+    /// @return portal Destination portal identifier, often the destination host ID.
+    /// @return resources Chain-specific resources assigned to the destination context.
     /// @return context Encoded CONTEXT block containing `account`, `state`, and relay request.
     function relayToContext(
         Cur memory cur,
         bytes32 account,
         bytes calldata state
-    ) internal pure returns (uint chain, uint resources, bytes memory context) {
+    ) internal pure returns (uint portal, uint resources, bytes memory context) {
         bytes calldata request;
-        (chain, resources, request) = cur.unpackRelay();
+        (portal, resources, request) = cur.unpackRelay();
         context = toContextBlock(account, bytes(state), bytes(request));
     }
 

package/blocks/Keys.sol

@@ -41,13 +41,13 @@ library Keys {
     bytes4 constant Transaction = bytes4(keccak256("#transaction"));
     /// @dev Sub-command invocation - (uint target, uint resources, #bytes as request)
     bytes4 constant Step = bytes4(keccak256("#step"));
-    /// @dev Cross-chain relay request - (uint chain, uint resources, #bytes as request)
+    /// @dev Portal relay request - (uint portal, uint resources, #bytes as request)
     bytes4 constant Relay = bytes4(keccak256("#relay"));
     /// @dev Command context transport - (bytes32 account, #bytes as state, #bytes as request)
     bytes4 constant Context = bytes4(keccak256("#context"));
-    /// @dev Recoverable context witness - (uint port, bytes32 key, uint resources, #context)
-    bytes4 constant ContextRecovery = bytes4(keccak256("#contextRecovery"));
-    /// @dev Cross-chain encoded payload dispatch - (uint chain, uint resources, #bytes as payload)
+    /// @dev Recoverable witness - (uint handler, uint resources, bytes32 key, #bytes as witness)
+    bytes4 constant Recover = bytes4(keccak256("#recover"));
+    /// @dev Portal encoded payload dispatch - (uint portal, uint resources, #bytes as payload)
     bytes4 constant Dispatch = bytes4(keccak256("#dispatch"));
     /// @dev Raw external call - (uint target, uint resources, #bytes as payload)
     bytes4 constant Call = bytes4(keccak256("#call"));

package/blocks/Schema.sol

@@ -16,10 +16,11 @@ pragma solidity ^0.8.33;
 // - run items may repeat at top level for batching
 // - `maybe #x { ... }` marks an optional block item
 // - `many #x { ... }` emits one generic list block containing repeated `#x` items
-// - `resources` fields are chain-specific resource words; one chain type may
-//   pack them differently from another, but a given chain type must use one
-//   stable format everywhere. EVM resources use the low 128 bits as native value.
-// - dotted field names and aliases, e.g. `dst.chain` or `#bytes as dst.payload`,
+// - `portal` fields are routing identifiers, often destination host IDs
+// - `resources` fields are chain-specific resource words. A portal adapter
+//   interprets them for the destination runtime. EVM resources use the low
+//   128 bits as native value.
+// - dotted field names and aliases, e.g. `dst.portal` or `#bytes as dst.payload`,
 //   are offchain projection metadata only and do not change runtime encoding
 // - a child block without an inline body, e.g. `#context as witness`, may resolve
 //   to a known schema in the active schema context; unresolved aliases are invalid
@@ -71,11 +72,11 @@ library Schemas {
     string constant Allowance = "#allowance { uint host, bytes32 asset, uint amount }";
     string constant Transaction = "#transaction { bytes32 from, bytes32 to, bytes32 asset, uint amount }";
     string constant Context = "#context { bytes32 account, #bytes as state, #bytes as request }";
-    string constant ContextRecovery = "#contextRecovery { uint port, bytes32 key, uint resources, #context as witness }";
+    string constant Recover = "#recover { uint handler, uint resources, bytes32 key, #bytes as witness }";
     string constant Call = "#call { uint target, uint resources, #bytes as payload }";
     string constant Step = "#step { uint target, uint resources, #bytes as request }";
-    string constant Relay = "#relay { uint chain, uint resources, #bytes as request }";
-    string constant Dispatch = "#dispatch { uint chain, uint resources, #bytes as payload }";
+    string constant Relay = "#relay { uint portal, uint resources, #bytes as request }";
+    string constant Dispatch = "#dispatch { uint portal, uint resources, #bytes as payload }";
     string constant Bounty = "#bounty { uint amount, bytes32 relayer }";
     string constant Fee = "#fee { uint amount }";
     string constant Auth = "#auth { uint cid, uint deadline, #bytes as proof }";

package/blocks/Writers.sol

@@ -872,7 +872,7 @@ library Writers {
     /// @notice Append a STEP block with a nested request BYTES payload.
     /// @param writer Destination writer; `i` is advanced by the encoded STEP block length.
     /// @param target Command target identifier.
-    /// @param resources Chain resources assigned to the step.
+    /// @param resources Packed resources assigned to the step.
     /// @param request Raw nested request payload.
     function appendStep(Writer memory writer, uint target, uint resources, bytes memory request) internal pure {
         appendBlock64Bytes(writer, Keys.Step, bytes32(target), bytes32(resources), request);
@@ -881,7 +881,7 @@ library Writers {
     /// @notice Append a CALL block with a nested payload BYTES block.
     /// @param writer Destination writer; `i` is advanced by the encoded CALL block length.
     /// @param target Call target identifier.
-    /// @param resources Chain resources assigned to the call.
+    /// @param resources Packed resources assigned to the call.
     /// @param data Raw nested call payload.
     function appendCall(Writer memory writer, uint target, uint resources, bytes memory data) internal pure {
         appendBlock64Bytes(writer, Keys.Call, bytes32(target), bytes32(resources), data);

package/commands/Burn.sol

@@ -30,7 +30,7 @@ abstract contract Burn is CommandBase, BurnHook {
     /// @param c Command context; `c.state` must contain BALANCE blocks.
     /// @return Empty output state.
     function burn(CommandContext calldata c) external onlyCommand returns (bytes memory) {
-        (Cur memory state, , ) = Cursors.init(c.state, 1);
+        (Cur memory state, ) = Cursors.init(c.state, 1);
 
         while (state.i < state.len) {
             (bytes32 asset, uint amount) = state.unpackBalance();

package/commands/Credit.sol

@@ -32,7 +32,7 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     function creditAccount(
         CommandContext calldata c
     ) external onlyCommand returns (bytes memory) {
-        (Cur memory state, , ) = Cursors.init(c.state, 1);
+        (Cur memory state, ) = Cursors.init(c.state, 1);
 
         while (state.i < state.len) {
             (bytes32 asset, uint amount) = state.unpackBalance();

package/commands/Debit.sol

@@ -32,7 +32,7 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
     /// The default implementation iterates AMOUNT blocks, calls
     /// `debitAccount`, and emits matching BALANCE blocks.
     function debitAccount(bytes32 account, bytes calldata request) internal virtual returns (bytes memory) {
-        (Cur memory input, uint groups, ) = Cursors.init(request, 1);
+        (Cur memory input, uint groups) = Cursors.init(request, 1);
         Writer memory writer = Writers.allocBalances(groups);
 
         while (input.i < input.len) {

package/commands/Deposit.sol

@@ -48,7 +48,7 @@ abstract contract Deposit is CommandBase, DepositHook {
     function deposit(
         CommandContext calldata c
     ) external onlyCommand returns (bytes memory) {
-        (Cur memory request, uint groups, ) = Cursors.init(c.request, 1);
+        (Cur memory request, uint groups) = Cursors.init(c.request, 1);
         Writer memory writer = Writers.allocBalances(groups);
 
         while (request.i < request.len) {
@@ -79,7 +79,7 @@ abstract contract DepositPayable is CommandBase, Payable, DepositPayableHook {
     function depositPayable(
         CommandContext calldata c
     ) external payable onlyCommand returns (bytes memory) {
-        (Cur memory request, uint groups, ) = Cursors.init(c.request, 1);
+        (Cur memory request, uint groups) = Cursors.init(c.request, 1);
         Writer memory writer = Writers.allocBalances(groups);
         Budget memory budget = openValue();
 

package/commands/Payout.sol

@@ -31,8 +31,8 @@ abstract contract Payout is CommandBase, PayoutHook {
     /// @param c Command context; `c.state` must contain BALANCE blocks and `c.request` matching ACCOUNT blocks.
     /// @return Empty output state.
     function payout(CommandContext calldata c) external onlyCommand returns (bytes memory) {
-        (Cur memory state, uint groups, ) = Cursors.init(c.state, 1);
-        (Cur memory request, ) = Cursors.init(c.request, 1, groups);
+        (Cur memory state, uint groups) = Cursors.init(c.state, 1);
+        Cur memory request = Cursors.init(c.request, 1, groups);
 
         while (state.i < state.len) {
             (bytes32 asset, uint amount) = state.unpackBalance();

package/commands/Provision.sol

@@ -44,7 +44,7 @@ abstract contract Provision is CommandBase, ProvisionHook {
     /// @param c Command context; `c.request` must contain ALLOCATION blocks.
     /// @return CUSTODY block stream matching the provisioned allocations.
     function provision(CommandContext calldata c) external onlyCommand returns (bytes memory) {
-        (Cur memory request, uint groups, ) = Cursors.init(c.request, 1);
+        (Cur memory request, uint groups) = Cursors.init(c.request, 1);
         Writer memory writer = Writers.allocCustodies(groups);
 
         while (request.i < request.len) {
@@ -76,7 +76,7 @@ abstract contract ProvisionPayable is CommandBase, Payable, ProvisionPayableHook
     function provisionPayable(
         CommandContext calldata c
     ) external payable onlyCommand returns (bytes memory) {
-        (Cur memory request, uint groups, ) = Cursors.init(c.request, 1);
+        (Cur memory request, uint groups) = Cursors.init(c.request, 1);
         Writer memory writer = Writers.allocCustodies(groups);
         Budget memory budget = openValue();