@rootzero/contracts 1.15.0 → 1.16.0

package/codec/Specs.sol

@@ -31,6 +31,8 @@ library Sizes {
     uint constant HostAmount = B96;
     /// @dev TRANSACTION block: 8 header + 32 from + 32 to + 32 asset + 32 amount = 136 bytes
     uint constant Transaction = B128;
+    /// @dev POSITION block: 8 header + four-word asset-liability pair = 136 bytes
+    uint constant Position = B128;
 }
 
 /// @title Specs
@@ -44,7 +46,6 @@ library Specs {
     error InvalidSpec();
     /// @dev A direct specification cannot contain a wrapper block.
     error InvalidContainer();
-
     uint private constant SizeFields = (uint(1) << 192) | (uint(1) << 160) | (uint(1) << 136);
 
     // Reusable field shapes keep public specs readable while remaining valid
@@ -60,12 +61,12 @@ library Specs {
     uint private constant UnboundedMin104Hint256 = (uint(104) << 192) | (uint(256) << 136);
 
     uint constant Empty = uint(bytes32(Keys.Empty));
-    uint constant Any = uint(bytes32(Keys.Any)) | UnboundedHint128;
     uint constant Amount = uint(bytes32(Keys.Amount)) | Exact64;
     uint constant Balance = uint(bytes32(Keys.Balance)) | Exact64;
     uint constant Allocation = uint(bytes32(Keys.Allocation)) | Exact96;
     uint constant Allowance = uint(bytes32(Keys.Allowance)) | Exact96;
     uint constant Custody = uint(bytes32(Keys.Custody)) | Exact96;
+    uint constant Position = uint(bytes32(Keys.Position)) | Exact128;
     uint constant List = uint(bytes32(Keys.List)) | UnboundedHint128;
     uint constant Evm = uint(bytes32(Keys.Evm)) | UnboundedHint128;
     uint constant Bytes = uint(bytes32(Keys.Bytes)) | UnboundedHint128;
@@ -237,4 +238,5 @@ library Specs {
     function group(uint spec, uint8 n) internal pure returns (uint) {
         return replace8(spec, 128, n);
     }
+
 }

package/codec/Writers.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {AssetAmount, AccountAmount, HostAmount, Tx} from "../core/Types.sol";
+import {AssetAmount, AccountAmount, HostAmount, Position, Tx} from "../core/Types.sol";
 import {Blocks} from "./Blocks.sol";
 import {Buffers} from "./Buffers.sol";
 import {Sizes, Specs} from "./Specs.sol";
@@ -44,7 +44,7 @@ library Writers {
         (uint capacity, bool growable) = Specs.allocation(spec, groups);
         if (capacity == 0) return writer;
 
-        writer.cur = Buffers.cursor(capacity, groups, growable, 0);
+        writer.cur = Buffers.cursor(capacity, Specs.count(spec, groups), growable, 0);
     }
 
     // -------------------------------------------------------------------------
@@ -291,6 +291,23 @@ library Writers {
         Blocks.writeHostAccountAsset(writer.dst, i, host, account, asset);
     }
 
+    /// @notice Append a POSITION block.
+    function appendPosition(
+        Writer memory writer,
+        bytes32 asset,
+        uint amount,
+        bytes32 liability,
+        uint debt
+    ) internal pure {
+        uint i = reserve(writer, Sizes.Position);
+        Blocks.writePosition(writer.dst, i, asset, amount, liability, debt);
+    }
+
+    /// @notice Append a structured POSITION value.
+    function appendPosition(Writer memory writer, Position memory value) internal pure {
+        appendPosition(writer, value.asset, value.amount, value.liability, value.debt);
+    }
+
     /// @notice Append a TRANSACTION block.
     /// @param writer Destination writer.
     /// @param from Debit account identifier.

package/commands/Base.sol

@@ -5,7 +5,7 @@ import {CallerAccess} from "../core/Access.sol";
 import {EndpointBase} from "../core/Endpoint.sol";
 import {Blocks} from "../codec/Blocks.sol";
 import {Specs} from "../codec/Specs.sol";
-import {HostAmount} from "../core/Types.sol";
+import {HostAmount, Position} from "../core/Types.sol";
 import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 import {ReceivedEvent} from "../events/Received.sol";
 import {Actions} from "../utils/Actions.sol";
@@ -74,20 +74,11 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
         published = endpoint(id, name, descriptor);
     }
 
-    /// @notice Open a command state stream and return the expected output block count.
-    /// @param source State block stream to open.
-    /// @param descriptor Packed command endpoint descriptor.
-    /// @param batches Required batch count, or zero to accept the state count.
-    /// @return exec Execution with its output buffer metadata initialized for the state batch count.
-    function openState(
-        bytes calldata source,
-        uint descriptor,
-        uint batches
-    ) internal view returns (Execution memory exec) {
-        return Executions.openState(source, descriptor, batches);
-    }
-
-    /// @notice Open a command execution with batches derived from its input and state lanes.
+    /// @notice Open and validate both command lanes, including lanes declared EMPTY.
+    /// Batches are derived from the input and state lanes. A non-empty stream for
+    /// a lane whose descriptor has zero stride reverts instead of being ignored.
+    /// Commands must account for the complete validated state by consuming it,
+    /// transforming and returning it, forwarding it intact, or reverting.
     /// @param state Current command state block stream.
     /// @param input Command input block stream.
     /// @param descriptor Packed command endpoint descriptor.

package/commands/Burn.sol

@@ -36,9 +36,9 @@ abstract contract Burn is CommandBase, BurnHook, Action {
     function burn(
         bytes32 account,
         bytes calldata state,
-        bytes calldata
+        bytes calldata input
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openState(state, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);

package/commands/Credit.sol

@@ -3,12 +3,15 @@ pragma solidity ^0.8.33;
 
 import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 import {CreditAccountHook} from "../core/Settlement.sol";
+import {Blocks} from "../codec/Blocks.sol";
+import {Reader, Readers} from "../codec/Readers.sol";
 
 using Executions for Execution;
+using Readers for Reader;
 
 /// @title CreditAccount
 /// @notice Command that delivers BALANCE state blocks to an account via a virtual hook.
-/// Use for internally recording credits that have already been settled externally.
+/// Use for internally recording credits that have already been posted externally.
 abstract contract CreditAccount is CommandBase, CreditAccountHook {
     uint private immutable descriptor;
     uint private immutable id;
@@ -29,9 +32,9 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     function creditAccount(
         bytes32 account,
         bytes calldata state,
-        bytes calldata
+        bytes calldata input
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openState(state, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
@@ -41,3 +44,32 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
         return close(exec, account);
     }
 }
+
+/// @title InternalCreditAccount
+/// @notice Extends the advertised credit-account command with memory-state pipeline dispatch.
+/// @dev This adapter is not a separate command. It uses the command ID and account hook
+/// inherited from `CreditAccount` while accepting the state location used by `Pipeline`.
+abstract contract InternalCreditAccount is CreditAccount {
+    /// @notice Execute the inherited credit-account command from an internal pipeline.
+    /// @param account Account credited by each balance.
+    /// @param state BALANCE block stream held in pipeline memory.
+    /// @param input Empty input required by the command schema.
+    /// @return output Empty output state.
+    /// @return transactions Empty transaction stream.
+    function executeCreditAccount(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input
+    ) internal returns (bytes memory, bytes memory) {
+        if (input.length != 0) revert Executions.ZeroStride();
+        if (state.length == 0) revert Blocks.EmptyRun();
+
+        Reader memory reader = Readers.open(state);
+        while (reader.more()) {
+            (bytes32 asset, uint amount) = reader.unpackBalance();
+            creditAccount(account, asset, amount);
+        }
+
+        return ("", "");
+    }
+}

package/commands/Debit.sol

@@ -3,13 +3,18 @@ pragma solidity ^0.8.33;
 
 import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 import {DebitAccountHook} from "../core/Settlement.sol";
+import {Blocks} from "../codec/Blocks.sol";
+import {Sizes} from "../codec/Specs.sol";
+import {Decoders} from "../codec/Decoders.sol";
+import {Cur} from "../utils/Cursors.sol";
 
 using Executions for Execution;
+using Decoders for Cur;
 
 /// @title DebitAccount
 /// @notice Command that deducts AMOUNT blocks from an account and emits matching BALANCE state.
 /// Use for internally recording debits. The virtual `debitAccount` hook is called once per
-/// AMOUNT block; the default batch implementation handles the full input loop.
+/// AMOUNT block.
 abstract contract DebitAccount is CommandBase, DebitAccountHook {
     uint private immutable descriptor;
     uint private immutable id;
@@ -23,11 +28,16 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
         return id;
     }
 
-    /// @notice Override to customize input parsing or batching for debits.
-    /// The default implementation iterates AMOUNT blocks, calls
-    /// `debitAccount`, and emits matching BALANCE blocks.
-    function debitAccount(bytes32 account, bytes calldata input) internal virtual returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+    /// @notice Debit AMOUNT input blocks from the command account and output matching BALANCE blocks.
+    /// @param input AMOUNT block stream.
+    /// @return BALANCE block stream matching the debited amounts.
+    /// @return Empty transaction stream.
+    function debitAccount(
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) external onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
@@ -37,16 +47,39 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
 
         return close(exec, account);
     }
+}
 
-    /// @notice Debit AMOUNT input blocks from the command account and output matching BALANCE blocks.
+/// @title InternalDebitAccount
+/// @notice Extends the advertised debit-account command with memory-state pipeline dispatch.
+/// @dev This adapter is not a separate command. It uses the command ID and account hook
+/// inherited from `DebitAccount` while accepting the state location used by `Pipeline`.
+abstract contract InternalDebitAccount is DebitAccount {
+    /// @notice Execute the inherited debit-account command from an internal pipeline.
+    /// @param account Account whose funds are debited.
+    /// @param state Empty pipeline state required by the command schema.
     /// @param input AMOUNT block stream.
-    /// @return BALANCE block stream matching the debited amounts.
-    /// @return Empty transaction stream.
-    function debitAccount(
+    /// @return output BALANCE block stream matching the debited amounts.
+    /// @return transactions Empty transaction stream.
+    function executeDebitAccount(
         bytes32 account,
-        bytes calldata,
+        bytes memory state,
         bytes calldata input
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        return debitAccount(account, input);
+    ) internal returns (bytes memory, bytes memory) {
+        if (state.length != 0) revert Executions.ZeroStride();
+        if (input.length == 0) revert Blocks.EmptyRun();
+
+        Cur memory cur = Decoders.wrap(input);
+        uint count = input.length / Sizes.Amount;
+        bytes memory output = new bytes(count * Sizes.Balance);
+        uint i;
+
+        while (cur.more()) {
+            (bytes32 asset, uint amount) = cur.unpackAmount();
+            debitAccount(account, asset, amount);
+            Blocks.writeBalance(output, i, asset, amount);
+            i += Sizes.Balance;
+        }
+
+        return (output, "");
     }
 }

package/commands/Deposit.sol

@@ -49,10 +49,10 @@ abstract contract Deposit is CommandBase, DepositHook, Action {
     /// @return Empty transaction stream.
     function deposit(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
@@ -82,10 +82,10 @@ abstract contract DepositPayable is CommandBase, DepositPayableHook, Action {
     /// @return Remaining native value as a refund transaction stream.
     function depositPayable(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);

package/commands/Provision.sol

@@ -41,10 +41,10 @@ abstract contract Provision is CommandBase, ProvisionHook {
     /// @return Empty transaction stream.
     function provision(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             HostAmount memory allocation = exec.unpackAllocationValue(Lanes.Input);
@@ -73,10 +73,10 @@ abstract contract ProvisionPayable is CommandBase, ProvisionPayableHook {
     /// @return Remaining native value as a refund transaction stream.
     function provisionPayable(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             HostAmount memory allocation = exec.unpackAllocationValue(Lanes.Input);

package/commands/Recover.sol

@@ -6,21 +6,28 @@ import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 using Executions for Execution;
 
 /// @notice Hook implemented by hosts that recover previously undelivered payloads.
-abstract contract RecoverHook {
+abstract contract RecoverPayableHook {
     /// @notice Override to recover a witness through `handler`.
     /// @param handler Port that should attempt recovery.
+    /// @param resources Chain-specific resources assigned to the recovery attempt.
     /// @param key Recovery lookup key.
     /// @param witness Witness payload used to prove and replay recovery.
-    /// @param value Native EVM value assigned to the recovery attempt.
-    function recover(uint handler, bytes32 key, bytes calldata witness, uint128 value) internal virtual;
+    /// @param funds Shared execution containing the source value budget.
+    function recover(
+        uint handler,
+        uint resources,
+        bytes32 key,
+        bytes calldata witness,
+        Execution memory funds
+    ) internal virtual;
 }
 
 /// @title RecoverPayable
 /// @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.
+/// value posting, but the recovered subject is defined by each witness.
 /// Produces no output state.
-abstract contract RecoverPayable is CommandBase, RecoverHook {
+abstract contract RecoverPayable is CommandBase, RecoverPayableHook {
     uint private immutable descriptor;
 
     constructor() {
@@ -33,14 +40,14 @@ abstract contract RecoverPayable is CommandBase, RecoverHook {
     /// @return Remaining native value as a refund transaction stream.
     function recoverPayable(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, 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));
+            recover(handler, resources, key, witness, exec);
         }
 
         return close(exec, account);

package/commands/Relay.sol

@@ -5,28 +5,53 @@ import {Blocks, Execution, Executions, CommandBase, Lanes, Specs} from "./Base.s
 
 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`.
+/// @notice Hook implemented by hosts that forward funded relay payloads.
+abstract contract RelayPayableHook {
+    /// @notice Override to relay an encoded payload to `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 funds Execution used only for source value available for transport
-    /// fees and destination resource funding.
-    function route(uint portal, uint resources, bytes memory payload, Execution memory funds) internal virtual;
+    /// @param funds Execution used for source value available for transport fees
+    /// and destination resource funding.
+    function relayTo(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.
+/// @notice Command that forwards one RELAY block without pipeline state.
+abstract contract RelayPayable is CommandBase, RelayPayableHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = command("relayPayable", Specs.Empty, Specs.Relay, Specs.Empty, 0, true, false);
+    }
+
+    /// @notice Relay one RELAY input block with the command account and empty state.
+    function relayPayable(
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) external payable onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openCommand(state, input, descriptor, 1);
+        (uint portal, uint resources, bytes calldata payload) = exec.unpackRelay(Lanes.Input);
+        bytes memory context = Blocks.context(account, bytes(state), bytes(payload));
+
+        relayTo(portal, resources, context, exec);
+
+        return close(exec, account);
+    }
+}
+
+/// @title RelayBalancePayable
+/// @notice Command that forwards required BALANCE state with one RELAY block.
 /// 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, RoutePayableHook {
+abstract contract RelayBalancePayable is CommandBase, RelayPayableHook {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("relayPayable", Specs.Any, Specs.Relay, Specs.Empty, 0, true, false);
+        (, descriptor) = command("relayBalancePayable", Specs.Balance, Specs.Relay, Specs.Empty, 0, true, false);
     }
 
     /// @notice Relay one RELAY input block with the command account and current state.
@@ -34,16 +59,16 @@ abstract contract RelayPayable is CommandBase, RoutePayableHook {
     /// @param input Exactly one RELAY block.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
-    function relayPayable(
+    function relayBalancePayable(
         bytes32 account,
         bytes calldata state,
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 1);
+        Execution memory exec = openCommand(state, 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);
+        relayTo(portal, resources, context, exec);
 
         return close(exec, account);
     }

package/commands/Settle.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
+import {SettleHook} from "../core/Settlement.sol";
+import {Action} from "../annotations/Action.sol";
+import {Actions} from "../utils/Actions.sol";
+import {Blocks} from "../codec/Blocks.sol";
+import {Reader, Readers} from "../codec/Readers.sol";
+
+using Executions for Execution;
+using Readers for Reader;
+
+/// @title Settle
+/// @notice Command that consumes POSITION state blocks through a virtual hook.
+abstract contract Settle is CommandBase, SettleHook, Action {
+    uint private immutable descriptor;
+    uint private immutable id;
+
+    constructor() {
+        (id, descriptor) = command("settle", Specs.Position, Specs.Empty, Specs.Empty, 0, false, false);
+        action(id, Actions.Settle);
+    }
+
+    /// @notice Return the registered SETTLE command ID.
+    function settleId() internal view returns (uint) {
+        return id;
+    }
+
+    /// @notice Settle each POSITION block from the command state.
+    /// @param state POSITION block stream.
+    /// @return Empty output state.
+    /// @return Empty transaction stream.
+    function settle(
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) external onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openCommand(state, input, descriptor, 0);
+
+        while (exec.more()) {
+            (bytes32 asset, uint amount, bytes32 liability, uint debt) = exec.unpackPosition(Lanes.State);
+            settle(account, asset, amount, liability, debt);
+        }
+
+        return close(exec, account);
+    }
+}
+
+/// @title InternalSettle
+/// @notice Extends the advertised settle command with memory-state pipeline dispatch.
+/// @dev This adapter is not a separate command. It uses the command ID and settlement hook
+/// inherited from `Settle` while accepting the state location used by `Pipeline`.
+abstract contract InternalSettle is Settle {
+    /// @notice Execute the inherited settle command from an internal pipeline.
+    /// @param account Account for which each position is settled.
+    /// @param state POSITION block stream held in pipeline memory.
+    /// @param input Empty input required by the command schema.
+    /// @return output Empty output state.
+    /// @return transactions Empty transaction stream.
+    function executeSettle(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input
+    ) internal returns (bytes memory, bytes memory) {
+        if (input.length != 0) revert Executions.ZeroStride();
+        if (state.length == 0) revert Blocks.EmptyRun();
+
+        Reader memory reader = Readers.open(state);
+        while (reader.more()) {
+            (bytes32 asset, uint amount, bytes32 liability, uint debt) = reader.unpackPosition();
+            settle(account, asset, amount, liability, debt);
+        }
+
+        return ("", "");
+    }
+}

package/commands/Withdraw.sol

@@ -36,9 +36,9 @@ abstract contract Withdraw is CommandBase, WithdrawHook, Action {
     function withdraw(
         bytes32 account,
         bytes calldata state,
-        bytes calldata
+        bytes calldata input
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openState(state, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);

package/commands/admin/AllowAssets.sol

@@ -28,10 +28,10 @@ abstract contract AllowAssets is AdminBase, AllowAssetsHook {
     /// @return Empty transaction stream.
     function allowAssets(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             bytes32 asset = exec.unpackAsset(Lanes.Input);

package/commands/admin/Allowance.sol

@@ -32,10 +32,10 @@ abstract contract Allowance is AdminBase, AllowanceHook {
     /// @return Empty transaction stream.
     function allowance(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (uint peer, bytes32 asset, uint amount) = exec.unpackAllowance(Lanes.Input);

package/commands/admin/Annotate.sol

@@ -21,10 +21,10 @@ abstract contract Annotate is AdminBase {
     /// @return Empty transaction stream.
     function annotate(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (uint entity, bytes calldata data) = exec.unpackAnnotation(Lanes.Input);

package/commands/admin/Appoint.sol

@@ -22,10 +22,10 @@ abstract contract Appoint is GuardianAccess, AdminBase {
     /// @return Empty transaction stream.
     function appoint(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             bytes32 guardian = exec.unpackAccount(Lanes.Input);

package/commands/admin/Authorize.sol

@@ -27,10 +27,10 @@ abstract contract Authorize is AdminBase {
     /// @return Empty transaction stream.
     function authorize(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             uint node = exec.unpackNode(Lanes.Input);

package/commands/admin/DenyAssets.sol

@@ -28,10 +28,10 @@ abstract contract DenyAssets is AdminBase, DenyAssetsHook {
     /// @return Empty transaction stream.
     function denyAssets(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             bytes32 asset = exec.unpackAsset(Lanes.Input);