@rootzero/contracts 1.25.0 → 1.26.0

package/commands/Allocate.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {Execution, Executions, CommandBase, HostAmount, Lanes, Specs} from "./Base.sol";
+import {Execution, Executions, CommandBase, HostAmount, Specs} from "./Base.sol";
 
 using Executions for Execution;
 
@@ -24,24 +24,25 @@ abstract contract Allocate is CommandBase, AllocateHook {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = command("allocate", Specs.Balance, Specs.Node, Specs.Custody, 0, 0);
+        (, descriptor) = command("allocate", Specs.Balance, Specs.Node, Specs.Custody, 0);
     }
 
     /// @notice Allocate BALANCE state blocks to matching NODE input blocks.
     /// @param context Command context carrying BALANCE state and matching NODE input.
     /// @return CUSTODY block stream matching the allocated balances.
-    /// @return Empty transaction stream.
+    /// @return Zero native budget credit.
     function allocate(
         bytes calldata context
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            HostAmount memory custody = exec.unpackBalanceForHost(Lanes.State, exec.unpackNode(Lanes.Input));
+            uint host = exec.oninput().unpackNode();
+            HostAmount memory custody = exec.onstate().unpackBalanceForHost(host);
             allocate(exec.account, custody);
             exec.outputCustody(custody);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }

package/commands/Base.sol

@@ -6,19 +6,17 @@ import {EndpointBase} from "../core/Endpoint.sol";
 import {Blocks} from "../codec/Blocks.sol";
 import {Specs} from "../codec/Specs.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";
+import {Execution, Executions} from "../execution/Execution.sol";
 import {Descriptors, Flags} from "../codec/Descriptors.sol";
 import {Nodes} from "../utils/Nodes.sol";
-import {Cursors} from "../utils/Cursors.sol";
 
 using Executions for Execution;
+using Descriptors for uint;
 
 /// @title CommandBase
 /// @notice Abstract base for all rootzero command contracts.
 /// Provides access control modifiers and command endpoint metadata helpers.
-abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
+abstract contract CommandBase is CallerAccess, EndpointBase {
     /// @dev Thrown when `onlyActive` finds that `deadline` has already passed.
     error Expired();
     /// @dev Thrown when a non-funded internal command receives native value.
@@ -43,7 +41,6 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
     /// @param state State block specification.
     /// @param input Input block specification.
     /// @param output Output block specification.
-    /// @param transactions Number of transaction blocks produced per batch, or zero for none.
     /// @param flags Packed command behavior flags.
     /// @return id Command node ID.
     /// @return descriptor Packed endpoint lane metadata and flags.
@@ -52,10 +49,9 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
         uint state,
         uint input,
         uint output,
-        uint8 transactions,
         uint8 flags
     ) internal returns (uint id, uint descriptor) {
-        descriptor = Descriptors.create(state, input, output, transactions, flags);
+        descriptor = Descriptors.create(state, input, output, flags);
         return command(name, descriptor);
     }
 
@@ -70,55 +66,24 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
         published = endpoint(id, name, descriptor);
     }
 
-    /// @notice Decode the command ABI argument as exactly one complete CONTEXT block.
+    /// @notice Decode one command context and open bounded state and input lanes.
     /// @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) {
+    /// The command's decode and loop implementation defines lane semantics.
+    /// Closing requires both lanes to have been consumed completely.
+    /// @param context Exactly one CONTEXT block carrying the account, state, and input.
+    /// @param descriptor Packed command endpoint descriptor.
+    /// @return exec Execution with a resizable output writer initialized from its descriptor hint.
+    function openCommand(bytes calldata context, uint descriptor) internal view returns (Execution memory exec) {
         uint abs;
         assembly ("memory-safe") {
             abs := context.offset
         }
 
-        uint end;
-        (account, state, input, end) = Blocks.unpackContext(abs);
+        (bytes32 account, bytes calldata state, bytes calldata input, uint 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 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 context,
-        uint descriptor,
-        uint batches
-    ) internal view returns (Execution memory exec) {
-        (bytes32 account, bytes calldata state, bytes calldata input) = unpackCommandContext(context);
-        exec = Executions.open(state, input, descriptor, batches);
+        (exec.decoders, exec.writer) = descriptor.open(state, input);
         exec.account = account;
-    }
-
-    /// @notice Close a command execution and refund unspent value to its account.
-    /// @param exec Command execution to close.
-    /// @return output Final encoded output block stream.
-    /// @return transactions Final encoded transaction block stream.
-    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(exec.account, nativeAsset);
-        if (amount != 0) {
-            emit Received(exec.account, nativeAsset, amount, Actions.Refund, 0);
-        }
-
-        transactions = exec.finishTransactions();
+        exec.budget = msg.value;
     }
 }

package/commands/Bootstrap.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Execution, Executions, CommandBase, Specs} from "./Base.sol";
+import {Blocks} from "../codec/Blocks.sol";
+import {Sizes} from "../codec/Specs.sol";
+import {Cursors} from "../utils/Cursors.sol";
+import {DebitAccountHook} from "../core/Settlement.sol";
+
+using Executions for Execution;
+
+/// @notice Hook implemented by hosts that source bootstrap pipeline budget.
+abstract contract BootstrapBudgetHook {
+    /// @notice Source native-value budget for `account` during bootstrap.
+    /// Called once per BOOTSTRAP input block.
+    /// @dev Implementations must revert unless the contribution can be made available.
+    /// A zero amount is valid and may return immediately without changing state.
+    /// @param account Account funding the pipeline.
+    /// @param amount Native value added to the pipeline budget.
+    function bootstrapBudget(bytes32 account, uint amount) internal virtual;
+}
+
+/// @title Bootstrap
+/// @notice Command that atomically starts a pipeline with BALANCE state and native-value budget.
+abstract contract Bootstrap is CommandBase, DebitAccountHook, BootstrapBudgetHook {
+    uint private immutable descriptor;
+    uint private immutable id;
+
+    constructor() {
+        (id, descriptor) = command("bootstrap", Specs.Empty, Specs.Bootstrap, Specs.Balance, 0);
+    }
+
+    /// @notice Return the registered BOOTSTRAP command ID.
+    function bootstrapId() internal view returns (uint) {
+        return id;
+    }
+
+    /// @notice Source initial balances and budget contributions for a pipeline.
+    /// @param context Command context carrying a BOOTSTRAP input stream.
+    /// @return output One BALANCE block per BOOTSTRAP input.
+    /// @return credit Sum of trusted native value contributed by every input.
+    function bootstrap(
+        bytes calldata context
+    ) external onlyCommand returns (bytes memory output, uint credit) {
+        Execution memory exec = openCommand(context, descriptor);
+
+        while (exec.more()) {
+            (bytes32 asset, uint amount, uint budget) = exec.unpackBootstrap();
+            debitAccount(exec.account, asset, amount);
+            bootstrapBudget(exec.account, budget);
+            exec.outputBalance(asset, amount);
+            credit += budget;
+        }
+
+        return exec.close(credit);
+    }
+}
+
+/// @title BootstrapInternal
+/// @notice Extends bootstrap with optimized local pipeline dispatch.
+abstract contract BootstrapInternal is Bootstrap {
+    /// @notice Execute bootstrap directly against a calldata BOOTSTRAP stream.
+    /// @param account Account funding the pipeline.
+    /// @param state Empty pipeline state required by the command schema.
+    /// @param input BOOTSTRAP block stream.
+    /// @param value Native value assigned to this command; must be zero.
+    /// @return output One BALANCE block per BOOTSTRAP input.
+    /// @return credit Sum of the sourced budget contributions.
+    function executeBootstrap(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input,
+        uint128 value
+    ) internal returns (bytes memory output, uint credit) {
+        if (value != 0) revert ValueNotAllowed();
+        if (state.length != 0) revert Executions.ZeroStride();
+        if (input.length % Sizes.Bootstrap != 0) revert Blocks.InvalidBlock();
+
+        (uint abs, uint end) = Cursors.bounds(input);
+        output = new bytes(input.length / Sizes.Bootstrap * Sizes.Balance);
+        uint i;
+
+        while (abs < end) {
+            (bytes32 asset, uint amount, uint budget) = Blocks.unpackBootstrap(abs);
+            debitAccount(account, asset, amount);
+            bootstrapBudget(account, budget);
+            Blocks.writeBalance(output, i, asset, amount);
+            credit += budget;
+            unchecked {
+                abs += Sizes.Bootstrap;
+                i += Sizes.Balance;
+            }
+        }
+    }
+}

package/commands/Burn.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { Execution, Executions, CommandBase, Lanes, Specs } from "./Base.sol";
+import { Execution, Executions, CommandBase, Specs } from "./Base.sol";
 import {Action} from "../annotations/Action.sol";
 import {Actions} from "../utils/Actions.sol";
 using Executions for Execution;
@@ -25,25 +25,25 @@ abstract contract Burn is CommandBase, BurnHook, Action {
 
     constructor() {
         uint id;
-        (id, descriptor) = command("burn", Specs.Balance, Specs.Empty, Specs.Empty, 0, 0);
+        (id, descriptor) = command("burn", Specs.Balance, Specs.Empty, Specs.Empty, 0);
         action(id, Actions.Burn);
     }
 
     /// @notice Burn each BALANCE block from the command state.
     /// @param context Command context carrying the BALANCE state stream.
     /// @return Empty output state.
-    /// @return Empty transaction stream.
+    /// @return Zero native budget credit.
     function burn(
         bytes calldata context
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
+            (bytes32 asset, uint amount) = exec.unpackBalance();
             burn(exec.account, asset, amount);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }
 

package/commands/Cashout.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Execution, Executions, CommandBase, Specs} from "./Base.sol";
+import {Blocks} from "../codec/Blocks.sol";
+import {Sizes} from "../codec/Specs.sol";
+import {Cursors} from "../utils/Cursors.sol";
+import {Action} from "../annotations/Action.sol";
+import {Actions} from "../utils/Actions.sol";
+
+using Executions for Execution;
+
+/// @notice Hook implemented by hosts that withdraw native assets from accounts.
+abstract contract CashoutHook {
+    /// @notice Withdraw an exact native-asset amount from `account`.
+    /// Called once per CASHOUT input block.
+    /// @dev Implementations must revert when the requested amount cannot be withdrawn.
+    /// @param account Account whose native asset is withdrawn.
+    /// @param amount Native-asset amount to withdraw.
+    function cashout(bytes32 account, uint amount) internal virtual;
+}
+
+/// @title Cashout
+/// @notice Command that withdraws requested native-asset amounts from its account.
+abstract contract Cashout is CommandBase, CashoutHook, Action {
+    uint private immutable descriptor;
+    uint private immutable id;
+
+    constructor() {
+        (id, descriptor) = command("cashout", Specs.Empty, Specs.Cashout, Specs.Empty, 0);
+        action(id, Actions.Cashout);
+    }
+
+    /// @notice Return the registered CASHOUT command ID.
+    function cashoutId() internal view returns (uint) {
+        return id;
+    }
+
+    /// @notice Withdraw native-asset amounts from the command account.
+    /// @param context Command context carrying a CASHOUT input stream.
+    /// @return output Empty output state.
+    /// @return credit Zero native budget credit.
+    function cashout(
+        bytes calldata context
+    ) external onlyCommand returns (bytes memory output, uint credit) {
+        Execution memory exec = openCommand(context, descriptor);
+
+        while (exec.more()) {
+            cashout(exec.account, exec.unpackCashout());
+        }
+
+        return exec.close();
+    }
+}
+
+/// @title CashoutInternal
+/// @notice Extends cashout with optimized local pipeline dispatch.
+abstract contract CashoutInternal is Cashout {
+    /// @notice Execute cashout directly against a calldata CASHOUT stream.
+    /// @param account Account whose native asset is withdrawn.
+    /// @param state Empty pipeline state required by the command schema.
+    /// @param input CASHOUT block stream.
+    /// @param value Native value assigned to this command; must be zero.
+    /// @return output Empty output state.
+    /// @return credit Zero native budget credit.
+    function executeCashout(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input,
+        uint128 value
+    ) internal returns (bytes memory, uint) {
+        if (value != 0) revert ValueNotAllowed();
+        if (state.length != 0) revert Executions.ZeroStride();
+        if (input.length % Sizes.Cashout != 0) revert Blocks.InvalidBlock();
+
+        (uint abs, uint end) = Cursors.bounds(input);
+        while (abs < end) {
+            cashout(account, Blocks.unpackCashout(abs));
+            unchecked {
+                abs += Sizes.Cashout;
+            }
+        }
+        return ("", 0);
+    }
+}

package/commands/Credit.sol

@@ -1,13 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
+import {Execution, Executions, CommandBase, Specs} from "./Base.sol";
 import {CreditAccountHook} from "../core/Settlement.sol";
-import {Blocks} from "../codec/Blocks.sol";
-import {Reader, Readers} from "../codec/Readers.sol";
+import {Blocks, Memory} from "../codec/Blocks.sol";
+import {Sizes} from "../codec/Specs.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.
@@ -17,7 +16,7 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     uint private immutable id;
 
     constructor() {
-        (id, descriptor) = command("creditAccount", Specs.Balance, Specs.Empty, Specs.Empty, 0, 0);
+        (id, descriptor) = command("creditAccount", Specs.Balance, Specs.Empty, Specs.Empty, 0);
     }
 
     /// @notice Return the registered CREDIT_ACCOUNT command ID.
@@ -28,18 +27,18 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     /// @notice Credit each BALANCE block from the command state to the command account.
     /// @param context Command context carrying the BALANCE state stream.
     /// @return Empty output state.
-    /// @return Empty transaction stream.
+    /// @return Zero native budget credit.
     function creditAccount(
         bytes calldata context
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            (bytes32 asset, uint amount) = exec.unpackBalance(Lanes.State);
+            (bytes32 asset, uint amount) = exec.unpackBalance();
             creditAccount(exec.account, asset, amount);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }
 
@@ -54,23 +53,26 @@ abstract contract CreditAccountInternal is CreditAccount {
     /// @param input Empty input required by the command schema.
     /// @param value Native value assigned to the command; must be zero.
     /// @return output Empty output state.
-    /// @return transactions Empty transaction stream.
+    /// @return credit Zero native budget credit.
     function executeCreditAccount(
         bytes32 account,
         bytes memory state,
         bytes calldata input,
         uint128 value
-    ) internal returns (bytes memory, bytes memory) {
+    ) internal returns (bytes memory, uint) {
         if (value != 0) revert ValueNotAllowed();
         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();
+        (uint abs, uint end) = Memory.bounds(state, Sizes.Balance);
+        while (abs < end) {
+            (bytes32 asset, uint amount) = Memory.unpackBalance(abs);
             creditAccount(account, asset, amount);
+            unchecked {
+                abs += Sizes.Balance;
+            }
         }
 
-        return ("", "");
+        return ("", 0);
     }
 }

package/commands/Debit.sol

@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
+import {Execution, Executions, CommandBase, 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";
+import {Cursors} 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.
@@ -20,7 +18,7 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
     uint private immutable id;
 
     constructor() {
-        (id, descriptor) = command("debitAccount", Specs.Empty, Specs.Amount, Specs.Balance, 0, 0);
+        (id, descriptor) = command("debitAccount", Specs.Empty, Specs.Amount, Specs.Balance, 0);
     }
 
     /// @notice Return the registered DEBIT_ACCOUNT command ID.
@@ -31,26 +29,26 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
     /// @notice Debit AMOUNT input blocks from the command account and output matching BALANCE blocks.
     /// @param context Command context carrying the AMOUNT input stream.
     /// @return BALANCE block stream matching the debited amounts.
-    /// @return Empty transaction stream.
+    /// @return Zero native budget credit.
     function debitAccount(
         bytes calldata context
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
+            (bytes32 asset, uint amount) = exec.unpackAmount();
             debitAccount(exec.account, asset, amount);
             exec.outputBalance(asset, amount);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }
 
 /// @title DebitAccountInternal
-/// @notice Extends the advertised debit-account command with memory-state pipeline dispatch.
+/// @notice Extends the advertised debit-account command with optimized 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`.
+/// inherited from `DebitAccount` while decoding its fixed-stride input directly from calldata.
 abstract contract DebitAccountInternal is DebitAccount {
     /// @notice Execute the inherited debit-account command from an internal pipeline.
     /// @param account Account whose funds are debited.
@@ -58,26 +56,32 @@ abstract contract DebitAccountInternal is DebitAccount {
     /// @param input AMOUNT block stream.
     /// @param value Native value assigned to the command; must be zero.
     /// @return output BALANCE block stream matching the debited amounts.
-    /// @return transactions Empty transaction stream.
+    /// @return credit Zero native budget credit.
     function executeDebitAccount(
         bytes32 account,
         bytes memory state,
         bytes calldata input,
         uint128 value
-    ) internal returns (bytes memory, bytes memory) {
+    ) internal returns (bytes memory, uint) {
         if (value != 0) revert ValueNotAllowed();
         if (state.length != 0) revert Executions.ZeroStride();
-        Cur memory cur = Decoders.open(input);
+        if (input.length == 0) revert Blocks.EmptyRun();
+        if (input.length % Sizes.Amount != 0) revert Blocks.InvalidBlock();
+
+        (uint abs, uint end) = Cursors.bounds(input);
         bytes memory output = new bytes(input.length);
         uint i;
 
-        while (cur.more()) {
-            (bytes32 asset, uint amount) = cur.unpackAmount();
+        while (abs < end) {
+            (bytes32 asset, uint amount) = Blocks.unpackAmount(abs);
             debitAccount(account, asset, amount);
             Blocks.writeBalance(output, i, asset, amount);
-            i += Sizes.Balance;
+            unchecked {
+                abs += Sizes.Amount;
+                i += Sizes.Balance;
+            }
         }
 
-        return (output, "");
+        return (output, 0);
     }
 }

package/commands/Deposit.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {Execution, Executions, CommandBase, Flags, Lanes, Specs} from "./Base.sol";
+import {Execution, Executions, CommandBase, Flags, Specs} from "./Base.sol";
 import {Action} from "../annotations/Action.sol";
 import {Actions} from "../utils/Actions.sol";
 
@@ -39,26 +39,26 @@ abstract contract Deposit is CommandBase, DepositHook, Action {
 
     constructor() {
         uint id;
-        (id, descriptor) = command("deposit", Specs.Empty, Specs.Amount, Specs.Balance, 0, 0);
+        (id, descriptor) = command("deposit", Specs.Empty, Specs.Amount, Specs.Balance, 0);
         action(id, Actions.Deposit);
     }
 
     /// @notice Deposit AMOUNT input blocks into the command account and output matching BALANCE blocks.
     /// @param context Command context carrying the AMOUNT input stream.
     /// @return BALANCE block stream matching the deposited amounts.
-    /// @return Empty transaction stream.
+    /// @return Zero native budget credit.
     function deposit(
         bytes calldata context
-    ) external onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
+            (bytes32 asset, uint amount) = exec.unpackAmount();
             deposit(exec.account, asset, amount);
             exec.outputBalance(asset, amount);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }
 
@@ -70,25 +70,25 @@ abstract contract DepositPayable is CommandBase, DepositPayableHook, Action {
 
     constructor() {
         uint id;
-        (id, descriptor) = command("depositPayable", Specs.Empty, Specs.Amount, Specs.Balance, 0, Flags.Funded);
+        (id, descriptor) = command("depositPayable", Specs.Empty, Specs.Amount, Specs.Balance, Flags.Funded);
         action(id, Actions.Deposit);
     }
 
     /// @notice Deposit AMOUNT input blocks with access to a mutable native-value budget.
     /// @param context Command context carrying the AMOUNT input stream.
     /// @return BALANCE block stream matching the deposited amounts.
-    /// @return Remaining native value as a refund transaction stream.
+    /// @return Native value to add to the caller's budget.
     function depositPayable(
         bytes calldata context
-    ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(context, descriptor, 0);
+    ) external payable onlyCommand returns (bytes memory, uint) {
+        Execution memory exec = openCommand(context, descriptor);
 
         while (exec.more()) {
-            (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
+            (bytes32 asset, uint amount) = exec.unpackAmount();
             deposit(exec.account, asset, amount, exec);
             exec.outputBalance(asset, amount);
         }
 
-        return closeCommand(exec);
+        return exec.close();
     }
 }