@rootzero/contracts 0.6.3 → 0.7.0

package/Commands.sol

@@ -1,42 +1,34 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-// Aggregator: re-exports all command and peer abstractions.
-// Import this file to inherit from any command or peer base contract without managing individual paths.
+// Aggregator: re-exports command, admin, and peer abstractions.
+// Import this file to inherit from the full rootzero command surface without managing individual paths.
 
-import { CommandBase, CommandContext, CommandPayable } from "./commands/Base.sol";
+import { CommandBase, CommandContext, CommandPayable, encodeCommandCall } from "./commands/Base.sol";
 import { State } from "./utils/State.sol";
-import { BorrowAgainstBalanceToBalance, BorrowAgainstCustodyToBalance } from "./commands/Borrow.sol";
 import { Burn } from "./commands/Burn.sol";
 import { Create } from "./commands/Create.sol";
 import { CreditAccount } from "./commands/Credit.sol";
 import { DebitAccount } from "./commands/Debit.sol";
 import { Deposit, DepositPayable } from "./commands/Deposit.sol";
 import { Remove } from "./commands/Remove.sol";
-import { AddLiquidityFromBalancesToBalances, AddLiquidityFromCustodiesToBalances, RemoveLiquidityFromBalanceToBalances, RemoveLiquidityFromCustodyToBalances } from "./commands/Liquidity.sol";
-import { LiquidateFromBalanceToBalances, LiquidateFromCustodyToBalances } from "./commands/Liquidate.sol";
-import { MintToBalances } from "./commands/Mint.sol";
 import { PipePayable } from "./commands/Pipe.sol";
 import { Provision, ProvisionPayable, ProvisionFromBalance } from "./commands/Provision.sol";
-import { ReclaimToBalances } from "./commands/Reclaim.sol";
-import { RedeemFromBalanceToBalances, RedeemFromCustodyToBalances } from "./commands/Redeem.sol";
-import { RepayFromBalanceToBalances, RepayFromCustodyToBalances } from "./commands/Repay.sol";
 import { Settle } from "./commands/Settle.sol";
-import { StakeBalanceToBalances, StakeCustodyToBalances, StakeCustodyToPosition } from "./commands/Stake.sol";
+import { StakeCustodyToPosition } from "./commands/Stake.sol";
 import { Supply } from "./commands/Supply.sol";
-import { SwapExactBalanceToBalance, SwapExactCustodyToBalance } from "./commands/Swap.sol";
 import { Transfer } from "./commands/Transfer.sol";
-import { UnstakeBalanceToBalances } from "./commands/Unstake.sol";
 import { Withdraw } from "./commands/Withdraw.sol";
-import { AllowAssets } from "./commands/admin/AllowAssets.sol";
+import { AllowAssets, AllowAssetsHook } from "./commands/admin/AllowAssets.sol";
 import { Destroy } from "./commands/admin/Destroy.sol";
 import { Authorize } from "./commands/admin/Authorize.sol";
-import { DenyAssets } from "./commands/admin/DenyAssets.sol";
+import { DenyAssets, DenyAssetsHook } from "./commands/admin/DenyAssets.sol";
 import { Init } from "./commands/admin/Init.sol";
 import { RelocatePayable } from "./commands/admin/Relocate.sol";
 import { Allocate } from "./commands/admin/Allocate.sol";
 import { Unauthorize } from "./commands/admin/Unauthorize.sol";
-import { PeerBase } from "./peer/Base.sol";
+import { PeerBase, encodePeerCall } from "./peer/Base.sol";
+import { PeerAssetPull } from "./peer/AssetPull.sol";
 import { PeerAllowAssets } from "./peer/AllowAssets.sol";
 import { PeerDenyAssets } from "./peer/DenyAssets.sol";
 import { PeerPull } from "./peer/Pull.sol";

package/Core.sol

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-// Aggregator: re-exports all core protocol contracts (Access, Balances, Host, Operation, Validator).
-// Import this file to bring the full host base layer into scope.
+// Aggregator: re-exports the core host, access, cursor, and validation layer.
+// Import this file to bring the full rootzero host base layer into scope.
 
 import { AccessControl } from "./core/Access.sol";
 import { Balances } from "./core/Balances.sol";
+import { CursorBase } from "./core/CursorBase.sol";
 import { Host } from "./core/Host.sol";
+import { HostBound } from "./core/HostBound.sol";
 import { FailedCall, OperationBase } from "./core/Operation.sol";
 import { Validator } from "./core/Validator.sol";
 import { HostDiscovery } from "./core/Host.sol";

package/Cursors.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.33;
 
-// Aggregator: re-exports all block stream primitives (Cursors, Writers, Schema, Keys).
+// Aggregator: re-exports all block stream primitives (Cursors, Writers, Schema, Keys, Sizes).
 // Import this file to get access to the full block encoding/decoding surface in one import.
 
-import { HostAmount, UserAmount, HostAsset, Tx, AssetAmount } from "./blocks/Schema.sol";
+import { HostAmount, UserAmount, HostAsset, Tx, AssetAmount, Sizes } from "./blocks/Schema.sol";
 import { Keys } from "./blocks/Keys.sol";
 import { Schemas } from "./blocks/Schema.sol";
 import { Cursors, Cur } from "./blocks/Cursors.sol";

package/Events.sol

@@ -11,13 +11,15 @@ import { CollateralEvent } from "./events/Collateral.sol";
 import { CommandEvent } from "./events/Command.sol";
 import { DebtEvent } from "./events/Debt.sol";
 import { DepositEvent } from "./events/Deposit.sol";
+import { Erc721PositionEvent } from "./events/Erc721.sol";
 import { EventEmitter } from "./events/Emitter.sol";
 import { GovernedEvent } from "./events/Governed.sol";
-import { HostAnnouncedEvent } from "./events/HostAnnounced.sol";
+import { HostAnnouncedEvent } from "./events/Host.sol";
 import { ListingEvent } from "./events/Listing.sol";
 import { PeerEvent } from "./events/Peer.sol";
-import { QuoteEvent } from "./events/Quote.sol";
+import { QueryEvent } from "./events/Query.sol";
 import { RootZeroEvent } from "./events/RootZero.sol";
+import { SwapEvent } from "./events/Swap.sol";
 import { WithdrawalEvent } from "./events/Withdraw.sol";
 
 

package/Queries.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+// Aggregator: re-exports query abstractions and reusable query bases.
+// Import this file to build rootzero query contracts without managing individual paths.
+
+import { IsAllowedAsset } from "./queries/Assets.sol";
+import { AssetPosition } from "./queries/Positions.sol";
+import { GetBalances } from "./queries/Balances.sol";
+import { QueryBase, encodeQueryCall } from "./queries/Base.sol";

package/blocks/Cursors.sol

@@ -222,6 +222,15 @@ library Cursors {
         return bytes.concat(key, bytes4(uint32(0x20)), value);
     }
 
+    /// @notice Encode a block with a 32-byte fixed head followed by a variable-length tail.
+    /// @param key Block type key.
+    /// @param head Fixed 32-byte head payload.
+    /// @param tail Variable-length payload bytes appended after the head.
+    /// @return Encoded block bytes.
+    function createHead32(bytes4 key, bytes32 head, bytes memory tail) internal pure returns (bytes memory) {
+        return bytes.concat(key, bytes4(uint32(0x20 + tail.length)), head, tail);
+    }
+
     /// @notice Encode a block with two 32-byte payload words (64-byte payload).
     /// @param key Block type key.
     /// @param a First payload word.
@@ -231,6 +240,16 @@ library Cursors {
         return bytes.concat(key, bytes4(uint32(0x40)), a, b);
     }
 
+    /// @notice Encode a block with a 64-byte fixed head followed by a variable-length tail.
+    /// @param key Block type key.
+    /// @param a First fixed payload word.
+    /// @param b Second fixed payload word.
+    /// @param tail Variable-length payload bytes appended after the fixed head.
+    /// @return Encoded block bytes.
+    function createHead64(bytes4 key, bytes32 a, bytes32 b, bytes memory tail) internal pure returns (bytes memory) {
+        return bytes.concat(key, bytes4(uint32(0x40 + tail.length)), a, b, tail);
+    }
+
     /// @notice Encode a block with three 32-byte payload words (96-byte payload).
     /// @param key Block type key.
     /// @param a First payload word.
@@ -283,6 +302,15 @@ library Cursors {
         return create32(Keys.Fee, bytes32(amount));
     }
 
+    /// @notice Encode a STEP block.
+    /// @param target Command target identifier.
+    /// @param value Native value forwarded with the step.
+    /// @param request Variable-length nested request payload.
+    /// @return Encoded STEP block bytes.
+    function toStepBlock(uint target, uint value, bytes memory request) internal pure returns (bytes memory) {
+        return createHead64(Keys.Step, bytes32(target), bytes32(value), request);
+    }
+
     /// @notice Encode a BALANCE block.
     /// @param asset Asset identifier.
     /// @param meta Asset metadata slot.
@@ -487,14 +515,6 @@ library Cursors {
         account = bytes32(msg.data[abs:abs + 32]);
     }
 
-    /// @notice Consume a PARTY block and return the account.
-    /// @param cur Cursor; advanced past the block.
-    /// @return account Counter-party account identifier.
-    function unpackParty(Cur memory cur) internal pure returns (bytes32 account) {
-        uint abs = consume(cur, Keys.Party, 32, 32);
-        account = bytes32(msg.data[abs:abs + 32]);
-    }
-
     /// @notice Consume a RATE block and return the value.
     /// @param cur Cursor; advanced past the block.
     /// @return value Encoded ratio or rate.
@@ -601,6 +621,26 @@ library Cursors {
         cur.i = next;
     }
 
+    /// @notice Consume a QUERY block and return the raw payload as a calldata slice.
+    /// The payload length is variable; the returned slice covers the entire payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return data Raw query payload bytes.
+    function unpackQuery(Cur memory cur) internal pure returns (bytes calldata data) {
+        (uint abs, uint next) = expect(cur, cur.i, Keys.Query, 0, 0);
+        data = msg.data[abs:cur.offset + next];
+        cur.i = next;
+    }
+
+    /// @notice Consume a RESPONSE block and return the raw payload as a calldata slice.
+    /// The payload length is variable; the returned slice covers the entire payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return data Raw response payload bytes.
+    function unpackResponse(Cur memory cur) internal pure returns (bytes calldata data) {
+        (uint abs, uint next) = expect(cur, cur.i, Keys.Response, 0, 0);
+        data = msg.data[abs:cur.offset + next];
+        cur.i = next;
+    }
+
     /// @notice Consume a PATH block and return the raw payload as a calldata slice.
     /// The payload length is variable; the returned slice covers the entire payload.
     /// @param cur Cursor; advanced past the block.
@@ -619,6 +659,22 @@ library Cursors {
         value = uint(bytes32(msg.data[abs:abs + 32]));
     }
 
+    /// @notice Consume a QUERY block with a single uint payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return value Decoded uint value.
+    function unpackQueryUint(Cur memory cur) internal pure returns (uint value) {
+        uint abs = consume(cur, Keys.Query, 32, 32);
+        value = uint(bytes32(msg.data[abs:abs + 32]));
+    }
+
+    /// @notice Consume a RESPONSE block with a single uint payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return value Decoded uint value.
+    function unpackResponseUint(Cur memory cur) internal pure returns (uint value) {
+        uint abs = consume(cur, Keys.Response, 32, 32);
+        value = uint(bytes32(msg.data[abs:abs + 32]));
+    }
+
     /// @notice Consume a ROUTE block with two uint payload words.
     /// @param cur Cursor; advanced past the block.
     /// @return a First decoded uint.
@@ -629,6 +685,26 @@ library Cursors {
         b = uint(bytes32(msg.data[abs + 32:abs + 64]));
     }
 
+    /// @notice Consume a QUERY block with two uint payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded uint.
+    /// @return b Second decoded uint.
+    function unpackQuery2Uint(Cur memory cur) internal pure returns (uint a, uint b) {
+        uint abs = consume(cur, Keys.Query, 64, 64);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+    }
+
+    /// @notice Consume a RESPONSE block with two uint payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded uint.
+    /// @return b Second decoded uint.
+    function unpackResponse2Uint(Cur memory cur) internal pure returns (uint a, uint b) {
+        uint abs = consume(cur, Keys.Response, 64, 64);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+    }
+
     /// @notice Consume a ROUTE block with three uint payload words.
     /// @param cur Cursor; advanced past the block.
     /// @return a First decoded uint.
@@ -641,6 +717,30 @@ library Cursors {
         c = uint(bytes32(msg.data[abs + 64:abs + 96]));
     }
 
+    /// @notice Consume a QUERY block with three uint payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded uint.
+    /// @return b Second decoded uint.
+    /// @return c Third decoded uint.
+    function unpackQuery3Uint(Cur memory cur) internal pure returns (uint a, uint b, uint c) {
+        uint abs = consume(cur, Keys.Query, 96, 96);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+        c = uint(bytes32(msg.data[abs + 64:abs + 96]));
+    }
+
+    /// @notice Consume a RESPONSE block with three uint payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded uint.
+    /// @return b Second decoded uint.
+    /// @return c Third decoded uint.
+    function unpackResponse3Uint(Cur memory cur) internal pure returns (uint a, uint b, uint c) {
+        uint abs = consume(cur, Keys.Response, 96, 96);
+        a = uint(bytes32(msg.data[abs:abs + 32]));
+        b = uint(bytes32(msg.data[abs + 32:abs + 64]));
+        c = uint(bytes32(msg.data[abs + 64:abs + 96]));
+    }
+
     /// @notice Consume a ROUTE block with a single bytes32 payload.
     /// @param cur Cursor; advanced past the block.
     /// @return value Decoded bytes32.
@@ -649,6 +749,22 @@ library Cursors {
         value = bytes32(msg.data[abs:abs + 32]);
     }
 
+    /// @notice Consume a QUERY block with a single bytes32 payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return value Decoded bytes32.
+    function unpackQuery32(Cur memory cur) internal pure returns (bytes32 value) {
+        uint abs = consume(cur, Keys.Query, 32, 32);
+        value = bytes32(msg.data[abs:abs + 32]);
+    }
+
+    /// @notice Consume a RESPONSE block with a single bytes32 payload.
+    /// @param cur Cursor; advanced past the block.
+    /// @return value Decoded bytes32.
+    function unpackResponse32(Cur memory cur) internal pure returns (bytes32 value) {
+        uint abs = consume(cur, Keys.Response, 32, 32);
+        value = bytes32(msg.data[abs:abs + 32]);
+    }
+
     /// @notice Consume a ROUTE block with two bytes32 payload words.
     /// @param cur Cursor; advanced past the block.
     /// @return a First decoded bytes32.
@@ -659,6 +775,26 @@ library Cursors {
         b = bytes32(msg.data[abs + 32:abs + 64]);
     }
 
+    /// @notice Consume a QUERY block with two bytes32 payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded bytes32.
+    /// @return b Second decoded bytes32.
+    function unpackQuery64(Cur memory cur) internal pure returns (bytes32 a, bytes32 b) {
+        uint abs = consume(cur, Keys.Query, 64, 64);
+        a = bytes32(msg.data[abs:abs + 32]);
+        b = bytes32(msg.data[abs + 32:abs + 64]);
+    }
+
+    /// @notice Consume a RESPONSE block with two bytes32 payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded bytes32.
+    /// @return b Second decoded bytes32.
+    function unpackResponse64(Cur memory cur) internal pure returns (bytes32 a, bytes32 b) {
+        uint abs = consume(cur, Keys.Response, 64, 64);
+        a = bytes32(msg.data[abs:abs + 32]);
+        b = bytes32(msg.data[abs + 32:abs + 64]);
+    }
+
     /// @notice Consume a ROUTE block with three bytes32 payload words.
     /// @param cur Cursor; advanced past the block.
     /// @return a First decoded bytes32.
@@ -671,6 +807,30 @@ library Cursors {
         c = bytes32(msg.data[abs + 64:abs + 96]);
     }
 
+    /// @notice Consume a QUERY block with three bytes32 payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded bytes32.
+    /// @return b Second decoded bytes32.
+    /// @return c Third decoded bytes32.
+    function unpackQuery96(Cur memory cur) internal pure returns (bytes32 a, bytes32 b, bytes32 c) {
+        uint abs = consume(cur, Keys.Query, 96, 96);
+        a = bytes32(msg.data[abs:abs + 32]);
+        b = bytes32(msg.data[abs + 32:abs + 64]);
+        c = bytes32(msg.data[abs + 64:abs + 96]);
+    }
+
+    /// @notice Consume a RESPONSE block with three bytes32 payload words.
+    /// @param cur Cursor; advanced past the block.
+    /// @return a First decoded bytes32.
+    /// @return b Second decoded bytes32.
+    /// @return c Third decoded bytes32.
+    function unpackResponse96(Cur memory cur) internal pure returns (bytes32 a, bytes32 b, bytes32 c) {
+        uint abs = consume(cur, Keys.Response, 96, 96);
+        a = bytes32(msg.data[abs:abs + 32]);
+        b = bytes32(msg.data[abs + 32:abs + 64]);
+        c = bytes32(msg.data[abs + 64:abs + 96]);
+    }
+
     /// @notice Consume a CUSTODY block and return its fields as a struct.
     /// @param cur Cursor; advanced past the block.
     /// @return value Decoded host, asset, meta, and amount.

package/blocks/Keys.sol

@@ -30,6 +30,10 @@ library Keys {
     bytes4 constant Bundle = bytes4(keccak256("bundle(bytes data)"));
     /// @dev Extensible routing field — (bytes data); layout is command-defined
     bytes4 constant Route = bytes4(keccak256("route(bytes data)"));
+    /// @dev Extensible query field - (bytes data); layout is query-defined, key is always `Keys.Query`
+    bytes4 constant Query = bytes4(keccak256("query(bytes data)"));
+    /// @dev Extensible response field - (bytes data); layout is response-defined, key is always `Keys.Response`
+    bytes4 constant Response = bytes4(keccak256("response(bytes data)"));
     /// @dev Opaque path payload — (bytes data); e.g. a Uniswap path encoding
     bytes4 constant Path = bytes4(keccak256("path(bytes data)"));
     /// @dev Plain scalar amount — (uint amount)
@@ -37,7 +41,6 @@ library Keys {
     /// @dev Ratio or rate value — (uint value)
     bytes4 constant Rate = bytes4(keccak256("rate(uint value)"));
     /// @dev Counter-party account — (bytes32 account)
-    bytes4 constant Party = bytes4(keccak256("party(bytes32 account)"));
     /// @dev Destination account — (bytes32 account)
     bytes4 constant Recipient = bytes4(keccak256("recipient(bytes32 account)"));
     /// @dev Transfer record passed through the pipeline — (bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)

package/blocks/Schema.sol

@@ -19,11 +19,12 @@ library Schemas {
     string constant Fee = "fee(uint amount)";
     string constant Break = "break()";
     string constant Route = "route(bytes data)";
+    string constant Query = "query(bytes data)";
+    string constant Response = "response(bytes data)";
     string constant Path = "path(bytes data)";
     string constant RouteEmpty = "route()";
     string constant Quantity = "quantity(uint amount)";
     string constant Rate = "rate(uint value)";
-    string constant Party = "party(bytes32 account)";
     string constant Recipient = "recipient(bytes32 account)";
     string constant Transaction = "tx(bytes32 from, bytes32 to, bytes32 asset, bytes32 meta, uint amount)";
     string constant Step = "step(uint target, uint value, bytes request)";
@@ -72,7 +73,11 @@ library Schemas {
 // - `->` separates request and response shapes, appears at most once, and is omitted when no output is modeled
 // - top-level blocks of the same type should be grouped together
 // - primary / driving blocks should appear before auxiliary blocks
-// - `route(<fields...>)` is a reserved extensible schema form whose key is always `Keys.Route`
+// - `route(<fields...>)`, `query(<fields...>)`, and `response(<fields...>)` are reserved
+//   extensible schema forms whose keys are always `Keys.Route`, `Keys.Query`, and
+//   `Keys.Response` respectively
+// - these extensible forms work like dynamic `bytes` blocks: they may carry arbitrary
+//   payload bytes while keeping one fixed key per semantic block type
 // - `&` compiles to a `Keys.Bundle` block whose self payload is the bundled member block stream
 // - canonical blocks are `amount(...)` for request amounts, `balance(...)` for state balances,
 //   `minimum(...)` for result floors, `maximum(...)` for spend ceilings, and `quantity(...)`
@@ -90,26 +95,42 @@ library Schemas {
 /// @title Sizes
 /// @notice Total byte sizes for fixed-width block types, including the 8-byte header (4-byte key + 4-byte payloadLen).
 library Sizes {
+    /// @dev Shared block header size: 4-byte key + 4-byte payload length.
+    uint constant Header = 8;
+    /// @dev One fixed-width payload word.
+    uint constant Word = 32;
+    /// @dev 8 header + 32 payload = 40 bytes total.
+    uint constant B32 = Header + Word;
+    /// @dev 8 header + 64 payload = 72 bytes total.
+    uint constant B64 = Header + 2 * Word;
+    /// @dev 8 header + 96 payload = 104 bytes total.
+    uint constant B96 = Header + 3 * Word;
+    /// @dev 8 header + 128 payload = 136 bytes total.
+    uint constant B128 = Header + 4 * Word;
+    /// @dev 8 header + 160 payload = 168 bytes total.
+    uint constant B160 = Header + 5 * Word;
     /// @dev AUTH proof segment only: 20-byte signer + 65-byte signature = 85 bytes
     uint constant Proof = 85;
     /// @dev AUTH block: 8 header + 32 cid + 32 deadline + 85 proof = 157 bytes
-    uint constant Auth = 157;
+    uint constant Auth = B64 + Proof;
+    /// @dev AMOUNT block: 8 header + 32 asset + 32 meta + 32 amount = 104 bytes
+    uint constant Amount = B96;
     /// @dev BALANCE block: 8 header + 32 asset + 32 meta + 32 amount = 104 bytes
-    uint constant Balance = 104;
+    uint constant Balance = B96;
     /// @dev MINIMUMS block: 8 header + 32 a + 32 b = 72 bytes
-    uint constant Minimums = 72;
+    uint constant Minimums = B64;
     /// @dev MAXIMUMS block: 8 header + 32 a + 32 b = 72 bytes
-    uint constant Maximums = 72;
+    uint constant Maximums = B64;
     /// @dev BOUNDS block: 8 header + 32 min + 32 max = 72 bytes
-    uint constant Bounds = 72;
+    uint constant Bounds = B64;
     /// @dev FEE block: 8 header + 32 amount = 40 bytes
-    uint constant Fee = 40;
+    uint constant Fee = B32;
     /// @dev BOUNTY block: 8 header + 32 amount + 32 relayer = 72 bytes
-    uint constant Bounty = 72;
+    uint constant Bounty = B64;
     /// @dev CUSTODY block: 8 header + 32 host + 32 asset + 32 meta + 32 amount = 136 bytes
-    uint constant Custody = 136;
+    uint constant Custody = B128;
     /// @dev TRANSACTION block: 8 header + 32 from + 32 to + 32 asset + 32 meta + 32 amount = 168 bytes
-    uint constant Transaction = 168;
+    uint constant Transaction = B160;
 }
 
 /// @notice Asset and amount pair; used for balance and amount blocks.