@rootzero/contracts 1.6.0 → 1.8.0

package/core/Calls.sol

@@ -12,7 +12,7 @@ import {Nodes} from "../utils/Nodes.sol";
 error FailedCall(address addr, bytes4 selector, bytes err);
 
 /// @title NodeCalls
-/// @notice Shared trusted inter-node call helpers for contracts that can talk to other nodes.
+/// @notice Shared low-level inter-node call helpers for contracts that can talk to other nodes.
 abstract contract NodeCalls is AccessControl {
     /// @notice Return the host node ID corresponding to the current caller.
     /// @dev Encodes `msg.sender` as a host ID using the local-chain host layout.
@@ -21,64 +21,100 @@ abstract contract NodeCalls is AccessControl {
         return Nodes.toHost(msg.sender);
     }
 
-    /// @notice Make a low-level call to an address.
-    /// Forwards `value` ETH and `data` to `addr`.
-    /// Reverts with `FailedCall` if the call is unsuccessful.
-    /// @param addr Contract address to call.
+    /// @notice Try a raw low-level call to another node and return whether it succeeded.
+    /// @param node Node ID of the callee.
     /// @param value Native value to forward in wei.
     /// @param data Encoded calldata to send.
-    /// @return out Return data from the successful call.
-    function callAddr(address addr, uint128 value, bytes memory data) internal returns (bytes memory out) {
-        bool success;
-        (success, out) = payable(addr).call{value: value}(data);
-        if (!success) revert FailedCall(addr, bytes4(data), out);
+    /// @return success True if the low-level call succeeded.
+    function tryRawCall(uint node, uint128 value, bytes memory data) internal returns (bool success) {
+        address addr = Nodes.addr(node);
+        (success, ) = payable(addr).call{value: value}(data);
     }
 
-    /// @notice Make a low-level read-only query to an address.
-    /// Issues a low-level `staticcall` with `data`.
-    /// Reverts with `FailedCall` if the call is unsuccessful.
-    /// @param addr Contract address to query.
+    /// @notice Try a trusted low-level call to another node and return whether it succeeded.
+    /// @param node Node ID of the callee.
+    /// @param value Native value to forward in wei.
     /// @param data Encoded calldata to send.
-    /// @return out Return data from the successful query.
-    function queryAddr(address addr, bytes memory data) internal view returns (bytes memory out) {
+    /// @return success True if the low-level call succeeded.
+    function tryTrustedCall(uint node, uint128 value, bytes memory data) internal returns (bool success) {
+        return tryRawCall(ensureTrusted(node), value, data);
+    }
+
+    /// @notice Make a raw low-level call to another node and revert when it fails.
+    /// @param node Node ID of the callee.
+    /// @param value Native value to forward in wei.
+    /// @param data Encoded calldata to send.
+    /// @return out Return data from the successful call.
+    function rawCall(uint node, uint128 value, bytes memory data) internal returns (bytes memory out) {
         bool success;
-        (success, out) = addr.staticcall(data);
+        address addr = Nodes.addr(node);
+        (success, out) = payable(addr).call{value: value}(data);
         if (!success) revert FailedCall(addr, bytes4(data), out);
     }
 
-    /// @notice Make a trusted call to another node in the network.
-    /// Looks up the node's contract address via `ensureTrusted` + `Nodes.addr`,
-    /// then issues a low-level call forwarding `value` ETH and `data`.
-    /// @param node Node ID of the callee (must be in the authorized set).
+    /// @notice Make a trusted low-level call to another node and revert when it fails.
+    /// @param node Node ID of the callee.
     /// @param value Native value to forward in wei.
     /// @param data Encoded calldata to send.
     /// @return out Return data from the successful call.
-    function callTo(uint node, uint128 value, bytes memory data) internal returns (bytes memory out) {
-        ensureTrusted(node);
-        address addr = Nodes.addr(node);
-        return callAddr(addr, value, data);
+    function trustedCall(uint node, uint128 value, bytes memory data) internal returns (bytes memory out) {
+        return rawCall(ensureTrusted(node), value, data);
     }
 
-    /// @notice Make a trusted query to another node in the network.
-    /// Looks up the node's contract address via `ensureTrusted` + `Nodes.addr`,
-    /// then issues a low-level `staticcall` with `data`.
-    /// @param node Node ID of the callee (must be in the authorized set).
+    /// @notice Make a raw low-level read-only query to another node and revert when it fails.
+    /// @param node Node ID of the callee.
     /// @param data Encoded calldata to send.
     /// @return out Return data from the successful query.
-    function queryTo(uint node, bytes memory data) internal view returns (bytes memory out) {
-        ensureTrusted(node);
+    function rawQuery(uint node, bytes memory data) internal view returns (bytes memory out) {
+        bool success;
         address addr = Nodes.addr(node);
-        return queryAddr(addr, data);
+        (success, out) = addr.staticcall(data);
+        if (!success) revert FailedCall(addr, bytes4(data), out);
+    }
+
+    /// @notice Make a trusted low-level read-only query to another node and revert when it fails.
+    /// @param node Node ID of the callee.
+    /// @param data Encoded calldata to send.
+    /// @return out Return data from the successful query.
+    function trustedQuery(uint node, bytes memory data) internal view returns (bytes memory out) {
+        return rawQuery(ensureTrusted(node), data);
     }
+}
 
+/// @title CommandCalls
+/// @notice Trusted command-call helpers for contracts that route command nodes.
+abstract contract CommandCalls is NodeCalls {
     /// @notice Encode and call a trusted command node.
-    /// @param id Command node ID embedding the target selector.
+    /// @param command Command node ID embedding the target selector.
     /// @param value Native value to forward in wei.
-    /// @param ctx Command execution context.
+    /// @param account Command account identifier.
+    /// @param state Current command state block stream.
+    /// @param request Command input block stream.
     /// @return Decoded command output block stream.
-    function callCommand(uint id, uint128 value, CommandContext memory ctx) internal returns (bytes memory) {
-        bytes4 selector = Nodes.commandSelector(id);
-        bytes memory data = abi.encodeWithSelector(selector, ctx);
-        return abi.decode(callTo(id, value, data), (bytes));
+    function callCommand(
+        uint command,
+        uint128 value,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata request
+    ) internal returns (bytes memory) {
+        bytes4 selector = Nodes.commandSelector(command);
+        bytes memory data = abi.encodeWithSelector(selector, CommandContext(account, state, request));
+        return abi.decode(trustedCall(command, value, data), (bytes));
+    }
+}
+
+/// @title PortCalls
+/// @notice Trusted port-call helpers for contracts that route port nodes.
+abstract contract PortCalls is NodeCalls {
+    /// @notice Encode and call a trusted port node.
+    /// @param port Port node ID embedding the target selector.
+    /// @param value Native value to forward in wei.
+    /// @param input Port input block stream.
+    /// @return Decoded port output block stream.
+    function callPort(uint port, uint128 value, bytes memory input) internal returns (bytes memory) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return abi.decode(trustedCall(port, value, data), (bytes));
     }
 }

package/core/Commitments.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.33;
 import {CommitmentEvent} from "../events/Commitment.sol";
 
 /// @title Commitments
-/// @notice On-chain registry for account-scoped digest commitments.
+/// @notice On-chain registry for digest commitments.
 abstract contract Commitments is CommitmentEvent {
     /// @dev key -> committed digest.
     mapping(bytes32 key => bytes32 digest) internal commitments;

package/core/Payable.sol

@@ -5,16 +5,14 @@ import {Budget, Values} from "../utils/Value.sol";
 
 /// @title Payable
 /// @notice Abstract mixin for entrypoints that accept native value (`msg.value`).
-/// Provides a shared settlement hook for any unspent value remaining in the
-/// mutable budget after execution completes.
+/// Provides shared helpers for mutable native-value budgets.
 abstract contract Payable {
     /// @dev Thrown when a payable entrypoint completes with unspent native value.
-    /// Override `settleValue` to implement refund or forwarding behavior instead.
     error UnusedValue(uint remaining);
 
-    /// @notice Create a native-value budget from the current call's `msg.value`.
-    /// @return Budget initialised with the full `msg.value`.
-    function valueBudget() internal view returns (Budget memory) {
+    /// @notice Open a native-value budget from the current call's `msg.value`.
+    /// @return Budget initialized with the full `msg.value`.
+    function openValue() internal view returns (Budget memory) {
         return Budget({remaining: msg.value});
     }
 
@@ -24,36 +22,25 @@ abstract contract Payable {
     /// @param resources Packed chain resources.
     /// @return value Native value to forward in wei.
     function useValue(Budget memory budget, uint resources) internal pure returns (uint128 value) {
-        return Values.use(budget, uint128(resources));
+        value = uint128(resources);
+        Values.use(budget, value);
     }
 
-    /// @notice Deduct the EVM value lane from a packed resource word as a new sub-budget.
-    /// @dev EVM resources use the low 128 bits as native value/endowment.
-    /// @param budget Mutable parent budget to deduct from.
-    /// @param resources Packed chain resources.
-    /// @return A new budget with the EVM value lane remaining.
-    function allocateValue(Budget memory budget, uint resources) internal pure returns (Budget memory) {
-        return Values.allocate(budget, uint128(resources));
-    }
-
-    /// @notice Drains the budget and settles any remaining native value.
-    /// @dev Calls the amount-based `settleValue` hook only when some value remains.
+    /// @notice Close a native-value budget and settle any drained value.
     /// @param account Account identifier for the current invocation.
-    /// @param budget Mutable native-value budget used during execution.
-    function settleValue(bytes32 account, Budget memory budget) internal {
-        uint value = budget.remaining;
+    /// @param budget Mutable native-value budget to close.
+    function closeValue(bytes32 account, Budget memory budget) internal {
+        uint value = Values.drain(budget);
         if (value == 0) return;
-        budget.remaining = 0;
         settleValue(account, value);
     }
 
-    /// @notice Handles leftover native value after payable execution has finished.
-    /// @dev Override this hook to refund or redirect unused value.
-    /// The default implementation rejects any leftover amount.
+    /// @notice Handle a drained native value amount.
+    /// @dev Override to refund or redirect unused value. The default rejects it.
     /// @param account Account identifier for the current invocation.
-    /// @param remaining Unspent native value left in the budget, in wei.
-    function settleValue(bytes32 account, uint remaining) internal virtual {
+    /// @param value Drained native value amount to settle, in wei.
+    function settleValue(bytes32 account, uint value) internal virtual {
         account;
-        revert UnusedValue(remaining);
+        revert UnusedValue(value);
     }
 }

package/core/Pipeline.sol

@@ -32,6 +32,7 @@ abstract contract Pipeline is Payable {
 
     /// @notice Execute a STEP block stream through the pipeline.
     /// @dev Reverts with `UnexpectedState` if the final threaded state is non-empty.
+    /// Callers remain responsible for settling any unspent value in `budget`.
     /// @param account Account identifier used for each dispatched step.
     /// @param state Initial state block stream passed to the first step.
     /// @param steps STEP block stream to execute.
@@ -50,7 +51,6 @@ abstract contract Pipeline is Payable {
         }
 
         if (state.length != 0) revert UnexpectedState();
-        settleValue(account, budget);
         input.complete();
     }
 }

package/docs/Schema.md

@@ -58,7 +58,6 @@ Once a child block appears, no more fixed fields may follow.
 ```txt
 #call { uint target, uint resources, #bytes as payload }
 #context { bytes32 account, #bytes as state, #bytes as request }
-#pipe { uint resources, #context { bytes32 account, #bytes as state, #bytes as steps } }
 ```
 
 The tail is embedded directly as child block bytes. There is no wrapper around a
@@ -118,6 +117,18 @@ maybe #account { bytes32 account } as recipient
 
 Aliases may be used on any block item, including child blocks and prime items.
 
+A child block without an inline body may also be used as a schema reference:
+
+```txt
+#contextRecovery { uint port, bytes32 key, uint resources, #context as witness }
+```
+
+Alias resolution is context-dependent. A consumer may resolve `#context` from the
+standard `Schemas` table, from app-specific schemas, or from another active
+schema context. Consumers should reject schemas with unresolved aliases. The
+runtime encoding is still an embedded child block with the referenced key and
+layout.
+
 ## Field Paths
 
 Field names and aliases may use dotted paths for offchain projection. A dotted
@@ -271,7 +282,7 @@ Common protocol schemas live in `contracts/blocks/Schema.sol`:
 #call { uint target, uint resources, #bytes as payload }
 #step { uint target, uint resources, #bytes as request }
 #context { bytes32 account, #bytes as state, #bytes as request }
-#pipe { uint resources, #context { bytes32 account, #bytes as state, #bytes as steps } }
+#contextRecovery { uint port, bytes32 key, uint resources, #context as witness }
 #auth { uint cid, uint deadline, #bytes as proof }
 ```
 

package/events/Commitment.sol

@@ -3,15 +3,15 @@ pragma solidity ^0.8.33;
 
 import { EventEmitter } from "./Emitter.sol";
 
-/// @notice Emitted when an account-scoped commitment is updated.
+/// @notice Emitted when a host-scoped commitment is updated.
 abstract contract CommitmentEvent is EventEmitter {
-    string private constant ABI = "event Commitment(bytes32 indexed account, bytes32 key, bytes32 digest, uint status)";
+    string private constant ABI = "event Commitment(uint indexed host, bytes32 key, bytes32 digest, uint status)";
 
-    /// @param account Account associated with the commitment.
+    /// @param host Host node ID that manages the commitment.
     /// @param key Commitment lookup key.
     /// @param digest Committed digest. Zero may be used when clearing without revealing the previous digest.
     /// @param status Commitment status. Zero means cleared; nonzero means committed or application-defined.
-    event Commitment(bytes32 indexed account, bytes32 key, bytes32 digest, uint status);
+    event Commitment(uint indexed host, bytes32 key, bytes32 digest, uint status);
 
     constructor() {
         emit EventAbi(ABI);

package/events/Dispatch.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted when a host records an outbound dispatch reference.
+abstract contract DispatchEvent is EventEmitter {
+    string private constant ABI = "event Dispatch(uint indexed host, uint chain, uint resources, bytes32 digest, bytes32 ref)";
+
+    /// @param host Host node ID that owns the dispatch.
+    /// @param chain Destination chain/domain node ID.
+    /// @param resources Chain-adapter-specific resources assigned to the dispatch.
+    /// @param digest Digest of the dispatched payload or canonical envelope.
+    /// @param ref Dispatch correlation or recovery reference.
+    event Dispatch(uint indexed host, uint chain, uint resources, bytes32 digest, bytes32 ref);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/events/Port.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted by hosts to advertise callable peer-facing ports.
+abstract contract PortEvent is EventEmitter {
+    string private constant ABI =
+        "event Port(uint indexed host, uint id, bytes32 shape, string request, string response, bool funded)";
+
+    /// @param host Host node ID that exposes the port.
+    /// @param id Port node ID.
+    /// @param shape Block shape/version descriptor.
+    /// @param request Human-readable request schema.
+    /// @param response Human-readable response schema.
+    /// @param funded True if the port accepts native value.
+    event Port(uint indexed host, uint id, bytes32 shape, string request, string response, bool funded);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/guards/Base.sol

@@ -6,17 +6,6 @@ import {GuardEvent} from "../events/Guard.sol";
 import {LabeledEvent} from "../events/Labeled.sol";
 import {Nodes} from "../utils/Nodes.sol";
 
-/// @notice ABI-encode a guard action call from a target guard ID and request block stream.
-/// @dev Derives the function selector from `target` via `Nodes.guardSelector(target)`.
-/// Reverts if `target` is not a valid guard ID.
-/// @param target Destination guard action node ID embedding the target selector.
-/// @param request Input block stream for the guard invocation.
-/// @return ABI-encoded calldata for the guard action entry point.
-function encodeGuardCall(uint target, bytes calldata request) pure returns (bytes memory) {
-    bytes4 selector = Nodes.guardSelector(target);
-    return abi.encodeWithSelector(selector, request);
-}
-
 /// @title GuardBase
 /// @notice Abstract base for guardian-only direct host actions.
 /// Guard actions are non-payable direct calls with no command context, state, or response.

package/package.json

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

package/ports/AllowAssets.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PortBase } from "./Base.sol";
+import { AllowAssetsHook } from "../commands/admin/AllowAssets.sol";
+import { Cursors, Cur, Schemas } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PortAllowAssets
+/// @notice Port that permits a list of assets on behalf of a peer host.
+/// Each ASSET block in the request calls `allowAsset`. Restricted to trusted peers.
+abstract contract PortAllowAssets is PortBase, AllowAssetsHook {
+    uint internal immutable portAllowAssetsId = portId(this.portAllowAssets.selector);
+
+    constructor() {
+        emit Port(host, portAllowAssetsId, "1:0", Schemas.Asset, "", false);
+        emit Labeled(portAllowAssetsId, bytes32(0), "portAllowAssets");
+    }
+
+    /// @notice Execute the allow-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portAllowAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory assets, , ) = Cursors.init(data, 1);
+
+        while (assets.i < assets.len) {
+            bytes32 asset = assets.unpackAsset();
+            allowAsset(asset);
+        }
+
+        assets.complete();
+        return "";
+    }
+}
+
+
+
+
+

package/ports/Allowance.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortBase} from "./Base.sol";
+import {AllowanceHook} from "../commands/admin/Allowance.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PortAllowance
+/// @notice Port that lets a trusted peer host request or refresh its own allowance.
+/// Each AMOUNT block in the request is scoped to the peer host and passed to the
+/// shared allowance hook as a host-scoped allowance. Restricted to trusted peers.
+abstract contract PortAllowance is PortBase, AllowanceHook {
+    uint internal immutable portAllowanceId = portId(this.portAllowance.selector);
+
+    constructor() {
+        emit Port(host, portAllowanceId, "1:0", Schemas.Amount, "", false);
+        emit Labeled(portAllowanceId, bytes32(0), "portAllowance");
+    }
+
+    /// @notice Execute the allowance port call.
+    /// @param data AMOUNT block stream requested by the trusted peer.
+    /// @return Empty response bytes.
+    function portAllowance(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory amounts, , ) = Cursors.init(data, 1);
+        uint peer = caller();
+
+        while (amounts.i < amounts.len) {
+            (bytes32 asset, uint amount) = amounts.unpackAmount();
+            allowance(peer, asset, amount);
+        }
+
+        amounts.complete();
+        return "";
+    }
+}

package/ports/Base.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { NodeCalls } from "../core/Calls.sol";
+import { PortEvent } from "../events/Port.sol";
+import { LabeledEvent } from "../events/Labeled.sol";
+import { Nodes } from "../utils/Nodes.sol";
+
+/// @title PortBase
+/// @notice Abstract base for peer-facing rootzero ports.
+/// Ports handle inter-host operations between cooperating hosts.
+/// Access is restricted to trusted peer callers via `onlyPeer`.
+abstract contract PortBase is NodeCalls, PortEvent, LabeledEvent {
+    /// @dev Thrown when the commander attempts to call a port entrypoint directly.
+    error CommanderNotAllowed();
+
+    /// @dev Restrict execution to trusted callers, excluding the commander.
+    modifier onlyPeer() {
+        if (msg.sender == commander) revert CommanderNotAllowed();
+        enforceCaller(msg.sender);
+        _;
+    }
+
+    /// @notice Derive the deterministic node ID for a port selector on this contract.
+    /// @param selector Port entrypoint selector.
+    /// @return Port node ID.
+    function portId(bytes4 selector) internal view returns (uint) {
+        return Nodes.toPort(selector, address(this));
+    }
+}

package/ports/Credit.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PortBase } from "./Base.sol";
+import { CreditAccountHook } from "../commands/Credit.sol";
+import { Cursors, Cur, Forms } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PortCreditAccount
+/// @notice Port that lets a trusted peer credit supplied accounts directly.
+/// Each ACCOUNT_AMOUNT block calls `creditAccount` for its account.
+abstract contract PortCreditAccount is PortBase, CreditAccountHook {
+    uint internal immutable portCreditAccountId = portId(this.portCreditAccount.selector);
+
+    constructor() {
+        emit Port(host, portCreditAccountId, "1:0", Forms.AccountAmount, "", false);
+        emit Labeled(portCreditAccountId, bytes32(0), "portCreditAccount");
+    }
+
+    /// @notice Execute the port-credit call.
+    /// @param data ACCOUNT_AMOUNT block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portCreditAccount(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory amounts, , ) = Cursors.init(data, 1);
+
+        while (amounts.i < amounts.len) {
+            (bytes32 account, bytes32 asset, uint amount) = amounts.unpackAccountAmount();
+            creditAccount(account, asset, amount);
+        }
+
+        amounts.complete();
+        return "";
+    }
+}

package/ports/Debit.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PortBase } from "./Base.sol";
+import { DebitAccountHook } from "../commands/Debit.sol";
+import { Cursors, Cur, Forms } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PortDebitAccount
+/// @notice Port that lets a trusted peer debit supplied accounts directly.
+/// Each ACCOUNT_AMOUNT block calls `debitAccount` for its account.
+abstract contract PortDebitAccount is PortBase, DebitAccountHook {
+    uint internal immutable portDebitAccountId = portId(this.portDebitAccount.selector);
+
+    constructor() {
+        emit Port(host, portDebitAccountId, "1:0", Forms.AccountAmount, "", false);
+        emit Labeled(portDebitAccountId, bytes32(0), "portDebitAccount");
+    }
+
+    /// @notice Execute the port-debit call.
+    /// @param data ACCOUNT_AMOUNT block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portDebitAccount(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory amounts, , ) = Cursors.init(data, 1);
+
+        while (amounts.i < amounts.len) {
+            (bytes32 account, bytes32 asset, uint amount) = amounts.unpackAccountAmount();
+            debitAccount(account, asset, amount);
+        }
+
+        amounts.complete();
+        return "";
+    }
+}

package/ports/DenyAssets.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortBase} from "./Base.sol";
+import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PortDenyAssets
+/// @notice Port that blocks a list of assets on behalf of a peer host.
+/// Each ASSET block in the request calls `denyAsset`. Restricted to trusted peers.
+abstract contract PortDenyAssets is PortBase, DenyAssetsHook {
+    uint internal immutable portDenyAssetsId = portId(this.portDenyAssets.selector);
+
+    constructor() {
+        emit Port(host, portDenyAssetsId, "1:0", Schemas.Asset, "", false);
+        emit Labeled(portDenyAssetsId, bytes32(0), "portDenyAssets");
+    }
+
+    /// @notice Execute the deny-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portDenyAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory assets, , ) = Cursors.init(data, 1);
+
+        while (assets.i < assets.len) {
+            bytes32 asset = assets.unpackAsset();
+            denyAsset(asset);
+        }
+
+        assets.complete();
+        return "";
+    }
+}
+
+
+
+
+

package/{peer → ports}/Dispatch.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { PeerBase } from "./Base.sol";
+import { PortBase } from "./Base.sol";
 import { Payable } from "../core/Payable.sol";
 import { Cursors, Cur, Schemas } from "../Cursors.sol";
 import { DispatchPayableHook } from "../commands/Relay.sol";
@@ -9,28 +9,24 @@ import { Budget } from "../utils/Value.sol";
 
 using Cursors for Cur;
 
-interface IPeerDispatchPayable {
-    function peerDispatchPayable(bytes calldata request) external payable returns (bytes memory);
-}
-
-/// @title PeerDispatchPayable
-/// @notice Peer endpoint that forwards DISPATCH blocks to a host-defined dispatch hook.
-abstract contract PeerDispatchPayable is PeerBase, Payable, DispatchPayableHook, IPeerDispatchPayable {
-    uint internal immutable peerDispatchPayableId = peerId(this.peerDispatchPayable.selector);
+/// @title PortDispatchPayable
+/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined dispatch hook.
+abstract contract PortDispatchPayable is PortBase, Payable, DispatchPayableHook {
+    uint internal immutable portDispatchPayableId = portId(this.portDispatchPayable.selector);
 
     constructor() {
-        emit Peer(host, peerDispatchPayableId, "1:0", Schemas.Dispatch, "", true);
-        emit Labeled(peerDispatchPayableId, bytes32(0), "peerDispatchPayable");
+        emit Port(host, portDispatchPayableId, "1:0", Schemas.Dispatch, "", true);
+        emit Labeled(portDispatchPayableId, bytes32(0), "portDispatchPayable");
     }
 
     /// @notice Forward peer-supplied dispatches to the host-defined dispatch hook.
     /// @dev Dispatch hooks receive the shared top-level source-chain value
     ///      budget. Any `msg.value` not spent by the hook remains on this host.
-    /// @param request DISPATCH block stream supplied by the trusted peer.
+    /// @param data DISPATCH block stream supplied by the trusted peer.
     /// @return output Empty response bytes.
-    function peerDispatchPayable(bytes calldata request) external payable onlyPeer returns (bytes memory output) {
-        (Cur memory input, , ) = Cursors.init(request, 1);
-        Budget memory budget = valueBudget();
+    function portDispatchPayable(bytes calldata data) external payable onlyPeer returns (bytes memory output) {
+        (Cur memory input, , ) = Cursors.init(data, 1);
+        Budget memory budget = openValue();
 
         while (input.i < input.len) {
             (uint chain, uint resources, bytes calldata payload) = input.unpackDispatch();