@rootzero/contracts 1.7.0 → 1.9.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,111 @@ 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 Try to 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 success True if the low-level port call succeeded.
+    function tryCallPort(uint port, uint128 value, bytes calldata input) internal returns (bool success) {
+        bytes4 selector = Nodes.portSelector(port);
+        bytes memory data = abi.encodeWithSelector(selector, input);
+        return tryTrustedCall(port, value, data);
+    }
+
+    /// @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 calldata 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/Payable.sol

@@ -19,7 +19,7 @@ abstract contract Payable {
     /// @notice Deduct the EVM value lane from a packed resource word and return it.
     /// @dev EVM resources use the low 128 bits as native value/endowment.
     /// @param budget Mutable budget to deduct from.
-    /// @param resources Packed chain resources.
+    /// @param resources Packed resources.
     /// @return value Native value to forward in wei.
     function useValue(Budget memory budget, uint resources) internal pure returns (uint128 value) {
         value = uint128(resources);

package/core/Portal.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortCalls} from "./Calls.sol";
+import {ResolvedEvent} from "../events/Resolved.sol";
+import {UndeliveredEvent} from "../events/Undelivered.sol";
+import {Budget} from "../utils/Value.sol";
+
+abstract contract RoutePayableHook {
+    /// @notice Override to route an encoded payload through `portal`.
+    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param resources Chain-specific destination resources. EVM adapters
+    /// may interpret this as packed execution gas and destination value.
+    /// @param payload Encoded payload ready for the transport layer.
+    /// @param budget Source native-value budget available for transport
+    /// fees and destination resource funding.
+    function route(uint portal, uint resources, bytes memory payload, Budget memory budget) internal virtual;
+}
+
+abstract contract RecoverHook {
+    /// @notice Override to recover a previously undelivered witness through `handler`.
+    /// @param handler Port that should attempt recovery.
+    /// @param key Recovery lookup key.
+    /// @param witness Witness payload used to prove and replay recovery.
+    /// @param value Native EVM value assigned to the recovery attempt.
+    function recover(uint handler, bytes32 key, bytes calldata witness, uint128 value) internal virtual;
+}
+
+/// @title Portal
+/// @notice Base contract for hosts that route payloads through portal adapters.
+abstract contract Portal is PortCalls, RecoverHook, ResolvedEvent, UndeliveredEvent {
+    error BadWitness();
+
+    /// @dev Remote port used to handle messages delivered through this portal.
+    uint private immutable port;
+
+    mapping(bytes32 key => bytes32 digest) internal undelivered;
+
+    /// @param handler Remote port used to handle messages delivered through this portal.
+    constructor(uint handler) {
+        port = handler;
+    }
+
+    /// @notice Try to deliver `message` to this portal's handler port.
+    /// @dev Records `keccak256(message)` under `key` only when delivery fails.
+    /// @param key Delivery/recovery lookup key.
+    /// @param message Encoded port input to deliver.
+    /// @param value Native EVM value assigned to the delivery attempt.
+    function deliver(bytes32 key, bytes calldata message, uint128 value) internal {
+        if (tryCallPort(port, value, message)) return;
+        bytes32 digest = keccak256(message);
+        undelivered[key] = digest;
+        emit Undelivered(host, key, digest);
+    }
+
+    /// @notice Recover a previously undelivered witness through `handler`.
+    /// @dev The witness must hash to the digest stored under `key`.
+    /// @param handler Port that should attempt recovery.
+    /// @param key Recovery lookup key.
+    /// @param witness Witness payload used to prove and replay recovery.
+    /// @param value Native EVM value assigned to the recovery attempt.
+    function recover(uint handler, bytes32 key, bytes calldata witness, uint128 value) internal virtual override {
+        if (keccak256(witness) != undelivered[key]) revert BadWitness();
+        delete undelivered[key];
+        callPort(handler, value, witness);
+        emit Resolved(host, key);
+    }
+}

package/docs/Schema.md

@@ -120,7 +120,7 @@ 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 }
+#recover { uint handler, uint resources, bytes32 key, #bytes as witness }
 ```
 
 Alias resolution is context-dependent. A consumer may resolve `#context` from the
@@ -136,13 +136,13 @@ path does not change the block key, payload bytes, payload length, cursor
 behavior, or any onchain validation. It is metadata only.
 
 ```txt
-#dispatch { uint dst.chain, uint dst.resources, #bytes as dst.payload }
+#dispatch { uint dst.portal, uint dst.resources, #bytes as dst.payload }
 ```
 
 This has the same runtime layout as:
 
 ```txt
-#dispatch { uint chain, uint resources, #bytes as payload }
+#dispatch { uint portal, uint resources, #bytes as payload }
 ```
 
 Offchain tooling may decode the dotted form into a nested object:
@@ -150,7 +150,7 @@ Offchain tooling may decode the dotted form into a nested object:
 ```ts
 {
   dst: {
-    chain,
+    portal,
     resources,
     payload
   }
@@ -165,8 +165,8 @@ object.
 Tooling should reject duplicate full paths and prefix/value collisions:
 
 ```txt
-uint dst.chain, uint dst.chain      // duplicate path
-uint dst, uint dst.chain            // prefix/value collision
+uint dst.portal, uint dst.portal    // duplicate path
+uint dst, uint dst.portal           // prefix/value collision
 ```
 
 The same rule applies to block aliases:
@@ -196,10 +196,14 @@ true. `bytesN` values are encoded as exactly `N` bytes with no padding.
 
 ## Chain Resources
 
-Fields named `resources` are chain-specific resource words. Different chain
-types may pack these words differently, but a given chain type must use one
-stable format everywhere. For EVM chains, the low 128 bits are native value /
-endowment in wei; higher bits are reserved for execution resources such as gas.
+Fields named `portal` are routing identifiers; they are often the destination
+host ID, but a transport adapter may define a different stable handle.
+
+Fields named `resources` are chain-specific resource words. A portal adapter
+interprets them for the destination runtime. Different runtimes may pack these
+words differently, but a given runtime must use one stable format everywhere.
+For EVM chains, the low 128 bits are native value / endowment in wei; higher
+bits are reserved for execution resources such as gas.
 
 ## Protocol IDs
 
@@ -282,7 +286,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 }
-#contextRecovery { uint port, bytes32 key, uint resources, #context as witness }
+#recover { uint handler, uint resources, bytes32 key, #bytes as witness }
 #auth { uint cid, uint deadline, #bytes as proof }
 ```
 

package/events/Dispatch.sol

@@ -5,14 +5,14 @@ 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)";
+    string private constant ABI = "event Dispatch(uint indexed host, uint portal, uint resources, bytes32 key, bytes32 digest)";
 
     /// @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 portal Destination portal identifier, often the destination host ID.
+    /// @param resources Chain-specific resources assigned to the dispatch.
+    /// @param key Dispatch correlation or recovery lookup key.
     /// @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);
+    event Dispatch(uint indexed host, uint portal, uint resources, bytes32 key, bytes32 digest);
 
     constructor() {
         emit EventAbi(ABI);

package/events/Resolved.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted when a host resolves a previously recorded key.
+abstract contract ResolvedEvent is EventEmitter {
+    string private constant ABI = "event Resolved(uint indexed host, bytes32 key)";
+
+    /// @param host Host node ID that owns the resolved key.
+    /// @param key Resolution lookup key.
+    event Resolved(uint indexed host, bytes32 key);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/events/Route.sol

@@ -3,14 +3,14 @@ pragma solidity ^0.8.33;
 
 import {EventEmitter} from "./Emitter.sol";
 
-/// @notice Emitted when a host announces a route to another chain/domain.
+/// @notice Emitted when a host updates a portal route.
 abstract contract RouteEvent is EventEmitter {
-    string private constant ABI = "event Route(uint indexed host, uint chain, uint context)";
+    string private constant ABI = "event Route(uint indexed host, uint portal, uint status)";
 
     /// @param host Host node ID that owns the route.
-    /// @param chain Destination chain/domain node ID.
-    /// @param context Route context identifier.
-    event Route(uint indexed host, uint chain, uint context);
+    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param status Route status. Zero means inactive; nonzero means active.
+    event Route(uint indexed host, uint portal, uint status);
 
     constructor() {
         emit EventAbi(ABI);

package/events/Undelivered.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {EventEmitter} from "./Emitter.sol";
+
+/// @notice Emitted when a host records an undelivered portal message.
+abstract contract UndeliveredEvent is EventEmitter {
+    string private constant ABI = "event Undelivered(uint indexed host, bytes32 key, bytes32 digest)";
+
+    /// @param host Host node ID that owns the undelivered message.
+    /// @param key Delivery lookup key.
+    /// @param digest Digest of the undelivered message.
+    event Undelivered(uint indexed host, bytes32 key, bytes32 digest);
+
+    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.7.0",
+  "version": "1.9.0",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",

package/ports/AllowAssets.sol

@@ -7,14 +7,10 @@ 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 {
+abstract contract PortAllowAssets is PortBase, AllowAssetsHook {
     uint internal immutable portAllowAssetsId = portId(this.portAllowAssets.selector);
 
     constructor() {

package/ports/Allowance.sol

@@ -7,15 +7,11 @@ 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 {
+abstract contract PortAllowance is PortBase, AllowanceHook {
     uint internal immutable portAllowanceId = portId(this.portAllowance.selector);
 
     constructor() {

package/ports/Base.sol

@@ -6,17 +6,6 @@ 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.

package/ports/Credit.sol

@@ -7,14 +7,10 @@ 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 {
+abstract contract PortCreditAccount is PortBase, CreditAccountHook {
     uint internal immutable portCreditAccountId = portId(this.portCreditAccount.selector);
 
     constructor() {

package/ports/Debit.sol

@@ -7,14 +7,10 @@ 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 {
+abstract contract PortDebitAccount is PortBase, DebitAccountHook {
     uint internal immutable portDebitAccountId = portId(this.portDebitAccount.selector);
 
     constructor() {

package/ports/DenyAssets.sol

@@ -7,14 +7,10 @@ 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 {
+abstract contract PortDenyAssets is PortBase, DenyAssetsHook {
     uint internal immutable portDenyAssetsId = portId(this.portDenyAssets.selector);
 
     constructor() {

package/ports/Dispatch.sol

@@ -3,19 +3,15 @@ pragma solidity ^0.8.33;
 
 import { PortBase } from "./Base.sol";
 import { Payable } from "../core/Payable.sol";
+import { RoutePayableHook } from "../core/Portal.sol";
 import { Cursors, Cur, Schemas } from "../Cursors.sol";
-import { DispatchPayableHook } from "../commands/Relay.sol";
 import { Budget } from "../utils/Value.sol";
 
 using Cursors for Cur;
 
-interface IPortDispatchPayable {
-    function portDispatchPayable(bytes calldata data) external payable returns (bytes memory);
-}
-
 /// @title PortDispatchPayable
-/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined dispatch hook.
-abstract contract PortDispatchPayable is PortBase, Payable, DispatchPayableHook, IPortDispatchPayable {
+/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined route hook.
+abstract contract PortDispatchPayable is PortBase, Payable, RoutePayableHook {
     uint internal immutable portDispatchPayableId = portId(this.portDispatchPayable.selector);
 
     constructor() {
@@ -23,8 +19,8 @@ abstract contract PortDispatchPayable is PortBase, Payable, DispatchPayableHook,
         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
+    /// @notice Forward peer-supplied dispatches to the host-defined route hook.
+    /// @dev Route hooks receive the shared top-level source value
     ///      budget. Any `msg.value` not spent by the hook remains on this host.
     /// @param data DISPATCH block stream supplied by the trusted peer.
     /// @return output Empty response bytes.
@@ -33,8 +29,8 @@ abstract contract PortDispatchPayable is PortBase, Payable, DispatchPayableHook,
         Budget memory budget = openValue();
 
         while (input.i < input.len) {
-            (uint chain, uint resources, bytes calldata payload) = input.unpackDispatch();
-            dispatch(chain, resources, bytes(payload), budget);
+            (uint portal, uint resources, bytes calldata payload) = input.unpackDispatch();
+            route(portal, resources, bytes(payload), budget);
         }
 
         input.complete();

package/ports/Pipe.sol

@@ -8,14 +8,10 @@ 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 {
+abstract contract PortPipePayable is PortBase, Pipeline {
     uint internal immutable portPipePayableId = portId(this.portPipePayable.selector);
 
     constructor() {

package/ports/Redeem.sol

@@ -6,10 +6,6 @@ import {Cursors, Cur, Schemas} from "../Cursors.sol";
 
 using Cursors for Cur;
 
-interface IPortRedeemBalance {
-    function portRedeemBalance(bytes calldata data) external returns (bytes memory);
-}
-
 abstract contract RedeemBalanceHook {
     /// @notice Override to redeem one balance claim from a peer host into local assets.
     /// @param peer Peer host node ID for this request.
@@ -22,7 +18,7 @@ abstract contract RedeemBalanceHook {
 /// @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 PortRedeemBalance is PortBase, RedeemBalanceHook, IPortRedeemBalance {
+abstract contract PortRedeemBalance is PortBase, RedeemBalanceHook {
     uint internal immutable portRedeemBalanceId = portId(this.portRedeemBalance.selector);
 
     constructor() {

package/ports/Settle.sol

@@ -8,14 +8,10 @@ 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 {
+abstract contract PortSettle is PortBase, DebitAccountHook, CreditAccountHook {
     uint internal immutable portSettleId = portId(this.portSettle.selector);
 
     constructor() {

package/queries/Base.sol

@@ -6,17 +6,6 @@ import { LabeledEvent } from "../events/Labeled.sol";
 import { QueryEvent } from "../events/Query.sol";
 import { Nodes } from "../utils/Nodes.sol";
 
-/// @notice ABI-encode a query call from a target query ID and request block stream.
-/// @dev Derives the function selector from `target` via `Nodes.querySelector(target)`.
-/// Reverts if `target` is not a valid query ID.
-/// @param target Destination query node ID embedding the target selector.
-/// @param request Input block stream for the query invocation.
-/// @return ABI-encoded calldata for the query entry point.
-function encodeQueryCall(uint target, bytes calldata request) pure returns (bytes memory) {
-    bytes4 selector = Nodes.querySelector(target);
-    return abi.encodeWithSelector(selector, request);
-}
-
 /// @title QueryBase
 /// @notice Abstract base for rootzero query contracts.
 /// Queries are view-only entry points that consume a block-stream request and