@rootzero/contracts 1.6.0 → 1.7.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootzero/contracts",
-  "version": "1.6.0",
+  "version": "1.7.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,44 @@
+// 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;
+
+interface IPortAllowAssets {
+    function portAllowAssets(bytes calldata data) external returns (bytes memory);
+}
+
+/// @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, IPortAllowAssets {
+    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,41 @@
+// 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;
+
+interface IPortAllowance {
+    function portAllowance(bytes calldata data) external returns (bytes memory);
+}
+
+/// @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, IPortAllowance {
+    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,41 @@
+// 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";
+
+/// @notice ABI-encode a port call from a target port ID and data block stream.
+/// @dev Derives the function selector from `target` via `Nodes.portSelector(target)`.
+/// Reverts if `target` is not a valid port ID.
+/// @param target Destination port node ID embedding the target selector.
+/// @param data Input block stream for the port invocation.
+/// @return ABI-encoded calldata for the port entry point.
+function encodePortCall(uint target, bytes calldata data) pure returns (bytes memory) {
+    bytes4 selector = Nodes.portSelector(target);
+    return abi.encodeWithSelector(selector, data);
+}
+
+/// @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,39 @@
+// 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;
+
+interface IPortCreditAccount {
+    function portCreditAccount(bytes calldata data) external returns (bytes memory);
+}
+
+/// @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, IPortCreditAccount {
+    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,39 @@
+// 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;
+
+interface IPortDebitAccount {
+    function portDebitAccount(bytes calldata data) external returns (bytes memory);
+}
+
+/// @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, IPortDebitAccount {
+    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,44 @@
+// 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;
+
+interface IPortDenyAssets {
+    function portDenyAssets(bytes calldata data) external returns (bytes memory);
+}
+
+/// @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, IPortDenyAssets {
+    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,28 @@ import { Budget } from "../utils/Value.sol";
 
 using Cursors for Cur;
 
-interface IPeerDispatchPayable {
-    function peerDispatchPayable(bytes calldata request) external payable returns (bytes memory);
+interface IPortDispatchPayable {
+    function portDispatchPayable(bytes calldata data) 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, IPortDispatchPayable {
+    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();

package/ports/Pipe.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortBase} from "./Base.sol";
+import {Pipeline} from "../core/Pipeline.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+import {Budget} from "../utils/Value.sol";
+
+using Cursors for Cur;
+
+interface IPortPipePayable {
+    function portPipePayable(bytes calldata data) external payable returns (bytes memory);
+}
+
+/// @title PortPipePayable
+/// @notice Port that consumes CONTEXT blocks and executes each request as a step stream.
+/// Each context's request bytes are passed to the shared pipeline.
+abstract contract PortPipePayable is PortBase, Pipeline, IPortPipePayable {
+    uint internal immutable portPipePayableId = portId(this.portPipePayable.selector);
+
+    constructor() {
+        emit Port(host, portPipePayableId, "1:0", Schemas.Context, "", true);
+        emit Labeled(portPipePayableId, bytes32(0), "portPipePayable");
+    }
+
+    /// @notice Execute peer-supplied contexts through the shared payable pipe.
+    /// @dev All contexts share the peer call's native-value budget. Any unspent
+    ///      `msg.value` remains on this host.
+    /// @param data CONTEXT block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portPipePayable(bytes calldata data) external payable onlyPeer returns (bytes memory) {
+        (Cur memory input, , ) = Cursors.init(data, 1);
+        Budget memory budget = openValue();
+
+        while (input.i < input.len) {
+            (bytes32 account, bytes calldata state, bytes calldata request) = input.unpackContext();
+            pipe(account, state, request, budget);
+        }
+
+        input.complete();
+        return "";
+    }
+}

package/{peer → ports}/Redeem.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {PeerBase} from "./Base.sol";
+import {PortBase} from "./Base.sol";
 import {Cursors, Cur, Schemas} from "../Cursors.sol";
 
 using Cursors for Cur;
 
-interface IPeerRedeemBalance {
-    function peerRedeemBalance(bytes calldata request) external returns (bytes memory);
+interface IPortRedeemBalance {
+    function portRedeemBalance(bytes calldata data) external returns (bytes memory);
 }
 
 abstract contract RedeemBalanceHook {
@@ -18,23 +18,23 @@ abstract contract RedeemBalanceHook {
     function redeemBalance(uint peer, bytes32 asset, uint amount) internal virtual;
 }
 
-/// @title PeerRedeemBalance
-/// @notice Peer that redeems balance state from a peer host into local assets.
+/// @title PortRedeemBalance
+/// @notice Port that redeems balance state from a peer host into local assets.
 /// Each BALANCE block in the request calls `redeemBalance(peer, asset, amount)`.
 /// Restricted to trusted peers.
-abstract contract PeerRedeemBalance is PeerBase, RedeemBalanceHook, IPeerRedeemBalance {
-    uint internal immutable peerRedeemBalanceId = peerId(this.peerRedeemBalance.selector);
+abstract contract PortRedeemBalance is PortBase, RedeemBalanceHook, IPortRedeemBalance {
+    uint internal immutable portRedeemBalanceId = portId(this.portRedeemBalance.selector);
 
     constructor() {
-        emit Peer(host, peerRedeemBalanceId, "1:0", Schemas.Balance, "", false);
-        emit Labeled(peerRedeemBalanceId, bytes32(0), "peerRedeemBalance");
+        emit Port(host, portRedeemBalanceId, "1:0", Schemas.Balance, "", false);
+        emit Labeled(portRedeemBalanceId, bytes32(0), "portRedeemBalance");
     }
 
-    /// @notice Execute the balance redemption peer call.
-    /// @param request BALANCE block stream supplied by the trusted peer.
+    /// @notice Execute the balance redemption port call.
+    /// @param data BALANCE block stream supplied by the trusted peer.
     /// @return Empty response bytes.
-    function peerRedeemBalance(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory input, , ) = Cursors.init(request, 1);
+    function portRedeemBalance(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory input, , ) = Cursors.init(data, 1);
         uint peer = caller();
 
         while (input.i < input.len) {

package/ports/Settle.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PortBase } from "./Base.sol";
+import { CreditAccountHook } from "../commands/Credit.sol";
+import { DebitAccountHook } from "../commands/Debit.sol";
+import { Cursors, Cur, Schemas } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+interface IPortSettle {
+    function portSettle(bytes calldata data) external returns (bytes memory);
+}
+
+/// @title PortSettle
+/// @notice Port that consumes peer-supplied TRANSACTION blocks through debit and credit hooks.
+/// Each TRANSACTION block calls `debitAccount` for `from` and `creditAccount` for `to`.
+abstract contract PortSettle is PortBase, DebitAccountHook, CreditAccountHook, IPortSettle {
+    uint internal immutable portSettleId = portId(this.portSettle.selector);
+
+    constructor() {
+        emit Port(host, portSettleId, "1:0", Schemas.Transaction, "", false);
+        emit Labeled(portSettleId, bytes32(0), "portSettle");
+    }
+
+    /// @notice Execute the port-settle call.
+    /// @param data TRANSACTION block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portSettle(bytes calldata data) external onlyPeer returns (bytes memory) {
+        (Cur memory state, , ) = Cursors.init(data, 1);
+
+        while (state.i < state.len) {
+            (bytes32 from, bytes32 to, bytes32 asset, uint amount) = state.unpackTransaction();
+            if (from != 0) debitAccount(from, asset, amount);
+            if (to != 0) creditAccount(to, asset, amount);
+        }
+
+        state.complete();
+        return "";
+    }
+}

package/utils/Layout.sol

@@ -29,7 +29,7 @@ library Layout {
 
     /// @dev ID encodes an account.
     uint8 constant Account = 0x01;
-    /// @dev ID encodes a network node (host, command, or peer).
+    /// @dev ID encodes a network node (host, command, port, query, or guard).
     uint8 constant Node = 0x02;
     /// @dev ID encodes an asset.
     uint8 constant Asset = 0x03;
@@ -54,8 +54,8 @@ library Layout {
     uint8 constant Host = 0x02;
     /// @dev Node is a command contract.
     uint8 constant Command = 0x03;
-    /// @dev Node is a peer contract.
-    uint8 constant Peer = 0x04;
+    /// @dev Node is a port callable by trusted peer hosts.
+    uint8 constant Port = 0x04;
     /// @dev Node is a query contract.
     uint8 constant Query = 0x05;
     /// @dev Node is a guardian-only direct action.

package/utils/Nodes.sol

@@ -9,9 +9,9 @@ import {ensureAddr, isFamily, matchesBase, toLocalBase} from "./Utils.sol";
 /// @notice Encoding and decoding helpers for 256-bit node identifiers.
 ///
 /// Node IDs share a common layout:
-///   - bits [255:224] — 4-byte type prefix (`Host`, `Command`, or `Peer`)
+///   - bits [255:224] — 4-byte type prefix (`Host`, `Command`, `Port`, etc.)
 ///   - bits [223:192] — current `block.chainid` (makes IDs chain-local)
-///   - bits [191:160] — 4-byte ABI selector (commands and peers only)
+///   - bits [191:160] — 4-byte ABI selector (commands, ports, queries, and guards)
 ///   - bits [159:0]   — 160-bit EVM contract address
 ///
 /// If the first byte is zero, the node is an opaque
@@ -31,8 +31,8 @@ library Nodes {
     uint32 constant Host = (uint32(Layout.Evm) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Host);
     /// @dev Full 4-byte type prefix for command nodes.
     uint32 constant Command = (uint32(Layout.Evm) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Command);
-    /// @dev Full 4-byte type prefix for peer nodes.
-    uint32 constant Peer = (uint32(Layout.Evm) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Peer);
+    /// @dev Full 4-byte type prefix for port nodes.
+    uint32 constant Port = (uint32(Layout.Evm) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Port);
     /// @dev Full 4-byte type prefix for query nodes.
     uint32 constant Query = (uint32(Layout.Evm) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Query);
     /// @dev Full 4-byte type prefix for guard action nodes.
@@ -48,9 +48,9 @@ library Nodes {
         return uint32(node >> 224) == Command;
     }
 
-    /// @notice Return true if `node` is a peer node ID.
-    function isPeer(uint node) internal pure returns (bool) {
-        return uint32(node >> 224) == Peer;
+    /// @notice Return true if `node` is a port node ID.
+    function isPort(uint node) internal pure returns (bool) {
+        return uint32(node >> 224) == Port;
     }
 
     /// @notice Return true if `node` is a query node ID.
@@ -94,11 +94,11 @@ library Nodes {
         return value;
     }
 
-    /// @notice Assert that `value` is a peer node ID and return it as a node.
+    /// @notice Assert that `value` is a port node ID and return it as a node.
     /// @param value Value to validate.
-    /// @return node The same `value` if it is a peer node.
-    function peer(uint value) internal pure returns (uint node) {
-        if (!isPeer(value)) revert InvalidId();
+    /// @return node The same `value` if it is a port node.
+    function port(uint value) internal pure returns (uint node) {
+        if (!isPort(value)) revert InvalidId();
         return value;
     }
 
@@ -149,11 +149,11 @@ library Nodes {
         return bytes4(uint32(command(node) >> 160));
     }
 
-    /// @notice Assert that `node` is a peer ID and return its embedded ABI selector.
+    /// @notice Assert that `node` is a port ID and return its embedded ABI selector.
     /// @param node Node ID to validate.
-    /// @return selector 4-byte peer selector stored in bits [191:160].
-    function peerSelector(uint node) internal pure returns (bytes4 selector) {
-        return bytes4(uint32(peer(node) >> 160));
+    /// @return selector 4-byte port selector stored in bits [191:160].
+    function portSelector(uint node) internal pure returns (bytes4 selector) {
+        return bytes4(uint32(port(node) >> 160));
     }
 
     /// @notice Assert that `node` is a query ID and return its embedded ABI selector.
@@ -201,12 +201,12 @@ library Nodes {
         node |= uint(uint32(selector)) << 160;
     }
 
-    /// @notice Build a chain-local peer ID for the given selector and contract.
-    /// @param selector 4-byte ABI selector of the peer entry point.
-    /// @param target Peer contract address.
-    /// @return node Peer node ID embedding both the selector and address.
-    function toPeer(bytes4 selector, address target) internal view returns (uint node) {
-        node = toLocalBase(Peer) | uint(uint160(target));
+    /// @notice Build a chain-local port ID for the given selector and contract.
+    /// @param selector 4-byte ABI selector of the port entry point.
+    /// @param target Port contract address.
+    /// @return node Port node ID embedding both the selector and address.
+    function toPort(bytes4 selector, address target) internal view returns (uint node) {
+        node = toLocalBase(Port) | uint(uint160(target));
         node |= uint(uint32(selector)) << 160;
     }
 

package/utils/Value.sol

@@ -18,19 +18,26 @@ library Values {
     /// @param budget Mutable budget to deduct from.
     /// @param amount Native value to spend in wei.
     /// @return The same `amount`, ready to forward to a callee.
-    function use(Budget memory budget, uint128 amount) internal pure returns (uint128) {
-        uint value = uint(amount);
-        if (value > budget.remaining) revert InsufficientValue();
-        budget.remaining -= value;
+    function use(Budget memory budget, uint amount) internal pure returns (uint) {
+        if (amount > budget.remaining) revert InsufficientValue();
+        budget.remaining -= amount;
         return amount;
     }
 
+    /// @notice Drain the remaining native value from `budget` and return it.
+    /// @param budget Mutable budget to drain.
+    /// @return value Native value removed from the budget, in wei.
+    function drain(Budget memory budget) internal pure returns (uint value) {
+        value = budget.remaining;
+        budget.remaining = 0;
+    }
+
     /// @notice Deduct `amount` from the budget and return it as a new sub-budget.
     /// Reverts if `amount` exceeds `budget.remaining`.
     /// @param budget Mutable parent budget to deduct from.
     /// @param amount Native value to assign to the sub-budget, in wei.
     /// @return A new budget with `amount` remaining.
-    function allocate(Budget memory budget, uint128 amount) internal pure returns (Budget memory) {
+    function allocate(Budget memory budget, uint amount) internal pure returns (Budget memory) {
         return Budget({remaining: use(budget, amount)});
     }
 }