@rootzero/contracts 0.9.8 → 1.0.0

package/peer/Settle.sol

@@ -2,15 +2,16 @@
 pragma solidity ^0.8.33;
 
 import { PeerBase } from "./Base.sol";
-import { TransferHook } from "../commands/Transfer.sol";
+import { CreditAccountHook } from "../commands/Credit.sol";
+import { DebitAccountHook } from "../commands/Debit.sol";
 import { Cursors, Cur, Schemas } from "../Cursors.sol";
 
 using Cursors for Cur;
 
 /// @title PeerSettle
-/// @notice Peer that consumes peer-supplied TRANSACTION blocks through the shared transfer hook.
-/// Each TRANSACTION block in the request calls `transfer(value)`. Restricted to trusted peers.
-abstract contract PeerSettle is PeerBase, TransferHook {
+/// @notice Peer that consumes peer-supplied TRANSACTION blocks through debit and credit hooks.
+/// Each TRANSACTION block calls `debitAccount` for `from` and `creditAccount` for `to`.
+abstract contract PeerSettle is PeerBase, DebitAccountHook, CreditAccountHook {
     string private constant NAME = "peerSettle";
     uint internal immutable peerSettleId = peerId(NAME);
 
@@ -19,14 +20,18 @@ abstract contract PeerSettle is PeerBase, TransferHook {
     }
 
     /// @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, ) = cursor(request, 1);
+        (Cur memory state, , ) = Cursors.init(request, 0, 1);
 
-        while (state.i < state.bound) {
-            transfer(state.unpackTxValue());
+        while (state.i < state.len) {
+            (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount) = state.unpackTransaction();
+            if (from != 0) debitAccount(from, asset, meta, amount);
+            if (to != 0) creditAccount(to, asset, meta, amount);
         }
 
-        state.close();
+        state.complete();
         return "";
     }
 }

package/queries/Assets.sol

@@ -33,16 +33,16 @@ 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) = cursor(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocStatuses(groups);
 
-        while (query.i < query.bound) {
+        while (query.i < query.len) {
             (bytes32 asset, bytes32 meta) = query.unpackAsset();
             uint status = assetStatus(asset, meta);
             response.appendStatus(status);
         }
 
-        query.close();
+        query.complete();
         return response.finish();
     }
 }

package/queries/Balances.sol

@@ -33,16 +33,16 @@ 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) = cursor(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocAccountAmounts(groups);
 
-        while (query.i < query.bound) {
+        while (query.i < query.len) {
             (bytes32 account, bytes32 asset, bytes32 meta) = query.unpackAccountAsset();
             uint amount = getBalance(account, asset, meta);
             response.appendAccountAmount(account, asset, meta, amount);
         }
 
-        query.close();
+        query.complete();
         return response.finish();
     }
 }

package/queries/Positions.sol

@@ -42,15 +42,15 @@ 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) = cursor(request, 1);
+        (Cur memory query, uint groups, ) = Cursors.init(request, 0, 1);
         Writer memory response = Writers.allocAny(groups);
 
-        while (query.i < query.bound) {
+        while (query.i < query.len) {
             (bytes32 account, bytes32 asset, bytes32 meta) = query.unpackAccountAsset();
             appendPosition(account, asset, meta, response);
         }
 
-        query.close();
+        query.complete();
         return response.finish();
     }
 }

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,8 +51,12 @@ 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 ensure(bytes32 input) internal pure returns (bytes32 account) {
+        if (!isAccount(input)) revert InvalidAccount();
+        return input;
     }
 
     /// @notice Assert that `input` is an admin account and return it unchanged.
@@ -81,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.
@@ -110,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/Actions.sol

@@ -4,13 +4,15 @@ pragma solidity ^0.8.33;
 library Actions {
     uint32 constant None = 0;
     uint32 constant Transfer = 1;
-    uint32 constant Deposit = 2;
-    uint32 constant Withdraw = 3;
-    uint32 constant Fee = 4;
-    uint32 constant Mint = 5;
-    uint32 constant Burn = 6;
-    uint32 constant Swap = 7;
-    uint32 constant Borrow = 8;
-    uint32 constant Repay = 9;
-    uint32 constant Liquidate = 10;
+    uint32 constant Payout = 2;
+    uint32 constant Settle = 3;
+    uint32 constant Deposit = 4;
+    uint32 constant Withdraw = 5;
+    uint32 constant Fee = 6;
+    uint32 constant Mint = 7;
+    uint32 constant Burn = 8;
+    uint32 constant Swap = 9;
+    uint32 constant Borrow = 10;
+    uint32 constant Repay = 11;
+    uint32 constant Liquidate = 12;
 }

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));
     }
 

package/utils/Layout.sol

@@ -6,19 +6,24 @@ pragma solidity ^0.8.33;
 /// layout of 256-bit IDs used throughout the rootzero protocol.
 ///
 /// IDs are structured as:
-///   `[uint16 width][uint16 chainId-prefix][uint32 prefix][... payload ...]`
-/// where the top bytes carry nested type tags drawn from the constants below.
+///   `[uint32 type][uint32 chainid][192-bit payload]`
+/// where `type` is `[uint8 vm][uint8 width][uint8 category][uint8 subtype]`.
 library Layout {
     // -------------------------------------------------------------------------
-    // Data-width tags (uint16, top 2 bytes of the ID type field)
+    // VM and data-width tags (top 2 bytes of the ID type field)
     // -------------------------------------------------------------------------
 
-    /// @dev 32-byte opaque value; no EVM address embedded.
-    uint16 constant Opaque32 = 0x2000;
+    /// @dev EVM-compatible value; payloads are built around 20-byte addresses.
+    uint8 constant Evm = 0x01;
+    /// @dev 32-byte ID; no paired metadata word is required.
+    uint8 constant Width32 = 0x20;
+    /// @dev 64-byte ID; a paired metadata word completes the identity.
+    uint8 constant Width64 = 0x40;
+
     /// @dev 32-byte EVM-compatible value; lower 20 bytes hold an address.
-    uint16 constant Evm32 = 0x2001;
+    uint16 constant Evm32 = (uint16(Evm) << 8) | uint16(Width32);
     /// @dev 64-byte EVM-compatible value; used when a paired metadata word completes the identity.
-    uint16 constant Evm64 = 0x4001;
+    uint16 constant Evm64 = (uint16(Evm) << 8) | uint16(Width64);
 
     // -------------------------------------------------------------------------
     // Category tags (uint8, third byte of the ID type field)
@@ -41,30 +46,29 @@ library Layout {
     uint8 constant Guardian = 0x02;
     /// @dev User account — chain-agnostic, backed by an EVM address.
     uint8 constant User = 0x03;
-    /// @dev Keccak account — opaque 28-byte keccak commitment.
-    uint8 constant Keccak = 0x04;
-
     // -------------------------------------------------------------------------
     // Node subtype tags (uint8, fourth byte of the ID type field)
     // -------------------------------------------------------------------------
 
+    /// @dev Node is a chain/domain identifier.
+    uint8 constant Chain = 0x01;
     /// @dev Node is a host contract.
-    uint8 constant Host = 0x01;
+    uint8 constant Host = 0x02;
     /// @dev Node is a command contract.
-    uint8 constant Command = 0x02;
+    uint8 constant Command = 0x03;
     /// @dev Node is a peer contract.
-    uint8 constant Peer = 0x03;
+    uint8 constant Peer = 0x04;
     /// @dev Node is a query contract.
-    uint8 constant Query = 0x04;
+    uint8 constant Query = 0x05;
     /// @dev Node is a guardian-only direct action.
-    uint8 constant Guard = 0x05;
+    uint8 constant Guard = 0x06;
 
     // -------------------------------------------------------------------------
     // Asset subtype tags (uint8, fourth byte of the ID type field)
     // -------------------------------------------------------------------------
 
-    /// @dev Native chain value asset (ETH / native token).
-    uint8 constant Value = 0x01;
+    /// @dev Native chain coin/token asset.
+    uint8 constant Native = 0x01;
     /// @dev ERC-20 fungible token; lower 20 bytes of the ID hold the contract address.
     uint8 constant Erc20 = 0x02;
     /// @dev ERC-721 non-fungible token; lower 20 bytes of the ID hold the collection address.

package/utils/Utils.sol

@@ -4,9 +4,9 @@ pragma solidity ^0.8.33;
 // Basis-points denominator: 10_000 BPS == 100.00%.
 uint16 constant MAX_BPS = 10_000;
 
-// Thrown by max* helpers when a value exceeds the target integer width.
+/// @dev Thrown by max* helpers when a value exceeds the target integer width.
 error ValueOverflow();
-// Thrown by `divisible` when `n` is not evenly divisible by `divisor`.
+/// @dev Thrown by `divisible` when `n` is not evenly divisible by `divisor`.
 error NotDivisible();
 
 /// @notice Assert that `value` fits in uint8 and return it unchanged.

package/commands/Transfer.sol

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import { CommandContext, CommandBase, Keys } from "./Base.sol";
-import { Cursors, Cur, Schemas, Tx } from "../Cursors.sol";
-import { Accounts } from "../utils/Accounts.sol";
-using Cursors for Cur;
-
-abstract contract TransferHook {
-    /// @notice Override to execute a single transfer record from the request pipeline.
-    /// Called once per PAYOUT block in the request.
-    /// @param value Decoded transfer record (from, to, asset, meta, amount).
-    function transfer(Tx memory value) internal virtual;
-}
-
-/// @title Transfer
-/// @notice Command that transfers assets from a caller to recipients specified in
-/// PAYOUT request blocks. Produces no state output.
-/// The virtual `transfer(value)` hook is called once per entry.
-abstract contract Transfer is CommandBase, TransferHook {
-    string private constant NAME = "transfer";
-
-    uint internal immutable transferId = commandId(NAME);
-
-    constructor() {
-        emit Command(host, transferId, NAME, "1:0:0", Schemas.Payout, Keys.Empty, Keys.Empty, false);
-    }
-
-    /// @notice Override to customize request parsing or batching for transfers.
-    /// The default implementation iterates entry blocks and calls `transfer(value)` for each.
-    /// @param from Source account identifier.
-    /// @param request Full request bytes.
-    /// @return Empty bytes (transfers produce no state output).
-    function transfer(bytes32 from, bytes calldata request) internal virtual returns (bytes memory) {
-        (Cur memory input, ) = cursor(request, 1);
-        Tx memory value;
-        value.from = from;
-
-        while (input.i < input.bound) {
-            (value.to, value.asset, value.meta, value.amount) = input.unpackPayout();
-            Accounts.ensure(value.to);
-            transfer(value);
-        }
-
-        input.close();
-        return "";
-    }
-
-    function transfer(
-        CommandContext calldata c
-    ) external onlyCommand returns (bytes memory) {
-        return transfer(c.account, c.request);
-    }
-}