@rootzero/contracts 0.9.9 → 1.0.0

package/commands/admin/Execute.sol

@@ -14,6 +14,7 @@ using Cursors for Cur;
 /// @notice Admin command that forwards raw calldata to one or more target nodes.
 /// Each CALL block specifies a target node ID, native value, and raw calldata payload.
 /// Only callable by the admin account.
+/// Unspent top-level `msg.value` remains on this host.
 abstract contract ExecutePayable is CommandBase, Payable, AdminEvent {
     string private constant NAME = "executePayable";
 
@@ -23,8 +24,11 @@ abstract contract ExecutePayable is CommandBase, Payable, AdminEvent {
         emit Admin(host, executePayableId, NAME, "1:0:0", Schemas.Call, Keys.Empty, Keys.Empty, false, true);
     }
 
+    /// @notice Execute each CALL block in the admin request.
+    /// @param c Admin command context; `c.request` must contain CALL blocks.
+    /// @return Empty output state.
     function executePayable(CommandContext calldata c) external payable onlyAdmin(c.account) returns (bytes memory) {
-        (Cur memory request, ) = Cursors.first(c.request, 1);
+        (Cur memory request, , ) = Cursors.init(c.request, 0, 1);
         Budget memory budget = valueBudget();
 
         while (request.i < request.len) {
@@ -34,7 +38,6 @@ abstract contract ExecutePayable is CommandBase, Payable, AdminEvent {
         }
 
         request.complete();
-        settleValue(c.account, budget);
         return "";
     }
 }

package/commands/admin/Init.sol

@@ -25,11 +25,13 @@ abstract contract Init is CommandBase, AdminEvent, InitHook {
         emit Admin(host, initId, NAME, "1:0:0", input, Keys.Empty, Keys.Empty, false, false);
     }
 
+    /// @notice Run host initialization logic over the full admin request.
+    /// @param c Admin command context; `c.request` is passed through as a cursor.
+    /// @return Empty output state.
     function init(
         CommandContext calldata c
     ) external onlyAdmin(c.account) returns (bytes memory) {
-        Cur memory input = Cursors.open(c.request);
-        init(input);
+        init(Cursors.open(c.request));
         return "";
     }
 }

package/commands/admin/Unauthorize.sol

@@ -19,10 +19,13 @@ abstract contract Unauthorize is CommandBase, AdminEvent {
         emit Admin(host, unauthorizeId, NAME, "1:0:0", Schemas.Node, Keys.Empty, Keys.Empty, false, false);
     }
 
+    /// @notice Unauthorize each NODE block in the admin request.
+    /// @param c Admin command context; `c.request` must contain NODE blocks.
+    /// @return Empty output state.
     function unauthorize(
         CommandContext calldata c
     ) external onlyAdmin(c.account) returns (bytes memory) {
-        (Cur memory request, ) = Cursors.first(c.request, 1);
+        (Cur memory request, , ) = Cursors.init(c.request, 0, 1);
 
         while (request.i < request.len) {
             uint node = request.unpackNode();

package/core/Host.sol

@@ -28,7 +28,16 @@ interface IHostIntroduction {
 /// guardian management, the default guardian revoke action, and
 /// optionally introduces itself to a commander host at deployment.
 /// Accepts native ETH payments via the `receive` function.
-abstract contract Host is Authorize, Unauthorize, Revoke, Appoint, Dismiss, ExecutePayable, IntroductionEvent, IHostIntroduction {
+abstract contract Host is
+    Authorize,
+    Unauthorize,
+    Revoke,
+    Appoint,
+    Dismiss,
+    ExecutePayable,
+    IntroductionEvent,
+    IHostIntroduction
+{
     /// @param cmdr Commander address; passed to `AccessControl`.
     ///        If `cmdr` is a deployed contract, the host calls `introduce`
     ///        on it during construction.

package/core/Pipeline.sol

@@ -10,6 +10,7 @@ using Cursors for Cur;
 /// @title Pipeline
 /// @notice Core pipeline functionality shared by higher-level surfaces.
 abstract contract Pipeline is Payable {
+    /// @dev Thrown when the pipeline finishes with non-empty threaded state.
     error UnexpectedState();
 
     /// @notice Override to dispatch one piped step.
@@ -41,7 +42,7 @@ abstract contract Pipeline is Payable {
         bytes calldata steps,
         Budget memory budget
     ) internal {
-        (Cur memory input, ) = Cursors.first(steps, 1);
+        (Cur memory input, , ) = Cursors.init(steps, 0, 1);
 
         while (input.i < input.len) {
             (uint target, uint value, bytes calldata request) = input.unpackStep();

package/core/Runtime.sol

@@ -5,10 +5,10 @@ import {Assets} from "../utils/Assets.sol";
 import {Ids} from "../utils/Ids.sol";
 
 /// @title Runtime
-/// @notice Shared runtime for host identity and native value identity.
+/// @notice Shared runtime for host identity and native asset identity.
 abstract contract Runtime {
     /// @dev This contract's host node ID, set to `Ids.toHost(address(this))` at construction.
     uint public immutable host = Ids.toHost(address(this));
-    /// @dev Asset ID for the native chain value (ETH), bound to the current chain at deployment.
-    bytes32 internal immutable valueAsset = Assets.toValue();
+    /// @dev Asset ID for the native chain coin/token, bound to the current chain at deployment.
+    bytes32 internal immutable nativeAsset = Assets.toNative();
 }

package/events/Admin.sol

@@ -6,19 +6,19 @@ import { EventEmitter } from "./Emitter.sol";
 /// @notice Emitted once per admin command during host deployment to publish its request schema and state keys.
 abstract contract AdminEvent is EventEmitter {
     string private constant ABI =
-        "event Admin(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool checked, bool funded)";
+        "event Admin(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool postcheck, bool funded)";
 
     /// @param host Host node ID that owns this admin command.
     /// @param id Command node ID.
     /// @param name Human-readable command name.
     /// @param shape Per-operation block counts encoded as `request:state:output`.
-    /// The request count covers only the input request run. If `checked` is true,
+    /// The request count covers only the input request run. If `postcheck` is true,
     /// a constraint run follows the input run, or starts the request when `request`
     /// is empty. State globals may follow the state run and are excluded.
     /// @param request Schema DSL string describing the input request run, or empty if none.
-    /// @param state Block key expected for input state, or `Keys.Empty`.
+    /// @param state Block key expected for input state, `Keys.Empty`, or `Keys.Any`.
     /// @param output Block key produced for output state, or `Keys.Empty`.
-    /// @param checked Whether a constraint block run is expected to exist in the request.
+    /// @param postcheck Whether command output is validated after execution.
     /// @param funded Whether the command entrypoint accepts nonzero `msg.value`.
     event Admin(
         uint indexed host,
@@ -28,7 +28,7 @@ abstract contract AdminEvent is EventEmitter {
         string request,
         bytes4 state,
         bytes4 output,
-        bool checked,
+        bool postcheck,
         bool funded
     );
 

package/events/Chain.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 chain/domain node is announced.
+abstract contract ChainEvent is EventEmitter {
+    string private constant ABI = "event Chain(uint indexed chain, bytes32 native, uint commander, bytes32 admin, string name)";
+
+    /// @param chain Chain node ID.
+    /// @param native Native asset ID for the chain.
+    /// @param commander Commander host node ID for the chain.
+    /// @param admin Admin account for the commander host on the chain.
+    /// @param name Chain or domain name.
+    event Chain(uint indexed chain, bytes32 native, uint commander, bytes32 admin, string name);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}

package/events/Command.sol

@@ -6,19 +6,19 @@ import { EventEmitter } from "./Emitter.sol";
 /// @notice Emitted once per command during host deployment to publish its request schema and state keys.
 abstract contract CommandEvent is EventEmitter {
     string private constant ABI =
-        "event Command(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool checked, bool funded)";
+        "event Command(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool postcheck, bool funded)";
 
     /// @param host Host node ID that owns this command.
     /// @param id Command node ID.
     /// @param name Human-readable command name.
     /// @param shape Per-operation block counts encoded as `request:state:output`.
-    /// The request count covers only the input request run. If `checked` is true,
+    /// The request count covers only the input request run. If `postcheck` is true,
     /// a constraint run follows the input run, or starts the request when `request`
     /// is empty. State globals may follow the state run and are excluded.
     /// @param request Schema string describing the input request run, or empty if none.
-    /// @param state Block key expected for input state, or `Keys.Empty`.
+    /// @param state Block key expected for input state, `Keys.Empty`, or `Keys.Any`.
     /// @param output Block key produced for output state, or `Keys.Empty`.
-    /// @param checked Whether a constraint block run is expected to exist in the request.
+    /// @param postcheck Whether command output is validated after execution.
     /// @param funded Whether the command entrypoint accepts nonzero `msg.value`.
     event Command(
         uint indexed host,
@@ -28,7 +28,7 @@ abstract contract CommandEvent is EventEmitter {
         string request,
         bytes4 state,
         bytes4 output,
-        bool checked,
+        bool postcheck,
         bool funded
     );
 

package/guards/Revoke.sol

@@ -19,7 +19,7 @@ abstract contract Revoke is GuardBase {
     }
 
     function revoke(bytes calldata request) external onlyGuardian {
-        (Cur memory input, ) = Cursors.first(request, 1);
+        (Cur memory input, , ) = Cursors.init(request, 0, 1);
 
         while (input.i < input.len) {
             uint node = input.unpackNode();

package/package.json

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

package/peer/AllowAssets.sol

@@ -19,8 +19,10 @@ abstract contract PeerAllowAssets is PeerBase, AllowAssetsHook {
     }
 
     /// @notice Execute the allow-assets peer call.
+    /// @param request ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
     function peerAllowAssets(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory assets, ) = Cursors.first(request, 1);
+        (Cur memory assets, , ) = Cursors.init(request, 0, 1);
 
         while (assets.i < assets.len) {
             (bytes32 asset, bytes32 meta) = assets.unpackAsset();

package/peer/Allowance.sol

@@ -20,8 +20,10 @@ abstract contract PeerAllowance is PeerBase, AllowanceHook {
     }
 
     /// @notice Execute the allowance peer call.
+    /// @param request AMOUNT block stream requested by the trusted peer.
+    /// @return Empty response bytes.
     function peerAllowance(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory amounts, ) = Cursors.first(request, 1);
+        (Cur memory amounts, , ) = Cursors.init(request, 0, 1);
         uint peer = caller();
 
         while (amounts.i < amounts.len) {

package/peer/BalancePull.sol

@@ -28,8 +28,10 @@ abstract contract PeerBalancePull is PeerBase, BalancePullHook {
     }
 
     /// @notice Execute the balance-pull peer call.
+    /// @param request BALANCE block stream requested by the trusted peer.
+    /// @return Empty response bytes.
     function peerBalancePull(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory input, ) = Cursors.first(request, 1);
+        (Cur memory input, , ) = Cursors.init(request, 0, 1);
         uint peer = caller();
 
         while (input.i < input.len) {

package/peer/DenyAssets.sol

@@ -19,8 +19,10 @@ abstract contract PeerDenyAssets is PeerBase, DenyAssetsHook {
     }
 
     /// @notice Execute the deny-assets peer call.
+    /// @param request ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
     function peerDenyAssets(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory assets, ) = Cursors.first(request, 1);
+        (Cur memory assets, , ) = Cursors.init(request, 0, 1);
 
         while (assets.i < assets.len) {
             (bytes32 asset, bytes32 meta) = assets.unpackAsset();

package/peer/Dispatch.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PeerBase } from "./Base.sol";
+import { Payable } from "../core/Payable.sol";
+import { Cursors, Cur, Schemas } from "../Cursors.sol";
+import { Budget } from "../utils/Value.sol";
+
+using Cursors for Cur;
+
+abstract contract PeerDispatchPayableHook {
+    /// @notice Override to dispatch an already encoded payload to `chain`.
+    /// @param chain Destination chain node ID.
+    /// @param endowment Native value requested for the destination dispatch. The
+    /// hook decides how much source-chain budget must be spent to fund this
+    /// value on the destination chain.
+    /// @param payload Encoded payload ready for the transport layer.
+    /// @param budget Source-chain native-value budget available for transport
+    /// fees and destination endowment funding.
+    function dispatch(uint chain, uint endowment, bytes calldata payload, Budget memory budget) internal virtual;
+}
+
+/// @title PeerDispatchPayable
+/// @notice Peer endpoint that forwards DISPATCH blocks to a host-defined dispatch hook.
+abstract contract PeerDispatchPayable is PeerBase, Payable, PeerDispatchPayableHook {
+    string private constant NAME = "peerDispatchPayable";
+    uint internal immutable peerDispatchPayableId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerDispatchPayableId, NAME, "1:0", Schemas.Dispatch, "", true);
+    }
+
+    /// @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.
+    /// @return output Empty response bytes.
+    function peerDispatchPayable(bytes calldata request) external payable onlyPeer returns (bytes memory output) {
+        (Cur memory input, , ) = Cursors.init(request, 0, 1);
+        Budget memory budget = valueBudget();
+
+        while (input.i < input.len) {
+            (uint chain, uint endowment, bytes calldata payload) = input.unpackDispatch();
+            dispatch(chain, endowment, payload, budget);
+        }
+
+        input.complete();
+        return "";
+    }
+
+}

package/peer/Pipe.sol

@@ -9,9 +9,9 @@ import {Budget} from "../utils/Value.sol";
 using Cursors for Cur;
 
 /// @title PeerPipePayable
-/// @notice Peer that consumes PIPE blocks and executes each context request as a STEP stream.
+/// @notice Peer that consumes PIPE blocks and executes each context step stream.
 /// Each PIPE block carries a value budget plus a CONTEXT block; the nested
-/// context request is passed to the shared pipeline as the step stream.
+/// context steps are passed to the shared pipeline as the step stream.
 abstract contract PeerPipePayable is PeerBase, Pipeline {
     string private constant NAME = "peerPipePayable";
     uint internal immutable peerPipePayableId = peerId(NAME);
@@ -23,8 +23,10 @@ abstract contract PeerPipePayable is PeerBase, Pipeline {
     /// @notice Execute peer-supplied pipes through the shared payable pipe.
     /// @dev Each pipe receives its own explicit value sub-budget. Any top-level
     ///      `msg.value` not assigned to a pipe remains on this host.
+    /// @param request PIPE block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
     function peerPipePayable(bytes calldata request) external payable onlyPeer returns (bytes memory) {
-        (Cur memory input, ) = Cursors.first(request, 1);
+        (Cur memory input, , ) = Cursors.init(request, 0, 1);
         Budget memory budget = valueBudget();
 
         while (input.i < input.len) {

package/peer/Settle.sol

@@ -20,8 +20,10 @@ abstract contract PeerSettle is PeerBase, DebitAccountHook, CreditAccountHook {
     }
 
     /// @notice Execute the peer-settle call.
+    /// @param request TRANSACTION block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
     function peerSettle(bytes calldata request) external onlyPeer returns (bytes memory) {
-        (Cur memory state, ) = Cursors.first(request, 1);
+        (Cur memory state, , ) = Cursors.init(request, 0, 1);
 
         while (state.i < state.len) {
             (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount) = state.unpackTransaction();

package/queries/Assets.sol

@@ -33,7 +33,7 @@ abstract contract AssetStatus is QueryBase, AssetStatusHook {
     /// @param request Block-stream request consisting of `#asset { bytes32 asset, bytes32 meta }` blocks.
     /// @return Block-stream response containing one `#status { uint code }` per asset block.
     function assetStatus(bytes calldata request) external view returns (bytes memory) {
-        (Cur memory query, uint groups) = Cursors.first(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocStatuses(groups);
 
         while (query.i < query.len) {

package/queries/Balances.sol

@@ -33,7 +33,7 @@ abstract contract GetBalances is QueryBase, GetBalancesHook {
     /// @param request Block-stream request consisting of `accountAsset(account, asset, meta)*`.
     /// @return Block-stream response containing one `accountAmount(account, asset, meta, amount)` block per request block.
     function getBalances(bytes calldata request) external view returns (bytes memory) {
-        (Cur memory query, uint groups) = Cursors.first(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocAccountAmounts(groups);
 
         while (query.i < query.len) {

package/queries/Positions.sol

@@ -42,7 +42,7 @@ abstract contract GetPosition is QueryBase, GetPositionHook {
     /// @param request Block-stream request consisting of `accountAsset(account, asset, meta)*`.
     /// @return Block-stream response containing one output-schema block per position block.
     function getPosition(bytes calldata request) external view returns (bytes memory) {
-        (Cur memory query, uint groups) = Cursors.first(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocAny(groups);
 
         while (query.i < query.len) {

package/utils/Accounts.sol

@@ -23,8 +23,6 @@ library Accounts {
     uint32 constant Guardian = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Account) << 8) | uint32(Layout.Guardian);
     /// @dev Full 4-byte type prefix for user accounts (chain-agnostic EVM address).
     uint32 constant User = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Account) << 8) | uint32(Layout.User);
-    /// @dev Full 4-byte type prefix for keccak accounts (opaque 28-byte hash).
-    uint32 constant Keccak = (uint32(Layout.Opaque32) << 16) | (uint32(Layout.Account) << 8) | uint32(Layout.Keccak);
 
     /// @notice Extract the 4-byte type prefix from an account ID.
     /// @param account Account identifier.
@@ -53,14 +51,10 @@ library Accounts {
         return prefix(account) == User;
     }
 
-    function isKeccak(bytes32 account) internal pure returns (bool) {
-        return prefix(account) == Keccak;
-    }
-
     /// @notice Assert that `input` is an account and return it unchanged.
     /// @param input Account identifier to validate.
     /// @return account The same `input` if it is an account.
-    function any(bytes32 input) internal pure returns (bytes32 account) {
+    function ensure(bytes32 input) internal pure returns (bytes32 account) {
         if (!isAccount(input)) revert InvalidAccount();
         return input;
     }
@@ -89,14 +83,6 @@ library Accounts {
         return input;
     }
 
-    /// @notice Assert that `input` is a keccak account and return it unchanged.
-    /// @param input Account identifier to validate.
-    /// @return account The same `input` if it is a keccak account.
-    function keccak(bytes32 input) internal pure returns (bytes32 account) {
-        if (!isKeccak(input)) revert InvalidAccount();
-        return input;
-    }
-
     /// @notice Encode an EVM address as a chain-local admin account ID.
     /// @param addr EVM address to embed.
     /// @return Admin account ID bound to the current chain.
@@ -118,25 +104,6 @@ library Accounts {
         return bytes32(toUnspecifiedBase(User) | (uint(uint160(addr)) << 32));
     }
 
-    function toKeccak(bytes32 head, bytes32 meta) internal pure returns (bytes32) {
-        return bytes32(toUnspecifiedBase(Keccak) | uint224(uint256(keccak256(bytes.concat(head, meta)))));
-    }
-
-    function matchesKeccak(bytes32 account, bytes32 head, bytes32 meta) internal pure returns (bool) {
-        return account == toKeccak(head, meta);
-    }
-
-    /// @notice Assert that `account` uses the Account layout tag and return it unchanged.
-    /// Ignores width, chain binding, and subtype details.
-    /// @param account Account ID to validate.
-    /// @return The same `account` value if valid.
-    function ensure(bytes32 account) internal pure returns (bytes32) {
-        if (uint8(uint(account) >> 232) != Layout.Account) {
-            revert InvalidAccount();
-        }
-        return account;
-    }
-
     /// @notice Assert that `account` belongs to the EVM account family and return it unchanged.
     /// @param account Account ID to validate.
     /// @return The same `account` value if valid.

package/utils/Assets.sol

@@ -8,10 +8,10 @@ import {matchesBase, toLocalBase} from "./Utils.sol";
 /// @notice Encoding and decoding helpers for 256-bit asset identifiers.
 ///
 /// Asset IDs embed a 4-byte type tag in bits [255:224]:
-///   - `Value`  — native chain value (ETH); no address payload
-///   - `Erc20`  — ERC-20 token; contract address in bits [191:32]
-///   - `Erc721` — ERC-721 collection; collection address in bits [191:32]
-///   - `Erc1155` — ERC-1155 collection; collection address in bits [191:32]
+///   - `Native` - native chain coin/token; no address payload
+///   - `Erc20` - ERC-20 token; contract address in bits [191:32]
+///   - `Erc721` - ERC-721 collection; collection address in bits [191:32]
+///   - `Erc1155` - ERC-1155 collection; collection address in bits [191:32]
 ///
 /// All asset IDs are chain-local (include `block.chainid` in bits [223:192]).
 library Assets {
@@ -20,8 +20,8 @@ library Assets {
     /// @dev Thrown when an asset is not authorized for the requested operation.
     error UnauthorizedAsset();
 
-    /// @dev Full 4-byte type prefix for the native value asset.
-    uint32 constant Value = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Value);
+    /// @dev Full 4-byte type prefix for the native chain coin/token asset.
+    uint32 constant Native = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Native);
     /// @dev Full 4-byte type prefix for ERC-20 assets.
     uint32 constant Erc20 = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Erc20);
     /// @dev Full 4-byte type prefix for ERC-721 assets.
@@ -34,19 +34,19 @@ library Assets {
         return uint8(uint(asset) >> 232) == Layout.Asset;
     }
 
-    /// @notice Return true if `asset` uses the 32-byte asset layout with no metadata identity (top byte is `0x20`).
+    /// @notice Return true if `asset` uses a 32-byte asset layout with no metadata identity.
     function is32(bytes32 asset) internal pure returns (bool) {
-        return isAsset(asset) && bytes1(asset) == 0x20;
+        return isAsset(asset) && uint8(uint(asset) >> 240) == Layout.Width32;
     }
 
-    /// @notice Return true if `asset` uses the 64-byte asset layout with metadata-backed identity (top byte is `0x40`).
+    /// @notice Return true if `asset` uses a 64-byte asset layout with metadata-backed identity.
     function is64(bytes32 asset) internal pure returns (bool) {
-        return isAsset(asset) && bytes1(asset) == 0x40;
+        return isAsset(asset) && uint8(uint(asset) >> 240) == Layout.Width64;
     }
 
-    /// @notice Return true if `asset` is the local native value asset.
-    function isValue(bytes32 asset) internal view returns (bool) {
-        return asset == toValue();
+    /// @notice Return true if `asset` is the local native chain coin/token asset.
+    function isNative(bytes32 asset) internal view returns (bool) {
+        return asset == toNative();
     }
 
     /// @notice Return true if `asset` is a local ERC-20 asset.
@@ -64,11 +64,11 @@ library Assets {
         return matchesBase(asset, toLocalBase(Erc1155));
     }
 
-    /// @notice Assert that `input` is the local native value asset and return it unchanged.
+    /// @notice Assert that `input` is the local native chain coin/token asset and return it unchanged.
     /// @param input Asset identifier to validate.
-    /// @return asset The same `input` if it is the local native value asset.
-    function value(bytes32 input) internal view returns (bytes32 asset) {
-        if (!isValue(input)) revert InvalidAsset();
+    /// @return asset The same `input` if it is the local native asset.
+    function native(bytes32 input) internal view returns (bytes32 asset) {
+        if (!isNative(input)) revert InvalidAsset();
         return input;
     }
 
@@ -96,10 +96,10 @@ library Assets {
         return input;
     }
 
-    /// @notice Create a chain-local native value asset ID.
+    /// @notice Create a chain-local native coin/token asset ID.
     /// @return Asset ID for the native token on the current chain.
-    function toValue() internal view returns (bytes32) {
-        return bytes32(toLocalBase(Value));
+    function toNative() internal view returns (bytes32) {
+        return bytes32(toLocalBase(Native));
     }
 
     /// @notice Create a chain-local ERC-20 asset ID for `addr`.
@@ -178,7 +178,7 @@ library Assets {
     }
 
     /// @notice Derive a storage slot for an (asset, meta) pair.
-    /// For 32-byte EVM assets (no meta), the slot is the asset ID itself.
+    /// For 32-byte assets (no meta), the slot is the asset ID itself.
     /// For assets with metadata (e.g. ERC-721 or ERC-1155 token IDs), the slot is
     /// `keccak256(asset ++ meta)`.
     /// Reverts only if `asset` is zero.

package/utils/Ids.sol

@@ -18,6 +18,8 @@ library Ids {
 
     /// @dev 24-bit family tag shared by all node types (Evm32 + Node category).
     uint24 constant Node = (uint24(Layout.Evm32) << 8) | uint24(Layout.Node);
+    /// @dev Full 4-byte type prefix for chain/domain nodes.
+    uint32 constant Chain = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Chain);
     /// @dev Full 4-byte type prefix for host nodes.
     uint32 constant Host = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Host);
     /// @dev Full 4-byte type prefix for command nodes.
@@ -56,7 +58,7 @@ library Ids {
 
     /// @notice Return true if `id` is a local node ID for this contract.
     function isLocalNode(uint id) internal view returns (bool) {
-        return isLocalFamily(id, Node) && address(uint160(id)) == address(this);
+        return uint32(id >> 224) != Chain && isLocalFamily(id, Node) && address(uint160(id)) == address(this);
     }
 
     /// @notice Assert that `id` is a command ID and return it unchanged.
@@ -128,6 +130,14 @@ library Ids {
         return id;
     }
 
+    /// @notice Build the chain node ID for the current chain.
+    /// @return Chain node ID with the Chain prefix and `block.chainid` payload.
+    function localChain() internal view returns (uint) {
+        uint id = block.chainid;
+        if (id >> 224 != 0) revert InvalidId();
+        return (uint(Chain) << 224) | id;
+    }
+
     /// @notice Build a chain-local host ID for `target`.
     /// @param target Host contract address.
     /// @return Host node ID on the current chain.
@@ -180,7 +190,7 @@ library Ids {
     /// @param id Node ID (host, command, or peer).
     /// @return Contract address in the lower 160 bits of `id`.
     function nodeAddr(uint id) internal view returns (address) {
-        if (!isLocalFamily(id, Node)) revert InvalidId();
+        if (uint32(id >> 224) == Chain || !isLocalFamily(id, Node)) revert InvalidId();
         return address(uint160(id));
     }