@rootzero/contracts 1.22.0 → 1.24.0

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);
     }
 }
 

package/commands/Deposit.sol

@@ -44,23 +44,21 @@ abstract contract Deposit is CommandBase, DepositHook, Action {
     }
 
     /// @notice Deposit AMOUNT input blocks into 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 deposited amounts.
     /// @return Empty transaction stream.
     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);
+            deposit(exec.account, asset, amount);
             exec.outputBalance(asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 
@@ -77,22 +75,20 @@ abstract contract DepositPayable is CommandBase, DepositPayableHook, Action {
     }
 
     /// @notice Deposit AMOUNT input blocks with access to a mutable native-value budget.
-    /// @param input AMOUNT block stream.
+    /// @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.
     function depositPayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable 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, exec);
+            deposit(exec.account, asset, amount, exec);
             exec.outputBalance(asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/Payout.sol

@@ -31,22 +31,19 @@ abstract contract Payout is CommandBase, PayoutHook, Action {
     }
 
     /// @notice Pay out BALANCE state blocks to matching ACCOUNT input blocks.
-    /// @param state BALANCE block stream.
-    /// @param input Matching ACCOUNT block stream.
+    /// @param context Command context carrying BALANCE state and matching ACCOUNT input.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function payout(
-        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);
-            payout(account, exec.unpackAccount(Lanes.Input), asset, amount);
+            payout(exec.account, exec.unpackAccount(Lanes.Input), asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/Provision.sol

@@ -36,23 +36,21 @@ abstract contract Provision is CommandBase, ProvisionHook {
     }
 
     /// @notice Provision ALLOCATION input blocks and output matching CUSTODY state blocks.
-    /// @param input ALLOCATION block stream.
+    /// @param context Command context carrying the ALLOCATION input stream.
     /// @return CUSTODY block stream matching the provisioned allocations.
     /// @return Empty transaction stream.
     function provision(
-        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 allocation = exec.unpackAllocationValue(Lanes.Input);
-            provision(account, allocation);
+            provision(exec.account, allocation);
             exec.outputCustody(allocation);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 
@@ -68,23 +66,21 @@ abstract contract ProvisionPayable is CommandBase, ProvisionPayableHook {
     }
 
     /// @notice Provision ALLOCATION input blocks with access to a mutable native-value budget.
-    /// @param input ALLOCATION block stream.
+    /// @param context Command context carrying the ALLOCATION input stream.
     /// @return CUSTODY block stream matching the provisioned allocations.
     /// @return Remaining native value as a refund transaction stream.
     function provisionPayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable 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 allocation = exec.unpackAllocationValue(Lanes.Input);
-            provision(account, allocation, exec);
+            provision(exec.account, allocation, exec);
             exec.outputCustody(allocation);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 

package/commands/Recover.sol

@@ -35,21 +35,19 @@ abstract contract RecoverPayable is CommandBase, RecoverPayableHook {
     }
 
     /// @notice Recover each recover block in the command input.
-    /// @param input RECOVER block stream.
+    /// @param context Command context carrying the RECOVER input stream.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
     function recoverPayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        Execution memory exec = openCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (uint handler, uint resources, bytes32 key, bytes calldata witness) = exec.unpackRecover(Lanes.Input);
             recover(handler, resources, key, witness, exec);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/Relay.sol

@@ -13,17 +13,15 @@ abstract contract RelayPayableHook {
     /// @param resources Chain-specific destination resources. EVM adapters
     /// may interpret this as packed execution gas and destination value.
     /// @param account Destination command account.
-    /// @param state State forwarded into the destination context.
     /// @param input Input forwarded into the destination context.
-    /// @param funds Execution used for source value available for transport fees
-    /// and destination resource funding.
+    /// @param exec Execution carrying the source state and value available for
+    /// transport fees and destination resource funding.
     function relay(
         uint portal,
         uint resources,
         bytes32 account,
-        bytes calldata state,
         bytes calldata input,
-        Execution memory funds
+        Execution memory exec
     ) internal virtual;
 }
 
@@ -38,15 +36,13 @@ abstract contract RelayPayable is CommandBase, RelayPayableHook {
 
     /// @notice Relay one RELAY input block with the command account and empty state.
     function relayPayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 1);
-        (uint portal, uint resources, bytes calldata relayInput) = exec.unpackRelay(Lanes.Input);
-        relay(portal, resources, account, state, relayInput, exec);
+        Execution memory exec = openCommand(context, descriptor, 1);
+        (uint portal, uint resources, bytes calldata input) = exec.unpackRelay(Lanes.Input);
+        relay(portal, resources, exec.account, input, exec);
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 
@@ -63,19 +59,16 @@ abstract contract RelayBalancePayable is CommandBase, RelayPayableHook {
     }
 
     /// @notice Relay one RELAY input block with the command account and current state.
-    /// @param state State forwarded into the destination context.
-    /// @param input Exactly one RELAY block.
+    /// @param context Command context carrying state and exactly one RELAY input block.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
     function relayBalancePayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 1);
-        (uint portal, uint resources, bytes calldata relayInput) = exec.unpackRelay(Lanes.Input);
-        relay(portal, resources, account, state, relayInput, exec);
+        Execution memory exec = openCommand(context, descriptor, 1);
+        (uint portal, uint resources, bytes calldata input) = exec.unpackRelay(Lanes.Input);
+        relay(portal, resources, exec.account, input, exec);
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/Repay.sol

@@ -5,10 +5,13 @@ import {Execution, Executions, CommandBase, Flags, Lanes, Specs} from "./Base.so
 import {RepayHook} 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;
 
-/// @notice Hook implemented by hosts that repay position liabilities using native value.
+/// @notice Hook implemented by hosts that repay liabilities using native value.
 abstract contract RepayPayableHook {
     /// @notice Override to repay one liability for `account` with a shared value budget.
     /// @param account Account whose liability is being repaid.
@@ -19,65 +22,158 @@ abstract contract RepayPayableHook {
 }
 
 /// @title Repay
-/// @notice Command that repays POSITION liabilities and returns their assets as BALANCE state.
+/// @notice Command that consumes DEBT state by repaying each liability.
 abstract contract Repay is CommandBase, RepayHook, Action {
     uint private immutable descriptor;
+    uint private immutable id;
+
+    constructor() {
+        (id, descriptor) = command("repay", Specs.Debt, Specs.Empty, Specs.Empty, 0, 0);
+        action(id, Actions.Repay);
+    }
+
+    /// @notice Return the registered REPAY command ID.
+    function repayId() internal view returns (uint) {
+        return id;
+    }
+
+    /// @notice Repay each liability in the DEBT state stream.
+    /// @param context Command context carrying the DEBT state stream.
+    /// @return Empty output state.
+    /// @return Empty transaction stream.
+    function repay(
+        bytes calldata context
+    ) external onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openCommand(context, descriptor, 0);
+
+        while (exec.more()) {
+            (bytes32 liability, uint debt) = exec.unpackDebt(Lanes.State);
+            repay(exec.account, liability, debt);
+        }
+
+        return closeCommand(exec);
+    }
+}
+
+/// @title RepayPayable
+/// @notice Funded command that consumes DEBT state by repaying each liability.
+abstract contract RepayPayable is CommandBase, RepayPayableHook, Action {
+    uint private immutable descriptor;
+
+    constructor() {
+        uint id;
+        (id, descriptor) = command("repayPayable", Specs.Debt, Specs.Empty, Specs.Empty, 0, Flags.Funded);
+        action(id, Actions.Repay);
+    }
+
+    /// @notice Repay each liability in the DEBT state stream.
+    /// @param context Command context carrying the DEBT state stream.
+    /// @return Empty output state.
+    /// @return Remaining native value as a refund transaction stream.
+    function repayPayable(
+        bytes calldata context
+    ) external payable onlyCommand returns (bytes memory, bytes memory) {
+        Execution memory exec = openCommand(context, descriptor, 0);
+
+        while (exec.more()) {
+            (bytes32 liability, uint debt) = exec.unpackDebt(Lanes.State);
+            repay(exec.account, liability, debt, exec);
+        }
+
+        return closeCommand(exec);
+    }
+}
+
+/// @title RepayPosition
+/// @notice Command that repays POSITION liabilities and returns their assets as BALANCE state.
+abstract contract RepayPosition is CommandBase, RepayHook, Action {
+    uint private immutable descriptor;
 
     constructor() {
         uint id;
-        (id, descriptor) = command("repay", Specs.Position, Specs.Empty, Specs.Balance, 0, 0);
-        action(id, Actions.Settle);
+        (id, descriptor) = command("repayPosition", Specs.Position, Specs.Empty, Specs.Balance, 0, 0);
+        action(id, Actions.Repay);
     }
 
     /// @notice Repay each POSITION liability and return its asset as BALANCE state.
-    /// @param state POSITION block stream.
+    /// @param context Command context carrying the POSITION state stream.
     /// @return BALANCE output state containing each released asset side.
     /// @return Empty transaction stream.
-    function repay(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+    function repayPosition(
+        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, bytes32 liability, uint debt) = exec.unpackPosition(Lanes.State);
-            repay(account, liability, debt);
+            repay(exec.account, liability, debt);
             exec.outputBalance(asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 
-/// @title RepayPayable
+/// @title RepayPositionPayable
 /// @notice Funded command that repays POSITION liabilities and returns their assets as BALANCE state.
-abstract contract RepayPayable is CommandBase, RepayPayableHook, Action {
+abstract contract RepayPositionPayable is CommandBase, RepayPayableHook, Action {
     uint private immutable descriptor;
 
     constructor() {
         uint id;
-        (id, descriptor) = command("repayPayable", Specs.Position, Specs.Empty, Specs.Balance, 0, Flags.Funded);
-        action(id, Actions.Settle);
+        (id, descriptor) = command(
+            "repayPositionPayable", Specs.Position, Specs.Empty, Specs.Balance, 0, Flags.Funded
+        );
+        action(id, Actions.Repay);
     }
 
     /// @notice Repay each POSITION liability and return its asset as BALANCE state.
-    /// @param state POSITION block stream.
+    /// @param context Command context carrying the POSITION state stream.
     /// @return BALANCE output state containing each released asset side.
     /// @return Remaining native value as a refund transaction stream.
-    function repayPayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+    function repayPositionPayable(
+        bytes calldata context
     ) external payable 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, bytes32 liability, uint debt) = exec.unpackPosition(Lanes.State);
-            repay(account, liability, debt, exec);
+            repay(exec.account, liability, debt, exec);
             exec.outputBalance(asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
+    }
+}
+
+/// @title RepayInternal
+/// @notice Extends the advertised repay command with memory-state pipeline dispatch.
+/// @dev This adapter is not a separate command. It uses the command ID and repayment hook
+/// inherited from `Repay` while accepting the state location used by `Pipeline`.
+abstract contract RepayInternal is Repay {
+    /// @notice Execute the inherited repay command from an internal pipeline.
+    /// @param account Account whose liabilities are repaid.
+    /// @param state DEBT block stream held in pipeline memory.
+    /// @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.
+    function executeRepay(
+        bytes32 account,
+        bytes memory state,
+        bytes calldata input,
+        uint128 value
+    ) internal returns (bytes memory, bytes memory) {
+        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 liability, uint debt) = reader.unpackDebt();
+            repay(account, liability, debt);
+        }
+
+        return ("", "");
     }
 }

package/commands/Settle.sol

@@ -47,22 +47,20 @@ abstract contract Settle is CommandBase, SettleHook, Action {
     }
 
     /// @notice Settle each POSITION block from the command state.
-    /// @param state POSITION block stream.
+    /// @param context Command context carrying the POSITION state stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function settle(
-        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, bytes32 liability, uint debt) = exec.unpackPosition(Lanes.State);
-            settle(account, asset, amount, liability, debt);
+            settle(exec.account, asset, amount, liability, debt);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 
@@ -78,22 +76,20 @@ abstract contract SettlePayable is CommandBase, SettlePayableHook, Action {
     }
 
     /// @notice Settle each POSITION block with access to a shared native-value budget.
-    /// @param state POSITION block stream.
+    /// @param context Command context carrying the POSITION state stream.
     /// @return Empty output state.
     /// @return Remaining native value as a refund transaction stream.
     function settlePayable(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
+        bytes calldata context
     ) external payable 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, bytes32 liability, uint debt) = exec.unpackPosition(Lanes.State);
-            settle(account, asset, amount, liability, debt, exec);
+            settle(exec.account, asset, amount, liability, debt, exec);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 

package/commands/Withdraw.sol

@@ -30,21 +30,19 @@ abstract contract Withdraw is CommandBase, WithdrawHook, Action {
     }
 
     /// @notice Withdraw 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 withdraw(
-        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);
-            withdraw(account, asset, amount);
+            withdraw(exec.account, asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }

package/commands/admin/AllowAssets.sol

@@ -23,22 +23,20 @@ abstract contract AllowAssets is AdminBase, AllowAssetsHook {
     }
 
     /// @notice Allow each ASSET block in the admin input.
-    /// @param input ASSET block stream.
+    /// @param context Admin command context carrying the ASSET input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function allowAssets(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             bytes32 asset = exec.unpackAsset(Lanes.Input);
             allowAsset(asset);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }
 

package/commands/admin/Allowance.sol

@@ -27,21 +27,19 @@ abstract contract Allowance is AdminBase, AllowanceHook {
     }
 
     /// @notice Apply each ALLOWANCE block in the admin input.
-    /// @param input ALLOWANCE block stream.
+    /// @param context Admin command context carrying the ALLOWANCE input stream.
     /// @return Empty output state.
     /// @return Empty transaction stream.
     function allowance(
-        bytes32 account,
-        bytes calldata state,
-        bytes calldata input
-    ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openCommand(state, input, descriptor, 0);
+        bytes calldata context
+    ) external returns (bytes memory, bytes memory) {
+        Execution memory exec = openAdminCommand(context, descriptor, 0);
 
         while (exec.more()) {
             (uint peer, bytes32 asset, uint amount) = exec.unpackAllowance(Lanes.Input);
             allowance(peer, asset, amount);
         }
 
-        return close(exec, account);
+        return closeCommand(exec);
     }
 }