@rootzero/contracts 1.10.0 → 1.12.0

package/core/Endpoint.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Cursors, Cur} from "../Cursors.sol";
+import {Keys} from "../blocks/Keys.sol";
+import {EndpointEvent} from "../events/Endpoint.sol";
+import {LabeledEvent} from "../events/Labeled.sol";
+import {SchemaEvent} from "../events/Schema.sol";
+import {Runtime} from "./Runtime.sol";
+
+/// @title Lane
+/// @notice Bit offsets for endpoint descriptor lanes.
+library Lane {
+    /// @dev Descriptor shift for the state lane.
+    uint internal constant State = 184;
+    /// @dev Descriptor shift for the input lane.
+    uint internal constant Input = 112;
+    /// @dev Descriptor shift for the output lane.
+    uint internal constant Output = 40;
+}
+
+/// @title EndpointBase
+/// @notice Shared endpoint metadata helpers.
+abstract contract EndpointBase is Runtime, EndpointEvent, LabeledEvent, SchemaEvent {
+    /// @dev Pack endpoint lanes and flags into a descriptor.
+    /// A non-empty lane with group 0 defaults to group 1; a zero lane is absent.
+    /// Layout: `[state:8][group:1][input:8][group:1][output:8][group:1]`
+    /// `[flags:1][reserved:4]`. Flag bits: funded = 0, admin = 1.
+    /// @param state Packed state lane plus optional group byte.
+    /// @param input Packed input lane plus optional group byte.
+    /// @param output Packed output lane plus optional group byte.
+    /// @param funded Whether the endpoint accepts nonzero native value.
+    /// @param admin Whether the endpoint is restricted to the admin account.
+    /// @return value Packed endpoint descriptor as an integer.
+    function pack(
+        bytes9 state,
+        bytes9 input,
+        bytes9 output,
+        bool funded,
+        bool admin
+    ) private pure returns (uint value) {
+        value |= uint(uint72(state)) << Lane.State;
+        value |= uint(uint72(input)) << Lane.Input;
+        value |= uint(uint72(output)) << Lane.Output;
+        value |= uint(funded ? 1 : 0) << 32;
+        value |= uint(admin ? 1 : 0) << 33;
+    }
+
+    /// @dev Return a lane's effective group size, defaulting non-empty lanes to one.
+    /// @param descriptor Packed endpoint descriptor.
+    /// @param shift Bit offset of the lane to inspect.
+    /// @return size Effective group size, or zero when the lane is absent.
+    function laneGroup(bytes32 descriptor, uint shift) private pure returns (uint8 size) {
+        uint72 lane = uint72(uint(descriptor) >> shift);
+        if (lane == 0) return 0;
+
+        size = uint8(lane);
+        if (size == 0) size = 1;
+    }
+
+    /// @notice Return an 8-byte lane value for a generic LIST containing `item`.
+    /// @param item Block key expected inside each LIST payload.
+    /// @return Packed lane key `[Keys.List][item]`.
+    function many(bytes4 item) internal pure returns (bytes8) {
+        return bytes8(bytes.concat(Keys.List, item));
+    }
+
+    /// @notice Append an explicit group size to an 8-byte lane value.
+    /// @param value Packed lane key `[key][item]`.
+    /// @param size Explicit per-operation group size for the lane.
+    /// @return Packed lane key plus group byte.
+    function group(bytes8 value, uint8 size) internal pure returns (bytes9) {
+        return bytes9(bytes.concat(value, bytes1(size)));
+    }
+
+    /// @dev Open a descriptor lane and return its effective group and output counts.
+    /// An absent lane inherits `expected`; a present lane must match it when nonzero.
+    /// @param source Block stream to open for the requested lane.
+    /// @param descriptor Packed endpoint descriptor.
+    /// @param shift Bit offset of the lane to open.
+    /// @param expected Required group count, or zero to accept the lane's count.
+    /// @return cur Cursor scoped to the lane's first block run.
+    /// @return groups Number of lane groups in `cur`, or `expected` for an absent lane.
+    /// @return outputs Number of output blocks implied by `groups` and the descriptor output lane.
+    function openLane(
+        bytes calldata source,
+        bytes32 descriptor,
+        uint shift,
+        uint expected
+    ) internal pure returns (Cur memory cur, uint groups, uint outputs) {
+        (cur, groups) = Cursors.init(source, laneGroup(descriptor, shift));
+        if (groups == 0) groups = expected;
+        else if (expected != 0 && groups != expected) revert Cursors.BadRatio();
+        outputs = groups * laneGroup(descriptor, Lane.Output);
+    }
+
+    /// @notice Open an endpoint state stream and return the expected output block count.
+    /// @param source State block stream to open.
+    /// @param descriptor Packed endpoint descriptor.
+    /// @return state Cursor scoped to the state lane's first block run.
+    /// @return outputs Number of output blocks implied by the state group count.
+    function openState(
+        bytes calldata source,
+        bytes32 descriptor
+    ) internal pure returns (Cur memory state, uint outputs) {
+        (state, , outputs) = openLane(source, descriptor, Lane.State, 0);
+    }
+
+    /// @notice Open an endpoint input stream and return the expected output block count.
+    /// @param source Input block stream to open.
+    /// @param descriptor Packed endpoint descriptor.
+    /// @return input Cursor scoped to the input lane's first block run.
+    /// @return outputs Number of output blocks implied by the input group count.
+    function openInput(
+        bytes calldata source,
+        bytes32 descriptor
+    ) internal pure returns (Cur memory input, uint outputs) {
+        (input, , outputs) = openLane(source, descriptor, Lane.Input, 0);
+    }
+
+    /// @notice Publish the default local block schema and return `Keys.Local`.
+    /// @param body Schema DSL string describing the block payload body.
+    /// @return The default context-local block key.
+    function localSchema(string memory body) internal returns (bytes4) {
+        return localSchema(1, body);
+    }
+
+    /// @notice Publish a context-local block schema and return its key.
+    /// @param key Context-local key value.
+    /// @param body Schema DSL string describing the block payload body.
+    /// @return The context-local block key.
+    function localSchema(uint32 key, string memory body) internal returns (bytes4) {
+        bytes4 k = Keys.local(key);
+        emit Schema(host, k, body, bytes32(0));
+        return k;
+    }
+
+    /// @notice Create and publish endpoint metadata with a default label.
+    /// @param id Endpoint node ID.
+    /// @param name Default human-readable endpoint label.
+    /// @param state Packed state lane plus optional group byte.
+    /// @param input Packed input lane plus optional group byte.
+    /// @param output Packed output lane plus optional group byte.
+    /// @param funded Whether the endpoint accepts nonzero native value.
+    /// @param admin Whether the endpoint is restricted to the admin account.
+    /// @return descriptor Packed endpoint lane metadata and flags.
+    function endpoint(
+        uint id,
+        string memory name,
+        bytes9 state,
+        bytes9 input,
+        bytes9 output,
+        bool funded,
+        bool admin
+    ) internal returns (bytes32 descriptor) {
+        descriptor = bytes32(pack(state, input, output, funded, admin));
+        emit Endpoint(host, id, descriptor);
+        emit Labeled(id, bytes32(0), name);
+    }
+}

package/core/Host.sol

@@ -23,7 +23,7 @@ interface IHostIntroduction {
 
 /// @title Host
 /// @notice Abstract base contract for rootzero host implementations.
-/// Inherits admin command support (authorize, unauthorize, executePayable),
+/// Inherits admin command support (authorize, unauthorize, label, executePayable),
 /// guardian management, the default guardian revoke action, and
 /// optionally introduces itself to a commander host at deployment.
 /// Accepts native ETH payments via the `receive` function.

package/docs/Schema.md

@@ -1,8 +1,10 @@
 # Schema
 
 Rootzero request and response data is encoded as a stream of typed blocks. A
-schema string describes payload layout for discovery events and tooling; the
-runtime block key is derived only from the block name.
+schema string describes the payload body for discovery events and tooling; the
+runtime block key is the compact type tag that identifies that payload layout in
+the active schema context. The block alias is published separately from the
+payload schema.
 
 ## Wire Format
 
@@ -15,53 +17,67 @@ Every block uses the same header:
 `payloadLen` is big-endian and counts only payload bytes. Child blocks and list
 items use the same header format.
 
-The block key is:
+Standard built-in block keys use:
 
 ```txt
 bytes4(keccak256("#name"))
 ```
 
-For example, `#amount { bytes32 asset, uint amount }` uses the key
-derived from `#amount`. Blocks must not be overloaded: one block name should have
-one protocol meaning.
+For example, the standard `amount` alias uses the key derived from `#amount`
+and the schema body `{ bytes32 asset, uint amount }`. Custom block keys do not
+have to be keccak-derived. They
+are opaque `bytes4` tags and only need to be unique in the context where they are
+used. A host can publish the meaning of a custom key with:
+
+```solidity
+event Schema(uint indexed host, bytes4 key, string schema, bytes32 name);
+```
+
+For example, a host-specific payment block can use `Keys.Local`, the command
+selector, or any other chosen `bytes4` value as long as that key is not
+overloaded in the relevant host/schema context.
 
 ## Block Syntax
 
-A block starts with `#`. Fixed fields are written in braces:
+A block definition has an event alias and a schema body. Fixed fields are
+written in braces:
 
 ```txt
-#amount { bytes32 asset, uint amount }
-#account { bytes32 account }
+alias:  amount
+schema: { bytes32 asset, uint amount }
 ```
 
-A block without braces has no payload:
+A block body can reference another block alias as a child item with `#`:
 
 ```txt
-#unit
-#bytes
+{ bytes32 account, #bytes as state, #bytes as request }
 ```
 
-Empty braces are invalid. A zero-payload block must omit braces.
+The empty schema string `""` means the block has no structured payload. This is
+used for zero-payload blocks such as `#unit` and raw dynamic blocks such as
+`#bytes`.
 
-A schema is a comma-separated list of items. Order is significant.
+A schema body is a comma-separated list of items. Order is significant.
 
 ```txt
-#amount { bytes32 asset, uint amount },
-maybe #account { bytes32 account }
+{ #amount, maybe #account as recipient }
 ```
 
 ## Payload Layout
 
-A block payload has fixed fields first, followed by an optional child-block tail.
-Once a child block appears, no more fixed fields may follow.
+A block payload encodes schema items in declaration order. Fixed fields are
+packed inline, and zero or more child blocks are embedded directly at their
+declared positions. Because every child block carries its own header and payload
+length, fixed fields may appear before, after, or between child blocks.
 
 ```txt
-#call { uint target, uint resources, #bytes as payload }
-#context { bytes32 account, #bytes as state, #bytes as request }
+{ uint target, uint resources, #bytes as payload }
+{ bytes32 account, #bytes as state, #bytes as request }
+{ bytes4 key, #string as body, bytes32 name }
+{ #bytes as left, uint op, #bytes as right }
 ```
 
-The tail is embedded directly as child block bytes. There is no wrapper around a
-child-block tail.
+There is no wrapper around embedded child blocks.
 
 Raw dynamic bytes are represented with the reserved `#bytes` child block. Use an
 alias to give those bytes a presentation name:
@@ -75,59 +91,87 @@ alias to give those bytes a presentation name:
 Cardinality is expressed with prefix keywords:
 
 ```txt
-#balance { bytes32 asset, uint amount }
-maybe #balance { bytes32 asset, uint amount }
-many #balance { bytes32 asset, uint amount }
-maybe many #balance { bytes32 asset, uint amount }
+#balance
+maybe #balance
+many #balance
+maybe many #balance
 ```
 
 - no prefix: one required item
 - `maybe`: optional item
-- `many`: one `#list` block whose payload contains repeated items
+- `many`: one generic `#list` block whose payload contains repeated items
 - `maybe many`: optional `#list` block
 
 `maybe` emits no placeholder when absent. `many` wraps repeated items in one
 generic list block; it does not repeat the item in place.
 
-## Prime Items
+## Endpoint Lanes
+
+Endpoint descriptors identify each lane with a block key and group size. In
+Solidity, endpoint definition helpers accept `bytes9` lane values, with plain
+`bytes4` keys and the `bytes8` values returned by `many(item)` widening
+implicitly. A plain key or `many(item)` stores a zero group byte that readers
+interpret as group size 1, while `bytes9(0)` or `Keys.Empty` means the endpoint
+has no blocks in that lane. Use
+`group(lane, size)` when a lane needs an explicit group size other than 1.
+
+The packed descriptor stores each lane key as an 8-byte value:
+
+```txt
+[key bytes4][item bytes4]
+```
+
+A plain block key is widened into `[key][0]`, so normal endpoint declarations can
+pass standard `bytes4` keys directly. A lane with a nonzero `item` describes a
+generic container block: `key` is the top-level wire key and `item` is the
+contained item key. The built-in `many(item)` helper creates `[Keys.List][item]`
+with the default group size 1, matching the DSL form `many #item`.
 
-The empty string `""` means no schema. Whitespace-only schemas are invalid.
+Any non-empty lane resolves its key to a block alias and schema body through the
+active schema context. If the item slot is nonzero, tooling also resolves that
+item key in the same context. A bare list lane, `[Keys.List][0]`, is incomplete
+discovery metadata because it does not say what the list contains; indexers
+should reject it for self-describing endpoints.
 
-For a non-empty schema, the first top-level item is the prime item. Prime items
-may repeat at the top level for batching. Later top-level items are globals for
-the whole batch and are not counted as per-operation prime blocks.
+The lane key is the prime item. Prime items may repeat at the top level for
+batching. When the lane is `many #item`, the repeated prime item is the generic
+LIST block and each LIST payload contains repeated `item` blocks. Later
+top-level items are globals for the whole batch and are not counted as
+per-operation prime blocks.
 
-The prime item cannot be optional. If a command needs a per-operation marker with
-no payload, use a zero-payload block such as `#unit`.
+The prime item cannot be optional. If an endpoint needs a per-operation marker
+with no payload, use a zero-payload block such as `#unit`.
 
-Command request and state streams currently use a narrower convention than the
-full block grammar: each is a single run of blocks, without additional global
-items. Future protocol surfaces may use the more flexible top-level structure,
-but command discovery metadata should describe only that one-run shape.
+Endpoint descriptors currently use a narrower convention than the full block
+grammar: each state, input, or output lane is a single run of blocks, without
+additional global items. Future protocol surfaces may use the more flexible
+top-level structure.
 
-## Aliases
+## Field Aliases
 
-Aliases are presentation metadata for tooling. They do not change payload layout
-or runtime keys.
+Block aliases are published in `Schema` events. Field aliases are presentation
+metadata for tooling. They do not change payload layout or runtime keys.
 
 ```txt
-maybe #account { bytes32 account } as recipient
-#call { uint target, uint resources, #bytes as payload }
+maybe #account as recipient
+{ uint target, uint resources, #bytes as payload }
 ```
 
-Aliases may be used on any block item, including child blocks and prime items.
+Field aliases may be used on any block item, including child blocks and prime
+items.
 
-A child block without an inline body may also be used as a schema reference:
+Child blocks are schema references:
 
 ```txt
-#recover { uint handler, uint resources, bytes32 key, #bytes as witness }
+{ uint handler, uint resources, bytes32 key, #bytes as witness }
 ```
 
-Alias resolution is context-dependent. A consumer may resolve `#context` from the
-standard `Schemas` table, from app-specific schemas, or from another active
-schema context. Consumers should reject schemas with unresolved aliases. The
-runtime encoding is still an embedded child block with the referenced key and
-layout.
+Alias resolution is context-dependent. A consumer may resolve `#context` from
+standard block events, from app-specific block events, or from another active
+schema context. Custom parents should define nested custom blocks from the
+bottom up and reference them by alias. Consumers should reject schemas with
+unresolved aliases. The runtime encoding is still an embedded child block with
+the referenced key and layout.
 
 ## Field Paths
 
@@ -136,13 +180,13 @@ path does not change the block key, payload bytes, payload length, cursor
 behavior, or any onchain validation. It is metadata only.
 
 ```txt
-#dispatch { uint dst.portal, uint dst.resources, #bytes as dst.payload }
+{ uint dst.portal, uint dst.resources, #bytes as dst.payload }
 ```
 
 This has the same runtime layout as:
 
 ```txt
-#dispatch { uint portal, uint resources, #bytes as payload }
+{ uint portal, uint resources, #bytes as payload }
 ```
 
 Offchain tooling may decode the dotted form into a nested object:
@@ -169,11 +213,11 @@ uint dst.portal, uint dst.portal    // duplicate path
 uint dst, uint dst.portal           // prefix/value collision
 ```
 
-The same rule applies to block aliases:
+The same rule applies to field aliases:
 
 ```txt
-#call { uint target, uint resources, #bytes as calldata.payload }
-maybe #account { bytes32 account } as recipient.account
+{ uint target, uint resources, #bytes as calldata.payload }
+maybe #account as recipient.account
 ```
 
 ## Field Types
@@ -226,8 +270,8 @@ the layout of an ID only apply to structured IDs.
 
 ## Identifiers
 
-Block names use lower camelCase ASCII identifiers. Field names and aliases use
-one or more lower camelCase path segments separated by dots:
+Block aliases use lower camelCase ASCII identifiers. Field names and aliases
+use one or more lower camelCase path segments separated by dots:
 
 ```txt
 [a-z][a-zA-Z0-9]*
@@ -246,48 +290,42 @@ asset.
 ```
 
 Reserved words include `maybe`, `many`, `as`, all field type names, and the
-reserved block names `bytes`, `data`, and `list`. For dotted paths, reserved
-words are invalid in any path segment.
+reserved block aliases `bytes` and `list`. For dotted paths, reserved words are
+invalid in any path segment.
 
 ## Reserved Blocks
 
 - `#bytes`: raw dynamic bytes, written without a body
-- `#data`: generic/custom payload block
+- `#string`: UTF-8 string bytes, written without a body
 - `#list`: generic list wrapper emitted by `many`
 
-Use `#data` when a local schema needs a stable generic key:
+Custom input shapes should define their own context-local block key and publish
+that key with a `Schema` event:
 
-```txt
-#data { uint foo, bytes32 tag }
-#data { #bytes as payload }
-```
-
-If a schema string starts with a fixed field type, it is shorthand for one
-top-level `#data` block:
-
-```txt
-uint foo, bytes32 tag
+```solidity
+bytes4 constant Input = Keys.Local;
+emit Schema(host, Input, "{ bytes32 asset, uint amount }", bytes32("payment"));
 ```
 
-expands to:
-
-```txt
-#data { uint foo, bytes32 tag }
-```
+Use `Keys.local(n)` when a host needs more than one local block key. The key can
+also be a small literal, a selector, or any other `bytes4` value that is unique
+in the context where it is used. The alias names the block; the schema string
+describes only the payload body.
 
 ## Standard Blocks
 
 Common protocol schemas live in `contracts/blocks/Schema.sol`:
 
 ```txt
-#amount { bytes32 asset, uint amount }
-#balance { bytes32 asset, uint amount }
-#custody { uint host, bytes32 asset, uint amount }
-#call { uint target, uint resources, #bytes as payload }
-#step { uint target, uint resources, #bytes as request }
-#context { bytes32 account, #bytes as state, #bytes as request }
-#recover { uint handler, uint resources, bytes32 key, #bytes as witness }
-#auth { uint cid, uint deadline, #bytes as proof }
+amount   { bytes32 asset, uint amount }
+balance  { bytes32 asset, uint amount }
+custody  { uint host, bytes32 asset, uint amount }
+call     { uint target, uint resources, #bytes as payload }
+step     { uint target, uint resources, #bytes as request }
+context  { bytes32 account, #bytes as state, #bytes as request }
+recover  { uint handler, uint resources, bytes32 key, #bytes as witness }
+auth     { uint cid, uint deadline, #bytes as proof }
+schema   { bytes4 key, #string as body, bytes32 name }
 ```
 
-`Keys.sol` contains the corresponding runtime keys.
+`Keys.sol` contains the corresponding standard runtime keys.

package/events/Endpoint.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @title EndpointEvent
+/// @notice Emitted during host deployment to publish a callable endpoint descriptor.
+abstract contract EndpointEvent is EventEmitter {
+    string private constant ABI = "event Endpoint(uint indexed host, uint id, bytes32 descriptor)";
+
+    /// @param host Host node ID that exposes the endpoint.
+    /// @param id Endpoint node ID.
+    /// @param descriptor Packed endpoint lane metadata and flags.
+    event Endpoint(uint indexed host, uint id, bytes32 descriptor);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/events/Schema.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @title SchemaEvent
+/// @notice Emitted during host deployment to publish a block key and payload schema.
+/// Block keys are opaque `bytes4` tags. Standard protocol blocks use
+/// keccak-derived keys by convention, but custom block keys only need to be
+/// unique within the publishing host/schema context.
+abstract contract SchemaEvent is EventEmitter {
+    string private constant ABI = "event Schema(uint indexed host, bytes4 key, string schema, bytes32 name)";
+
+    /// @param host Host node ID that publishes this block schema.
+    /// @param key Block type key being defined by `host`.
+    /// @param schema Schema DSL string describing the block payload body.
+    /// @param name Optional block alias used by endpoint descriptors and nested schemas.
+    event Schema(uint indexed host, bytes4 key, string schema, bytes32 name);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/guards/Base.sol

@@ -2,24 +2,33 @@
 pragma solidity ^0.8.33;
 
 import {AccessControl} from "../core/Access.sol";
-import {GuardEvent} from "../events/Guard.sol";
-import {LabeledEvent} from "../events/Labeled.sol";
+import {EndpointBase} from "../core/Endpoint.sol";
 import {Nodes} from "../utils/Nodes.sol";
+import {Selectors} from "../utils/Selectors.sol";
 
 /// @title GuardBase
 /// @notice Abstract base for guardian-only direct host actions.
 /// Guard actions are non-payable direct calls with no command context, state, or response.
-abstract contract GuardBase is AccessControl, GuardEvent, LabeledEvent {
+abstract contract GuardBase is AccessControl, EndpointBase {
     /// @dev Restrict execution to active guardian addresses.
     modifier onlyGuardian() {
         if (!isGuardian(msg.sender)) revert AccessDenied();
         _;
     }
 
-    /// @notice Derive the deterministic node ID for a guard action selector on this contract.
-    /// @param selector Guard action entrypoint selector.
-    /// @return Guard action node ID.
-    function guardId(bytes4 selector) internal view returns (uint) {
-        return Nodes.toGuard(selector, address(this));
+    /// @notice Publish guard metadata and a default label.
+    /// @param name Default human-readable guard label and selector name.
+    /// @param input Packed input lane plus optional group byte.
+    /// @param selector Guard ABI selector, or zero to derive it from `name`.
+    /// @return id Guard action node ID.
+    /// @return descriptor Packed endpoint lane metadata and flags.
+    function guard(
+        string memory name,
+        bytes9 input,
+        bytes4 selector
+    ) internal returns (uint id, bytes32 descriptor) {
+        selector = selector == bytes4(0) ? Selectors.guard(name) : selector;
+        id = Nodes.toGuard(selector, address(this));
+        descriptor = endpoint(id, name, bytes9(0), input, bytes9(0), false, false);
     }
 }

package/guards/Revoke.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {GuardBase} from "./Base.sol";
-import {Cursors, Cur, Schemas} from "../Cursors.sol";
+import {Cursors, Cur, Keys} from "../Cursors.sol";
 using Cursors for Cur;
 
 /// @title Revoke
@@ -10,21 +10,19 @@ using Cursors for Cur;
 /// Each NODE block in the request is deauthorized on the host.
 /// Only callable by active guardian addresses.
 abstract contract Revoke is GuardBase {
-    uint internal immutable revokeId = guardId(this.revoke.selector);
+    bytes32 private immutable descriptor;
 
     constructor() {
-        emit Guard(host, revokeId, Schemas.Node);
-        emit Labeled(revokeId, bytes32(0), "revoke");
+        (, descriptor) = guard("revoke", Keys.Node, 0);
     }
 
     function revoke(bytes calldata request) external onlyGuardian {
-        (Cur memory input, ) = Cursors.init(request, 1);
+        (Cur memory input, ) = openInput(request, descriptor);
 
         while (input.i < input.len) {
             uint node = input.unpackNode();
             setNode(node, false);
         }
 
-        input.complete();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",