@rootzero/contracts 0.7.2 → 0.8.0

package/commands/Create.sol

@@ -8,21 +8,23 @@ string constant NAME = "create";
 
 using Cursors for Cur;
 
+abstract contract CreateHook {
+    /// @dev Override to create or initialize an object described by `input`.
+    /// Called once per top-level request item.
+    function create(bytes32 account, Cur memory input) internal virtual;
+}
+
 /// @title Create
 /// @notice Generic command that creates or initializes objects via a virtual hook.
 /// The request schema is constructor-defined; `create` is called once per top-level group.
 /// Produces no output state.
-abstract contract Create is CommandBase {
+abstract contract Create is CommandBase, CreateHook {
     uint internal immutable createId = commandId(NAME);
 
     constructor(string memory input) {
         emit Command(host, NAME, input, createId, State.Empty, State.Empty, false);
     }
 
-    /// @dev Override to create or initialize an object described by `input`.
-    /// Called once per top-level request item.
-    function create(bytes32 account, Cur memory input) internal virtual;
-
     function create(CommandContext calldata c) external onlyCommand(createId, c.target) returns (bytes memory) {
         (Cur memory request, , ) = cursor(c.request, 1);
 

package/commands/Credit.sol

@@ -7,25 +7,27 @@ string constant NAME = "creditAccount";
 
 using Cursors for Cur;
 
+abstract contract CreditAccountHook {
+    /// @notice Override to credit externally managed funds to `account`.
+    /// Called once per BALANCE block in state.
+    /// @param account Recipient account identifier.
+    /// @param asset Asset identifier.
+    /// @param meta Asset metadata slot.
+    /// @param amount Amount to credit.
+    function creditAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
 /// @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.
 /// An optional RECIPIENT block in the request overrides the default `c.account` destination.
-abstract contract CreditAccount is CommandBase {
+abstract contract CreditAccount is CommandBase, CreditAccountHook {
     uint internal immutable creditAccountId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, Schemas.Recipient, creditAccountId, State.Balances, State.Empty, false);
     }
 
-    /// @notice Override to credit externally managed funds to `account`.
-    /// Called once per BALANCE block in state.
-    /// @param account Recipient account identifier.
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @param amount Amount to credit.
-    function creditAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
-
     function creditAccount(
         CommandContext calldata c
     ) external onlyCommand(creditAccountId, c.target) returns (bytes memory) {

package/commands/Debit.sol

@@ -9,25 +9,27 @@ string constant NAME = "debitAccount";
 using Cursors for Cur;
 using Writers for Writer;
 
+abstract contract DebitAccountHook {
+    /// @notice Override to debit externally managed funds from `account`.
+    /// Called once per AMOUNT block before a matching BALANCE is emitted.
+    /// @param account Source account identifier.
+    /// @param asset Asset identifier.
+    /// @param meta Asset metadata slot.
+    /// @param amount Amount to debit.
+    function debitAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
 /// @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 request loop.
-abstract contract DebitAccount is CommandBase {
+abstract contract DebitAccount is CommandBase, DebitAccountHook {
     uint internal immutable debitAccountId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, Schemas.Amount, debitAccountId, State.Empty, State.Balances, false);
     }
 
-    /// @notice Override to debit externally managed funds from `account`.
-    /// Called once per AMOUNT block before a matching BALANCE is emitted.
-    /// @param account Source account identifier.
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @param amount Amount to debit.
-    function debitAccount(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
-
     /// @notice Override to customize request parsing or batching for debits.
     /// The default implementation iterates AMOUNT blocks, calls
     /// `debitAccount`, and emits matching BALANCE blocks.

package/commands/Deposit.sol

@@ -11,31 +11,40 @@ string constant DEPOSIT_PAYABLE = "depositPayable";
 using Cursors for Cur;
 using Writers for Writer;
 
+abstract contract DepositHook {
+    /// @notice Override to receive externally sourced funds for `account`.
+    /// Called once per AMOUNT block. A matching BALANCE block is appended to the
+    /// output after each call.
+    /// @param account Recipient account identifier.
+    /// @param asset Asset identifier.
+    /// @param meta Asset metadata slot.
+    /// @param amount Amount received.
+    function deposit(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
+abstract contract DepositPayableHook {
+    /// @notice Override to receive externally sourced funds for `account`.
+    /// Called once per AMOUNT block. A matching BALANCE block is appended to the
+    /// output after each call.
+    /// @param account Recipient account identifier.
+    /// @param asset Asset identifier.
+    /// @param meta Asset metadata slot.
+    /// @param amount Amount received.
+    /// @param budget Mutable native-value budget drawn from `msg.value`.
+    function deposit(bytes32 account, bytes32 asset, bytes32 meta, uint amount, Budget memory budget) internal virtual;
+}
+
 /// @title Deposit
 /// @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 {
+abstract contract Deposit is CommandBase, DepositHook {
     uint internal immutable depositId = commandId(DEPOSIT);
 
     constructor() {
         emit Command(host, DEPOSIT, Schemas.Amount, depositId, State.Empty, State.Balances, false);
     }
 
-    /// @notice Override to receive externally sourced funds for `account`.
-    /// Called once per AMOUNT block. A matching BALANCE block is appended to the
-    /// output after each call.
-    /// @param account Recipient account identifier.
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @param amount Amount received.
-    function deposit(
-        bytes32 account,
-        bytes32 asset,
-        bytes32 meta,
-        uint amount
-    ) internal virtual;
-
     function deposit(
         CommandContext calldata c
     ) external onlyCommand(depositId, c.target) returns (bytes memory) {
@@ -55,29 +64,13 @@ abstract contract Deposit is CommandBase {
 /// @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 CommandPayable {
+abstract contract DepositPayable is CommandPayable, DepositPayableHook {
     uint internal immutable depositPayableId = commandId(DEPOSIT_PAYABLE);
 
     constructor() {
         emit Command(host, DEPOSIT_PAYABLE, Schemas.Amount, depositPayableId, State.Empty, State.Balances, true);
     }
 
-    /// @notice Override to receive externally sourced funds for `account`.
-    /// Called once per AMOUNT block. A matching BALANCE block is appended to the
-    /// output after each call.
-    /// @param account Recipient account identifier.
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @param amount Amount received.
-    /// @param budget Mutable native-value budget drawn from `msg.value`.
-    function deposit(
-        bytes32 account,
-        bytes32 asset,
-        bytes32 meta,
-        uint amount,
-        Budget memory budget
-    ) internal virtual;
-
     function depositPayable(
         CommandContext calldata c
     ) external payable onlyCommand(depositPayableId, c.target) returns (bytes memory) {

package/commands/Pipe.sol

@@ -10,34 +10,28 @@ using Cursors for Cur;
 
 string constant NAME = "pipePayable";
 
+abstract contract PipePayableHook {
+    function dispatchStep(
+        uint target,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata request,
+        uint value
+    ) internal virtual returns (bytes memory);
+}
+
 /// @title PipePayable
 /// @notice Command that sequences multiple sub-command STEP invocations in a single transaction.
 /// Each STEP block carries a target node, native value to forward, and an embedded request.
 /// State threads through the steps: each step's output becomes the next step's state.
 /// Admin accounts are not permitted to use `pipePayable`.
-abstract contract PipePayable is CommandPayable {
+abstract contract PipePayable is CommandPayable, PipePayableHook {
     uint internal immutable pipePayableId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, Schemas.Step, pipePayableId, 0, 0, true);
     }
 
-    /// @notice Override to execute a single STEP and return the resulting state.
-    /// The returned state is passed as the `state` argument of the next STEP.
-    /// @param target Destination command node ID from the STEP block.
-    /// @param account Caller's account identifier.
-    /// @param state Current threaded state from the previous step.
-    /// @param request Embedded request bytes from the STEP block.
-    /// @param value Native value forwarded with this step.
-    /// @return Next state to thread into the following step.
-    function dispatchStep(
-        uint target,
-        bytes32 account,
-        bytes memory state,
-        bytes calldata request,
-        uint value
-    ) internal virtual returns (bytes memory);
-
     function pipe(
         bytes32 account,
         bytes memory state,

package/commands/Remove.sol

@@ -8,21 +8,23 @@ string constant NAME = "remove";
 
 using Cursors for Cur;
 
+abstract contract RemoveHook {
+    /// @dev Override to remove or dismantle an object described by `input`.
+    /// Called once per top-level request item.
+    function remove(bytes32 account, Cur memory input) internal virtual;
+}
+
 /// @title Remove
 /// @notice Generic command that removes or dismantles objects via a virtual hook.
 /// The request schema is constructor-defined; `remove` is called once per top-level group.
 /// Produces no output state.
-abstract contract Remove is CommandBase {
+abstract contract Remove is CommandBase, RemoveHook {
     uint internal immutable removeId = commandId(NAME);
 
     constructor(string memory input) {
         emit Command(host, NAME, input, removeId, State.Empty, State.Empty, false);
     }
 
-    /// @dev Override to remove or dismantle an object described by `input`.
-    /// Called once per top-level request item.
-    function remove(bytes32 account, Cur memory input) internal virtual;
-
     function remove(CommandContext calldata c) external onlyCommand(removeId, c.target) returns (bytes memory) {
         (Cur memory request, , ) = cursor(c.request, 1);
 

package/commands/Stake.sol

@@ -8,20 +8,22 @@ string constant SCTP = "stakeCustodyToPosition";
 
 using Cursors for Cur;
 
+abstract contract StakeCustodyToPositionHook {
+    /// @dev Override to stake a custody position into a non-balance setup
+    /// target described by `request`.
+    function stakeCustodyToPosition(bytes32 account, HostAmount memory custody, Cur memory request) internal virtual;
+}
+
 /// @title StakeCustodyToPosition
 /// @notice Command that stakes CUSTODY state positions into a non-balance target
 /// described by the request stream. Produces no output state.
-abstract contract StakeCustodyToPosition is CommandBase {
+abstract contract StakeCustodyToPosition is CommandBase, StakeCustodyToPositionHook {
     uint internal immutable stakeCustodyToPositionId = commandId(SCTP);
 
     constructor(string memory input) {
         emit Command(host, SCTP, input, stakeCustodyToPositionId, State.Custodies, State.Empty, false);
     }
 
-    /// @dev Override to stake a custody position into a non-balance setup
-    /// target described by `request`.
-    function stakeCustodyToPosition(bytes32 account, HostAmount memory custody, Cur memory request) internal virtual;
-
     function stakeCustodyToPosition(
         CommandContext calldata c
     ) external onlyCommand(stakeCustodyToPositionId, c.target) returns (bytes memory) {

package/commands/Supply.sol

@@ -7,23 +7,25 @@ string constant NAME = "supply";
 
 using Cursors for Cur;
 
+abstract contract SupplyHook {
+    /// @notice Override to consume or supply a single custody position.
+    /// Called once per CUSTODY block in state.
+    /// @param account Caller's account identifier.
+    /// @param value Decoded custody position (host, asset, meta, amount).
+    function supply(bytes32 account, HostAmount memory value) internal virtual;
+}
+
 /// @title Supply
 /// @notice Command that processes each CUSTODY state block through a virtual hook.
 /// Used to move assets out of cross-host custody positions (e.g. to settle or redeem them).
 /// Produces no output state.
-abstract contract Supply is CommandBase {
+abstract contract Supply is CommandBase, SupplyHook {
     uint internal immutable supplyId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, "", supplyId, State.Custodies, State.Empty, false);
     }
 
-    /// @notice Override to consume or supply a single custody position.
-    /// Called once per CUSTODY block in state.
-    /// @param account Caller's account identifier.
-    /// @param value Decoded custody position (host, asset, meta, amount).
-    function supply(bytes32 account, HostAmount memory value) internal virtual;
-
     /// @notice Execute the supply command.
     function supply(CommandContext calldata c) external onlyCommand(supplyId, c.target) returns (bytes memory) {
         (Cur memory state, , ) = cursor(c.state, 1);

package/commands/Transfer.sol

@@ -38,10 +38,11 @@ abstract contract Transfer is CommandBase, TransferHook {
         value.from = from;
 
         while (input.i < input.bound) {
-            Cur memory bundle = input.bundle();
-            (value.asset, value.meta, value.amount) = bundle.unpackAmount();
-            value.to = Accounts.ensure(bundle.unpackRecipient());
+            uint next = input.bundle();
+            (value.asset, value.meta, value.amount) = input.unpackAmount();
+            value.to = Accounts.ensure(input.unpackRecipient());
             transfer(value);
+            input.ensure(next);
         }
 
         input.complete();

package/commands/Withdraw.sol

@@ -7,25 +7,27 @@ using Cursors for Cur;
 
 string constant NAME = "withdraw";
 
+abstract contract WithdrawHook {
+    /// @notice Override to send funds to `account`.
+    /// Called once per BALANCE block in state.
+    /// @param account Destination account identifier (resolved from RECIPIENT block or caller).
+    /// @param asset Asset identifier.
+    /// @param meta Asset metadata slot.
+    /// @param amount Amount to deliver.
+    function withdraw(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
 /// @title Withdraw
 /// @notice Command that delivers BALANCE state blocks to an external destination.
 /// Use `withdraw` for assets being sent outside the protocol (e.g. ERC-20 transfers, ETH sends).
 /// For internal balance credits, use `creditAccount` instead.
-abstract contract Withdraw is CommandBase {
+abstract contract Withdraw is CommandBase, WithdrawHook {
     uint internal immutable withdrawId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, Schemas.Recipient, withdrawId, State.Balances, State.Empty, false);
     }
 
-    /// @notice Override to send funds to `account`.
-    /// Called once per BALANCE block in state.
-    /// @param account Destination account identifier (resolved from RECIPIENT block or caller).
-    /// @param asset Asset identifier.
-    /// @param meta Asset metadata slot.
-    /// @param amount Amount to deliver.
-    function withdraw(bytes32 account, bytes32 asset, bytes32 meta, uint amount) internal virtual;
-
     function withdraw(
         CommandContext calldata c
     ) external onlyCommand(withdrawId, c.target) returns (bytes memory) {

package/commands/admin/Allocate.sol

@@ -7,20 +7,22 @@ using Cursors for Cur;
 
 string constant NAME = "allocate";
 
+abstract contract AllocateHook {
+    /// @dev Override to apply a single allocation entry.
+    /// Called once per ALLOCATION block in the request.
+    function allocate(uint host, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
 /// @title Allocate
 /// @notice Admin command that applies cross-host allocation entries via a virtual hook.
 /// Each ALLOCATION block in the request calls `allocate`. Only callable by the admin account.
-abstract contract Allocate is CommandBase {
+abstract contract Allocate is CommandBase, AllocateHook {
     uint internal immutable allocateId = commandId(NAME);
 
     constructor() {
         emit Command(host, NAME, Schemas.Allocation, allocateId, State.Empty, State.Empty, false);
     }
 
-    /// @dev Override to apply a single allocation entry.
-    /// Called once per ALLOCATION block in the request.
-    function allocate(uint host, bytes32 asset, bytes32 meta, uint amount) internal virtual;
-
     function allocate(CommandContext calldata c) external onlyAdmin(c.account) onlyCommand(allocateId, c.target) returns (bytes memory) {
         (Cur memory request, , ) = cursor(c.request, 1);
 

package/commands/admin/Destroy.sol

@@ -8,20 +8,22 @@ string constant NAME = "destroy";
 
 using Cursors for Cur;
 
+abstract contract DestroyHook {
+    /// @notice Override to run host teardown or destruction logic.
+    /// @param input Cursor over the full request byte stream.
+    function destroy(Cur memory input) internal virtual;
+}
+
 /// @title Destroy
 /// @notice Admin command that runs host teardown logic via a virtual hook.
 /// The full request is passed to `destroy` as a cursor. Only callable by the admin account.
-abstract contract Destroy is CommandBase {
+abstract contract Destroy is CommandBase, DestroyHook {
     uint internal immutable destroyId = commandId(NAME);
 
     constructor(string memory input) {
         emit Command(host, NAME, input, destroyId, State.Empty, State.Empty, false);
     }
 
-    /// @notice Override to run host teardown or destruction logic.
-    /// @param input Cursor over the full request byte stream.
-    function destroy(Cur memory input) internal virtual;
-
     function destroy(
         CommandContext calldata c
     ) external onlyAdmin(c.account) onlyCommand(destroyId, c.target) returns (bytes memory) {

package/commands/admin/Init.sol

@@ -8,20 +8,22 @@ string constant NAME = "init";
 
 using Cursors for Cur;
 
+abstract contract InitHook {
+    /// @notice Override to run host initialization logic.
+    /// @param input Cursor over the full request byte stream.
+    function init(Cur memory input) internal virtual;
+}
+
 /// @title Init
 /// @notice Admin command that runs host initialization logic via a virtual hook.
 /// The full request is passed to `init` as a cursor. Only callable by the admin account.
-abstract contract Init is CommandBase {
+abstract contract Init is CommandBase, InitHook {
     uint internal immutable initId = commandId(NAME);
 
     constructor(string memory input) {
         emit Command(host, NAME, input, initId, State.Empty, State.Empty, false);
     }
 
-    /// @notice Override to run host initialization logic.
-    /// @param input Cursor over the full request byte stream.
-    function init(Cur memory input) internal virtual;
-
     function init(
         CommandContext calldata c
     ) external onlyAdmin(c.account) onlyCommand(initId, c.target) returns (bytes memory) {

package/core/Host.sol

@@ -19,7 +19,7 @@ abstract contract HostDiscovery is HostAnnouncedEvent, IHostDiscovery {
     /// @param version Protocol version the host implements.
     /// @param namespace Human-readable namespace string for the host.
     function announceHost(uint id, uint blocknum, uint16 version, string calldata namespace) external {
-        emit HostAnnounced(Ids.host(id, msg.sender), blocknum, version, namespace);
+        emit HostAnnounced(Ids.matchHost(id, msg.sender), blocknum, version, namespace);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",

package/peer/AssetPull.sol

@@ -8,35 +8,37 @@ string constant NAME = "peerAssetPull";
 
 using Cursors for Cur;
 
+abstract contract PeerAssetPullHook {
+    /// @notice Override to process one incoming amount-based asset pull request from a remote host.
+    /// @param peer Host node ID derived from the caller address.
+    /// @param asset Requested asset identifier.
+    /// @param meta Requested asset metadata slot.
+    /// @param amount Requested amount in the asset's native units.
+    function peerAssetPull(uint peer, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
 /// @title PeerAssetPull
-/// @notice Peer that pulls requested asset amounts from a remote host into this one.
-/// Each AMOUNT block in the request calls `peerAssetPull(peer, asset, meta, amount)`, where `peer`
-/// is derived from `msg.sender`. Restricted to trusted peers.
-abstract contract PeerAssetPull is PeerBase {
-    uint internal immutable peerAssetPullId = peerId(NAME);
-
-    constructor() {
-        emit Peer(host, NAME, Schemas.Amount, peerAssetPullId, false);
-    }
-
-    /// @notice Override to process one incoming amount-based asset pull request from a remote host.
-    /// @param peer Host node ID derived from the caller address.
-    /// @param asset Requested asset identifier.
-    /// @param meta Requested asset metadata slot.
-    /// @param amount Requested amount in the asset's native units.
-    function peerAssetPull(uint peer, bytes32 asset, bytes32 meta, uint amount) internal virtual;
-
-    /// @notice Execute the asset-pull peer call.
-    function peerAssetPull(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory assets, , ) = cursor(request, 1);
-        uint peer = caller();
-
-        while (assets.i < assets.bound) {
-            (bytes32 asset, bytes32 meta, uint amount) = assets.unpackAmount();
-            peerAssetPull(peer, asset, meta, amount);
-        }
-
-        assets.complete();
-        return "";
-    }
-}
+/// @notice Peer that pulls requested asset amounts from a remote host into this one.
+/// Each AMOUNT block in the request calls `peerAssetPull(peer, asset, meta, amount)`, where `peer`
+/// is derived from `msg.sender`. Restricted to trusted peers.
+abstract contract PeerAssetPull is PeerBase, PeerAssetPullHook {
+    uint internal immutable peerAssetPullId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, NAME, Schemas.Amount, peerAssetPullId, false);
+    }
+
+    /// @notice Execute the asset-pull peer call.
+    function peerAssetPull(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory assets, , ) = cursor(request, 1);
+        uint peer = caller();
+
+        while (assets.i < assets.bound) {
+            (bytes32 asset, bytes32 meta, uint amount) = assets.unpackAmount();
+            peerAssetPull(peer, asset, meta, amount);
+        }
+
+        assets.complete();
+        return "";
+    }
+}

package/peer/Pull.sol

@@ -8,22 +8,24 @@ string constant NAME = "peerPull";
 
 using Cursors for Cur;
 
+abstract contract PeerPullHook {
+    /// @notice Override to process a single incoming block from the pull request.
+    /// @param peer Host node ID derived from the caller address.
+    /// @param input Cursor positioned at the current input block; advance it before returning.
+    function peerPull(uint peer, Cur memory input) internal virtual;
+}
+
 /// @title PeerPull
 /// @notice Peer that pulls assets from a remote host into this one.
 /// Each block in the request is dispatched to `peerPull(peer, input)`, where `peer`
 /// is derived from `msg.sender`. Restricted to trusted peers.
-abstract contract PeerPull is PeerBase {
+abstract contract PeerPull is PeerBase, PeerPullHook {
     uint internal immutable peerPullId = peerId(NAME);
 
     constructor(string memory input) {
         emit Peer(host, NAME, input, peerPullId, false);
     }
 
-    /// @notice Override to process a single incoming block from the pull request.
-    /// @param peer Host node ID derived from the caller address.
-    /// @param input Cursor positioned at the current input block; advance it before returning.
-    function peerPull(uint peer, Cur memory input) internal virtual;
-
     /// @notice Execute the pull peer call.
     function peerPull(bytes calldata request) external onlyPeer returns (bytes memory) {
         (Cur memory input, , ) = cursor(request, 1);

package/peer/Push.sol

@@ -8,22 +8,24 @@ string constant NAME = "peerPush";
 
 using Cursors for Cur;
 
+abstract contract PeerPushHook {
+    /// @notice Override to process a single incoming block from the push request.
+    /// @param peer Host node ID derived from the caller address.
+    /// @param input Cursor positioned at the current input block; advance it before returning.
+    function peerPush(uint peer, Cur memory input) internal virtual;
+}
+
 /// @title PeerPush
 /// @notice Peer that receives assets pushed from a remote host into this one.
 /// Each block in the request is dispatched to `peerPush(peer, input)`, where `peer`
 /// is derived from `msg.sender`. Restricted to trusted peers.
-abstract contract PeerPush is PeerBase {
+abstract contract PeerPush is PeerBase, PeerPushHook {
     uint internal immutable peerPushId = peerId(NAME);
 
     constructor(string memory input) {
         emit Peer(host, NAME, input, peerPushId, false);
     }
 
-    /// @notice Override to process a single incoming block from the push request.
-    /// @param peer Host node ID derived from the caller address.
-    /// @param input Cursor positioned at the current input block; advance it before returning.
-    function peerPush(uint peer, Cur memory input) internal virtual;
-
     /// @notice Execute the push peer call.
     function peerPush(bytes calldata request) external onlyPeer returns (bytes memory) {
         (Cur memory input, , ) = cursor(request, 1);