@rootzero/contracts 1.18.0 → 1.20.0

package/codec/Writers.sol

@@ -22,6 +22,7 @@ struct Writer {
 /// then lazily allocates and writes binary-encoded blocks sequentially.
 /// Physical allocation is rounded up to whole 32-byte words for scratch space,
 /// while the writer cursor length tracks logical capacity. Call `finish` to trim the buffer.
+/// `append*` helpers consume memory inputs; `copy*` helpers consume calldata inputs.
 library Writers {
     // -------------------------------------------------------------------------
     // Initialization helpers
@@ -497,6 +498,107 @@ library Writers {
         Blocks.writeSchema(writer.dst, i, spec, body, name);
     }
 
+    // -------------------------------------------------------------------------
+    // Calldata copy helpers
+    // -------------------------------------------------------------------------
+
+    /// @notice Append arbitrary calldata bytes to the writer.
+    /// @param writer Destination writer; `i` is advanced by `data.length`.
+    /// @param data Calldata bytes to append.
+    function copy(Writer memory writer, bytes calldata data) internal pure {
+        uint i = reserve(writer, data.length, data.length);
+        Buffers.copy(writer.dst, i, data);
+    }
+
+    /// @notice Append a custom block by copying its payload from calldata.
+    function copyBlock(Writer memory writer, uint spec, bytes calldata data) internal pure {
+        Specs.validate(spec, data.length);
+        uint size = Sizes.Header + data.length;
+        uint i = reserve(writer, size);
+        Blocks.copy(writer.dst, i, Specs.key(spec), data);
+    }
+
+    /// @notice Append a LIST block by copying its payload from calldata.
+    function copyList(Writer memory writer, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(writer, size);
+        Blocks.copyList(writer.dst, i, value);
+    }
+
+    /// @notice Append an EVM block by copying its payload from calldata.
+    function copyEvm(Writer memory writer, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(writer, size);
+        Blocks.copyEvm(writer.dst, i, value);
+    }
+
+    /// @notice Append a BYTES block by copying its payload from calldata.
+    function copyBytes(Writer memory writer, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(writer, size);
+        Blocks.copyBytes(writer.dst, i, value);
+    }
+
+    /// @notice Append a STRING block by copying its payload from calldata.
+    function copyString(Writer memory writer, string calldata value) internal pure {
+        uint size = Sizes.Header + bytes(value).length;
+        uint i = reserve(writer, size);
+        Blocks.copyString(writer.dst, i, value);
+    }
+
+    /// @notice Append a STEP block by copying its nested input from calldata.
+    function copyStep(Writer memory writer, uint cmd, uint resources, bytes calldata input) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + input.length;
+        uint i = reserve(writer, size);
+        Blocks.copyStep(writer.dst, i, cmd, resources, input);
+    }
+
+    /// @notice Append a CALL block by copying its nested payload from calldata.
+    function copyCall(Writer memory writer, uint target, uint resources, bytes calldata payload) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + payload.length;
+        uint i = reserve(writer, size);
+        Blocks.copyCall(writer.dst, i, target, resources, payload);
+    }
+
+    /// @notice Append a RELAY block by copying its nested input from calldata.
+    function copyRelay(Writer memory writer, uint portal, uint resources, bytes calldata input) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + input.length;
+        uint i = reserve(writer, size);
+        Blocks.copyRelay(writer.dst, i, portal, resources, input);
+    }
+
+    /// @notice Append a DISPATCH block by copying its nested payload from calldata.
+    function copyDispatch(Writer memory writer, uint portal, uint resources, bytes calldata payload) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + payload.length;
+        uint i = reserve(writer, size);
+        Blocks.copyDispatch(writer.dst, i, portal, resources, payload);
+    }
+
+    /// @notice Append a CONTEXT block by copying its nested streams from calldata.
+    function copyContext(
+        Writer memory writer,
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) internal pure {
+        uint size = Sizes.B32 + 2 * Sizes.Header + state.length + input.length;
+        uint i = reserve(writer, size);
+        Blocks.copyContext(writer.dst, i, account, state, input);
+    }
+
+    /// @notice Append a RECOVER block by copying its nested witness from calldata.
+    function copyRecover(
+        Writer memory writer,
+        uint handler,
+        uint resources,
+        bytes32 recoverykey,
+        bytes calldata witness
+    ) internal pure {
+        uint size = Sizes.B96 + Sizes.Header + witness.length;
+        uint i = reserve(writer, size);
+        Blocks.copyRecover(writer.dst, i, handler, resources, recoverykey, witness);
+    }
+
     // -------------------------------------------------------------------------
     // Finalisation
     // -------------------------------------------------------------------------

package/commands/Base.sol

@@ -11,7 +11,6 @@ import {ReceivedEvent} from "../events/Received.sol";
 import {Actions} from "../utils/Actions.sol";
 import {Descriptors} from "../codec/Descriptors.sol";
 import {Nodes} from "../utils/Nodes.sol";
-import {Selectors} from "../utils/Selectors.sol";
 import {Cursors} from "../utils/Cursors.sol";
 
 using Executions for Execution;
@@ -72,7 +71,7 @@ abstract contract CommandBase is CallerAccess, EndpointBase, ReceivedEvent {
     /// @return id Command node ID.
     /// @return published Published endpoint descriptor.
     function command(string memory name, uint descriptor) internal returns (uint id, uint published) {
-        id = Nodes.toCommand(Selectors.command(name), address(this));
+        id = Nodes.toCommand(name, address(this));
         published = endpoint(id, name, descriptor);
     }
 

package/commands/Credit.sol

@@ -45,11 +45,11 @@ abstract contract CreditAccount is CommandBase, CreditAccountHook {
     }
 }
 
-/// @title InternalCreditAccount
+/// @title CreditAccountInternal
 /// @notice Extends the advertised credit-account command with memory-state pipeline dispatch.
 /// @dev This adapter is not a separate command. It uses the command ID and account hook
 /// inherited from `CreditAccount` while accepting the state location used by `Pipeline`.
-abstract contract InternalCreditAccount is CreditAccount {
+abstract contract CreditAccountInternal is CreditAccount {
     /// @notice Execute the inherited credit-account command from an internal pipeline.
     /// @param account Account credited by each balance.
     /// @param state BALANCE block stream held in pipeline memory.

package/commands/Debit.sol

@@ -49,11 +49,11 @@ abstract contract DebitAccount is CommandBase, DebitAccountHook {
     }
 }
 
-/// @title InternalDebitAccount
+/// @title DebitAccountInternal
 /// @notice Extends the advertised debit-account command with memory-state pipeline dispatch.
 /// @dev This adapter is not a separate command. It uses the command ID and account hook
 /// inherited from `DebitAccount` while accepting the state location used by `Pipeline`.
-abstract contract InternalDebitAccount is DebitAccount {
+abstract contract DebitAccountInternal is DebitAccount {
     /// @notice Execute the inherited debit-account command from an internal pipeline.
     /// @param account Account whose funds are debited.
     /// @param state Empty pipeline state required by the command schema.

package/commands/Relay.sol

@@ -1,20 +1,29 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {Blocks, Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
+import {Execution, Executions, CommandBase, Lanes, Specs} from "./Base.sol";
 
 using Executions for Execution;
 
-/// @notice Hook implemented by hosts that forward funded relay payloads.
+/// @notice Hook implemented by hosts that relay command contexts.
 abstract contract RelayPayableHook {
-    /// @notice Override to relay an encoded payload to `portal`.
+    /// @notice Override to relay a command context to `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 account Destination command account.
+    /// @param state State forwarded into the destination context.
+    /// @param input Input forwarded into the destination context.
     /// @param funds Execution used for source value available for transport fees
     /// and destination resource funding.
-    function relayTo(uint portal, uint resources, bytes memory payload, Execution memory funds) internal virtual;
+    function relay(
+        uint portal,
+        uint resources,
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input,
+        Execution memory funds
+    ) internal virtual;
 }
 
 /// @title RelayPayable
@@ -33,10 +42,8 @@ abstract contract RelayPayable is CommandBase, RelayPayableHook {
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
         Execution memory exec = openCommand(state, input, descriptor, 1);
-        (uint portal, uint resources, bytes calldata payload) = exec.unpackRelay(Lanes.Input);
-        bytes memory context = Blocks.context(account, bytes(state), bytes(payload));
-
-        relayTo(portal, resources, context, exec);
+        (uint portal, uint resources, bytes calldata relayInput) = exec.unpackRelay(Lanes.Input);
+        relay(portal, resources, account, state, relayInput, exec);
 
         return close(exec, account);
     }
@@ -65,10 +72,8 @@ abstract contract RelayBalancePayable is CommandBase, RelayPayableHook {
         bytes calldata input
     ) external payable onlyCommand returns (bytes memory, bytes memory) {
         Execution memory exec = openCommand(state, input, descriptor, 1);
-        (uint portal, uint resources, bytes calldata payload) = exec.unpackRelay(Lanes.Input);
-        bytes memory context = Blocks.context(account, bytes(state), bytes(payload));
-
-        relayTo(portal, resources, context, exec);
+        (uint portal, uint resources, bytes calldata relayInput) = exec.unpackRelay(Lanes.Input);
+        relay(portal, resources, account, state, relayInput, exec);
 
         return close(exec, account);
     }

package/commands/Settle.sol

@@ -97,11 +97,11 @@ abstract contract SettlePayable is CommandBase, SettlePayableHook, Action {
     }
 }
 
-/// @title InternalSettle
+/// @title SettleInternal
 /// @notice Extends the advertised settle command with memory-state pipeline dispatch.
 /// @dev This adapter is not a separate command. It uses the command ID and settlement hook
 /// inherited from `Settle` while accepting the state location used by `Pipeline`.
-abstract contract InternalSettle is Settle {
+abstract contract SettleInternal is Settle {
     /// @notice Execute the inherited settle command from an internal pipeline.
     /// @param account Account for which each position is settled.
     /// @param state POSITION block stream held in pipeline memory.

package/core/Settlement.sol

@@ -69,7 +69,7 @@ abstract contract Settlement is PostHook, SettleHook, RepayHook, DebitAccountHoo
         bytes32 liability,
         uint debt
     ) internal virtual override {
+        repay(account, liability, debt);
         if (amount != 0) creditAccount(account, asset, amount);
-        if (debt != 0) debitAccount(account, liability, debt);
     }
 }

package/docs/Schema.md

@@ -301,6 +301,11 @@ bytes1 through bytes32
 `uint` means `uint256`; `int` means `int256`. Other integer widths, unsized
 `bytes`, `string`, and array syntax are not part of the core schema DSL.
 
+Restricting fixed bytes to the power-of-two widths `bytes1`, `bytes2`,
+`bytes4`, `bytes8`, `bytes16`, and `bytes32` is under consideration, but has
+not been decided. Until that decision is made, the schema DSL continues to
+allow every `bytesN` width from 1 through 32.
+
 Integers are encoded big-endian. Signed integers use two's-complement encoding
 for their declared width. `bool` is one byte: `0x00` for false and `0x01` for
 true. `bytesN` values are encoded as exactly `N` bytes with no padding.

package/events/Relay.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 an account records an outbound relay reference.
+abstract contract RelayEvent is EventEmitter {
+    string private constant ABI = "event Relay(bytes32 indexed account, uint portal, uint resources, bytes32 key, bytes32 digest)";
+
+    /// @param account Account that owns the relayed context.
+    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param resources Chain-specific resources assigned to the relay.
+    /// @param key Relay correlation or recovery lookup key.
+    /// @param digest Digest of the relayed payload or canonical envelope.
+    event Relay(bytes32 indexed account, uint portal, uint resources, bytes32 key, bytes32 digest);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/execution/Execution.sol

@@ -24,6 +24,8 @@ struct Execution {
 
 /// @title Executions
 /// @notice Opening, decoding, output, transaction, and value helpers for executions.
+/// @dev `output*` helpers consume memory inputs; `outputCopy*` helpers copy
+/// calldata inputs directly to the output lane.
 library Executions {
     using Cursors for uint;
 
@@ -197,6 +199,21 @@ library Executions {
         exec.decoders = cur.seekAbs(end);
     }
 
+    /// @notice Validate and enter the payload of the next block in an execution decoder lane.
+    /// @dev The selected lane remains in its existing frame so callers can decode
+    /// child blocks in place. Callers should prove complete payload consumption
+    /// with `exec.expectAbs(end)` after decoding the children from the same lane.
+    /// @param exec Execution whose selected decoder cursor advances over the block header.
+    /// @param lane Execution decoder lane to select.
+    /// @param spec Expected parent block specification.
+    /// @return abs Absolute position of the first payload byte.
+    /// @return end Absolute position immediately after the payload.
+    function enter(Execution memory exec, uint8 lane, uint spec) internal pure returns (uint abs, uint end) {
+        uint cur = exec.decoders.select(lane);
+        (abs, end) = Blocks.expect(cur.absolute(), spec);
+        exec.decoders = cur.seekAbs(abs);
+    }
+
     /// @notice Require the active execution decoder to be at absolute position `abs`.
     /// @dev The most recent lane-aware decoder operation determines the active lane.
     /// @param exec Execution whose active decoder position is validated.
@@ -218,6 +235,46 @@ library Executions {
     // Fixed-width block decoding
     // -------------------------------------------------------------------------
 
+    /// @dev Return the next raw calldata word from `lane` and advance by `size` bytes.
+    function next(Execution memory exec, uint8 lane, uint size) private pure returns (bytes32 value) {
+        uint abs;
+        (exec.decoders, abs) = exec.decoders.consume(lane, size);
+        value = Blocks.read32(abs);
+    }
+
+    /// @notice Return the next raw byte from a decoder lane and advance it by one byte.
+    function next1(Execution memory exec, uint8 lane) internal pure returns (bytes1 value) {
+        value = bytes1(next(exec, lane, 1));
+    }
+
+    /// @notice Return the next two raw bytes from a decoder lane and advance it by two bytes.
+    function next2(Execution memory exec, uint8 lane) internal pure returns (bytes2 value) {
+        value = bytes2(next(exec, lane, 2));
+    }
+
+    /// @notice Return the next four raw bytes from a decoder lane and advance it by four bytes.
+    function next4(Execution memory exec, uint8 lane) internal pure returns (bytes4 value) {
+        value = bytes4(next(exec, lane, 4));
+    }
+
+    /// @notice Return the next eight raw bytes from a decoder lane and advance it by eight bytes.
+    function next8(Execution memory exec, uint8 lane) internal pure returns (bytes8 value) {
+        value = bytes8(next(exec, lane, 8));
+    }
+
+    /// @notice Return the next sixteen raw bytes from a decoder lane and advance it by sixteen bytes.
+    function next16(Execution memory exec, uint8 lane) internal pure returns (bytes16 value) {
+        value = bytes16(next(exec, lane, 16));
+    }
+
+    /// @notice Return the next raw calldata word from a decoder lane and advance it.
+    /// @param exec Execution whose selected decoder cursor advances by one word.
+    /// @param lane Execution decoder lane to select.
+    /// @return value Raw word at the selected lane's previous position.
+    function next32(Execution memory exec, uint8 lane) internal pure returns (bytes32 value) {
+        value = next(exec, lane, Sizes.Word);
+    }
+
     /// @notice Decode one fixed 32-byte payload from `lane`.
     /// @param exec Execution whose decoder is advanced.
     /// @param lane Decoder lane to consume.
@@ -1097,6 +1154,99 @@ library Executions {
         Blocks.writeSchema(exec.output, i, spec, body, name);
     }
 
+    // -------------------------------------------------------------------------
+    // Calldata output copy helpers
+    // -------------------------------------------------------------------------
+
+    /// @notice Append a custom block to execution output by copying its payload from calldata.
+    function outputCopyBlock(Execution memory exec, uint spec, bytes calldata data) internal pure {
+        Specs.validate(spec, data.length);
+        uint size = Sizes.Header + data.length;
+        uint i = reserve(exec, size);
+        Blocks.copy(exec.output, i, Specs.key(spec), data);
+    }
+
+    /// @notice Append a LIST block to execution output by copying its payload from calldata.
+    function outputCopyList(Execution memory exec, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(exec, size);
+        Blocks.copyList(exec.output, i, value);
+    }
+
+    /// @notice Append an EVM block to execution output by copying its payload from calldata.
+    function outputCopyEvm(Execution memory exec, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(exec, size);
+        Blocks.copyEvm(exec.output, i, value);
+    }
+
+    /// @notice Append a BYTES block to execution output by copying its payload from calldata.
+    function outputCopyBytes(Execution memory exec, bytes calldata value) internal pure {
+        uint size = Sizes.Header + value.length;
+        uint i = reserve(exec, size);
+        Blocks.copyBytes(exec.output, i, value);
+    }
+
+    /// @notice Append a STRING block to execution output by copying its payload from calldata.
+    function outputCopyString(Execution memory exec, string calldata value) internal pure {
+        uint size = Sizes.Header + bytes(value).length;
+        uint i = reserve(exec, size);
+        Blocks.copyString(exec.output, i, value);
+    }
+
+    /// @notice Append a STEP block to execution output by copying its nested input from calldata.
+    function outputCopyStep(Execution memory exec, uint cmd, uint resources, bytes calldata input) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + input.length;
+        uint i = reserve(exec, size);
+        Blocks.copyStep(exec.output, i, cmd, resources, input);
+    }
+
+    /// @notice Append a CALL block to execution output by copying its nested payload from calldata.
+    function outputCopyCall(Execution memory exec, uint target, uint resources, bytes calldata payload) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + payload.length;
+        uint i = reserve(exec, size);
+        Blocks.copyCall(exec.output, i, target, resources, payload);
+    }
+
+    /// @notice Append a RELAY block to execution output by copying its nested input from calldata.
+    function outputCopyRelay(Execution memory exec, uint portal, uint resources, bytes calldata input) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + input.length;
+        uint i = reserve(exec, size);
+        Blocks.copyRelay(exec.output, i, portal, resources, input);
+    }
+
+    /// @notice Append a DISPATCH block to execution output by copying its nested payload from calldata.
+    function outputCopyDispatch(Execution memory exec, uint portal, uint resources, bytes calldata payload) internal pure {
+        uint size = Sizes.B64 + Sizes.Header + payload.length;
+        uint i = reserve(exec, size);
+        Blocks.copyDispatch(exec.output, i, portal, resources, payload);
+    }
+
+    /// @notice Append a CONTEXT block to execution output by copying its nested streams from calldata.
+    function outputCopyContext(
+        Execution memory exec,
+        bytes32 account,
+        bytes calldata state,
+        bytes calldata input
+    ) internal pure {
+        uint size = Sizes.B32 + 2 * Sizes.Header + state.length + input.length;
+        uint i = reserve(exec, size);
+        Blocks.copyContext(exec.output, i, account, state, input);
+    }
+
+    /// @notice Append a RECOVER block to execution output by copying its nested witness from calldata.
+    function outputCopyRecover(
+        Execution memory exec,
+        uint handler,
+        uint resources,
+        bytes32 recoverykey,
+        bytes calldata witness
+    ) internal pure {
+        uint size = Sizes.B96 + Sizes.Header + witness.length;
+        uint i = reserve(exec, size);
+        Blocks.copyRecover(exec.output, i, handler, resources, recoverykey, witness);
+    }
+
     // -------------------------------------------------------------------------
     // Value and transaction writing
     // -------------------------------------------------------------------------

package/guards/Base.sol

@@ -5,7 +5,6 @@ import {InputEndpointBase} from "../core/Endpoint.sol";
 import {GuardianAccess} from "../core/Access.sol";
 import {Specs} from "../codec/Specs.sol";
 import {Nodes} from "../utils/Nodes.sol";
-import {Selectors} from "../utils/Selectors.sol";
 
 /// @title GuardBase
 /// @notice Abstract base for guardian-only direct host actions.
@@ -27,7 +26,7 @@ abstract contract GuardBase is GuardianAccess, InputEndpointBase {
         string memory name,
         uint input
     ) internal returns (uint id, uint descriptor) {
-        id = Nodes.toGuard(Selectors.guard(name), address(this));
+        id = Nodes.toGuard(name, address(this));
         descriptor = endpoint(id, name, Specs.Empty, input, Specs.Empty, 0, 0);
     }
 }

package/package.json

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

package/ports/AllowAssets.sol

@@ -8,10 +8,10 @@ import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortAllowAssets
+/// @title AllowAssetsPort
 /// @notice Port that permits a list of assets on behalf of a peer host.
 /// Each ASSET block in the input calls `allowAsset`. Restricted to trusted peers.
-abstract contract PortAllowAssets is PortBase, AllowAssetsHook {
+abstract contract AllowAssetsPort is PortBase, AllowAssetsHook {
     uint private immutable descriptor;
 
     constructor() {

package/ports/Allowance.sol

@@ -8,11 +8,11 @@ import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortAllowance
+/// @title AllowancePort
 /// @notice Port that lets a trusted peer host input or refresh its own allowance.
 /// Each AMOUNT block in the input 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 {
+abstract contract AllowancePort is PortBase, AllowanceHook {
     uint private immutable descriptor;
 
     constructor() {

package/ports/Base.sol

@@ -6,7 +6,6 @@ import { NodeAccess } from "../core/Access.sol";
 import { Specs } from "../codec/Specs.sol";
 import { InputEndpointBase } from "../core/Endpoint.sol";
 import { Nodes } from "../utils/Nodes.sol";
-import { Selectors } from "../utils/Selectors.sol";
 import { Descriptors } from "../codec/Descriptors.sol";
 
 /// @title PortBase
@@ -56,7 +55,7 @@ abstract contract PortBase is NodeCalls, NodeAccess, InputEndpointBase {
         string memory name,
         uint descriptor
     ) internal returns (uint id, uint published) {
-        id = Nodes.toPort(Selectors.port(name), address(this));
+        id = Nodes.toPort(name, address(this));
         published = endpoint(id, name, descriptor);
     }
 }

package/ports/Credit.sol

@@ -8,10 +8,10 @@ import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortCreditAccount
+/// @title CreditAccountPort
 /// @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 {
+abstract contract CreditAccountPort is PortBase, CreditAccountHook {
     uint private immutable descriptor;
 
     constructor() {

package/ports/Debit.sol

@@ -8,10 +8,10 @@ import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortDebitAccount
+/// @title DebitAccountPort
 /// @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 {
+abstract contract DebitAccountPort is PortBase, DebitAccountHook {
     uint private immutable descriptor;
 
     constructor() {

package/ports/DenyAssets.sol

@@ -8,10 +8,10 @@ import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortDenyAssets
+/// @title DenyAssetsPort
 /// @notice Port that blocks a list of assets on behalf of a peer host.
 /// Each ASSET block in the input calls `denyAsset`. Restricted to trusted peers.
-abstract contract PortDenyAssets is PortBase, DenyAssetsHook {
+abstract contract DenyAssetsPort is PortBase, DenyAssetsHook {
     uint private immutable descriptor;
 
     constructor() {

package/ports/Dispatch.sol

@@ -2,23 +2,34 @@
 pragma solidity ^0.8.33;
 
 import {PortBase} from "./Base.sol";
-import {RelayPayableHook} from "../commands/Relay.sol";
 import {Specs} from "../Codec.sol";
 import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title PortDispatchPayable
-/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined relay hook.
-abstract contract PortDispatchPayable is PortBase, RelayPayableHook {
+/// @notice Hook implemented by hosts that forward funded dispatch payloads.
+abstract contract DispatchPayableHook {
+    /// @notice Override to dispatch an encoded payload to `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 funds Execution used for source value available for transport fees
+    /// and destination resource funding.
+    function dispatchTo(uint portal, uint resources, bytes memory payload, Execution memory funds) internal virtual;
+}
+
+/// @title DispatchPayablePort
+/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined dispatch hook.
+abstract contract DispatchPayablePort is PortBase, DispatchPayableHook {
     uint private immutable descriptor;
 
     constructor() {
         (, descriptor) = port("portDispatchPayable", Specs.Dispatch, Specs.Empty, true);
     }
 
-    /// @notice Forward peer-supplied dispatches to the host-defined relay hook.
-    /// @dev Relay hooks receive the shared top-level source value
+    /// @notice Forward peer-supplied dispatches to the host-defined dispatch hook.
+    /// @dev Dispatch 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 Empty response bytes.
@@ -27,7 +38,7 @@ abstract contract PortDispatchPayable is PortBase, RelayPayableHook {
 
         while (exec.more()) {
             (uint portal, uint resources, bytes calldata payload) = exec.unpackDispatch(Lanes.Input);
-            relayTo(portal, resources, bytes(payload), exec);
+            dispatchTo(portal, resources, payload, exec);
         }
         
         return "";

package/ports/Pipe.sol

@@ -9,10 +9,10 @@ import {Budget} from "../execution/Budget.sol";
 
 using Executions for Execution;
 
-/// @title PortPipePayable
+/// @title PipePayablePort
 /// @notice Port that consumes CONTEXT blocks and executes each input as a step stream.
 /// Each context's input bytes are passed to the shared pipeline.
-abstract contract PortPipePayable is PortBase, Pipeline {
+abstract contract PipePayablePort is PortBase, Pipeline {
     uint private immutable descriptor;
 
     constructor() {