@rootzero/contracts 1.21.0 → 1.23.0

package/commands/admin/Annotate.sol

@@ -16,21 +16,19 @@ abstract contract Annotate is AdminBase {
     }
 
     /// @notice Publish each ANNOTATION block in the admin input.
-    /// @param input ANNOTATION block stream.
+    /// @param context Admin command context carrying the ANNOTATION input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function annotate(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (uint entity, bytes calldata data) = exec.unpackAnnotation(Lanes.Input);
             emit Annotation(entity, data);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Appoint.sol

@@ -17,21 +17,19 @@ abstract contract Appoint is GuardianAccess, AdminBase {
     }
 
     /// @notice Appoint each user ACCOUNT block in the admin input as a guardian.
-    /// @param input ACCOUNT block stream.
+    /// @param context Admin command context carrying the ACCOUNT input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function appoint(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             bytes32 guardian = exec.unpackAccount(Lanes.Input);
             setGuardian(guardian, true);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Authorize.sol

@@ -22,21 +22,19 @@ abstract contract Authorize is AdminBase {
     }
 
     /// @notice Authorize each NODE block in the admin input.
-    /// @param input NODE block stream.
+    /// @param context Admin command context carrying the NODE input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function authorize(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             uint node = exec.unpackNode(Lanes.Input);
             setNode(node, true);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Base.sol

@@ -7,9 +7,18 @@ import {NodeAccess} from "../../core/Access.sol";
 /// @title AdminBase
 /// @notice Shared base for admin commands.
 abstract contract AdminBase is NodeAccess, CommandBase {
-    /// @dev Restrict execution to the commander using the host's admin account.
-    modifier onlyAdmin(bytes32 account) {
+    /// @notice Decode, authorize, and open one admin command context.
+    function openAdminCommand(
+        bytes calldata context,
+        uint descriptor,
+        uint batches
+    ) internal view returns (Execution memory exec) {
+        bytes32 account;
+        bytes calldata state;
+        bytes calldata input;
+        (account, state, input) = unpackCommandContext(context);
         enforceAdmin(account, msg.sender);
-        _;
+        exec = Executions.open(state, input, descriptor, batches);
+        exec.account = account;
     }
 }

package/commands/admin/DenyAssets.sol

@@ -23,21 +23,19 @@ abstract contract DenyAssets is AdminBase, DenyAssetsHook {
     }
 
     /// @notice Deny each ASSET block in the admin input.
-    /// @param input ASSET block stream.
+    /// @param context Admin command context carrying the ASSET input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function denyAssets(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             bytes32 asset = exec.unpackAsset(Lanes.Input);
             denyAsset(asset);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Dismiss.sol

@@ -17,21 +17,19 @@ abstract contract Dismiss is GuardianAccess, AdminBase {
     }
 
     /// @notice Dismiss each user ACCOUNT block in the admin input from guardian status.
-    /// @param input ACCOUNT block stream.
+    /// @param context Admin command context carrying the ACCOUNT input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function dismiss(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             bytes32 guardian = exec.unpackAccount(Lanes.Input);
             setGuardian(guardian, false);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Execute.sol

@@ -19,21 +19,19 @@ abstract contract ExecutePayable is RawNodeCalls, AdminBase {
     }
 
     /// @notice Execute each CALL block in the admin input.
-    /// @param input CALL block stream.
+    /// @param context Admin command context carrying the CALL input stream.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
     function executePayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external payable onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external payable returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (uint target, uint resources, bytes calldata data) = exec.unpackCall(Lanes.Input);
             rawCall(target, exec.useResourceValue(resources), data);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/Unauthorize.sol

@@ -22,21 +22,19 @@ abstract contract Unauthorize is AdminBase {
     }
 
     /// @notice Unauthorize each NODE block in the admin input.
-    /// @param input NODE block stream.
+    /// @param context Admin command context carrying the NODE input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function unauthorize(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             uint node = exec.unpackNode(Lanes.Input);
             setNode(node, false);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/core/Calls.sol

@@ -3,6 +3,9 @@ pragma solidity ^0.8.33;
 
 import {TrustAccess} from "./Access.sol";
 import {Nodes} from "../utils/Nodes.sol";
+import {Keys} from "../codec/Keys.sol";
+import {Sizes} from "../codec/Specs.sol";
+import {max32} from "../utils/Utils.sol";
 
 /// @dev Emitted when a trusted inter-node call fails.
 /// @param addr Contract address that was called.
@@ -81,6 +84,50 @@ abstract contract NodeCalls is RawNodeCalls, TrustAccess {
 /// @title CommandCalls
 /// @notice Trusted command-call helpers for contracts that route command nodes.
 abstract contract CommandCalls is NodeCalls {
+    /// @dev Build `command(bytes)` calldata and its nested CONTEXT block in one allocation.
+    /// Threaded state is copied from memory and step input directly from calldata.
+    function encodeCommandCall(
+        bytes4 selector,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input
+    ) internal pure returns (bytes memory data) {
+        uint contextLen = max32(Sizes.B32 + 2 * Sizes.Header + state.length + input.length);
+        uint paddedContextLen = (contextLen + 31) & ~uint(31);
+        uint dataLen = 4 + 64 + paddedContextLen;
+
+        // Reserve one scratch word because the final eight-byte block header is
+        // written with mstore. Exclude that word from the returned calldata.
+        data = new bytes(dataLen + 32);
+
+        uint contextKey = uint32(Keys.Context);
+        uint bytesKey = uint32(Keys.Bytes);
+        assembly ("memory-safe") {
+            mstore(data, dataLen)
+            let out := add(data, 0x20)
+
+            // ABI envelope for command(bytes).
+            mstore(out, selector)
+            mstore(add(out, 0x04), 0x20)
+            mstore(add(out, 0x24), contextLen)
+
+            // CONTEXT(account, BYTES(state), BYTES(input)).
+            let context := add(out, 0x44)
+            mstore(context, or(shl(224, contextKey), shl(192, sub(contextLen, 8))))
+            mstore(add(context, 0x08), account)
+
+            let stateBlock := add(context, 0x28)
+            let stateLen := mload(state)
+            mstore(stateBlock, or(shl(224, bytesKey), shl(192, stateLen)))
+            mcopy(add(stateBlock, 0x08), add(state, 0x20), stateLen)
+
+            let inputBlock := add(add(stateBlock, 0x08), stateLen)
+            let inputLen := input.length
+            mstore(inputBlock, or(shl(224, bytesKey), shl(192, inputLen)))
+            calldatacopy(add(inputBlock, 0x08), input.offset, inputLen)
+        }
+    }
+
     /// @notice Encode and call a trusted command node.
     /// @param command Command node ID embedding the target selector.
     /// @param value Native value to forward in wei.
@@ -97,7 +144,7 @@ abstract contract CommandCalls is NodeCalls {
         bytes calldata input
     ) internal returns (bytes memory nextState, bytes memory transactions) {
         bytes4 selector = Nodes.commandSelector(command);
-        bytes memory data = abi.encodeWithSelector(selector, account, state, input);
+        bytes memory data = encodeCommandCall(selector, account, state, input);
         return abi.decode(trustedCall(command, value, data), (bytes, bytes));
     }
 }
@@ -110,7 +157,18 @@ abstract contract PortCalls is NodeCalls {
     /// @param value Native value to forward in wei.
     /// @param input Port input block stream.
     /// @return success True if the low-level port call succeeded.
-    function tryCallPort(uint port, uint128 value, bytes calldata input) internal returns (bool success) {
+    function tryCallPort(uint port, uint128 value, bytes memory input) internal returns (bool success) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return tryTrustedCall(port, value, data);
+    }
+
+    /// @notice Try to encode and call a trusted port node by copying input from calldata.
+    /// @param port Port node ID embedding the target selector.
+    /// @param value Native value to forward in wei.
+    /// @param input Port input block stream.
+    /// @return success True if the low-level port call succeeded.
+    function tryCallPortCopy(uint port, uint128 value, bytes calldata input) internal returns (bool success) {
         bytes4 selector = Nodes.portSelector(port);
         bytes memory data = abi.encodeWithSelector(selector, input);
         return tryTrustedCall(port, value, data);
@@ -121,7 +179,18 @@ abstract contract PortCalls is NodeCalls {
     /// @param value Native value to forward in wei.
     /// @param input Port input block stream.
     /// @return Decoded port output block stream.
-    function callPort(uint port, uint128 value, bytes calldata input) internal returns (bytes memory) {
+    function callPort(uint port, uint128 value, bytes memory input) internal returns (bytes memory) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return abi.decode(trustedCall(port, value, data), (bytes));
+    }
+
+    /// @notice Encode and call a trusted port node by copying input from calldata.
+    /// @param port Port node ID embedding the target selector.
+    /// @param value Native value to forward in wei.
+    /// @param input Port input block stream.
+    /// @return Decoded port output block stream.
+    function callPortCopy(uint port, uint128 value, bytes calldata input) internal returns (bytes memory) {
         bytes4 selector = Nodes.portSelector(port);
         bytes memory data = abi.encodeWithSelector(selector, input);
         return abi.decode(trustedCall(port, value, data), (bytes));

package/core/Host.sol

@@ -61,16 +61,19 @@ abstract contract CommandHost is CommanderAccess, CallerAccess, HostIntroduction
     function enforceCaller(address caller) internal view virtual override returns (address) {
         return enforceCommander(caller);
     }
-
 }
 
 /// @title Admins
 /// @notice Optional bundle of the default host administration commands.
-abstract contract Admins is Annotate, ExecutePayable, Authorize, Unauthorize {}
+abstract contract Admins is Annotate, ExecutePayable, Authorize, Unauthorize {
+
+}
 
 /// @title Guardians
 /// @notice Optional bundle for guardian management and the default revoke guard.
-abstract contract Guardians is Appoint, Dismiss, Revoke {}
+abstract contract Guardians is Appoint, Dismiss, Revoke {
+
+}
 
 /// @title Host
 /// @notice Abstract base contract for rootzero host implementations.
@@ -78,13 +81,7 @@ abstract contract Guardians is Appoint, Dismiss, Revoke {}
 /// 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.
-abstract contract Host is
-    Admins,
-    Guardians,
-    HostIntroduction,
-    IntroductionEvent,
-    IHostIntroduction
-{
+abstract contract Host is Admins, Guardians, HostIntroduction, IntroductionEvent, IHostIntroduction {
     /// @param cmdr Commander address; used by the composed access capabilities.
     ///        If `cmdr` is a deployed contract, the host calls `introduce`
     ///        on it during construction.

package/core/Portal.sol

@@ -21,7 +21,7 @@ abstract contract Portal is PortCalls, NodeAccess, UnresolvedEvent, ResolvedEven
     /// @param value Native EVM value assigned to the forwarding attempt.
     /// @return miss Message digest recorded for recovery when forwarding fails; zero on success.
     function forward(uint port, bytes32 key, bytes calldata message, uint128 value) internal returns (bytes32 miss) {
-        if (tryCallPort(port, value, message)) return bytes32(0);
+        if (tryCallPortCopy(port, value, message)) return bytes32(0);
 
         miss = keccak256(message);
         unresolved[key] = miss;
@@ -37,6 +37,6 @@ abstract contract Portal is PortCalls, NodeAccess, UnresolvedEvent, ResolvedEven
         if (unresolved[key] != keccak256(witness)) revert BadWitness();
 
         delete unresolved[key];
-        callPort(port, value, witness);
+        callPortCopy(port, value, witness);
     }
 }

package/events/Dispatch.sol

@@ -8,7 +8,7 @@ abstract contract DispatchEvent is EventEmitter {
     string private constant ABI = "event Dispatch(uint indexed host, uint portal, uint resources, bytes32 key, bytes32 digest)";
 
     /// @param host Host node ID that owns the dispatch.
-    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param portal Destination portal implementation's host ID.
     /// @param resources Chain-specific resources assigned to the dispatch.
     /// @param key Dispatch correlation or recovery lookup key.
     /// @param digest Digest of the dispatched payload or canonical envelope.

package/events/Positioned.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted when an action produces an account position.
+abstract contract PositionedEvent is EventEmitter {
+    string private constant ABI =
+        "event Positioned(bytes32 indexed account, bytes32 asset, uint amount, bytes32 liability, uint debt, uint32 action)";
+
+    /// @param account Account associated with the position.
+    /// @param asset Identifier for the asset side.
+    /// @param amount Quantity on the asset side.
+    /// @param liability Identifier for the liability side.
+    /// @param debt Quantity owed on the liability side.
+    /// @param action Primary operation hint from `Actions` that produced the position.
+    event Positioned(bytes32 indexed account, bytes32 asset, uint amount, bytes32 liability, uint debt, uint32 action);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/events/Relay.sol

@@ -8,7 +8,7 @@ abstract contract RelayEvent is EventEmitter {
     string private constant ABI = "event Relay(bytes32 indexed account, uint portal, uint resources, bytes32 key, bytes32 digest)";
 
     /// @param account Account that owns the relayed context.
-    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param portal Destination portal implementation's host ID.
     /// @param resources Chain-specific resources assigned to the relay.
     /// @param key Relay correlation or recovery lookup key.
     /// @param digest Digest of the relayed payload or canonical envelope.

package/events/Route.sol

@@ -8,7 +8,7 @@ abstract contract RouteEvent is EventEmitter {
     string private constant ABI = "event Route(uint indexed host, uint portal, uint status)";
 
     /// @param host Host node ID that owns the route.
-    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param portal Destination portal implementation's host ID.
     /// @param status Route status. Zero means inactive; nonzero means active.
     event Route(uint indexed host, uint portal, uint status);
 

package/execution/Execution.sol

@@ -15,6 +15,7 @@ import {max16} from "../utils/Utils.sol";
 /// @dev `decoders` contains tagged input and state cursor lanes. Cursor operations
 /// select one logical lane by swapping it into the lower 128 bits.
 struct Execution {
+    bytes32 account;
     uint budget;
     uint decoders;
     uint writers;
@@ -187,6 +188,52 @@ library Executions {
         return exec.decoders.any();
     }
 
+    /// @notice Return a decoder lane's current absolute calldata position.
+    /// @param exec Execution whose decoder is inspected.
+    /// @param lane Decoder lane to select.
+    /// @return Current absolute calldata position of the selected lane.
+    function absolute(Execution memory exec, uint8 lane) internal pure returns (uint) {
+        return exec.decoders.select(lane).absolute();
+    }
+
+    /// @dev Return the complete validated calldata source for a decoder lane.
+    /// @dev Does not consume or depend on the lane's current position. A lane
+    /// absent because its descriptor is EMPTY returns an empty calldata slice.
+    /// @param exec Execution whose input or state source is requested.
+    /// @param lane Input or state decoder lane.
+    /// @return data Complete calldata region represented by the lane.
+    function raw(Execution memory exec, uint8 lane) private pure returns (bytes calldata data) {
+        if (!exec.decoders.contains(lane)) return msg.data[0:0];
+
+        uint cur = exec.decoders.select(lane);
+        (, uint offset, uint len) = cur.decode();
+        if (len > msg.data.length || offset > msg.data.length - len) revert Blocks.MalformedBlocks();
+        return msg.data[offset:offset + len];
+    }
+
+    /// @notice Return the complete validated command state without consuming it.
+    /// @dev Remains the complete original state after the state cursor advances.
+    function rawState(Execution memory exec) internal pure returns (bytes calldata) {
+        return raw(exec, Lanes.State);
+    }
+
+    /// @notice Return the complete validated endpoint input without consuming it.
+    /// @dev Remains the complete original input after the input cursor advances.
+    function rawInput(Execution memory exec) internal pure returns (bytes calldata) {
+        return raw(exec, Lanes.Input);
+    }
+
+    /// @notice Return whether the next block on `lane` has `key` and an empty payload.
+    /// @param exec Execution whose decoder is inspected without advancing.
+    /// @param lane Decoder lane to inspect.
+    /// @param key Expected block key.
+    /// @return Whether a complete matching empty block header occurs next.
+    function isEmpty(Execution memory exec, uint8 lane, bytes4 key) internal pure returns (bool) {
+        uint cur = exec.decoders.select(lane);
+        (uint i, uint offset, uint len) = cur.decode();
+        return Blocks.isEmpty(offset + i, offset + len, key);
+    }
+
     /// @notice Validate and consume the next block from an execution decoder lane.
     /// @param exec Execution whose selected decoder cursor is advanced over the complete block.
     /// @param lane Execution decoder lane to select.
@@ -199,6 +246,34 @@ library Executions {
         exec.decoders = cur.seekAbs(end);
     }
 
+    /// @notice Validate and consume one block from a decoder lane, returning its complete encoding.
+    /// @param exec Execution whose selected decoder cursor is advanced past the block.
+    /// @param lane Execution decoder lane to select.
+    /// @param key Expected block key.
+    /// @return data Calldata view of the complete block, including its header.
+    function takeBlock(
+        Execution memory exec,
+        uint8 lane,
+        bytes4 key
+    ) internal pure returns (bytes calldata data) {
+        (uint abs, uint end) = consume(exec, lane, Specs.create(key, 0, 0, 0));
+        data = msg.data[abs - Sizes.Header:end];
+    }
+
+    /// @notice Consume a matching empty block from an execution decoder lane when present.
+    /// @param exec Execution whose selected decoder advances only for a matching empty block.
+    /// @param lane Decoder lane to consume.
+    /// @param key Expected block key.
+    /// @return Whether an empty block was consumed.
+    function tryConsumeEmpty(Execution memory exec, uint8 lane, bytes4 key) internal pure returns (bool) {
+        uint cur = exec.decoders.select(lane);
+        (uint i, uint offset, uint size) = cur.decode();
+        (bytes4 current, uint len) = Blocks.peek(offset + i, offset + size);
+        if (current != key || len != 0) return false;
+        exec.decoders = cur.seek(i + Sizes.Header);
+        return true;
+    }
+
     /// @notice Validate and enter the payload of the next block in an execution decoder lane.
     /// @dev The selected lane remains in its existing frame so callers can decode
     /// child blocks in place. Callers should prove complete payload consumption
@@ -209,9 +284,48 @@ library Executions {
     /// @return abs Absolute position of the first payload byte.
     /// @return end Absolute position immediately after the payload.
     function enter(Execution memory exec, uint8 lane, uint spec) internal pure returns (uint abs, uint end) {
+        return enter(exec, lane, spec, 0);
+    }
+
+    /// @notice Validate a parent block and advance over a fixed payload prefix.
+    /// @dev `amount` is relative to the payload start and cannot exceed the
+    /// current parent payload. The returned `abs` remains the payload start.
+    /// @param exec Execution whose selected decoder advances over the header and fixed prefix.
+    /// @param lane Execution decoder lane to select.
+    /// @param spec Expected parent block specification.
+    /// @param amount Number of initial payload bytes to advance over.
+    /// @return abs Absolute position of the first payload byte.
+    /// @return end Absolute position immediately after the payload.
+    function enter(
+        Execution memory exec,
+        uint8 lane,
+        uint spec,
+        uint amount
+    ) internal pure returns (uint abs, uint end) {
         uint cur = exec.decoders.select(lane);
         (abs, end) = Blocks.expect(cur.absolute(), spec);
-        exec.decoders = cur.seekAbs(abs);
+        if (amount > end - abs) revert Blocks.InvalidBlock();
+        exec.decoders = cur.seekAbs(abs + amount);
+    }
+
+    /// @notice Advance an execution decoder lane by a raw byte count.
+    /// @dev No block header or schema is validated.
+    /// @param exec Execution whose selected decoder cursor is advanced.
+    /// @param lane Decoder lane to select.
+    /// @param amount Number of bytes to advance.
+    function advance(Execution memory exec, uint8 lane, uint amount) internal pure {
+        uint cur = exec.decoders.select(lane);
+        exec.decoders = cur.advance(amount);
+    }
+
+    /// @notice Take a raw byte range from an execution decoder lane.
+    /// @dev No block header or schema is validated.
+    /// @param exec Execution whose selected decoder cursor is advanced.
+    /// @param lane Decoder lane to select.
+    /// @param amount Number of bytes to take.
+    /// @return abs Absolute position of the first taken byte.
+    function take(Execution memory exec, uint8 lane, uint amount) internal pure returns (uint abs) {
+        (exec.decoders, abs) = exec.decoders.consume(lane, amount);
     }
 
     /// @notice Require the active execution decoder to be at absolute position `abs`.
@@ -246,9 +360,7 @@ library Executions {
 
     /// @dev Return the next raw calldata word from `lane` and advance by `size` bytes.
     function next(Execution memory exec, uint8 lane, uint size) private pure returns (bytes32 value) {
-        uint abs;
-        (exec.decoders, abs) = exec.decoders.consume(lane, size);
-        value = Blocks.read32(abs);
+        value = Blocks.read32(take(exec, lane, size));
     }
 
     /// @notice Return the next raw byte from a decoder lane and advance it by one byte.
@@ -806,6 +918,14 @@ library Executions {
         return reserve(exec, size, size);
     }
 
+    /// @notice Append an empty block to execution output.
+    /// @param exec Execution receiving the block.
+    /// @param key Block key.
+    function outputEmpty(Execution memory exec, bytes4 key) internal pure {
+        uint i = reserve(exec, Sizes.Header);
+        Blocks.writeEmpty(exec.output, i, key);
+    }
+
     /// @notice Append an ACCOUNT block to execution output.
     /// @param exec Execution receiving the block.
     /// @param account Account identifier to encode.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",
@@ -9,8 +9,7 @@
     "**/*.sol",
     "README.md",
     "CHANGELOG.md",
-    "LICENSE",
-    "docs/Schema.md"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"