@rootzero/contracts 1.25.0 → 1.26.0

package/utils/Cursors.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-import {clear32, max16, max32, max128} from "./Utils.sol";
+import {MissingCursor, OutOfBounds, UnexpectedPosition, ValueOverflow} from "./Errors.sol";
 
 /// @notice Mutable memory wrapper around a packed cursor.
 /// @dev A second tagged cursor may occupy the upper 128-bit lane of `state`.
@@ -17,7 +17,8 @@ struct Cur {
 /// bits   0-31    i
 /// bits  32-63    offset
 /// bits  64-95    len
-/// bits  96-111   count (opaque consumer metadata)
+/// bits  96-103   stride (optional blocks per group)
+/// bits 104-111   reserved
 /// bits 112-119   flags (consumer-defined)
 /// bits 120-127   tag
 ///
@@ -27,15 +28,6 @@ struct Cur {
 /// inspection operations target it, and `select` swaps a requested tagged
 /// cursor into that position while preserving the pair.
 ///
-/// A mark is a standalone cursor value used as an immutable positional
-/// reference. It retains the cursor's offset, length, count, flags, and tag,
-/// but may carry a different `i`. A mark has no intrinsic boundary or movement
-/// semantics; callers may later use its position for comparison, validation,
-/// seeking, or another operation. Because it has the ordinary single-cursor
-/// layout, existing positional decoding and absolute-position rules also apply
-/// to marks. A zero mark identifies the empty cursor at position zero; `before`
-/// therefore treats it as already reached.
-///
 /// Cursor navigation assumes packed cursor inputs satisfy `i <= len`.
 /// Constructors and composition helpers establish this invariant, and navigation
 /// helpers preserve it. Manually constructing or modifying packed cursor words
@@ -43,33 +35,20 @@ struct Cur {
 ///
 /// The zero word represents an absent cursor.
 library Cursors {
-    /// @dev A cursor position exceeds its logical length.
-    error OutOfBounds();
-
-    /// @dev A cursor is not positioned at the expected offset.
-    error UnexpectedPosition();
-
-    /// @dev Paired cursors must have different identity tags.
-    error DuplicateTag(uint8 tag);
-
-    /// @dev Neither packed cursor matches the requested identity.
-    error MissingCursor();
-
     // Creation and sources
 
     /// @notice Create a cursor positioned at its beginning.
     /// @param offset Absolute source or buffer offset.
     /// @param len Logical byte length.
-    /// @param items Opaque item count associated with the region.
+    /// @param stride Optional blocks per group associated with the region.
     /// @param flags Consumer-defined flags.
     /// @param tag Cursor identity tag.
     /// @return cur Packed cursor.
-    function create(uint offset, uint len, uint items, uint8 flags, uint8 tag) internal pure returns (uint cur) {
-        cur |= uint(max32(offset)) << 32;
-        cur |= uint(max32(len)) << 64;
-        cur |= uint(max16(items)) << 96;
-        cur |= uint(flags) << 112;
-        cur |= uint(tag) << 120;
+    function create(uint offset, uint len, uint8 stride, uint8 flags, uint8 tag) internal pure returns (uint cur) {
+        if (offset > type(uint32).max || len > type(uint32).max) {
+            revert ValueOverflow();
+        }
+        cur = (offset << 32) | (len << 64) | (uint(stride) << 96) | (uint(flags) << 112) | (uint(tag) << 120);
     }
 
     /// @notice Return the absolute calldata position where `source` begins.
@@ -86,17 +65,30 @@ library Cursors {
     /// @return abs Absolute start position.
     /// @return end Absolute exclusive end position.
     function bounds(bytes calldata source) internal pure returns (uint abs, uint end) {
-        abs = base(source);
-        end = abs + source.length;
+        assembly ("memory-safe") {
+            abs := source.offset
+            end := add(abs, source.length)
+        }
+    }
+
+    /// @notice Return the absolute start and exclusive end of the lower cursor frame.
+    /// @dev Ignores the cursor's current relative position and any upper cursor.
+    /// @param cur Packed cursor or cursor pair whose active frame is inspected.
+    /// @return abs Absolute frame start position.
+    /// @return end Absolute exclusive frame end position.
+    function bounds(uint cur) internal pure returns (uint abs, uint end) {
+        abs = uint32(cur >> 32);
+        end = abs + uint32(cur >> 64);
     }
 
     /// @notice Create a cursor backed by a calldata slice.
     /// @param source Calldata slice represented by the cursor.
-    /// @param flags Consumer-defined flags.
     /// @param tag Cursor identity tag.
     /// @return cur Packed cursor positioned at the slice beginning.
-    function wrap(bytes calldata source, uint8 flags, uint8 tag) internal pure returns (uint cur) {
-        cur = create(base(source), source.length, 0, flags, tag);
+    function wrap(bytes calldata source, uint8 tag) internal pure returns (uint cur) {
+        assembly ("memory-safe") {
+            cur := or(or(shl(32, source.offset), shl(64, source.length)), shl(120, tag))
+        }
     }
 
     // Inspection
@@ -115,9 +107,9 @@ library Cursors {
     /// @notice Return the active cursor without its position.
     /// @dev Ignores the upper cursor when `cur` is a pair.
     /// @param cur Packed cursor or cursor pair.
-    /// @return The lower cursor's offset, length, count, flags, and tag.
+    /// @return The lower cursor's offset, length, stride, flags, and tag.
     function frame(uint cur) internal pure returns (uint) {
-        return clear32(uint128(cur), 0);
+        return uint128(cur) & ~uint(type(uint32).max);
     }
 
     /// @notice Return the absolute position of the lower cursor as `offset + i`.
@@ -128,22 +120,17 @@ library Cursors {
         return uint32(cur) + uint32(cur >> 32);
     }
 
-    /// @notice Decode the consumer metadata and identity tag from the lower cursor.
+    /// @notice Decode the optional stride, consumer flags, and identity tag.
     /// @param cur Packed cursor or cursor pair.
-    /// @return items Opaque item count.
+    /// @return stride Optional blocks per group.
     /// @return flags Consumer-defined flags.
     /// @return tag Cursor identity tag.
-    function meta(uint cur) internal pure returns (uint items, uint8 flags, uint8 tag) {
-        items = uint16(cur >> 96);
+    function meta(uint cur) internal pure returns (uint8 stride, uint8 flags, uint8 tag) {
+        stride = uint8(cur >> 96);
         flags = uint8(cur >> 112);
         tag = uint8(cur >> 120);
     }
 
-    /// @notice Return the opaque item count attached to the active cursor.
-    function count(uint cur) internal pure returns (uint) {
-        return uint16(cur >> 96);
-    }
-
     /// @notice Return whether both packed cursors remain at their initial positions.
     /// @param cur Packed cursor or cursor pair.
     /// @return Whether both lane positions are zero.
@@ -162,7 +149,7 @@ library Cursors {
     /// @param cur Packed cursor or cursor pair.
     /// @return Whether either lane has bytes remaining.
     function any(uint cur) internal pure returns (bool) {
-        return more(cur) || more(cur >> 128);
+        return uint32(cur) < uint32(cur >> 64) || uint32(cur >> 128) < uint32(cur >> 192);
     }
 
     /// @notice Require the lower cursor to be positioned at `i`.
@@ -176,7 +163,7 @@ library Cursors {
     /// @param cur Packed cursor or cursor pair.
     /// @param abs Expected absolute position.
     function expectAbs(uint cur, uint abs) internal pure {
-        if (absolute(cur) != abs) revert UnexpectedPosition();
+        if (uint32(cur) + uint32(cur >> 32) != abs) revert UnexpectedPosition();
     }
 
     /// @notice Return whether the lower cursor contains `flag`.
@@ -189,14 +176,6 @@ library Cursors {
 
     // Navigation
 
-    /// @dev Return `cur` after ensuring its lower position does not exceed its length.
-    /// @param cur Packed cursor or cursor pair.
-    /// @return Validated cursor unchanged.
-    function validate(uint cur) private pure returns (uint) {
-        if (uint32(cur) > uint32(cur >> 64)) revert OutOfBounds();
-        return cur;
-    }
-
     /// @notice Move the lower cursor forward to `i`.
     /// @param cur Packed cursor or cursor pair.
     /// @param i New relative position; must not move backward.
@@ -205,7 +184,7 @@ library Cursors {
         uint current = uint32(cur);
         uint len = uint32(cur >> 64);
         if (i < current || i > len) revert OutOfBounds();
-        updated = clear32(cur, 0) | i;
+        updated = (cur & ~uint(type(uint32).max)) | i;
     }
 
     /// @notice Replace the lower cursor's position using an absolute position.
@@ -215,7 +194,9 @@ library Cursors {
     function seekAbs(uint cur, uint abs) internal pure returns (uint updated) {
         uint offset = uint32(cur >> 32);
         if (abs < offset) revert OutOfBounds();
-        updated = seek(cur, abs - offset);
+        uint i = abs - offset;
+        if (i < uint32(cur) || i > uint32(cur >> 64)) revert OutOfBounds();
+        updated = (cur & ~uint(type(uint32).max)) | i;
     }
 
     /// @notice Advance the current position of the lower cursor.
@@ -236,8 +217,9 @@ library Cursors {
     /// @param len New logical length.
     /// @return updated Cursor with the replaced length.
     function resize(uint cur, uint len) internal pure returns (uint updated) {
-        if (uint32(cur) > max32(len)) revert OutOfBounds();
-        updated = clear32(cur, 64) | (len << 64);
+        if (len > type(uint32).max) revert ValueOverflow();
+        if (uint32(cur) > len) revert OutOfBounds();
+        updated = (cur & ~(uint(type(uint32).max) << 64)) | (len << 64);
     }
 
     /// @notice Create a child cursor over `[start, end)` within the lower cursor.
@@ -250,30 +232,15 @@ library Cursors {
     /// @param tag Child identity tag.
     /// @return child Packed child cursor.
     function slice(uint cur, uint start, uint end, uint8 tag) internal pure returns (uint child) {
-        (, uint offset, uint len) = decode(cur);
+        uint offset = uint32(cur >> 32);
+        uint len = uint32(cur >> 64);
         if (start > end || end > len) revert OutOfBounds();
-        child = create(offset + start, end - start, 0, 0, tag);
+        uint childOffset = offset + start;
+        if (childOffset > type(uint32).max) revert ValueOverflow();
+        child = (childOffset << 32) | ((end - start) << 64) | (uint(tag) << 120);
     }
 
-    // Pairing and selection
-
-    /// @notice Combine two cursors into one packed word.
-    /// @dev Zero represents absence and acts as the identity value.
-    /// @param low Cursor placed in the lower lane.
-    /// @param high Cursor placed in the higher lane.
-    /// @return cur Packed cursor pair, or the nonzero cursor when one is absent.
-    function pair(uint low, uint high) internal pure returns (uint cur) {
-        low = validate(max128(low));
-        high = validate(max128(high));
-
-        if (low == 0) return high;
-        if (high == 0) return low;
-
-        uint8 tag = uint8(low >> 120);
-        if (tag == uint8(high >> 120)) revert DuplicateTag(tag);
-
-        cur = low | (high << 128);
-    }
+    // Selection
 
     /// @notice Swap the lower and higher cursors.
     /// @param cur Packed cursor pair.
@@ -299,41 +266,10 @@ library Cursors {
     function select(uint cur, uint8 expected) internal pure returns (uint updated) {
         if (uint8(cur >> 120) == expected) return cur;
 
-        updated = swap(cur);
+        updated = (cur << 128) | (cur >> 128);
         if (uint8(updated >> 120) != expected) revert MissingCursor();
     }
 
-    // Marks
-
-    /// @notice Select the live cursor whose frame matches the active cursor in `mark`.
-    /// @dev Only the lower 128 bits of `mark` are considered. The returned value
-    /// preserves the cursor pair and places the matching cursor in the lower half.
-    /// A zero frame may select an empty cursor lane.
-    /// @param cur Packed cursor or cursor pair to search.
-    /// @param mark Cursor-shaped positional reference to match.
-    /// @return located Cursor pair with the matching cursor active.
-    function locate(uint cur, uint mark) internal pure returns (uint located) {
-        uint expected = frame(mark);
-        if (frame(cur) == expected) return cur;
-
-        located = swap(cur);
-        if (frame(located) != expected) revert MissingCursor();
-    }
-
-    /// @notice Return whether a matched cursor is positioned before `mark`.
-    /// @dev Returns false at the mark and reverts after it. Only the active lower
-    /// cursor in `mark` participates in the comparison. A zero mark represents
-    /// the already-reached position of an empty cursor.
-    /// @param cur Packed cursor or cursor pair containing the marked cursor.
-    /// @param mark Cursor-shaped positional reference.
-    /// @return Whether the live cursor position precedes the marked position.
-    function before(uint cur, uint mark) internal pure returns (bool) {
-        uint i = uint32(locate(cur, mark));
-        uint target = uint32(mark);
-        if (i > target) revert OutOfBounds();
-        return i < target;
-    }
-
     // Consumption
 
     /// @notice Return a cursor's absolute position and advance it.
@@ -343,8 +279,11 @@ library Cursors {
     /// @return updated Cursor advanced by `amount`.
     /// @return abs Absolute pre-advance position.
     function consume(uint cur, uint amount) internal pure returns (uint updated, uint abs) {
-        abs = Cursors.absolute(cur);
-        updated = advance(cur, amount);
+        uint i = uint32(cur);
+        uint len = uint32(cur >> 64);
+        if (amount > len - i) revert OutOfBounds();
+        abs = uint32(cur >> 32) + i;
+        updated = cur + amount;
     }
 
     /// @notice Select a tagged cursor, return its absolute position, and advance it.
@@ -355,6 +294,11 @@ library Cursors {
     /// @return abs Absolute pre-advance position in the selected lane.
     function consume(uint cur, uint8 tag, uint amount) internal pure returns (uint updated, uint abs) {
         updated = select(cur, tag);
-        (updated, abs) = consume(updated, amount);
+
+        uint i = uint32(updated);
+        uint len = uint32(updated >> 64);
+        if (amount > len - i) revert OutOfBounds();
+        abs = uint32(updated >> 32) + i;
+        updated += amount;
     }
 }

package/utils/Errors.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+/// @dev Thrown when an operation attempts to spend more value than remains.
+error InsufficientValue();
+
+/// @dev Thrown when a decoder or execution is finalized with unread data.
+error UnconsumedData();
+
+/// @dev Thrown when an ID does not match the expected convention or type.
+error InvalidId();
+
+/// @dev Thrown when an operation exceeds its logical data boundary.
+error OutOfBounds();
+
+/// @dev Thrown when a value exceeds the target integer width.
+error ValueOverflow();
+
+/// @dev Thrown when a value is not evenly divisible by its divisor.
+error NotDivisible();
+
+/// @dev Thrown when an identifier contains a zero address.
+error ZeroAddress();
+
+/// @dev Thrown when an address does not contain deployed bytecode.
+error InvalidContract();
+
+/// @dev Thrown when an account ID does not match the expected family or type.
+error InvalidAccount();
+
+/// @dev Thrown when an asset ID does not match the expected type or chain.
+error InvalidAsset();
+
+/// @dev Thrown when an asset is not authorized for an operation.
+error UnauthorizedAsset();
+
+/// @dev Thrown when a required nonzero amount is zero.
+error ZeroAmount();
+
+/// @dev Thrown when an amount falls outside its allowed range.
+error BadAmount(uint amount);
+
+/// @dev Thrown when an opaque ID preimage is missing or unsupported.
+error InvalidPreimage();
+
+/// @dev Thrown when a cursor is not positioned at the expected offset.
+error UnexpectedPosition();
+
+/// @dev Thrown when no packed cursor matches a requested identity.
+error MissingCursor();

package/utils/Ids.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
+import {InvalidId, InvalidPreimage} from "./Errors.sol";
+
 /// @title Ids
 /// @notice Shared helpers for the protocol-wide 256-bit ID convention.
 ///
@@ -10,11 +12,6 @@ pragma solidity ^0.8.33;
 /// Opaque keccak preimages start with `0x01`, and the ID is derived as:
 ///   `0x00 || bytes31(keccak256(preimage))`
 library Ids {
-    /// @dev Thrown when an ID does not match the expected convention.
-    error InvalidId();
-    /// @dev Thrown when an opaque ID preimage is missing or uses an unsupported format/hash tag.
-    error InvalidPreimage();
-
     /// @dev Preimage format/hash tag for keccak256-derived opaque IDs.
     uint8 constant Keccak = 0x01;
 

package/utils/Lanes.sol

@@ -9,6 +9,4 @@ library Lanes {
     uint8 internal constant State = 2;
     /// @dev Writer lane containing regular endpoint output blocks.
     uint8 internal constant Output = 3;
-    /// @dev Writer lane containing deferred transaction blocks.
-    uint8 internal constant Transactions = 4;
 }

package/utils/Nodes.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.33;
 
 import {Layout} from "./Layout.sol";
+import {InvalidId} from "./Errors.sol";
 import {Ids} from "./Ids.sol";
 import {ensureAddr, isFamily, matchesBase, toLocalBase} from "./Utils.sol";
 
@@ -20,9 +21,6 @@ import {ensureAddr, isFamily, matchesBase, toLocalBase} from "./Utils.sol";
 ///
 /// The helpers in this library validate and deconstruct structured node IDs.
 library Nodes {
-    /// @dev Thrown when an ID does not match the expected node type or chain.
-    error InvalidId();
-
     /// @dev 24-bit family tag shared by all node types (Evm + Node category).
     uint24 constant Family = (uint24(Layout.Evm) << 8) | uint24(Layout.Node);
     /// @dev Full 4-byte type prefix for chain/domain nodes.

package/utils/Utils.sol

@@ -1,18 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
+import {InvalidContract, NotDivisible, ValueOverflow, ZeroAddress} from "./Errors.sol";
+
 // Basis-points denominator: 10_000 BPS == 100.00%.
 uint16 constant MAX_BPS = 10_000;
 
-/// @dev Thrown by max* helpers when a value exceeds the target integer width.
-error ValueOverflow();
-/// @dev Thrown by `divisible` when `n` is not evenly divisible by `divisor`.
-error NotDivisible();
-/// @dev Thrown when an ID claims to carry an address but the embedded address is zero.
-error ZeroAddress();
-/// @dev Thrown when an address does not contain deployed bytecode.
-error InvalidContract();
-
 /// @notice Assert that `value` fits in uint8 and return it as uint8.
 function max8(uint value) pure returns (uint8) {
     if (value > type(uint8).max) {

package/codec/Readers.sol

@@ -1,190 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {Sizes, Specs} from "./Specs.sol";
-import {Keys} from "./Keys.sol";
-
-/// @notice Mutable reader over a block stream stored in memory.
-/// All positions (`i`) are byte offsets relative to the start of `source`.
-struct Reader {
-    /// @dev Current read position, relative to the source start.
-    uint i;
-    /// @dev Memory bytes containing the complete source region.
-    bytes source;
-}
-
-using Readers for Reader;
-
-/// @title Readers
-/// @notice Memory block stream parser for the rootzero protocol.
-/// A `Reader` advances through an existing `bytes memory` source without copying its contents.
-/// Blocks are encoded as `[bytes4 key][bytes4 payloadLen][payload]`.
-library Readers {
-    /// @dev The current block has a truncated header or payload, an unexpected key,
-    ///      or a payload size outside the accepted range.
-    error InvalidBlock();
-
-    /// @notice Create a reader backed by a memory byte array.
-    /// @param source Memory bytes containing the block stream.
-    /// @return cur Reader positioned at the beginning of `source`.
-    function open(bytes memory source) internal pure returns (Reader memory cur) {
-        cur.source = source;
-    }
-
-    /// @notice Return whether the reader has consumed its entire source.
-    /// @param cur Reader whose position should be checked.
-    /// @return Whether `cur.i` equals the source length.
-    function done(Reader memory cur) internal pure returns (bool) {
-        return cur.i == cur.source.length;
-    }
-
-    /// @notice Return whether the reader has bytes left to consume.
-    /// @param cur Reader whose position should be checked.
-    /// @return Whether `cur.i` differs from the source length.
-    function more(Reader memory cur) internal pure returns (bool) {
-        return cur.i != cur.source.length;
-    }
-
-    /// @notice Return whether the current block has `key` and an empty payload.
-    /// @param cur Reader inspected without advancing.
-    /// @param key Expected block key.
-    /// @return Whether a complete matching empty block header occurs at the current position.
-    function isEmpty(Reader memory cur, bytes4 key) internal pure returns (bool) {
-        bytes memory source = cur.source;
-        uint i = cur.i;
-        if (i > source.length || source.length - i < Sizes.Header) return false;
-
-        uint header;
-        assembly ("memory-safe") {
-            header := mload(add(add(source, 0x20), i))
-        }
-        return bytes4(uint32(header >> 224)) == key && uint32(header >> 192) == 0;
-    }
-
-    /// @notice Consume a matching empty block from the reader when present.
-    /// @param cur Reader advanced only when the matching block is empty.
-    /// @param key Expected block key.
-    /// @return Whether an empty block was consumed.
-    function tryConsumeEmpty(Reader memory cur, bytes4 key) internal pure returns (bool) {
-        bytes memory source = cur.source;
-        uint i = cur.i;
-        if (i > source.length || source.length - i < Sizes.Header) revert InvalidBlock();
-
-        bytes4 current;
-        uint len;
-        assembly ("memory-safe") {
-            let header := mload(add(add(source, 0x20), i))
-            current := header
-            len := and(shr(192, header), 0xffffffff)
-        }
-
-        if (len > source.length - i - Sizes.Header) revert InvalidBlock();
-        if (current != key || len != 0) return false;
-        cur.i += Sizes.Header;
-        return true;
-    }
-
-    /// @notice Validate and consume the current block, advancing `cur.i` past it.
-    /// @param cur Reader to advance.
-    /// @param key Expected block key.
-    /// @param min Minimum payload length.
-    /// @param max Maximum payload length; zero means unbounded.
-    /// @return abs Absolute memory address of the payload start.
-    function consume(
-        Reader memory cur,
-        bytes4 key,
-        uint min,
-        uint max
-    ) private pure returns (uint abs) {
-        bytes memory source = cur.source;
-        uint i = cur.i;
-
-        if (i > source.length || source.length - i < Sizes.Header) revert InvalidBlock();
-
-        bytes4 current;
-        uint len;
-        assembly ("memory-safe") {
-            let header := mload(add(add(source, 0x20), i))
-            current := header
-            len := and(shr(192, header), 0xffffffff)
-            abs := add(add(source, 0x28), i)
-        }
-
-        if (current != key || len < min || (max != 0 && len > max)) revert InvalidBlock();
-        if (len > source.length - i - Sizes.Header) revert InvalidBlock();
-        cur.i = i + Sizes.Header + len;
-    }
-
-    /// @notice Validate and consume the current block described by `spec`.
-    function consume(Reader memory cur, uint spec) internal pure returns (uint abs) {
-        (bytes4 key, uint32 min, uint32 max) = Specs.decode(spec);
-        return consume(cur, key, min, max);
-    }
-
-    /// @notice Consume a BALANCE block and return its fields.
-    /// @param cur Reader; advanced past the block.
-    /// @return asset Asset identifier.
-    /// @return amount Token amount.
-    function unpackBalance(Reader memory cur) internal pure returns (bytes32 asset, uint amount) {
-        uint abs = consume(cur, Keys.Balance, 64, 64);
-        assembly ("memory-safe") {
-            asset := mload(abs)
-            amount := mload(add(abs, 0x20))
-        }
-    }
-
-    /// @notice Consume a DEBT block and return its fields.
-    /// @param cur Reader; advanced past the block.
-    /// @return liability Liability identifier.
-    /// @return debt Debt quantity.
-    function unpackDebt(Reader memory cur) internal pure returns (bytes32 liability, uint debt) {
-        uint abs = consume(cur, Keys.Debt, 64, 64);
-        assembly ("memory-safe") {
-            liability := mload(abs)
-            debt := mload(add(abs, 0x20))
-        }
-    }
-
-    /// @notice Consume a HOST_ASSET block and return its fields.
-    /// @param cur Reader; advanced past the block.
-    /// @return host Host identifier.
-    /// @return asset Asset identifier.
-    function unpackHostAsset(Reader memory cur) internal pure returns (uint host, bytes32 asset) {
-        uint abs = consume(cur, Keys.HostAsset, 64, 64);
-        assembly ("memory-safe") {
-            host := mload(abs)
-            asset := mload(add(abs, 0x20))
-        }
-    }
-
-    /// @notice Consume a POSITION block and return its fields.
-    function unpackPosition(
-        Reader memory cur
-    ) internal pure returns (bytes32 asset, uint amount, bytes32 liability, uint debt) {
-        uint abs = consume(cur, Keys.Position, 128, 128);
-        assembly ("memory-safe") {
-            asset := mload(abs)
-            amount := mload(add(abs, 0x20))
-            liability := mload(add(abs, 0x40))
-            debt := mload(add(abs, 0x60))
-        }
-    }
-
-    /// @notice Consume a TRANSACTION block and return its fields.
-    /// @param cur Reader; advanced past the block.
-    /// @return from Source account identifier.
-    /// @return to Destination account identifier.
-    /// @return asset Asset identifier.
-    /// @return amount Token amount.
-    function unpackTransaction(
-        Reader memory cur
-    ) internal pure returns (bytes32 from, bytes32 to, bytes32 asset, uint amount) {
-        uint abs = consume(cur, Keys.Transaction, 128, 128);
-        assembly ("memory-safe") {
-            from := mload(abs)
-            to := mload(add(abs, 0x20))
-            asset := mload(add(abs, 0x40))
-            amount := mload(add(abs, 0x60))
-        }
-    }
-}