@rootzero/contracts 0.9.2 → 0.9.4

package/core/Payable.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Budget, Values} from "../utils/Value.sol";
+
+/// @title Payable
+/// @notice Abstract mixin for entrypoints that accept native value (`msg.value`).
+/// Provides a shared settlement hook for any unspent value remaining in the
+/// mutable budget after execution completes.
+abstract contract Payable {
+    /// @dev Thrown when a payable entrypoint completes with unspent native value.
+    /// Override `settleValue` to implement refund or forwarding behavior instead.
+    error UnusedValue(uint remaining);
+
+    /// @notice Create a native-value budget from the current call's `msg.value`.
+    /// @return Budget initialised with the full `msg.value`.
+    function valueBudget() internal view returns (Budget memory) {
+        return Budget({remaining: msg.value});
+    }
+
+    /// @notice Deduct `amount` from the budget and return it.
+    /// @param budget Mutable budget to deduct from.
+    /// @param amount Native value to spend.
+    /// @return The same `amount`, ready to forward to a callee.
+    function useValue(Budget memory budget, uint amount) internal pure returns (uint) {
+        return Values.use(budget, amount);
+    }
+
+    /// @notice Deduct `amount` from the budget and return it as a new sub-budget.
+    /// @param budget Mutable parent budget to deduct from.
+    /// @param amount Native value to assign to the sub-budget.
+    /// @return A new budget with `amount` remaining.
+    function allocateValue(Budget memory budget, uint amount) internal pure returns (Budget memory) {
+        return Values.allocate(budget, amount);
+    }
+
+    /// @notice Drains the budget and settles any remaining native value.
+    /// @dev Calls the amount-based `settleValue` hook only when some value remains.
+    /// @param account Account identifier for the current invocation.
+    /// @param budget Mutable native-value budget used during execution.
+    function settleValue(bytes32 account, Budget memory budget) internal {
+        uint value = budget.remaining;
+        if (value == 0) return;
+        budget.remaining = 0;
+        settleValue(account, value);
+    }
+
+    /// @notice Handles leftover native value after payable execution has finished.
+    /// @dev Override this hook to refund or redirect unused value.
+    /// The default implementation rejects any leftover amount.
+    /// @param account Account identifier for the current invocation.
+    /// @param remaining Unspent native value left in the budget, in wei.
+    function settleValue(bytes32 account, uint remaining) internal virtual {
+        account;
+        revert UnusedValue(remaining);
+    }
+}

package/core/Pipeline.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Cursors, Cur} from "../Cursors.sol";
+import {Payable} from "./Payable.sol";
+import {Budget} from "../utils/Value.sol";
+
+using Cursors for Cur;
+
+/// @title Pipeline
+/// @notice Core pipeline functionality shared by higher-level surfaces.
+abstract contract Pipeline is Payable {
+    error UnexpectedState();
+
+    /// @notice Override to dispatch one piped step.
+    /// Called once per STEP block. The returned bytes become the state passed to
+    /// the next step, and the final returned state must be empty.
+    /// @param target Node ID to invoke or handle.
+    /// @param account Account identifier for the piped context.
+    /// @param state Current threaded state block stream.
+    /// @param request Step request block stream.
+    /// @param value Native value assigned to this step.
+    /// @return Updated state block stream for the next step.
+    function dispatch(
+        uint target,
+        bytes32 account,
+        bytes memory state,
+        bytes calldata request,
+        uint value
+    ) internal virtual returns (bytes memory);
+
+    /// @notice Execute a STEP block stream through the pipeline.
+    /// @dev Reverts with `UnexpectedState` if the final threaded state is non-empty.
+    /// @param account Account identifier used for each dispatched step.
+    /// @param state Initial state block stream passed to the first step.
+    /// @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 input, ) = Cursors.init(steps, 1);
+
+        while (input.i < input.bound) {
+            (uint target, uint value, bytes calldata request) = input.unpackStep();
+            state = dispatch(target, account, state, request, useValue(budget, value));
+        }
+
+        if (state.length != 0) revert UnexpectedState();
+        settleValue(account, budget);
+        input.close();
+    }
+}

package/docs/Schema.md

@@ -0,0 +1,194 @@
+# Schema
+
+Rootzero request and response data is encoded as a stream of typed blocks. A
+schema string describes payload layout for discovery events and tooling; the
+runtime block key is derived only from the block name.
+
+## Wire Format
+
+Every block uses the same header:
+
+```txt
+[bytes4 key][uint32 payloadLen][payload]
+```
+
+`payloadLen` is big-endian and counts only payload bytes. Child blocks and list
+items use the same header format.
+
+The block key is:
+
+```txt
+bytes4(keccak256("#name"))
+```
+
+For example, `#amount { bytes32 asset, bytes32 meta, uint amount }` uses the key
+derived from `#amount`. Blocks must not be overloaded: one block name should have
+one protocol meaning.
+
+## Block Syntax
+
+A block starts with `#`. Fixed fields are written in braces:
+
+```txt
+#amount { bytes32 asset, bytes32 meta, uint amount }
+#account { bytes32 account }
+```
+
+A block without braces has no payload:
+
+```txt
+#unit
+#bytes
+```
+
+Empty braces are invalid. A zero-payload block must omit braces.
+
+A schema is a comma-separated list of items. Order is significant.
+
+```txt
+#amount { bytes32 asset, bytes32 meta, uint amount },
+maybe #account { bytes32 account }
+```
+
+## Payload Layout
+
+A block payload has fixed fields first, followed by an optional child-block tail.
+Once a child block appears, no more fixed fields may follow.
+
+```txt
+#call { uint target, uint value, #bytes as payload }
+#context { bytes32 account, uint value, #bytes as state, #bytes as request }
+```
+
+The tail is embedded directly as child block bytes. There is no wrapper around a
+child-block tail.
+
+Raw dynamic bytes are represented with the reserved `#bytes` child block. Use an
+alias to give those bytes a presentation name:
+
+```txt
+#bytes as payload
+```
+
+## Modifiers
+
+Cardinality is expressed with prefix keywords:
+
+```txt
+#balance { bytes32 asset, bytes32 meta, uint amount }
+maybe #balance { bytes32 asset, bytes32 meta, uint amount }
+many #balance { bytes32 asset, bytes32 meta, uint amount }
+maybe many #balance { bytes32 asset, bytes32 meta, uint amount }
+```
+
+- no prefix: one required item
+- `maybe`: optional item
+- `many`: one `#list` block whose payload contains repeated items
+- `maybe many`: optional `#list` block
+
+`maybe` emits no placeholder when absent. `many` wraps repeated items in one
+generic list block; it does not repeat the item in place.
+
+## Prime Items
+
+The empty string `""` means no schema. Whitespace-only schemas are invalid.
+
+For a non-empty schema, the first top-level item is the prime item. Prime items
+may repeat at the top level for batching. Later top-level items are globals for
+the whole batch and are not counted as per-operation prime blocks.
+
+The prime item cannot be optional. If a command needs a per-operation marker with
+no payload, use a zero-payload block such as `#unit`.
+
+## Aliases
+
+Aliases are presentation metadata for tooling. They do not change payload layout
+or runtime keys.
+
+```txt
+maybe #account { bytes32 account } as recipient
+#call { uint target, uint value, #bytes as payload }
+```
+
+Aliases may be used on any block item, including child blocks and prime items.
+
+## Field Types
+
+Supported field types are chain-neutral:
+
+```txt
+uint, uint8, uint16, uint32, uint64, uint128, uint256
+int, int8, int16, int32, int64, int128, int256
+bool
+bytes1 through bytes32
+```
+
+`uint` means `uint256`; `int` means `int256`. Other integer widths, unsized
+`bytes`, `string`, and array syntax are not part of the core schema DSL.
+
+Integers are encoded big-endian. Signed integers use two's-complement encoding
+for their declared width. `bool` is one byte: `0x00` for false and `0x01` for
+true. `bytesN` values are encoded as exactly `N` bytes with no padding.
+
+## Identifiers
+
+Block names, field names, and aliases use lower camelCase ASCII identifiers:
+
+```txt
+[a-z][a-zA-Z0-9]*
+```
+
+Invalid examples:
+
+```txt
+Amount
+asset_meta
+asset-meta
+0account
+```
+
+Reserved words include `maybe`, `many`, `as`, all field type names, and the
+reserved block names `bytes`, `data`, and `list`.
+
+## Reserved Blocks
+
+- `#bytes`: raw dynamic bytes, written without a body
+- `#data`: generic/custom payload block
+- `#list`: generic list wrapper emitted by `many`
+
+Use `#data` when a local schema needs a stable generic key:
+
+```txt
+#data { uint foo, bytes32 tag }
+#data { #bytes as payload }
+```
+
+If a schema string starts with a fixed field type, it is shorthand for one
+top-level `#data` block:
+
+```txt
+uint foo, bytes32 tag
+```
+
+expands to:
+
+```txt
+#data { uint foo, bytes32 tag }
+```
+
+## Standard Blocks
+
+Common protocol schemas live in `contracts/blocks/Schema.sol`:
+
+```txt
+#amount { bytes32 asset, bytes32 meta, uint amount }
+#balance { bytes32 asset, bytes32 meta, uint amount }
+#custody { uint host, bytes32 asset, bytes32 meta, uint amount }
+#payout { bytes32 account, bytes32 asset, bytes32 meta, uint amount }
+#call { uint target, uint value, #bytes as payload }
+#step { uint target, uint value, #bytes as request }
+#context { bytes32 account, uint value, #bytes as state, #bytes as request }
+#auth { uint cid, uint deadline, #bytes as proof }
+```
+
+`Keys.sol` contains the corresponding runtime keys.

package/events/Admin.sol

@@ -4,13 +4,16 @@ pragma solidity ^0.8.33;
 import { EventEmitter } from "./Emitter.sol";
 
 string constant ABI =
-    "event Admin(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 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`.
@@ -19,6 +22,7 @@ abstract contract AdminEvent is EventEmitter {
         uint indexed host,
         uint id,
         string name,
+        bytes32 shape,
         string request,
         bytes4 state,
         bytes4 output,

package/events/Command.sol

@@ -4,14 +4,17 @@ 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 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`.
@@ -19,6 +22,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

@@ -4,16 +4,18 @@ pragma solidity ^0.8.33;
 import { EventEmitter } from "./Emitter.sol";
 
 string constant ABI =
-    "event Peer(uint indexed host, uint id, string name, string request, bool acceptsValue)";
+    "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 schema.
+/// @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, string request, bool acceptsValue);
+    event Peer(uint indexed host, uint id, string name, bytes32 shape, string request, string response, bool acceptsValue);
 
     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.2",
+  "version": "0.9.4",
   "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
   "private": false,
   "license": "GPL-3.0-only",
@@ -9,7 +9,7 @@
     "**/*.sol",
     "README.md",
     "LICENSE",
-    "docs/GETTING_STARTED.md"
+    "docs/Schema.md"
   ],
   "publishConfig": {
     "access": "public"

package/peer/AllowAssets.sol

@@ -15,19 +15,19 @@ abstract contract PeerAllowAssets is PeerBase, AllowAssetsHook {
     uint internal immutable peerAllowAssetsId = peerId(NAME);
 
     constructor() {
-        emit Peer(host, peerAllowAssetsId, NAME, Schemas.Asset, false);
+        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);
+        (Cur memory assets, ) = cursor(request, 1);
 
         while (assets.i < assets.bound) {
             (bytes32 asset, bytes32 meta) = assets.unpackAsset();
             allowAsset(asset, meta);
         }
 
-        assets.complete();
+        assets.close();
         return "";
     }
 }

package/peer/Allowance.sol

@@ -16,12 +16,12 @@ abstract contract PeerAllowance is PeerBase, AllowanceHook {
     uint internal immutable peerAllowanceId = peerId(NAME);
 
     constructor() {
-        emit Peer(host, peerAllowanceId, NAME, Schemas.Amount, false);
+        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);
+        (Cur memory amounts, ) = cursor(request, 1);
         uint peer = caller();
 
         while (amounts.i < amounts.bound) {
@@ -29,7 +29,7 @@ abstract contract PeerAllowance is PeerBase, AllowanceHook {
             allowance(peer, asset, meta, amount);
         }
 
-        amounts.complete();
+        amounts.close();
         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.close();
+        return "";
+    }
+}

package/peer/DenyAssets.sol

@@ -15,19 +15,19 @@ abstract contract PeerDenyAssets is PeerBase, DenyAssetsHook {
     uint internal immutable peerDenyAssetsId = peerId(NAME);
 
     constructor() {
-        emit Peer(host, peerDenyAssetsId, NAME, Schemas.Asset, false);
+        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);
+        (Cur memory assets, ) = cursor(request, 1);
 
         while (assets.i < assets.bound) {
             (bytes32 asset, bytes32 meta) = assets.unpackAsset();
             denyAsset(asset, meta);
         }
 
-        assets.complete();
+        assets.close();
         return "";
     }
 }

package/peer/Pipe.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PeerBase} from "./Base.sol";
+import {Pipeline} from "../core/Pipeline.sol";
+import {Cursors, Cur, Schemas} from "../Cursors.sol";
+import {Budget} from "../utils/Value.sol";
+
+using Cursors for Cur;
+
+/// @title PeerPipePayable
+/// @notice Peer that consumes CONTEXT blocks and executes each context request as a STEP stream.
+/// Each CONTEXT block carries an account, state, and request; the request is 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);
+
+    constructor() {
+        emit Peer(host, peerPipePayableId, NAME, "1:0", Schemas.Context, "", true);
+    }
+
+    /// @notice Execute peer-supplied contexts through the shared payable pipe.
+    /// @dev Each context receives its own explicit value sub-budget. Any top-level
+    ///      `msg.value` not assigned to a context remains on this host.
+    function peerPipePayable(bytes calldata request) external payable onlyPeer returns (bytes memory) {
+        (Cur memory input, ) = cursor(request, 1);
+        Budget memory budget = valueBudget();
+
+        while (input.i < input.bound) {
+            (bytes32 account, uint value, bytes calldata state, bytes calldata steps) = input.unpackContext();
+            pipe(account, state, steps, allocateValue(budget, value));
+        }
+
+        input.close();
+        return "";
+    }
+}

package/peer/Settle.sol

@@ -15,18 +15,18 @@ abstract contract PeerSettle is PeerBase, TransferHook {
     uint internal immutable peerSettleId = peerId(NAME);
 
     constructor() {
-        emit Peer(host, peerSettleId, NAME, Schemas.Transaction, false);
+        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);
+        (Cur memory state, ) = cursor(request, 1);
 
         while (state.i < state.bound) {
             transfer(state.unpackTxValue());
         }
 
-        state.complete();
+        state.close();
         return "";
     }
 }

package/queries/Assets.sol

@@ -26,15 +26,15 @@ abstract contract IsAllowedAsset is QueryBase, IsAllowedAssetHook {
     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.
+    /// @param request Block-stream request consisting of `#asset { bytes32 asset, bytes32 meta }` blocks.
+    /// @return Block-stream response containing one `#status { bool 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();
@@ -42,6 +42,7 @@ abstract contract IsAllowedAsset is QueryBase, IsAllowedAssetHook {
             response.appendStatus(allowed);
         }
 
-        return query.complete(response);
+        query.close();
+        return response.finish();
     }
 }