@rootzero/contracts 0.9.1 → 0.9.3

package/core/Context.sol

@@ -27,23 +27,22 @@ abstract contract RootZeroContext {
     /// @param source Calldata slice to parse.
     /// @param group Expected block group size (e.g. 1 for single, 2 for paired).
     /// @return cur Cursor with `bound` set to the end of the first run.
-    /// @return count Total number of blocks in the run (a multiple of `group`).
-    /// @return quotient Number of groups in the run (`count / group`).
-    function cursor(bytes calldata source, uint group) internal pure returns (Cur memory cur, uint count, uint quotient) {
+    /// @return groups Number of block groups in the run (`prime block count / group`).
+    function cursor(bytes calldata source, uint group) internal pure returns (Cur memory cur, uint groups) {
         cur = Cursors.open(source);
-        (, count, quotient) = cur.primeRun(group);
+        (, , groups) = cur.primeRun(group);
     }
 
-    /// @notice Open a cursor, prime it, and assert that its normalized quotient matches `expectedQuotient`.
-    /// Equivalent to `open(source)` followed by `primeRun(group)` and a direct quotient equality check.
-    /// Reverts with `Cursors.BadRatio` when the quotient does not match.
+    /// @notice Open a cursor, prime it, and assert that its group count matches `expectedGroups`.
+    /// Equivalent to `open(source)` followed by `primeRun(group)` and a direct group-count equality check.
+    /// Reverts with `Cursors.BadRatio` when the group count does not match.
     /// @param source Calldata slice to parse.
     /// @param group Expected block group size (e.g. 1 for single, 2 for paired).
-    /// @param expectedQuotient Required number of groups in the first run.
+    /// @param expectedGroups Required number of groups in the first run.
     /// @return cur Cursor with `bound` set to the end of the first run.
-    function cursor(bytes calldata source, uint group, uint expectedQuotient) internal pure returns (Cur memory cur) {
+    function cursor(bytes calldata source, uint group, uint expectedGroups) internal pure returns (Cur memory cur) {
         cur = Cursors.open(source);
-        (, , uint quotient) = cur.primeRun(group);
-        if (quotient != expectedQuotient) revert Cursors.BadRatio();
+        (, , uint groups) = cur.primeRun(group);
+        if (groups != expectedGroups) revert Cursors.BadRatio();
     }
 }

package/core/Host.sol

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.33;
 
 import {AccessControl} from "./Access.sol";
-import {Authorize} from "../commands/control/Authorize.sol";
-import {Unauthorize} from "../commands/control/Unauthorize.sol";
-import {ExecutePayable} from "../commands/control/Execute.sol";
+import {Authorize} from "../commands/admin/Authorize.sol";
+import {Unauthorize} from "../commands/admin/Unauthorize.sol";
+import {ExecutePayable} from "../commands/admin/Execute.sol";
 import {HostAnnouncedEvent} from "../events/Host.sol";
 import {IHostDiscovery} from "../interfaces/IHostDiscovery.sol";
 import {Ids} from "../utils/Ids.sol";
@@ -25,7 +25,7 @@ abstract contract HostDiscovery is HostAnnouncedEvent, IHostDiscovery {
 
 /// @title Host
 /// @notice Abstract base contract for rootzero host implementations.
-/// Inherits control command support (authorize, unauthorize, executePayable) and
+/// Inherits admin command support (authorize, unauthorize, executePayable) and
 /// optionally announces itself to a discovery contract at deployment.
 /// Accepts native ETH payments via the `receive` function.
 abstract contract Host is Authorize, Unauthorize, ExecutePayable {

package/core/Types.sol

@@ -71,7 +71,7 @@ struct HostAccountAmount {
     uint amount;
 }
 
-/// @notice Transfer payload used by transaction blocks and remote settlement.
+/// @notice Transfer payload used by transaction blocks and peer settlement.
 struct Tx {
     /// @dev Sender account identifier.
     bytes32 from;

package/events/{Control.sol → Admin.sol}

@@ -4,21 +4,25 @@ pragma solidity ^0.8.33;
 import { EventEmitter } from "./Emitter.sol";
 
 string constant ABI =
-    "event Control(uint indexed host, uint id, string name, string request, bytes4 state, bytes4 output, bool acceptsValue)";
+    "event Admin(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool acceptsValue)";
 
-/// @notice Emitted once per control command during host deployment to publish its request schema and state keys.
-abstract contract ControlEvent is EventEmitter {
-    /// @param host Host node ID that owns this control command.
+/// @notice Emitted once per admin command during host deployment to publish its request schema and state keys.
+abstract contract AdminEvent is EventEmitter {
+    /// @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 prime block counts encoded as `request:state:output`.
+    /// Blocks outside the prime runs are global batch blocks and are excluded
+    /// from the counts.
     /// @param request Schema DSL string describing the request shape.
     /// @param state Block key expected for input state, or `Keys.Empty`.
     /// @param output Block key produced for output state, or `Keys.Empty`.
     /// @param acceptsValue Whether the command entrypoint accepts nonzero `msg.value`.
-    event Control(
+    event Admin(
         uint indexed host,
         uint id,
         string name,
+        bytes32 shape,
         string request,
         bytes4 state,
         bytes4 output,

package/events/Command.sol

@@ -4,14 +4,18 @@ pragma solidity ^0.8.33;
 import { EventEmitter } from "./Emitter.sol";
 
 string constant ABI =
-    "event Command(uint indexed host, uint id, string name, string request, bytes4 state, bytes4 output, bool acceptsValue)";
+    "event Command(uint indexed host, uint id, string name, bytes32 shape, string request, bytes4 state, bytes4 output, bool acceptsValue)";
 
 /// @notice Emitted once per command during host deployment to publish its request schema and state keys.
 abstract contract CommandEvent is EventEmitter {
     /// @param host Host node ID that owns this command.
     /// @param id Command node ID.
     /// @param name Human-readable command name.
-    /// @param request Schema DSL string describing the request shape.
+    /// @param shape Per-operation prime block counts encoded as `request:state:output`.
+    /// Blocks outside the prime runs are global batch blocks and are excluded
+    /// from the counts.
+    /// @param request Schema DSL string describing the request shape; use `empty;...`
+    /// when the request has global blocks but no prime blocks.
     /// @param state Block key expected for input state, or `Keys.Empty`.
     /// @param output Block key produced for output state, or `Keys.Empty`.
     /// @param acceptsValue Whether the command entrypoint accepts nonzero `msg.value`.
@@ -19,6 +23,7 @@ abstract contract CommandEvent is EventEmitter {
         uint indexed host,
         uint id,
         string name,
+        bytes32 shape,
         string request,
         bytes4 state,
         bytes4 output,

package/events/Listing.sol

@@ -3,16 +3,15 @@ pragma solidity ^0.8.33;
 
 import { EventEmitter } from "./Emitter.sol";
 
-string constant ABI = "event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active, bool created)";
+string constant ABI = "event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active)";
 
-/// @notice Emitted when an asset listing is created or updated on a host.
+/// @notice Emitted when an asset listing is updated on a host.
 abstract contract ListingEvent is EventEmitter {
     /// @param host Host node ID that manages this listing.
     /// @param asset Asset identifier.
     /// @param meta Asset metadata slot.
     /// @param active True if the listing is currently active.
-    /// @param created True if the asset was created as part of this listing.
-    event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active, bool created);
+    event Listing(uint indexed host, bytes32 asset, bytes32 meta, bool active);
 
     constructor() {
         emit EventAbi(ABI);

package/events/Peer.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { EventEmitter } from "./Emitter.sol";
+
+string constant ABI =
+    "event Peer(uint indexed host, uint id, string name, bytes32 shape, string request, string response, bool acceptsValue)";
+
+/// @notice Emitted once per peer during host deployment to publish its request and response schemas.
+abstract contract PeerEvent is EventEmitter {
+    /// @param host Host node ID that owns this peer.
+    /// @param id Peer node ID.
+    /// @param name Human-readable peer name.
+    /// @param shape Prime block counts as `request:response`; global blocks are excluded.
+    /// @param request Schema DSL string describing the peer request shape.
+    /// @param response Schema DSL string describing the peer response shape.
+    /// @param acceptsValue Whether the peer entrypoint accepts nonzero `msg.value`.
+    event Peer(uint indexed host, uint id, string name, bytes32 shape, string request, string response, bool acceptsValue);
+
+    constructor() {
+        emit EventAbi(ABI);
+    }
+}
+
+
+

package/events/{RootZero.sol → Piped.sol}

@@ -3,14 +3,14 @@ pragma solidity ^0.8.33;
 
 import { EventEmitter } from "./Emitter.sol";
 
-string constant ABI = "event RootZero(bytes32 indexed account, uint deadline, uint value)";
+string constant ABI = "event Piped(bytes32 indexed account, uint deadline, uint value)";
 
 /// @notice Emitted for root-level protocol actions (e.g. governance or protocol-wide operations).
-abstract contract RootZeroEvent is EventEmitter {
+abstract contract PipedEvent is EventEmitter {
     /// @param account Account identifier associated with the action.
     /// @param deadline Expiry timestamp of the action.
     /// @param value Native value associated with the action.
-    event RootZero(bytes32 indexed account, uint deadline, uint value);
+    event Piped(bytes32 indexed account, uint deadline, uint value);
 
     constructor() {
         emit EventAbi(ABI);

package/events/Query.sol

@@ -3,16 +3,19 @@ pragma solidity ^0.8.33;
 
 import {EventEmitter} from "./Emitter.sol";
 
-string constant ABI = "event Query(uint indexed host, uint id, string name, string request, string response)";
+string constant ABI = "event Query(uint indexed host, uint id, string name, bytes32 shape, string request, string response)";
 
 /// @notice Emitted once per query during host deployment to publish its request and response schemas.
 abstract contract QueryEvent is EventEmitter {
     /// @param host Host node ID that owns this query.
     /// @param id Query node ID.
     /// @param name Human-readable query name.
+    /// @param shape Per-operation prime block counts encoded as `request:response`.
+    /// Blocks outside the prime runs are global batch blocks and are excluded
+    /// from the counts.
     /// @param request Schema DSL string describing the query request shape.
     /// @param response Schema DSL string describing the query response shape.
-    event Query(uint indexed host, uint id, string name, string request, string response);
+    event Query(uint indexed host, uint id, string name, bytes32 shape, string request, string response);
 
     constructor() {
         emit EventAbi(ABI);

package/package.json

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

package/peer/AllowAssets.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PeerBase } from "./Base.sol";
+import { AllowAssetsHook } from "../commands/admin/AllowAssets.sol";
+import { Cursors, Cur, Schemas } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PeerAllowAssets
+/// @notice Peer that permits a list of (asset, meta) pairs on behalf of a peer host.
+/// Each ASSET block in the request calls `allowAsset`. Restricted to trusted peers.
+abstract contract PeerAllowAssets is PeerBase, AllowAssetsHook {
+    string private constant NAME = "peerAllowAssets";
+    uint internal immutable peerAllowAssetsId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerAllowAssetsId, NAME, "1:0", Schemas.Asset, "", false);
+    }
+
+    /// @notice Execute the allow-assets peer call.
+    function peerAllowAssets(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory assets, ) = cursor(request, 1);
+
+        while (assets.i < assets.bound) {
+            (bytes32 asset, bytes32 meta) = assets.unpackAsset();
+            allowAsset(asset, meta);
+        }
+
+        assets.complete();
+        return "";
+    }
+}
+
+
+
+
+

package/peer/Allowance.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {AllowanceHook} from "../commands/admin/Allowance.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PeerAllowance
+/// @notice Peer that lets a trusted peer host request or refresh its own allowance.
+/// Each AMOUNT block in the request is scoped to the peer host and passed to the
+/// shared allowance hook as a host-scoped allowance. Restricted to trusted peers.
+abstract contract PeerAllowance is PeerBase, AllowanceHook {
+    string private constant NAME = "peerAllowance";
+    uint internal immutable peerAllowanceId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerAllowanceId, NAME, "1:0", Schemas.Amount, "", false);
+    }
+
+    /// @notice Execute the allowance peer call.
+    function peerAllowance(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory amounts, ) = cursor(request, 1);
+        uint peer = caller();
+
+        while (amounts.i < amounts.bound) {
+            (bytes32 asset, bytes32 meta, uint amount) = amounts.unpackAmount();
+            allowance(peer, asset, meta, amount);
+        }
+
+        amounts.complete();
+        return "";
+    }
+}

package/peer/BalancePull.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+
+using Cursors for Cur;
+
+abstract contract BalancePullHook {
+    /// @notice Override to process one incoming balance-based pull request from a peer host.
+    /// @param peer Peer host node ID for this request.
+    /// @param asset Requested asset identifier.
+    /// @param meta Requested asset metadata slot.
+    /// @param amount Requested amount in the asset's native units.
+    function balancePull(uint peer, bytes32 asset, bytes32 meta, uint amount) internal virtual;
+}
+
+/// @title PeerBalancePull
+/// @notice Peer that pulls requested balances from a peer host into this one.
+/// Each BALANCE block in the request calls `balancePull(peer, asset, meta, amount)`.
+/// Restricted to trusted peers.
+abstract contract PeerBalancePull is PeerBase, BalancePullHook {
+    string private constant NAME = "peerBalancePull";
+    uint internal immutable peerBalancePullId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerBalancePullId, NAME, "1:0", Schemas.Balance, "", false);
+    }
+
+    /// @notice Execute the balance-pull peer call.
+    function peerBalancePull(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory input, ) = cursor(request, 1);
+        uint peer = caller();
+
+        while (input.i < input.bound) {
+            (bytes32 asset, bytes32 meta, uint amount) = input.unpackBalance();
+            balancePull(peer, asset, meta, amount);
+        }
+
+        input.complete();
+        return "";
+    }
+}

package/peer/Base.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { NodeCalls } from "../core/Calls.sol";
+import { PeerEvent } from "../events/Peer.sol";
+import { Ids, Selectors } from "../utils/Ids.sol";
+
+/// @notice ABI-encode a peer call from a target peer ID and request block stream.
+/// @dev Derives the function selector from `target` via `Ids.peerSelector(target)`.
+/// Reverts if `target` is not a valid peer ID.
+/// @param target Destination peer node ID embedding the target selector.
+/// @param request Input block stream for the peer invocation.
+/// @return ABI-encoded calldata for the peer entry point.
+function encodePeerCall(uint target, bytes calldata request) pure returns (bytes memory) {
+    bytes4 selector = Ids.peerSelector(target);
+    return abi.encodeWithSelector(selector, request);
+}
+
+/// @title PeerBase
+/// @notice Abstract base for all rootzero peer contracts.
+/// Peers handle inter-host operations and asset allow/deny management
+/// between cooperating hosts. Access is restricted to trusted callers via `onlyPeer`.
+abstract contract PeerBase is NodeCalls, PeerEvent {
+    /// @dev Thrown when the commander attempts to call a peer entrypoint directly.
+    error CommanderNotAllowed();
+
+    /// @dev Restrict execution to trusted callers, excluding the commander.
+    modifier onlyPeer() {
+        if (msg.sender == commander) revert CommanderNotAllowed();
+        enforceCaller(msg.sender);
+        _;
+    }
+
+    /// @notice Derive the deterministic node ID for a named peer on this contract.
+    /// @param name Peer function name (without argument list).
+    /// @return Peer node ID.
+    function peerId(string memory name) internal view returns (uint) {
+        return Ids.toPeer(Selectors.peer(name), address(this));
+    }
+}

package/peer/DenyAssets.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+
+using Cursors for Cur;
+
+/// @title PeerDenyAssets
+/// @notice Peer that blocks a list of (asset, meta) pairs on behalf of a peer host.
+/// Each ASSET block in the request calls `denyAsset`. Restricted to trusted peers.
+abstract contract PeerDenyAssets is PeerBase, DenyAssetsHook {
+    string private constant NAME = "peerDenyAssets";
+    uint internal immutable peerDenyAssetsId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerDenyAssetsId, NAME, "1:0", Schemas.Asset, "", false);
+    }
+
+    /// @notice Execute the deny-assets peer call.
+    function peerDenyAssets(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory assets, ) = cursor(request, 1);
+
+        while (assets.i < assets.bound) {
+            (bytes32 asset, bytes32 meta) = assets.unpackAsset();
+            denyAsset(asset, meta);
+        }
+
+        assets.complete();
+        return "";
+    }
+}
+
+
+
+
+

package/peer/Settle.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { PeerBase } from "./Base.sol";
+import { TransferHook } from "../commands/Transfer.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 {
+    string private constant NAME = "peerSettle";
+    uint internal immutable peerSettleId = peerId(NAME);
+
+    constructor() {
+        emit Peer(host, peerSettleId, NAME, "1:0", Schemas.Transaction, "", false);
+    }
+
+    /// @notice Execute the peer-settle call.
+    function peerSettle(bytes calldata request) external onlyPeer returns (bytes memory) {
+        (Cur memory state, ) = cursor(request, 1);
+
+        while (state.i < state.bound) {
+            transfer(state.unpackTxValue());
+        }
+
+        state.complete();
+        return "";
+    }
+}

package/queries/Assets.sol

@@ -8,8 +8,6 @@ import {QueryBase} from "./Base.sol";
 using Cursors for Cur;
 using Writers for Writer;
 
-string constant NAME = "isAllowedAsset";
-
 abstract contract IsAllowedAssetHook {
     /// @notice Resolve whether one asset tuple is allowed.
     /// Concrete implementations define the allowlist policy.
@@ -24,18 +22,19 @@ abstract contract IsAllowedAssetHook {
 /// The request is a run of `ASSET` blocks.
 /// The response returns one `STATUS` form block per query entry, preserving request order.
 abstract contract IsAllowedAsset is QueryBase, IsAllowedAssetHook {
+    string private constant NAME = "isAllowedAsset";
     uint public immutable isAllowedAssetId = queryId(NAME);
 
     constructor() {
-        emit Query(host, isAllowedAssetId, NAME, Schemas.Asset, Forms.Status);
+        emit Query(host, isAllowedAssetId, NAME, "1:1", Schemas.Asset, Forms.Status);
     }
 
     /// @notice Resolve allowlist status for a run of requested `(asset, meta)` tuples.
     /// @param request Block-stream request consisting of `asset(asset, meta)*`.
     /// @return Block-stream response containing one `status(ok)` per asset block.
     function isAllowedAsset(bytes calldata request) external view returns (bytes memory) {
-        (Cur memory query, uint count, ) = cursor(request, 1);
-        Writer memory response = Writers.allocStatuses(count);
+        (Cur memory query, uint groups) = cursor(request, 1);
+        Writer memory response = Writers.allocStatuses(groups);
 
         while (query.i < query.bound) {
             (bytes32 asset, bytes32 meta) = query.unpackAsset();

package/queries/Balances.sol

@@ -7,8 +7,6 @@ import {QueryBase} from "./Base.sol";
 using Cursors for Cur;
 using Writers for Writer;
 
-string constant NAME = "getBalances";
-
 abstract contract GetBalancesHook {
     /// @notice Resolve one account's balance for one supported asset.
     /// Concrete implementations define how assets are resolved.
@@ -24,18 +22,19 @@ abstract contract GetBalancesHook {
 /// The request is a run of `ACCOUNT_ASSET` form blocks.
 /// The response returns one `ACCOUNT_AMOUNT` form block per requested position, preserving request order.
 abstract contract GetBalances is QueryBase, GetBalancesHook {
+    string private constant NAME = "getBalances";
     uint public immutable getBalancesId = queryId(NAME);
 
     constructor() {
-        emit Query(host, getBalancesId, NAME, Forms.AccountAsset, Forms.AccountAmount);
+        emit Query(host, getBalancesId, NAME, "1:1", Forms.AccountAsset, Forms.AccountAmount);
     }
 
     /// @notice Resolve balances for a run of requested `(account, asset, meta)` tuples.
     /// @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 count, ) = cursor(request, 1);
-        Writer memory response = Writers.allocAccountAmounts(count);
+        (Cur memory query, uint groups) = cursor(request, 1);
+        Writer memory response = Writers.allocAccountAmounts(groups);
 
         while (query.i < query.bound) {
             (bytes32 account, bytes32 asset, bytes32 meta) = query.unpackAccountAsset();

package/queries/Positions.sol

@@ -7,8 +7,6 @@ import {QueryBase} from "./Base.sol";
 
 using Cursors for Cur;
 
-string constant NAME = "getPosition";
-
 abstract contract GetPositionHook {
     /// @notice Resolve the position payload for one requested position.
     /// Concrete implementations must append exactly one `RESPONSE` block whose payload
@@ -30,12 +28,13 @@ abstract contract GetPositionHook {
 /// The request is a run of `ACCOUNT_ASSET` form blocks.
 /// The response returns one dynamic `RESPONSE` block per position entry, preserving request order.
 abstract contract GetPosition is QueryBase, GetPositionHook {
+    string private constant NAME = "getPosition";
     uint public immutable getPositionId = queryId(NAME);
     uint internal immutable positionResponseSize;
 
     constructor(string memory output, uint responseSize) {
         positionResponseSize = responseSize;
-        emit Query(host, getPositionId, NAME, Forms.AccountAsset, output);
+        emit Query(host, getPositionId, NAME, "1:1", Forms.AccountAsset, output);
     }
 
     /// @notice Resolve positions for a run of requested `(account, asset, meta)` tuples.
@@ -44,8 +43,8 @@ abstract contract GetPosition is QueryBase, GetPositionHook {
     /// @param request Block-stream request consisting of `accountAsset(account, asset, meta)*`.
     /// @return Block-stream response containing one `response(bytes data)` block per position block.
     function getPosition(bytes calldata request) external view returns (bytes memory) {
-        (Cur memory query, uint count, ) = cursor(request, 1);
-        Writer memory response = Writers.allocBytes(count, positionResponseSize);
+        (Cur memory query, uint groups) = cursor(request, 1);
+        Writer memory response = Writers.allocBytes(groups, positionResponseSize);
 
         while (query.i < query.bound) {
             (bytes32 account, bytes32 asset, bytes32 meta) = query.unpackAccountAsset();

package/utils/Accounts.sol

@@ -92,6 +92,14 @@ library Accounts {
         return account;
     }
 
+    /// @notice Assert that `account` is not an admin account and return it unchanged.
+    /// @param account Account ID to validate.
+    /// @return The same `account` value if valid.
+    function ensureNotAdmin(bytes32 account) internal pure returns (bytes32) {
+        if (isAdmin(account)) revert InvalidAccount();
+        return account;
+    }
+
     /// @notice Extract the EVM address embedded in an EVM-family account ID.
     /// Reverts if `account` is not an EVM-family account.
     /// @param account EVM-family account ID.