@rootzero/contracts 1.22.0 → 1.23.0

package/CHANGELOG.md

@@ -3,6 +3,74 @@
 Until the protocol reaches integration-stable status, minor versions may include
 breaking API changes. Breaking changes are called out explicitly.
 
+## 1.23.0
+
+### Breaking Changes
+
+- Changed every command entrypoint from
+  `(bytes32 account, bytes state, bytes input)` to one `bytes context` argument
+  containing exactly one encoded `CONTEXT` block. Canonical command selectors
+  now use `(bytes)`, so every command node ID changes. Existing command callers,
+  cached IDs, and deployed host graphs are not compatible with this release.
+- Added the acting account to `Execution`. `CommandBase.openCommand` and
+  `AdminBase.openAdminCommand` now accept the encoded context and return only
+  the initialized execution, and command implementations close with
+  `closeCommand(exec)` instead of `close(exec, account)`.
+- Removed the separate state argument from `RelayPayableHook.relay`. Relay
+  implementations can obtain the complete validated state with
+  `exec.rawState()` while the explicit account and nested relay input arguments
+  remain unchanged.
+- Consolidated `AllowAssetsPort` and `DenyAssetsPort` into
+  `ports/Assets.sol`; update direct source imports to the new path.
+- Renamed the peer `AllowancePort` and `portAllowance` selector to
+  `RequestAllowancePort` and `portRequestAllowance`. The peer port now uses a
+  distinct `RequestAllowanceHook.requestAllowance` hook; the admin `Allowance`
+  command and its authoritative `AllowanceHook.allowance` hook are unchanged.
+- Removed the `Commander` event declaration. Commander addresses and chain
+  context are off-chain configuration; host, native-asset, and admin IDs are
+  deterministic from that information.
+- Prefixed every typed `Blocks` factory with `create`, including calldata-copy
+  variants; for example, use `createBalance`, `createStepCopy`, `createBytes`,
+  and `createString` instead of `balance`, `stepCopy`, `data`, and `text`.
+- Changed the `max8`, `max16`, `max24`, `max32`, `max40`, `max64`, `max96`,
+  `max128`, and `max160` bounds helpers to return their corresponding narrowed
+  integer types instead of `uint`.
+
+### Added
+
+- Added `PositionedEvent`, which publishes asset and liability sides together
+  with the semantic action that produced the observed position.
+- Added `RequestAssetPort`, which passes trusted peers' batched asset and amount
+  requests to a host hook for validation and fulfillment.
+- Added `Executions.takeBlock`, which validates and consumes a block from a
+  selected decoder lane and returns its complete calldata encoding.
+- Added `Executions.rawState` and `Executions.rawInput` for retrieving complete
+  validated calldata lanes independently of current cursor progress.
+- Added `Blocks.createAmount` for constructing canonical `AMOUNT` blocks.
+
+### Changed
+
+- Command pipeline hops now construct `command(bytes)` calldata and the nested
+  `CONTEXT` block directly in one allocation, copying memory state and calldata
+  input into the final call buffer.
+- Added memory `callPort`/`tryCallPort` helpers and calldata-copy
+  `callPortCopy`/`tryCallPortCopy` counterparts, matching the block factory
+  naming convention. Portal forwarding and recovery use the copy variants.
+
+### Upgrade Compatibility
+
+- Rebuild command IDs from the new `(bytes)` selectors, redeploy command hosts,
+  and update pipeline builders and other callers to pass one encoded `CONTEXT`
+  block. Do not mix 1.22 command IDs or callers with 1.23 deployments.
+- Update custom commands to read the acting account from `exec.account`, use
+  `openCommand(context, descriptor, batches)`, and return
+  `closeCommand(exec)`.
+- Update relay hook implementations to remove the state parameter and use
+  `exec.rawState()` when the forwarded state is required.
+- Update direct port imports, renamed request-allowance endpoints and hooks,
+  typed `Blocks` factory calls, and any assignments that relied on `max*`
+  returning `uint`.
+
 ## 1.22.0
 
 ### Breaking Changes

package/Endpoints.sol

@@ -37,12 +37,11 @@ import {Unauthorize} from "./commands/admin/Unauthorize.sol";
 
 // Port endpoints
 import {PortBase} from "./ports/Base.sol";
-import {AllowAssetsPort} from "./ports/AllowAssets.sol";
-import {AllowancePort} from "./ports/Allowance.sol";
+import {AllowAssetsPort, DenyAssetsPort, RequestAssetPort, RequestAssetHook} from "./ports/Assets.sol";
+import {RequestAllowancePort, RequestAllowanceHook} from "./ports/Allowance.sol";
 import {RedeemBalancePort, RedeemBalanceHook} from "./ports/Redeem.sol";
 import {CreditAccountPort} from "./ports/Credit.sol";
 import {DebitAccountPort} from "./ports/Debit.sol";
-import {DenyAssetsPort} from "./ports/DenyAssets.sol";
 import {PipePayablePort} from "./ports/Pipe.sol";
 import {DispatchPayablePort, DispatchPayableHook} from "./ports/Dispatch.sol";
 import {PostPort} from "./ports/Post.sol";

package/Events.sol

@@ -8,7 +8,6 @@ import { AnnotationEvent } from "./events/Annotation.sol";
 import { AssetEvent, AssetStatusEvent } from "./events/Asset.sol";
 import { Actions } from "./utils/Actions.sol";
 import { BalanceEvent } from "./events/Balance.sol";
-import { CommanderEvent } from "./events/Commander.sol";
 import { DispatchEvent } from "./events/Dispatch.sol";
 import { EndpointEvent } from "./events/Endpoint.sol";
 import { ReceivedEvent } from "./events/Received.sol";
@@ -19,6 +18,7 @@ import { GuardianEvent } from "./events/Guardian.sol";
 import { IntroductionEvent } from "./events/Introduction.sol";
 import { LockedEvent } from "./events/Locked.sol";
 import { NodeEvent } from "./events/Node.sol";
+import { PositionedEvent } from "./events/Positioned.sol";
 import { RootedEvent } from "./events/Rooted.sol";
 import { RouteEvent } from "./events/Route.sol";
 import { SpentEvent } from "./events/Spent.sol";

package/README.md

@@ -288,19 +288,17 @@ command lanes, loop the batch, call the hook, and write the output run:
 
 ```solidity
 function deposit(
-    bytes32 account,
-    bytes calldata state,
-    bytes calldata input
+    bytes calldata context
 ) external onlyCommand returns (bytes memory, bytes memory) {
-    Execution memory exec = openCommand(state, input, descriptor, 0);
+    Execution memory exec = openCommand(context, descriptor, 0);
 
     while (exec.more()) {
         (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
-        deposit(account, asset, amount); // host policy hook
+        deposit(exec.account, asset, amount); // host policy hook
         exec.outputBalance(asset, amount);
     }
 
-    return close(exec, account);
+    return closeCommand(exec);
 }
 ```
 
@@ -317,17 +315,15 @@ abstract contract MyCommand is CommandBase {
     }
 
     function myCommand(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
             // Apply command-specific behavior for this group.
             exec.outputBalance(asset, amount);
         }
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 ```
@@ -435,6 +431,12 @@ central ones are batches all the way down:
 - `portPost` consumes `transaction { bytes32 from, bytes32 to, bytes32 asset,
   uint amount }` blocks, debiting `from` and crediting `to` per
   block — how two hosts post transactions between their ledgers.
+- `portRequestAsset` consumes `amount { bytes32 asset, uint amount }` blocks and
+  passes the authenticated peer, asset, and amount to a host hook. The hook
+  validates asset support and applies the host's request and transfer policy.
+- `portRequestAllowance` consumes the same amount blocks and lets the
+  authenticated peer request an asset allowance. The hook decides what
+  allowance, if any, to grant.
 - `portPipePayable` consumes `context` blocks, each carrying an account, an
   initial state, and a run of steps — a complete pipeline delivered by another
   host, executed locally against the port call's shared value budget.

package/annotations/Action.sol

@@ -12,6 +12,6 @@ abstract contract Action is AnnotationEvent {
     /// @param entity Entity receiving the action annotation.
     /// @param value Canonical action identifier, such as a value from `Actions`.
     function action(uint entity, uint value) internal virtual {
-        emit Annotation(entity, Blocks.action(value));
+        emit Annotation(entity, Blocks.createAction(value));
     }
 }

package/annotations/Label.sol

@@ -14,6 +14,6 @@ abstract contract Label is AnnotationEvent {
     /// @param namespace Label namespace.
     /// @param name Human-readable name within the namespace.
     function label(uint entity, bytes32 namespace, string memory name) internal virtual {
-        emit Annotation(entity, Blocks.label(namespace, name));
+        emit Annotation(entity, Blocks.createLabel(namespace, name));
     }
 }

package/annotations/Schema.sol

@@ -80,7 +80,7 @@ abstract contract Schema is Runtime, AnnotationEvent {
     /// @param name Schema alias name, or zero for unnamed schemas.
     /// @return The published block specification.
     function schema(uint spec, string memory body, bytes32 name) internal returns (uint) {
-        emit Annotation(host, Blocks.schema(spec, body, name));
+        emit Annotation(host, Blocks.createSchema(spec, body, name));
         return spec;
     }
 }

package/codec/Blocks.sol

@@ -1776,7 +1776,7 @@ library Blocks {
     /// @notice Encode an empty block.
     /// @param key Block type key.
     /// @return value Encoded empty block header.
-    function empty(bytes4 key) internal pure returns (bytes memory value) {
+    function createEmpty(bytes4 key) internal pure returns (bytes memory value) {
         value = allocate(Sizes.Header);
         writeEmpty(value, 0, key);
     }
@@ -1801,28 +1801,28 @@ library Blocks {
     // Dynamic leaf factories
 
     /// @notice Encode a LIST block.
-    function list(bytes memory value) internal pure returns (bytes memory blockdata) {
+    function createList(bytes memory value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         writeList(blockdata, 0, value);
     }
 
     /// @notice Encode a LIST block by copying its payload from calldata.
-    function listCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
+    function createListCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         copyList(blockdata, 0, value);
     }
 
     /// @notice Encode an EVM block.
-    function evm(bytes memory value) internal pure returns (bytes memory blockdata) {
+    function createEvm(bytes memory value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         writeEvm(blockdata, 0, value);
     }
 
     /// @notice Encode an EVM block by copying its payload from calldata.
-    function evmCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
+    function createEvmCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         copyEvm(blockdata, 0, value);
@@ -1831,14 +1831,14 @@ library Blocks {
     /// @notice Encode a BYTES block with a raw payload.
     /// @param value Raw payload bytes.
     /// @return blockdata Encoded BYTES block bytes.
-    function data(bytes memory value) internal pure returns (bytes memory blockdata) {
+    function createBytes(bytes memory value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         writeBytes(blockdata, 0, value);
     }
 
     /// @notice Encode a BYTES block by copying its payload from calldata.
-    function dataCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
+    function createBytesCopy(bytes calldata value) internal pure returns (bytes memory blockdata) {
         uint len = max32(value.length);
         blockdata = allocate(Sizes.Header + len);
         copyBytes(blockdata, 0, value);
@@ -1847,14 +1847,14 @@ library Blocks {
     /// @notice Encode a STRING block with a UTF-8 payload.
     /// @param value String payload.
     /// @return blockdata Encoded STRING block bytes.
-    function text(string memory value) internal pure returns (bytes memory blockdata) {
+    function createString(string memory value) internal pure returns (bytes memory blockdata) {
         uint len = max32(bytes(value).length);
         blockdata = allocate(Sizes.Header + len);
         writeString(blockdata, 0, value);
     }
 
     /// @notice Encode a STRING block by copying its payload from calldata.
-    function textCopy(string calldata value) internal pure returns (bytes memory blockdata) {
+    function createStringCopy(string calldata value) internal pure returns (bytes memory blockdata) {
         uint len = max32(bytes(value).length);
         blockdata = allocate(Sizes.Header + len);
         copyString(blockdata, 0, value);
@@ -1866,7 +1866,7 @@ library Blocks {
     /// @param namespace Label namespace.
     /// @param name Label text.
     /// @return value Encoded LABEL block bytes.
-    function label(bytes32 namespace, string memory name) internal pure returns (bytes memory value) {
+    function createLabel(bytes32 namespace, string memory name) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B32 + bytes(name).length);
         value = allocate(Sizes.Header + len);
         writeLabel(value, 0, namespace, name);
@@ -1875,7 +1875,7 @@ library Blocks {
     /// @notice Encode an ACTION annotation block.
     /// @param actionid Canonical semantic action identifier.
     /// @return value Encoded ACTION block bytes.
-    function action(uint actionid) internal pure returns (bytes memory value) {
+    function createAction(uint actionid) internal pure returns (bytes memory value) {
         value = allocate(Sizes.B32);
         write32(value, 0, Keys.Action, bytes32(actionid));
     }
@@ -1884,8 +1884,8 @@ library Blocks {
     /// @param spec Block specification.
     /// @param body Schema body.
     /// @return value Encoded SCHEMA block bytes.
-    function schema(uint spec, string memory body) internal pure returns (bytes memory value) {
-        return schema(spec, body, bytes32(0));
+    function createSchema(uint spec, string memory body) internal pure returns (bytes memory value) {
+        return createSchema(spec, body, bytes32(0));
     }
 
     /// @notice Encode a named SCHEMA block.
@@ -1893,7 +1893,7 @@ library Blocks {
     /// @param body Schema body.
     /// @param name Schema name.
     /// @return value Encoded SCHEMA block bytes.
-    function schema(uint spec, string memory body, bytes32 name) internal pure returns (bytes memory value) {
+    function createSchema(uint spec, string memory body, bytes32 name) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + bytes(body).length);
         value = allocate(Sizes.Header + len);
         writeSchema(value, 0, spec, body, name);
@@ -1901,11 +1901,20 @@ library Blocks {
 
     // Fixed-width factories
 
+    /// @notice Encode an AMOUNT block.
+    /// @param asset Asset identifier.
+    /// @param amount Token amount.
+    /// @return value Encoded AMOUNT block bytes.
+    function createAmount(bytes32 asset, uint amount) internal pure returns (bytes memory value) {
+        value = allocate(Sizes.Amount);
+        writeAmount(value, 0, asset, amount);
+    }
+
     /// @notice Encode a BALANCE block.
     /// @param asset Asset identifier.
     /// @param amount Token amount.
     /// @return value Encoded BALANCE block bytes.
-    function balance(bytes32 asset, uint amount) internal pure returns (bytes memory value) {
+    function createBalance(bytes32 asset, uint amount) internal pure returns (bytes memory value) {
         value = allocate(Sizes.Balance);
         writeBalance(value, 0, asset, amount);
     }
@@ -1915,7 +1924,7 @@ library Blocks {
     /// @param asset Asset identifier.
     /// @param amount Token amount.
     /// @return value Encoded CUSTODY block bytes.
-    function custody(uint host, bytes32 asset, uint amount) internal pure returns (bytes memory value) {
+    function createCustody(uint host, bytes32 asset, uint amount) internal pure returns (bytes memory value) {
         value = allocate(Sizes.B96);
         writeCustody(value, 0, host, asset, amount);
     }
@@ -1926,7 +1935,7 @@ library Blocks {
     /// @param liability Identifier for the liability side.
     /// @param debt Quantity owed on the liability side.
     /// @return value Encoded POSITION block bytes.
-    function position(
+    function createPosition(
         bytes32 asset,
         uint amount,
         bytes32 liability,
@@ -1942,7 +1951,7 @@ library Blocks {
     /// @param asset Asset identifier.
     /// @param amount Transfer amount.
     /// @return value Encoded TRANSACTION block bytes.
-    function transaction(
+    function createTransaction(
         bytes32 from,
         bytes32 to,
         bytes32 asset,
@@ -1959,14 +1968,14 @@ library Blocks {
     /// @param resources Packed resources assigned to the step.
     /// @param input Raw nested input payload.
     /// @return value Encoded STEP block bytes.
-    function step(uint cmd, uint resources, bytes memory input) internal pure returns (bytes memory value) {
+    function createStep(uint cmd, uint resources, bytes memory input) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + input.length);
         value = allocate(len);
         writeStep(value, 0, cmd, resources, input);
     }
 
     /// @notice Encode a STEP block by copying its nested input from calldata.
-    function stepCopy(uint cmd, uint resources, bytes calldata input) internal pure returns (bytes memory value) {
+    function createStepCopy(uint cmd, uint resources, bytes calldata input) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + input.length);
         value = allocate(len);
         copyStep(value, 0, cmd, resources, input);
@@ -1977,14 +1986,14 @@ library Blocks {
     /// @param resources Packed resources assigned to the call.
     /// @param payload Raw calldata payload for the target.
     /// @return value Encoded CALL block bytes.
-    function call(uint target, uint resources, bytes memory payload) internal pure returns (bytes memory value) {
+    function createCall(uint target, uint resources, bytes memory payload) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + payload.length);
         value = allocate(len);
         writeCall(value, 0, target, resources, payload);
     }
 
     /// @notice Encode a CALL block by copying its nested payload from calldata.
-    function callCopy(uint target, uint resources, bytes calldata payload) internal pure returns (bytes memory value) {
+    function createCallCopy(uint target, uint resources, bytes calldata payload) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + payload.length);
         value = allocate(len);
         copyCall(value, 0, target, resources, payload);
@@ -1996,14 +2005,14 @@ library Blocks {
     /// @param resources Chain-specific resources for the destination context.
     /// @param input Nested input block stream.
     /// @return value Encoded RELAY block bytes.
-    function relay(uint portal, uint resources, bytes memory input) internal pure returns (bytes memory value) {
+    function createRelay(uint portal, uint resources, bytes memory input) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + input.length);
         value = allocate(len);
         writeRelay(value, 0, portal, resources, input);
     }
 
     /// @notice Encode a RELAY block by copying its nested input from calldata.
-    function relayCopy(uint portal, uint resources, bytes calldata input) internal pure returns (bytes memory value) {
+    function createRelayCopy(uint portal, uint resources, bytes calldata input) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + input.length);
         value = allocate(len);
         copyRelay(value, 0, portal, resources, input);
@@ -2015,14 +2024,14 @@ library Blocks {
     /// @param resources Chain-specific resources for the destination dispatch.
     /// @param payload Encoded payload.
     /// @return value Encoded DISPATCH block bytes.
-    function dispatch(uint portal, uint resources, bytes memory payload) internal pure returns (bytes memory value) {
+    function createDispatch(uint portal, uint resources, bytes memory payload) internal pure returns (bytes memory value) {
         uint len = max32(Sizes.B64 + Sizes.Header + payload.length);
         value = allocate(len);
         writeDispatch(value, 0, portal, resources, payload);
     }
 
     /// @notice Encode a DISPATCH block by copying its nested payload from calldata.
-    function dispatchCopy(
+    function createDispatchCopy(
         uint portal,
         uint resources,
         bytes calldata payload
@@ -2033,7 +2042,7 @@ library Blocks {
     }
 
     /// @notice Encode a CONTEXT block.
-    function context(
+    function createContext(
         bytes32 account,
         bytes memory state,
         bytes memory input
@@ -2044,7 +2053,7 @@ library Blocks {
     }
 
     /// @notice Encode a CONTEXT block by copying its nested streams from calldata.
-    function contextCopy(
+    function createContextCopy(
         bytes32 account,
         bytes calldata state,
         bytes calldata input
@@ -2055,7 +2064,7 @@ library Blocks {
     }
 
     /// @notice Encode a RECOVER block.
-    function recover(
+    function createRecover(
         uint handler,
         uint resources,
         bytes32 recoverykey,
@@ -2067,7 +2076,7 @@ library Blocks {
     }
 
     /// @notice Encode a RECOVER block by copying its nested witness from calldata.
-    function recoverCopy(
+    function createRecoverCopy(
         uint handler,
         uint resources,
         bytes32 recoverykey,

package/commands/Allocate.sol

@@ -28,23 +28,20 @@ abstract contract Allocate is CommandBase, AllocateHook {
     }
 
     /// @notice Allocate BALANCE state blocks to matching NODE input blocks.
-    /// @param state BALANCE block stream.
-    /// @param input Matching NODE block stream.
+    /// @param context Command context carrying BALANCE state and matching NODE input.
     /// @return CUSTODY block stream matching the allocated balances.
     /// @return Empty transaction stream.
     function allocate(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
 
         while (exec.more()) {
             HostAmount memory custody = exec.unpackBalanceForHost(Lanes.State, exec.unpackNode(Lanes.Input));
-            allocate(account, custody);
+            allocate(exec.account, custody);
             exec.outputCustody(custody);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/Base.sol

@@ -70,40 +70,56 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
         published = endpoint(id, name, descriptor);
     }
 
-    /// @notice Open and validate both command lanes, including lanes declared EMPTY.
+    /// @notice Decode the command ABI argument as exactly one complete CONTEXT block.
+    /// @dev Rejects empty input, trailing bytes, and additional context blocks.
+    function unpackCommandContext(
+        bytes calldata context
+    ) internal pure returns (bytes32 account, bytes calldata state, bytes calldata input) {
+        uint abs;
+        assembly ("memory-safe") {
+            abs := context.offset
+        }
+
+        uint end;
+        (account, state, input, end) = Blocks.unpackContext(abs);
+        if (end != abs + context.length) revert Blocks.InvalidBlock();
+    }
+
+    /// @notice Decode one command context and validate both 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 context Exactly one CONTEXT block carrying the account, state, and input.
     /// @param descriptor Packed command endpoint descriptor.
     /// @param batches Required batch count, or zero to reconcile the lane counts.
     /// @return exec Execution with its output buffer metadata initialized for the reconciled batch count.
     function openCommand(
-        bytes calldata state,
-        bytes calldata input,
+        bytes calldata context,
         uint descriptor,
         uint batches
     ) internal view returns (Execution memory exec) {
-        return Executions.open(state, input, descriptor, batches);
+        bytes32 account;
+        bytes calldata state;
+        bytes calldata input;
+        (account, state, input) = unpackCommandContext(context);
+        exec = Executions.open(state, input, descriptor, batches);
+        exec.account = account;
     }
 
-    /// @notice Close a command execution and refund unspent value to `account`.
+    /// @notice Close a command execution and refund unspent value to its 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
+    function closeCommand(
+        Execution memory exec
     ) 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);
+        uint amount = exec.refundValue(exec.account, nativeAsset);
         if (amount != 0) {
-            emit Received(account, nativeAsset, amount, Actions.Refund, 0);
+            emit Received(exec.account, nativeAsset, amount, Actions.Refund, 0);
         }
 
         transactions = exec.finishTransactions();

package/commands/Burn.sol

@@ -30,22 +30,20 @@ abstract contract Burn is CommandBase, BurnHook, Action {
     }
 
     /// @notice Burn each BALANCE block from the command state.
-    /// @param state BALANCE block stream.
+    /// @param context Command context carrying the BALANCE state stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function burn(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
-            burn(account, asset, amount);
+            burn(exec.account, asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 

package/commands/Credit.sol

@@ -26,22 +26,20 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     }
 
     /// @notice Credit each BALANCE block from the command state to the command account.
-    /// @param state BALANCE block stream.
+    /// @param context Command context carrying the BALANCE state stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function creditAccount(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
-            creditAccount(account, asset, amount);
+            creditAccount(exec.account, asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 

package/commands/Debit.sol

@@ -29,23 +29,21 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
     }
 
     /// @notice Debit AMOUNT input blocks from the command account and output matching BALANCE blocks.
-    /// @param input AMOUNT block stream.
+    /// @param context Command context carrying the AMOUNT input stream.
     /// @return BALANCE block stream matching the debited amounts.
     /// @return Empty transaction stream.
     function debitAccount(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
-            debitAccount(account, asset, amount);
+            debitAccount(exec.account, asset, amount);
             exec.outputBalance(asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }