@rootzero/contracts 1.14.0 → 1.16.0

package/commands/Base.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {NodeCalls} from "../core/Calls.sol";
+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";
@@ -19,17 +19,10 @@ using Executions for Execution;
 /// @title CommandBase
 /// @notice Abstract base for all rootzero command contracts.
 /// Provides access control modifiers and command endpoint metadata helpers.
-abstract contract CommandBase is NodeCalls, EndpointBase, ReceivedEvent {
+abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
     /// @dev Thrown when `onlyActive` finds that `deadline` has already passed.
     error Expired();
 
-    /// @dev Restrict execution to the commander using the host's admin account.
-    modifier onlyAdmin(bytes32 account) {
-        if (account != admin) revert AccessDenied();
-        enforceCommander(msg.sender);
-        _;
-    }
-
     /// @dev Restrict execution to trusted callers.
     modifier onlyCommand() {
         enforceCaller(msg.sender);
@@ -43,26 +36,6 @@ abstract contract CommandBase is NodeCalls, EndpointBase, ReceivedEvent {
         _;
     }
 
-    /// @notice Close a command execution and refund unspent value to `account`.
-    /// @param exec Command execution to close.
-    /// @param account Account that should receive any unspent value.
-    /// @return output Final encoded output block stream.
-    /// @return transactions Final encoded transaction block stream.
-    function close(
-        Execution memory exec,
-        bytes32 account
-    ) internal returns (bytes memory output, bytes memory transactions) {
-        if (exec.budget == 0 && Cursors.initial(exec.writers)) return ("", "");
-
-        output = close(exec);
-        uint amount = exec.refundValue(account, nativeAsset);
-        if (amount != 0) {
-            emit Received(account, nativeAsset, amount, Actions.Refund, 0);
-        }
-
-        transactions = exec.finishTransactions();
-    }
-
     /// @notice Publish command metadata and a default label.
     /// @param name Command entrypoint name and default label. It must exactly
     /// match the Solidity command function name used by the canonical ABI.
@@ -83,27 +56,29 @@ abstract contract CommandBase is NodeCalls, EndpointBase, ReceivedEvent {
         bool funded,
         bool admin
     ) internal returns (uint id, uint descriptor) {
-        id = Nodes.toCommand(Selectors.command(name), address(this));
-        uint8 flags;
+        uint8 flags = 0;
         if (funded) flags |= Descriptors.Funded;
         if (admin) flags |= Descriptors.Admin;
-        descriptor = endpoint(id, name, state, input, output, transactions, flags);
+        descriptor = Descriptors.create(state, input, output, transactions, flags);
+        return command(name, descriptor);
     }
 
-    /// @notice Open a command state stream and return the expected output block count.
-    /// @param source State block stream to open.
+    /// @notice Publish an already constructed command descriptor and default label.
+    /// @param name Command entrypoint name and default label. It must exactly
+    /// match the Solidity command function name used by the canonical ABI.
     /// @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);
+    /// @return id Command node ID.
+    /// @return published Published endpoint descriptor.
+    function command(string memory name, uint descriptor) internal returns (uint id, uint published) {
+        id = Nodes.toCommand(Selectors.command(name), address(this));
+        published = endpoint(id, name, descriptor);
     }
 
-    /// @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.
@@ -117,4 +92,24 @@ abstract contract CommandBase is NodeCalls, EndpointBase, ReceivedEvent {
     ) internal view returns (Execution memory exec) {
         return Executions.open(state, input, descriptor, batches);
     }
+
+    /// @notice Close a command execution and refund unspent value to `account`.
+    /// @param exec Command execution to close.
+    /// @param account Account that should receive any unspent value.
+    /// @return output Final encoded output block stream.
+    /// @return transactions Final encoded transaction block stream.
+    function close(
+        Execution memory exec,
+        bytes32 account
+    ) internal returns (bytes memory output, bytes memory transactions) {
+        if (exec.budget == 0 && Cursors.initial(exec.writers)) return ("", "");
+
+        output = close(exec);
+        uint amount = exec.refundValue(account, nativeAsset);
+        if (amount != 0) {
+            emit Received(account, nativeAsset, amount, Actions.Refund, 0);
+        }
+
+        transactions = exec.finishTransactions();
+    }
 }

package/commands/Burn.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.33;
 
 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 burn account assets.
@@ -18,11 +20,13 @@ abstract contract BurnHook {
 /// @title Burn
 /// @notice Command that irreversibly destroys each BALANCE state block via a virtual hook.
 /// Produces no output state.
-abstract contract Burn is CommandBase, BurnHook {
+abstract contract Burn is CommandBase, BurnHook, Action {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("burn", Specs.Balance, Specs.Empty, Specs.Empty, 0, false, false);
+        uint id;
+        (id, descriptor) = command("burn", Specs.Balance, Specs.Empty, Specs.Empty, 0, false, false);
+        action(id, Actions.Burn);
     }
 
     /// @notice Burn each BALANCE block from the command state.
@@ -32,9 +36,9 @@ abstract contract Burn is CommandBase, BurnHook {
     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

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.33;
 
 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;
 
@@ -32,11 +34,13 @@ abstract contract DepositPayableHook {
 /// @notice Command that receives externally sourced assets and records them as BALANCE state.
 /// Use `deposit` for assets arriving from outside the protocol (e.g. ERC-20 transfers, ETH).
 /// For internal balance deductions, use `debitAccount` instead.
-abstract contract Deposit is CommandBase, DepositHook {
+abstract contract Deposit is CommandBase, DepositHook, Action {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("deposit", Specs.Empty, Specs.Amount, Specs.Balance, 0, false, false);
+        uint id;
+        (id, descriptor) = command("deposit", Specs.Empty, Specs.Amount, Specs.Balance, 0, false, false);
+        action(id, Actions.Deposit);
     }
 
     /// @notice Deposit AMOUNT input blocks into the command account and output matching BALANCE blocks.
@@ -45,10 +49,10 @@ abstract contract Deposit is CommandBase, DepositHook {
     /// @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);
@@ -63,11 +67,13 @@ abstract contract Deposit is CommandBase, DepositHook {
 /// @title DepositPayable
 /// @notice Command that receives externally sourced assets and records them as BALANCE state.
 /// Use `depositPayable` when the hook needs tracked access to `msg.value` via a mutable budget.
-abstract contract DepositPayable is CommandBase, DepositPayableHook {
+abstract contract DepositPayable is CommandBase, DepositPayableHook, Action {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("depositPayable", Specs.Empty, Specs.Amount, Specs.Balance, 0, true, false);
+        uint id;
+        (id, descriptor) = command("depositPayable", Specs.Empty, Specs.Amount, Specs.Balance, 0, true, false);
+        action(id, Actions.Deposit);
     }
 
     /// @notice Deposit AMOUNT input blocks with access to a mutable native-value budget.
@@ -76,10 +82,10 @@ abstract contract DepositPayable is CommandBase, DepositPayableHook {
     /// @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/Payout.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.33;
 
 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;
 
@@ -19,11 +21,13 @@ abstract contract PayoutHook {
 /// @title Payout
 /// @notice Command that sinks BALANCE state blocks to matching ACCOUNT input blocks.
 /// Each BALANCE block is paired with one ACCOUNT block at the same position.
-abstract contract Payout is CommandBase, PayoutHook {
+abstract contract Payout is CommandBase, PayoutHook, Action {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("payout", Specs.Balance, Specs.Account, Specs.Empty, 0, false, false);
+        uint id;
+        (id, descriptor) = command("payout", Specs.Balance, Specs.Account, Specs.Empty, 0, false, false);
+        action(id, Actions.Payout);
     }
 
     /// @notice Pay out BALANCE state blocks to matching ACCOUNT input blocks.

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 ("", "");
+    }
+}