@rootzero/contracts 1.13.0 → 1.15.0

package/commands/Provision.sol

@@ -1,12 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {CommandContext, CommandBase, Keys} from "./Base.sol";
-import {Payable} from "../core/Payable.sol";
-import {HostAmount, Cursors, Cur, Writer, Writers} from "../Cursors.sol";
-import {Budget} from "../utils/Value.sol";
-using Cursors for Cur;
-using Writers for Writer;
+import {Execution, Executions, CommandBase, HostAmount, Lanes, Specs} from "./Base.sol";
+using Executions for Execution;
 
 /// @notice Shared provision hook used by `Provision`.
 abstract contract ProvisionHook {
@@ -25,67 +21,70 @@ abstract contract ProvisionPayableHook {
     /// side effect (e.g. transfer or record); output blocks are written by the caller.
     /// @param account Caller's account identifier.
     /// @param allocation Host-scoped amount to provision.
-    /// @param budget Mutable native-value budget drawn from `msg.value`.
-    function provision(bytes32 account, HostAmount memory allocation, Budget memory budget) internal virtual;
+    /// @param funds Mutable execution used only for its remaining native-value budget.
+    function provision(bytes32 account, HostAmount memory allocation, Execution memory funds) internal virtual;
 }
 
 /// @title Provision
-/// @notice Command that provisions assets to peer hosts from ALLOCATION request blocks.
-/// Each request block supplies the target host plus an asset amount; the output is a CUSTODY state stream.
+/// @notice Command that provisions assets to peer hosts from ALLOCATION input blocks.
+/// Each input block supplies the target host plus an asset amount; the output is a CUSTODY state stream.
 abstract contract Provision is CommandBase, ProvisionHook {
-    bytes32 private immutable descriptor;
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("provision", Keys.Empty, Keys.Allocation, Keys.Custody, 0, false, false);
+        (, descriptor) = command("provision", Specs.Empty, Specs.Allocation, Specs.Custody, 0, false, false);
     }
 
-    /// @notice Provision ALLOCATION request blocks and output matching CUSTODY state blocks.
-    /// @param c Command context; `c.input` must contain ALLOCATION blocks.
+    /// @notice Provision ALLOCATION input blocks and output matching CUSTODY state blocks.
+    /// @param input ALLOCATION block stream.
     /// @return CUSTODY block stream matching the provisioned allocations.
     /// @return Empty transaction stream.
-    function provision(CommandContext calldata c) external onlyCommand returns (bytes memory, bytes memory) {
-        (Cur memory input, uint outputs) = openInput(c.input, descriptor);
-        Writer memory output = Writers.allocCustodies(outputs);
+    function provision(
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
 
-        while (input.i < input.len) {
-            HostAmount memory allocation = input.unpackAllocationValue();
-            provision(c.account, allocation);
-            output.appendCustody(allocation);
+        while (exec.more()) {
+            HostAmount memory allocation = exec.unpackAllocationValue(Lanes.Input);
+            provision(account, allocation);
+            exec.outputCustody(allocation);
         }
 
-        return (output.finish(), "");
+        return close(exec, account);
     }
 }
 
 /// @title ProvisionPayable
-/// @notice Command that provisions assets to peer hosts from ALLOCATION request blocks.
-/// Each request block supplies the target host plus an asset amount; the output is a CUSTODY state stream.
+/// @notice Command that provisions assets to peer hosts from ALLOCATION input blocks.
+/// Each input block supplies the target host plus an asset amount; the output is a CUSTODY state stream.
 /// The hook receives a mutable native-value budget drawn from `msg.value`.
-abstract contract ProvisionPayable is CommandBase, Payable, ProvisionPayableHook {
-    bytes32 private immutable descriptor;
+abstract contract ProvisionPayable is CommandBase, ProvisionPayableHook {
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("provisionPayable", Keys.Empty, Keys.Allocation, Keys.Custody, 0, true, false);
+        (, descriptor) = command("provisionPayable", Specs.Empty, Specs.Allocation, Specs.Custody, 0, true, false);
     }
 
-    /// @notice Provision ALLOCATION request blocks with access to a mutable native-value budget.
-    /// @param c Command context; `c.input` must contain ALLOCATION blocks.
+    /// @notice Provision ALLOCATION input blocks with access to a mutable native-value budget.
+    /// @param input ALLOCATION block stream.
     /// @return CUSTODY block stream matching the provisioned allocations.
     /// @return Remaining native value as a refund transaction stream.
     function provisionPayable(
-        CommandContext calldata c
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        (Cur memory input, uint outputs) = openInput(c.input, descriptor);
-        Writer memory output = Writers.allocCustodies(outputs);
-        Budget memory budget = openValue();
+        Execution memory exec = openInput(input, descriptor, 0);
 
-        while (input.i < input.len) {
-            HostAmount memory allocation = input.unpackAllocationValue();
-            provision(c.account, allocation, budget);
-            output.appendCustody(allocation);
+        while (exec.more()) {
+            HostAmount memory allocation = exec.unpackAllocationValue(Lanes.Input);
+            provision(account, allocation, exec);
+            exec.outputCustody(allocation);
         }
 
-        return (output.finish(), closeValue(budget, c.account));
+        return close(exec, account);
     }
 }
 

package/commands/Recover.sol

@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {CommandBase, CommandContext, Keys} from "./Base.sol";
-import {Payable} from "../core/Payable.sol";
-import {Cursors, Cur} from "../Cursors.sol";
-import {Budget} from "../utils/Value.sol";
+import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 
-using Cursors for Cur;
+using Executions for Execution;
 
+/// @notice Hook implemented by hosts that recover previously undelivered payloads.
 abstract contract RecoverHook {
     /// @notice Override to recover a witness through `handler`.
     /// @param handler Port that should attempt recovery.
@@ -18,30 +16,33 @@ abstract contract RecoverHook {
 }
 
 /// @title RecoverPayable
-/// @notice Command that forwards recover request blocks to a virtual hook.
+/// @notice Command that forwards recover input blocks to a virtual hook.
 /// Recovery is witness-driven: the command account pays and receives leftover
 /// value settlement, but the recovered subject is defined by each witness.
 /// Produces no output state.
-abstract contract RecoverPayable is CommandBase, Payable, RecoverHook {
-    bytes32 private immutable descriptor;
+abstract contract RecoverPayable is CommandBase, RecoverHook {
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("recoverPayable", Keys.Empty, Keys.Recover, Keys.Empty, 0, true, false);
+        (, descriptor) = command("recoverPayable", Specs.Empty, Specs.Recover, Specs.Empty, 0, true, false);
     }
 
-    /// @notice Recover each recover block in the command request.
-    /// @param c Command context; `c.input` must contain Recover blocks.
+    /// @notice Recover each recover block in the command input.
+    /// @param input RECOVER block stream.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
-    function recoverPayable(CommandContext calldata c) external payable onlyCommand returns (bytes memory, bytes memory) {
-        (Cur memory input, ) = openInput(c.input, descriptor);
-        Budget memory budget = openValue();
-
-        while (input.i < input.len) {
-            (uint handler, uint resources, bytes32 key, bytes calldata witness) = input.unpackRecover();
-            recover(handler, key, witness, useValue(budget, resources));
+    function recoverPayable(
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external payable onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
+
+        while (exec.more()) {
+            (uint handler, uint resources, bytes32 key, bytes calldata witness) = exec.unpackRecover(Lanes.Input);
+            recover(handler, key, witness, exec.useValue(resources));
         }
 
-        return ("", closeValue(budget, c.account));
+        return close(exec, account);
     }
 }

package/commands/Relay.sol

@@ -1,48 +1,50 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {CommandBase, CommandContext, Keys} from "./Base.sol";
-import {Lane} from "../core/Endpoint.sol";
-import {Payable} from "../core/Payable.sol";
-import {Cursors, Cur} from "../Cursors.sol";
-import {Budget} from "../utils/Value.sol";
+import {Blocks, Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 
-using Cursors for Cur;
+using Executions for Execution;
 
+/// @notice Hook implemented by hosts that route funded relay payloads.
 abstract contract RoutePayableHook {
     /// @notice Override to route an encoded payload through `portal`.
     /// @param portal Destination portal identifier, often the destination host ID.
     /// @param resources Chain-specific destination resources. EVM adapters
     /// may interpret this as packed execution gas and destination value.
     /// @param payload Encoded payload ready for the transport layer.
-    /// @param budget Source native-value budget available for transport
+    /// @param funds Execution used only for source value available for transport
     /// fees and destination resource funding.
-    function route(uint portal, uint resources, bytes memory payload, Budget memory budget) internal virtual;
+    function route(uint portal, uint resources, bytes memory payload, Execution memory funds) internal virtual;
 }
 
 /// @title RelayPayable
 /// @notice Command that forwards one RELAY block to a host-defined relay hook.
-/// Reverts unless the request contains exactly one RELAY block, preventing
+/// Reverts unless the input contains exactly one RELAY block, preventing
 /// the same state from being duplicated across multiple relays.
 /// Produces no output state.
-abstract contract RelayPayable is CommandBase, Payable, RoutePayableHook {
-    bytes32 private immutable descriptor;
+abstract contract RelayPayable is CommandBase, RoutePayableHook {
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("relayPayable", Keys.Any, Keys.Relay, Keys.Empty, 0, true, false);
+        (, descriptor) = command("relayPayable", Specs.Any, Specs.Relay, Specs.Empty, 0, true, false);
     }
 
-    /// @notice Relay one RELAY request block with the command account and current state.
-    /// @param c Command context; `c.input` must contain exactly one RELAY block.
+    /// @notice Relay one RELAY input block with the command account and current state.
+    /// @param state State forwarded into the destination context.
+    /// @param input Exactly one RELAY block.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
-    function relayPayable(CommandContext calldata c) external payable onlyCommand returns (bytes memory, bytes memory) {
-        (Cur memory input, , ) = openLane(c.input, descriptor, Lane.Input, 1);
-        (uint portal, uint resources, bytes memory context) = input.relayToContext(c.account, c.state);
-
-        Budget memory budget = openValue();
-        route(portal, resources, context, budget);
-
-        return ("", closeValue(budget, c.account));
+    function relayPayable(
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) external payable onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 1);
+        (uint portal, uint resources, bytes calldata payload) = exec.unpackRelay(Lanes.Input);
+        bytes memory context = Blocks.context(account, bytes(state), bytes(payload));
+
+        route(portal, resources, context, exec);
+
+        return close(exec, account);
     }
 }

package/commands/Withdraw.sol

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { CommandContext, CommandBase, Keys } from "./Base.sol";
-import { Cursors, Cur } from "../Cursors.sol";
-using Cursors for Cur;
+import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
+import {Action} from "../annotations/Action.sol";
+import {Actions} from "../utils/Actions.sol";
+using Executions for Execution;
 
+/// @notice Hook implemented by hosts that withdraw account balances.
 abstract contract WithdrawHook {
     /// @notice Override to send funds to `account`.
     /// Called once per BALANCE block in state.
@@ -18,32 +20,31 @@ abstract contract WithdrawHook {
 /// @notice Command that delivers BALANCE state blocks to an external destination.
 /// Use `withdraw` for assets being sent outside the protocol (e.g. ERC-20 transfers, ETH sends).
 /// For internal balance credits, use `creditAccount` instead.
-abstract contract Withdraw is CommandBase, WithdrawHook {
-    bytes32 private immutable descriptor;
+abstract contract Withdraw is CommandBase, WithdrawHook, Action {
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("withdraw", Keys.Balance, Keys.Empty, Keys.Empty, 0, false, false);
+        uint id;
+        (id, descriptor) = command("withdraw", Specs.Balance, Specs.Empty, Specs.Empty, 0, false, false);
+        action(id, Actions.Withdraw);
     }
 
     /// @notice Withdraw each BALANCE block from the command state to the command account.
-    /// @param c Command context; `c.state` must contain BALANCE blocks.
+    /// @param state BALANCE block stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function withdraw(
-        CommandContext calldata c
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        (Cur memory state, ) = openState(c.state, descriptor);
+        Execution memory exec = openState(state, descriptor, 0);
 
-        while (state.i < state.len) {
-            (bytes32 asset, uint amount) = state.unpackBalance();
-            withdraw(c.account, asset, amount);
+        while (exec.more()) {
+            (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
+            withdraw(account, asset, amount);
         }
-        return ("", "");
+
+        return close(exec, account);
     }
 }
-
-
-
-
-
-

package/commands/admin/AllowAssets.sol

@@ -1,41 +1,44 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { AdminBase, CommandContext, Keys } from "./Base.sol";
-import { Cursors, Cur } from "../../Cursors.sol";
-using Cursors for Cur;
+import { AdminBase, Execution, Executions, Lanes, Specs } from "./Base.sol";
+using Executions for Execution;
 
+/// @notice Hook implemented by hosts that allow assets.
 abstract contract AllowAssetsHook {
     /// @dev Override to allow a single asset.
-    /// Called once per ASSET block in the request.
+    /// Called once per ASSET block in the input.
     /// @param asset Asset identifier.
     function allowAsset(bytes32 asset) internal virtual;
 }
 
 /// @title AllowAssets
 /// @notice Admin command that permits a list of assets via a virtual hook.
-/// Each ASSET block in the request calls `allowAsset`. Only callable by the admin account.
+/// Each ASSET block in the input calls `allowAsset`. Only callable by the admin account.
 abstract contract AllowAssets is AdminBase, AllowAssetsHook {
-    bytes32 private immutable descriptor;
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("allowAssets", Keys.Empty, Keys.Asset, Keys.Empty, 0, false, true);
+        (, descriptor) = command("allowAssets", Specs.Empty, Specs.Asset, Specs.Empty, 0, false, true);
     }
 
-    /// @notice Allow each ASSET block in the admin request.
-    /// @param c Admin command context; `c.input` must contain ASSET blocks.
+    /// @notice Allow each ASSET block in the admin input.
+    /// @param input ASSET block stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function allowAssets(
-        CommandContext calldata c
-    ) external onlyAdmin(c.account) returns (bytes memory, bytes memory) {
-        (Cur memory input, ) = openInput(c.input, descriptor);
-
-        while (input.i < input.len) {
-            bytes32 asset = input.unpackAsset();
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
+
+        while (exec.more()) {
+            bytes32 asset = exec.unpackAsset(Lanes.Input);
             allowAsset(asset);
         }
-        return ("", "");
+
+        return close(exec, account);
     }
 }
 

package/commands/admin/Allowance.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {AdminBase, CommandContext, Keys} from "./Base.sol";
-import {Cursors, Cur} from "../../Cursors.sol";
-using Cursors for Cur;
+import {AdminBase, Execution, Executions, Lanes, Specs} from "./Base.sol";
+using Executions for Execution;
 
+/// @notice Hook implemented by hosts that configure peer asset allowances.
 abstract contract AllowanceHook {
     /// @notice Apply or revoke one host-scoped allowance.
-    /// Called once per ALLOWANCE block in the request. Implementations decide
+    /// Called once per ALLOWANCE block in the input. Implementations decide
     /// how the allowance is represented, e.g. ERC-20 approval, an internal cap,
     /// or another host-specific authorization record.
     /// @param peer Host node receiving the allowed cap.
@@ -20,23 +20,28 @@ abstract contract AllowanceHook {
 /// @notice Admin command that applies cross-host allowance entries via a virtual hook.
 /// Each ALLOWANCE block grants or updates a host-scoped asset cap. Only callable by the admin account.
 abstract contract Allowance is AdminBase, AllowanceHook {
-    bytes32 private immutable descriptor;
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("allowance", Keys.Empty, Keys.Allowance, Keys.Empty, 0, false, true);
+        (, descriptor) = command("allowance", Specs.Empty, Specs.Allowance, Specs.Empty, 0, false, true);
     }
 
-    /// @notice Apply each ALLOWANCE block in the admin request.
-    /// @param c Admin command context; `c.input` must contain ALLOWANCE blocks.
+    /// @notice Apply each ALLOWANCE block in the admin input.
+    /// @param input ALLOWANCE block stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
-    function allowance(CommandContext calldata c) external onlyAdmin(c.account) returns (bytes memory, bytes memory) {
-        (Cur memory input, ) = openInput(c.input, descriptor);
+    function allowance(
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
 
-        while (input.i < input.len) {
-            (uint peer, bytes32 asset, uint amount) = input.unpackAllowance();
+        while (exec.more()) {
+            (uint peer, bytes32 asset, uint amount) = exec.unpackAllowance(Lanes.Input);
             allowance(peer, asset, amount);
         }
-        return ("", "");
+
+        return close(exec, account);
     }
 }

package/commands/admin/Annotate.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {AdminBase, Execution, Executions, Lanes, Specs} from "./Base.sol";
+using Executions for Execution;
+
+/// @title Annotate
+/// @notice Admin command that attaches encoded annotation block streams to entities.
+/// Each ANNOTATION block in the input emits one `Annotation` event. Only callable
+/// by the admin account.
+abstract contract Annotate is AdminBase {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = command("annotate", Specs.Empty, Specs.Annotation, Specs.Empty, 0, false, true);
+    }
+
+    /// @notice Publish each ANNOTATION block in the admin input.
+    /// @param input ANNOTATION block stream.
+    /// @return Empty output state.
+    /// @return Empty transaction stream.
+    function annotate(
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
+
+        while (exec.more()) {
+            (uint entity, bytes calldata data) = exec.unpackAnnotation(Lanes.Input);
+            emit Annotation(entity, data);
+        }
+
+        return close(exec, account);
+    }
+}

package/commands/admin/Appoint.sol

@@ -1,34 +1,37 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { AdminBase, CommandContext, Keys } from "./Base.sol";
-import { Cursors, Cur } from "../../Cursors.sol";
-using Cursors for Cur;
+import { AdminBase, Execution, Executions, Lanes, Specs } from "./Base.sol";
+import { GuardianAccess } from "../../core/Access.sol";
+using Executions for Execution;
 
 /// @title Appoint
 /// @notice Admin command that grants guardian status to a list of account IDs.
-/// Each ACCOUNT block in the request is enabled as a guardian on the host.
+/// Each USER ACCOUNT block in the input is assigned the guardian role on the host.
 /// Only callable by the admin account.
-abstract contract Appoint is AdminBase {
-    bytes32 private immutable descriptor;
+abstract contract Appoint is GuardianAccess, AdminBase {
+    uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("appoint", Keys.Empty, Keys.Account, Keys.Empty, 0, false, true);
+        (, descriptor) = command("appoint", Specs.Empty, Specs.Account, Specs.Empty, 0, false, true);
     }
 
-    /// @notice Appoint each ACCOUNT block in the admin request as a guardian.
-    /// @param c Admin command context; `c.input` must contain ACCOUNT blocks.
+    /// @notice Appoint each user ACCOUNT block in the admin input as a guardian.
+    /// @param input ACCOUNT block stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function appoint(
-        CommandContext calldata c
-    ) external onlyAdmin(c.account) returns (bytes memory, bytes memory) {
-        (Cur memory input, ) = openInput(c.input, descriptor);
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
 
-        while (input.i < input.len) {
-            bytes32 account = input.unpackAccount();
-            setGuardian(account, true);
+        while (exec.more()) {
+            bytes32 guardian = exec.unpackAccount(Lanes.Input);
+            setGuardian(guardian, true);
         }
-        return ("", "");
+
+        return close(exec, account);
     }
 }

package/commands/admin/Authorize.sol

@@ -1,33 +1,42 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {AdminBase, CommandContext, Keys} from "./Base.sol";
-import {Cursors, Cur} from "../../Cursors.sol";
-using Cursors for Cur;
+import {AdminBase, Execution, Executions, Lanes, Specs} from "./Base.sol";
+using Executions for Execution;
 
 /// @title Authorize
 /// @notice Admin command that grants authorization to a list of node IDs.
-/// Each NODE block in the request is authorized on the host.
+/// Each NODE block in the input is authorized on the host.
 /// Only callable by the admin account.
 abstract contract Authorize is AdminBase {
-    bytes32 private immutable descriptor;
-    uint internal immutable authorizeId;
+    uint private immutable descriptor;
+    uint private immutable id;
 
     constructor() {
-        (authorizeId, descriptor) = command("authorize", Keys.Empty, Keys.Node, Keys.Empty, 0, false, true);
+        (id, descriptor) = command("authorize", Specs.Empty, Specs.Node, Specs.Empty, 0, false, true);
     }
 
-    /// @notice Authorize each NODE block in the admin request.
-    /// @param c Admin command context; `c.input` must contain NODE blocks.
+    /// @notice Return the registered AUTHORIZE command ID.
+    function authorizeId() internal view returns (uint) {
+        return id;
+    }
+
+    /// @notice Authorize each NODE block in the admin input.
+    /// @param input NODE block stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
-    function authorize(CommandContext calldata c) external onlyAdmin(c.account) returns (bytes memory, bytes memory) {
-        (Cur memory input, ) = openInput(c.input, descriptor);
+    function authorize(
+        bytes32 account,
+        bytes calldata,
+        bytes calldata input
+    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
+        Execution memory exec = openInput(input, descriptor, 0);
 
-        while (input.i < input.len) {
-            uint node = input.unpackNode();
+        while (exec.more()) {
+            uint node = exec.unpackNode(Lanes.Input);
             setNode(node, true);
         }
-        return ("", "");
+
+        return close(exec, account);
     }
 }

package/commands/admin/Base.sol

@@ -1,8 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {CommandBase, CommandContext, Keys} from "../Base.sol";
+import {CommandBase, Execution, Executions, Lanes, Specs} from "../Base.sol";
+import {NodeAccess} from "../../core/Access.sol";
 
 /// @title AdminBase
 /// @notice Shared base for admin commands.
-abstract contract AdminBase is CommandBase {}
+abstract contract AdminBase is NodeAccess, CommandBase {
+    /// @dev Restrict execution to the commander using the host's admin account.
+    modifier onlyAdmin(bytes32 account) {
+        enforceAdmin(account, msg.sender);
+        _;
+    }
+}