@rootzero/contracts 1.15.0 → 1.16.0

package/commands/admin/Dismiss.sol

@@ -22,10 +22,10 @@ abstract contract Dismiss is GuardianAccess, AdminBase {
     /// @return Empty transaction stream.
     function dismiss(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             bytes32 guardian = exec.unpackAccount(Lanes.Input);

package/commands/admin/Execute.sol

@@ -24,14 +24,14 @@ abstract contract ExecutePayable is RawNodeCalls, AdminBase {
     /// @return Remaining native value as a refund transaction stream.
     function executePayable(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external payable onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             (uint target, uint resources, bytes calldata data) = exec.unpackCall(Lanes.Input);
-            rawCall(target, exec.useValue(resources), data);
+            rawCall(target, exec.useResourceValue(resources), data);
         }
 
         return close(exec, account);

package/commands/admin/Unauthorize.sol

@@ -27,10 +27,10 @@ abstract contract Unauthorize is AdminBase {
     /// @return Empty transaction stream.
     function unauthorize(
         bytes32 account,
-        bytes calldata,
+        bytes calldata state,
         bytes calldata input
     ) external onlyAdmin(account) returns (bytes memory, bytes memory) {
-        Execution memory exec = openInput(input, descriptor, 0);
+        Execution memory exec = openCommand(state, input, descriptor, 0);
 
         while (exec.more()) {
             uint node = exec.unpackNode(Lanes.Input);

package/core/Endpoint.sol

@@ -43,19 +43,6 @@ abstract contract EndpointBase is EndpointEvent, Label, Schema {
         return descriptor;
     }
 
-    /// @notice Open an endpoint input stream with an expected batch count.
-    /// @param source Input block stream to open.
-    /// @param descriptor Packed endpoint descriptor.
-    /// @param batches Required batch count, or zero to accept the input count.
-    /// @return exec Execution with its output buffer metadata initialized for the input batch count.
-    function openInput(
-        bytes calldata source,
-        uint descriptor,
-        uint batches
-    ) internal view returns (Execution memory exec) {
-        return Executions.openInput(source, descriptor, batches);
-    }
-
     /// @notice Finalize an execution output and return its encoded block stream.
     /// @param exec Completed endpoint execution.
     /// @return Encoded output block stream.
@@ -63,3 +50,18 @@ abstract contract EndpointBase is EndpointEvent, Label, Schema {
         return Executions.finish(exec);
     }
 }
+
+/// @title InputEndpointBase
+/// @notice Shared input opening for endpoint families that have only an input lane.
+/// Commands intentionally do not inherit this base because they must open state
+/// and input together through `openCommand`.
+abstract contract InputEndpointBase is EndpointBase {
+    /// @notice Open an endpoint input stream with an expected batch count.
+    function openInput(
+        bytes calldata input,
+        uint descriptor,
+        uint batches
+    ) internal view returns (Execution memory exec) {
+        return Executions.openInput(input, descriptor, batches);
+    }
+}

package/core/Pipeline.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {Decoders, Cur, Readers, Reader} from "../Codec.sol";
-import {Settlement} from "./Settlement.sol";
+import {PostHook} from "./Settlement.sol";
 import {Budget, Budgets} from "../execution/Budget.sol";
 
 using Decoders for Cur;
@@ -11,14 +11,14 @@ using Budgets for Budget;
 
 /// @title Pipeline
 /// @notice Core pipeline functionality shared by higher-level surfaces.
-abstract contract Pipeline is Settlement {
+abstract contract Pipeline is PostHook {
     /// @dev Thrown when the pipeline finishes with non-empty threaded state.
     error UnexpectedState();
 
     /// @notice Override to dispatch one piped step.
     /// Called once per STEP block. The returned state becomes the state passed to
     /// the next step, and the final returned state must be empty. Returned
-    /// transactions are decoded and passed individually to `settle` before the next step runs.
+    /// transactions are decoded and passed individually to `post` before the next step runs.
     /// @param cmd Command node ID to invoke or handle.
     /// @param account Account identifier for the piped context.
     /// @param state Current threaded state block stream.
@@ -42,16 +42,16 @@ abstract contract Pipeline is Settlement {
     /// @param steps STEP block stream to execute.
     /// @param budget Mutable native-value budget shared across all steps.
     function pipe(bytes32 account, bytes memory state, bytes calldata steps, Budget memory budget) internal {
-        Cur memory cur = Decoders.open(steps, 1);
+        Cur memory cur = Decoders.open(steps);
 
         while (cur.more()) {
             (uint cmd, uint resources, bytes calldata input) = cur.unpackStep();
             Reader memory txs;
-            (state, txs.source) = dispatch(cmd, account, state, input, budget.use(resources));
+            (state, txs.source) = dispatch(cmd, account, state, input, budget.useResourceValue(resources));
 
             while (txs.more()) {
                 (bytes32 from, bytes32 to, bytes32 asset, uint amount) = txs.unpackTransaction();
-                settle(from, to, asset, amount);
+                post(from, to, asset, amount);
             }
         }
 

package/core/Settlement.sol

@@ -21,19 +21,48 @@ abstract contract CreditAccountHook {
     function creditAccount(bytes32 account, bytes32 asset, uint amount) internal virtual;
 }
 
+/// @title PostHook
+/// @notice Hook for posting one transaction between accounts.
+abstract contract PostHook {
+    /// @notice Override to post one transaction.
+    function post(bytes32 from, bytes32 to, bytes32 asset, uint amount) internal virtual;
+}
+
+/// @title SettleHook
+/// @notice Hook for settling one asset-liability position.
+abstract contract SettleHook {
+    /// @notice Override to settle one position for `account`.
+    function settle(
+        bytes32 account,
+        bytes32 asset,
+        uint amount,
+        bytes32 liability,
+        uint debt
+    ) internal virtual;
+}
+
 /// @title Settlement
-/// @notice Settles decoded transactions through debit and credit account hooks.
-abstract contract Settlement is DebitAccountHook, CreditAccountHook {
-    /// @notice Settle one transaction by debiting its source and crediting its destination.
+/// @notice Default account-hook implementation for transaction posting and position settlement.
+abstract contract Settlement is PostHook, SettleHook, DebitAccountHook, CreditAccountHook {
+    /// @notice Post one transaction by debiting its source and crediting its destination.
     /// Returns without calling either hook when `amount` is zero and skips either
     /// operation when the corresponding account is zero.
-    /// @param from Source account identifier.
-    /// @param to Destination account identifier.
-    /// @param asset Asset identifier.
-    /// @param amount Token amount.
-    function settle(bytes32 from, bytes32 to, bytes32 asset, uint amount) internal {
+    function post(bytes32 from, bytes32 to, bytes32 asset, uint amount) internal virtual override {
         if (amount == 0) return;
         if (from != 0) debitAccount(from, asset, amount);
         if (to != 0) creditAccount(to, asset, amount);
     }
+
+    /// @notice Settle one position by crediting its asset and debiting its liability.
+    /// Skips either operation when its corresponding amount is zero.
+    function settle(
+        bytes32 account,
+        bytes32 asset,
+        uint amount,
+        bytes32 liability,
+        uint debt
+    ) internal virtual override {
+        if (amount != 0) creditAccount(account, asset, amount);
+        if (debt != 0) debitAccount(account, liability, debt);
+    }
 }

package/core/Types.sol

@@ -59,7 +59,19 @@ struct HostAccountAmount {
     uint amount;
 }
 
-/// @notice Transfer payload used by transaction blocks and peer settlement.
+/// @notice Asset and liability pair threaded as live pipeline state.
+struct Position {
+    /// @dev Identifier for the asset side.
+    bytes32 asset;
+    /// @dev Quantity on the asset side.
+    uint amount;
+    /// @dev Identifier for the liability side.
+    bytes32 liability;
+    /// @dev Quantity owed on the liability side.
+    uint debt;
+}
+
+/// @notice Transfer payload used by transaction blocks and peer posting.
 struct Tx {
     /// @dev Sender account identifier.
     bytes32 from;

package/docs/Schema.md

@@ -161,8 +161,58 @@ with no payload, use a zero-payload block such as `#unit`.
 
 Endpoint descriptors currently use a narrower convention than the full block
 grammar: each state, input, or output lane is a single run of blocks, without
-additional global items. Future protocol surfaces may use the more flexible
-top-level structure.
+additional global items. Endpoint decoder opening requires that run to consume
+the complete supplied lane; a trailing block with another key is invalid.
+Lower-level cursor scanning may still intentionally open only a prefix run.
+Those lower layers retain only the raw block count; descriptor strides are
+applied and lane groups reconciled once when an endpoint execution opens.
+Future protocol surfaces may use the more flexible top-level structure.
+
+For commands, complete-lane validation is also a state-safety rule. State is a
+linear value owned by the current pipeline step, not optional context that a
+command may disregard. Every command must account for the complete supplied
+state by consuming it, transforming and returning it, forwarding it intact, or
+reverting. A command whose descriptor declares an empty state lane must reject
+non-empty state. A command that accepts state must validate the complete stream
+against its declared schema; accepting only a prefix and silently dropping the
+remainder is invalid.
+
+## Live Pipeline State
+
+`#balance`, `#custody`, and `#position` are live state carried between command
+steps for the active account. A position atomically pairs an asset side with a
+liability side:
+
+```txt
+position { bytes32 asset, uint amount, bytes32 liability, uint debt }
+```
+
+The pair is deliberately general. The asset side represents value acquired or
+controlled, and the liability side represents value owed or required. Commands
+may preserve or replace either side and return a new position. The terminal
+`settle` command consumes the pair. Position state is transient protocol state;
+rewriting it does not by itself create, discharge, or replace an obligation
+persisted by a host or external protocol. The responsible command hook must
+perform or verify those effects. A command must not ignore a supplied position:
+it must explicitly consume, transform, forward, or reject it, so neither its
+asset nor its debt can disappear accidentally.
+
+This representation supports ordinary forward transformations as well as
+backward composition. For example, an exact-output route can carry its desired
+asset while successive hops replace the upstream liability:
+
+```txt
+position(C, 100, C, 100)
+→ position(C, 100, B, 50)
+→ position(C, 100, A, 25)
+→ settle
+```
+
+“Backward” describes how requirements are composed from the desired result
+toward the source. Pipeline execution is not reversed: STEP blocks always run
+forward in their encoded order. Exact-output routing is only an example;
+borrowing, refinancing, collateral transformation, callback obligations,
+cross-host claims, fees, and netting can use the same position state.
 
 ## Field Aliases
 

package/execution/Budget.sol

@@ -19,15 +19,23 @@ library Budgets {
         budget.remaining = msg.value;
     }
 
+    /// @notice Deduct an exact native value from `budget`.
+    /// @param budget Mutable budget to debit.
+    /// @param value Native value to consume in wei.
+    /// @return The consumed native value.
+    function useValue(Budget memory budget, uint value) internal pure returns (uint) {
+        if (value > budget.remaining) revert InsufficientValue();
+        budget.remaining -= value;
+        return value;
+    }
+
     /// @notice Deduct the EVM value lane of `resources` from `budget`.
     /// @dev EVM resources use the low 128 bits as native value/endowment.
     /// @param budget Mutable budget to debit.
     /// @param resources Packed resources whose low 128 bits contain native value.
     /// @return value Native value to forward in wei.
-    function use(Budget memory budget, uint resources) internal pure returns (uint128 value) {
-        value = uint128(resources);
-        if (value > budget.remaining) revert InsufficientValue();
-        budget.remaining -= value;
+    function useResourceValue(Budget memory budget, uint resources) internal pure returns (uint128) {
+        return uint128(useValue(budget, uint128(resources)));
     }
 
     /// @notice Remove and return all remaining value from `budget`.

package/execution/Execution.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {AssetAmount, AccountAsset, AccountAmount, HostAmount, HostAccountAsset, Tx} from "../core/Types.sol";
+import {AssetAmount, AccountAsset, AccountAmount, HostAmount, HostAccountAsset, Position, Tx} from "../core/Types.sol";
 import {Blocks} from "../codec/Blocks.sol";
 import {Buffers} from "../codec/Buffers.sol";
 import {Sizes, Specs} from "../codec/Specs.sol";
@@ -9,6 +9,7 @@ import {Descriptors} from "../codec/Descriptors.sol";
 import {Cursors, Cur} from "../utils/Cursors.sol";
 import {Lanes} from "../utils/Lanes.sol";
 import {Budget} from "./Budget.sol";
+import {max16} from "../utils/Utils.sol";
 
 /// @notice Mutable state shared across one endpoint execution.
 /// @dev `decoders` contains tagged input and state cursor lanes. Cursor operations
@@ -28,6 +29,10 @@ library Executions {
 
     /// @dev Thrown when an execution attempts to spend more value than remains in its budget.
     error InsufficientValue();
+    /// @dev Decoder block counts do not form compatible descriptor groups.
+    error BadRatio();
+    /// @dev A descriptor-empty lane received a non-empty block source.
+    error ZeroStride();
 
     // -------------------------------------------------------------------------
     // Opening
@@ -37,15 +42,39 @@ library Executions {
     /// @param source Calldata source for the decoder lane.
     /// @param descriptor Packed endpoint descriptor.
     /// @param lane Input or state lane identifier.
-    /// @return cur Tagged packed decoder cursor, or zero for an absent lane.
+    /// @return cur Tagged packed decoder cursor carrying its raw block count, or zero for an absent lane.
     function openDecoder(bytes calldata source, uint descriptor, uint8 lane) private pure returns (uint cur) {
         uint stride = Descriptors.stride(descriptor, lane);
         (uint abs, uint limit) = Cursors.bounds(source);
         if (stride == 0 && abs == limit) return 0;
+        if (stride == 0) revert ZeroStride();
 
-        bytes4 key = bytes4(source);
-        (uint groups, uint end) = Blocks.scope(abs, limit, key, stride);
-        cur = Cursors.create(abs, end - abs, groups, 0, lane);
+        bytes4 key = Descriptors.key(descriptor, lane);
+        (uint count, uint end) = Blocks.runExact(abs, limit, key);
+        if (count == 0) revert Blocks.EmptyRun();
+        cur = Cursors.create(abs, end - abs, count, 0, lane);
+    }
+
+    /// @dev Convert one decoder lane's raw block count into descriptor groups.
+    function groupCount(uint decoders, uint descriptor, uint8 lane) private pure returns (uint groups) {
+        uint stride = Descriptors.stride(descriptor, lane);
+        if (stride == 0) return 0;
+
+        uint count = decoders.select(lane).count();
+        if (count % stride != 0) revert BadRatio();
+        groups = count / stride;
+    }
+
+    /// @dev Reconcile decoder lane groups once at endpoint execution opening.
+    function reconcile(uint decoders, uint descriptor, uint expected) private pure returns (uint groups) {
+        uint input = groupCount(decoders, descriptor, Lanes.Input);
+        uint state = groupCount(decoders, descriptor, Lanes.State);
+        if (input != 0 && state != 0 && input != state) revert BadRatio();
+
+        groups = input != 0 ? input : state;
+        if (groups != 0 && expected != 0 && groups != expected) revert BadRatio();
+        if (groups == 0) groups = expected;
+        max16(groups);
     }
 
     /// @dev Initialize one tagged writer cursor from a descriptor lane.
@@ -58,7 +87,9 @@ library Executions {
         (uint capacity, bool growable) = Descriptors.allocation(descriptor, lane, batches);
         if (capacity == 0) return 0;
 
-        cur = Buffers.cursor(capacity + padding, batches, growable, lane);
+        uint count = batches * Descriptors.stride(descriptor, lane);
+        if (padding != 0) count += padding / Sizes.Transaction;
+        cur = Buffers.cursor(capacity + padding, count, growable, lane);
     }
 
     /// @dev Open and pair the input and state decoder cursors.
@@ -91,7 +122,7 @@ library Executions {
     function open(uint decoders, uint descriptor, uint batches) private view returns (Execution memory exec) {
         exec.budget = msg.value;
         exec.decoders = decoders;
-        batches = Cursors.reconcile(decoders, batches);
+        batches = reconcile(decoders, descriptor, batches);
         exec.writers = writerCursors(descriptor, batches);
     }
 
@@ -294,6 +325,24 @@ library Executions {
         (value.asset, value.amount) = unpackBalance(exec, lane);
     }
 
+    /// @notice Decode and consume one POSITION block from `lane`.
+    function unpackPosition(
+        Execution memory exec,
+        uint8 lane
+    ) internal pure returns (bytes32 asset, uint amount, bytes32 liability, uint debt) {
+        uint abs;
+        (exec.decoders, abs) = exec.decoders.consume(lane, Sizes.Position);
+        (asset, amount, liability, debt) = Blocks.unpackPosition(abs);
+    }
+
+    /// @notice Decode one POSITION block into its structured value.
+    function unpackPositionValue(
+        Execution memory exec,
+        uint8 lane
+    ) internal pure returns (Position memory value) {
+        (value.asset, value.amount, value.liability, value.debt) = unpackPosition(exec, lane);
+    }
+
     /// @notice Decode one BALANCE block and associate it with `host`.
     /// @param exec Execution whose decoder is advanced.
     /// @param lane Decoder lane to consume.
@@ -730,6 +779,23 @@ library Executions {
         outputBalance(exec, value.asset, value.amount);
     }
 
+    /// @notice Append a POSITION block to execution output.
+    function outputPosition(
+        Execution memory exec,
+        bytes32 asset,
+        uint amount,
+        bytes32 liability,
+        uint debt
+    ) internal pure {
+        uint i = reserve(exec, Sizes.Position);
+        Blocks.writePosition(exec.output, i, asset, amount, liability, debt);
+    }
+
+    /// @notice Append a structured POSITION value to execution output.
+    function outputPosition(Execution memory exec, Position memory value) internal pure {
+        outputPosition(exec, value.asset, value.amount, value.liability, value.debt);
+    }
+
     /// @notice Append an ACCOUNT_ASSET block to execution output.
     /// @param exec Execution receiving the block.
     /// @param account Account identifier to encode.
@@ -1010,15 +1076,23 @@ library Executions {
         exec.budget = 0;
     }
 
+    /// @notice Deduct an exact native value from the execution budget.
+    /// @param exec Mutable execution whose budget is charged.
+    /// @param value Native value to consume in wei.
+    /// @return The consumed native value.
+    function useValue(Execution memory exec, uint value) internal pure returns (uint) {
+        if (value > exec.budget) revert InsufficientValue();
+        exec.budget -= value;
+        return value;
+    }
+
     /// @notice Deduct the EVM value lane of `resources` from the execution budget.
     /// @dev EVM resources use the low 128 bits as native value/endowment.
     /// @param exec Mutable execution whose budget is charged.
     /// @param resources Packed resources whose value lane should be spent.
     /// @return value Native value to forward in wei.
-    function useValue(Execution memory exec, uint resources) internal pure returns (uint128 value) {
-        value = uint128(resources);
-        if (value > exec.budget) revert InsufficientValue();
-        exec.budget -= value;
+    function useResourceValue(Execution memory exec, uint resources) internal pure returns (uint128) {
+        return uint128(useValue(exec, uint128(resources)));
     }
 
     /// @notice Append a deferred transaction to the transaction writer lane.

package/guards/Base.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {EndpointBase} from "../core/Endpoint.sol";
+import {InputEndpointBase} from "../core/Endpoint.sol";
 import {GuardianAccess} from "../core/Access.sol";
 import {Specs} from "../codec/Specs.sol";
 import {Nodes} from "../utils/Nodes.sol";
@@ -10,7 +10,7 @@ import {Selectors} from "../utils/Selectors.sol";
 /// @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.
-abstract contract GuardBase is GuardianAccess, EndpointBase {
+abstract contract GuardBase is GuardianAccess, InputEndpointBase {
     /// @dev Restrict execution to active guardian addresses.
     modifier onlyGuardian() {
         enforceGuardian(msg.sender);

package/package.json

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

package/ports/Base.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.33;
 import { NodeCalls } from "../core/Calls.sol";
 import { NodeAccess } from "../core/Access.sol";
 import { Specs } from "../codec/Specs.sol";
-import { EndpointBase } from "../core/Endpoint.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";
@@ -13,7 +13,7 @@ import { Descriptors } from "../codec/Descriptors.sol";
 /// @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, NodeAccess, EndpointBase {
+abstract contract PortBase is NodeCalls, NodeAccess, InputEndpointBase {
 
     /// @dev Restrict execution to trusted callers, excluding the commander.
     modifier onlyPeer() {

package/ports/Dispatch.sol

@@ -2,23 +2,23 @@
 pragma solidity ^0.8.33;
 
 import {PortBase} from "./Base.sol";
-import {RoutePayableHook} from "../commands/Relay.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 route hook.
-abstract contract PortDispatchPayable is PortBase, RoutePayableHook {
+/// @notice Port endpoint that forwards DISPATCH blocks to a host-defined relay hook.
+abstract contract PortDispatchPayable is PortBase, RelayPayableHook {
     uint private immutable descriptor;
 
     constructor() {
         (, descriptor) = port("portDispatchPayable", Specs.Dispatch, Specs.Empty, true);
     }
 
-    /// @notice Forward peer-supplied dispatches to the host-defined route hook.
-    /// @dev Route hooks receive the shared top-level source value
+    /// @notice Forward peer-supplied dispatches to the host-defined relay hook.
+    /// @dev Relay 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 +27,7 @@ abstract contract PortDispatchPayable is PortBase, RoutePayableHook {
 
         while (exec.more()) {
             (uint portal, uint resources, bytes calldata payload) = exec.unpackDispatch(Lanes.Input);
-            route(portal, resources, bytes(payload), exec);
+            relayTo(portal, resources, bytes(payload), exec);
         }
         
         return "";

package/ports/{Settle.sol → Post.sol}

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {PortBase} from "./Base.sol";
-import {Settlement} from "../core/Settlement.sol";
+import {PostHook} from "../core/Settlement.sol";
 import {Specs} from "../Codec.sol";
 import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 import {Action} from "../annotations/Action.sol";
@@ -10,29 +10,29 @@ import {Actions} from "../utils/Actions.sol";
 
 using Executions for Execution;
 
-/// @title PortSettle
-/// @notice Port that consumes peer-supplied TRANSACTION blocks through debit and credit hooks.
+/// @title PortPost
+/// @notice Port that posts 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, Settlement, Action {
+abstract contract PortPost is PortBase, PostHook, Action {
     uint private immutable descriptor;
 
     constructor() {
         uint id;
-        (id, descriptor) = port("portSettle", Specs.Transaction, Specs.Empty, false);
-        action(id, Actions.Settle);
+        (id, descriptor) = port("portPost", Specs.Transaction, Specs.Empty, false);
+        action(id, Actions.Post);
     }
 
-    /// @notice Execute the port-settle call.
+    /// @notice Post peer-supplied transactions.
     /// @param data TRANSACTION block stream supplied by the trusted peer.
     /// @return Empty response bytes.
-    function portSettle(bytes calldata data) external onlyPeer returns (bytes memory) {
+    function portPost(bytes calldata data) external onlyPeer returns (bytes memory) {
         Execution memory exec = openInput(data, descriptor, 0);
 
         while (exec.more()) {
             (bytes32 from, bytes32 to, bytes32 asset, uint amount) = exec.unpackTransaction(Lanes.Input);
-            settle(from, to, asset, amount);
+            post(from, to, asset, amount);
         }
-        
+
         return "";
     }
 }

package/queries/Base.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import { EndpointBase } from "../core/Endpoint.sol";
+import { InputEndpointBase } from "../core/Endpoint.sol";
 import { Descriptors } from "../codec/Descriptors.sol";
 import { Specs } from "../codec/Specs.sol";
 import { Nodes } from "../utils/Nodes.sol";
@@ -11,7 +11,7 @@ import { Selectors } from "../utils/Selectors.sol";
 /// @notice Abstract base for rootzero query contracts.
 /// Queries are view-only entry points that consume a block-stream input and
 /// return a block-stream response.
-abstract contract QueryBase is EndpointBase {
+abstract contract QueryBase is InputEndpointBase {
 
     /// @notice Publish query metadata and a default label.
     /// @param name Query entrypoint name and default label. It must exactly

package/utils/Actions.sol

@@ -17,4 +17,5 @@ library Actions {
     uint32 constant Repay = 11;
     uint32 constant Liquidate = 12;
     uint32 constant Refund = 13;
+    uint32 constant Post = 14;
 }