@rootzero/contracts 0.4.0 → 0.5.0

package/contracts/test/TestSwapHost.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Host } from "../core/Host.sol";
+import { SwapExactBalanceToBalance } from "../commands/Swap.sol";
+import { AssetAmount, Cur, Cursors, Cursors, Keys } from "../Cursors.sol";
+
+using Cursors for Cur;
+
+contract TestSwapHost is Host, SwapExactBalanceToBalance {
+    event SwapMapped(bytes32 account, bytes32 asset, bytes32 meta, uint amount, bytes inputData);
+    event SwapMinimum(bytes32 asset, bytes32 meta, uint amount);
+
+    constructor(address rootzero)
+        Host(rootzero, 1, "test")
+        SwapExactBalanceToBalance("route(bytes data)")
+    {}
+
+    function swapExactBalanceToBalance(
+        bytes32 account,
+        AssetAmount memory balance,
+        Cur memory request
+    ) internal override returns (AssetAmount memory out) {
+        if (request.i == request.len) revert Cursors.InvalidBlock();
+
+        Cur memory input = request;
+        (bytes4 key, uint len) = request.peek(request.i);
+        if (key == Keys.Bundle) input = request.bundle();
+
+        bytes calldata inputData;
+        (key, len) = input.peek(input.i);
+        if (key == Keys.Route) {
+            inputData = input.unpackRoute();
+        } else {
+            uint next = input.i + 8 + len;
+            inputData = msg.data[input.offset + input.i:input.offset + next];
+            input.i = next;
+        }
+        emit SwapMapped(account, balance.asset, balance.meta, balance.amount, inputData);
+
+        if (input.i < input.len) {
+            (key, ) = input.peek(input.i);
+        }
+        if (input.i < input.len && key == Keys.Minimum) {
+            (bytes32 minAsset, bytes32 minMeta, uint minAmount) = input.unpackMinimum();
+            emit SwapMinimum(minAsset, minMeta, minAmount);
+        }
+
+        return AssetAmount({
+            asset: balance.asset,
+            meta: bytes32(inputData.length),
+            amount: balance.amount + inputData.length
+        });
+    }
+
+    function getSwapExactInAsset32Id() external view returns (uint) {
+        return swapExactBalanceToBalanceId;
+    }
+
+    function getAdminAccount() external view returns (bytes32) {
+        return adminAccount;
+    }
+}
+
+
+
+

package/contracts/test/TestUtils.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Accounts } from "../utils/Accounts.sol";
+import { Amounts, Assets } from "../utils/Assets.sol";
+import { Ids, Selectors } from "../utils/Ids.sol";
+import { addrOr, applyBps, beforeBps, bytes32ToString, isFamily, isLocal, isLocalFamily, matchesBase, toLocalBase, toUnspecifiedBase, max8, max16, max32, max64, max128, max160 } from "../utils/Utils.sol";
+import { Values } from "../utils/Value.sol";
+
+contract TestUtils {
+    function testAddrOr(address addr, address or_) external pure returns (address) {
+        return addrOr(addr, or_);
+    }
+
+    function testToAdminAccount(address addr) external view returns (bytes32) {
+        return Accounts.toAdmin(addr);
+    }
+
+    function testToUserAccount(address addr) external pure returns (bytes32) {
+        return Accounts.toUser(addr);
+    }
+
+    function testAccountEvmAddr(bytes32 account) external pure returns (address) {
+        return Accounts.addrEvm(account);
+    }
+
+    function testIsAdminAccount(bytes32 account) external pure returns (bool) {
+        return Accounts.isAdmin(account);
+    }
+
+    function testIsKeccakAccount(bytes32 account) external pure returns (bool) {
+        return Accounts.isKeccak(account);
+    }
+
+    function testToKeccakAccount(bytes calldata raw) external pure returns (bytes32) {
+        return Accounts.toKeccak(raw);
+    }
+
+    function testMatchesKeccakAccount(bytes32 account, bytes calldata raw) external pure returns (bool) {
+        return Accounts.matchesKeccak(account, raw);
+    }
+
+    function testToValueAsset() external view returns (bytes32) {
+        return Assets.toValue();
+    }
+
+    function testToErc20Asset(address addr) external view returns (bytes32) {
+        return Assets.toErc20(addr);
+    }
+
+    function testToErc721Asset(address addr) external view returns (bytes32) {
+        return Assets.toErc721(addr);
+    }
+
+    function testIsAsset32(bytes32 asset) external pure returns (bool) {
+        return Assets.is32(asset);
+    }
+
+    function testResolveAmount(uint available, uint min, uint max) external pure returns (uint) {
+        return Amounts.resolve(available, min, max);
+    }
+
+    function testEnsureAmount(uint amount) external pure returns (uint) {
+        return Amounts.ensure(amount);
+    }
+
+    function testEnsureAmountRange(uint amount, uint min, uint max) external pure returns (uint) {
+        return Amounts.ensure(amount, min, max);
+    }
+
+    function testAssetKey(bytes32 asset, bytes32 meta) external pure returns (bytes32) {
+        return Assets.key(asset, meta);
+    }
+
+    function testLocalErc20Addr(bytes32 asset) external view returns (address) {
+        return Assets.erc20Addr(asset);
+    }
+
+    function testLocalErc721Issuer(bytes32 asset) external view returns (address) {
+        return Assets.erc721Issuer(asset);
+    }
+
+    function testToHostId(address addr) external view returns (uint) {
+        return Ids.toHost(addr);
+    }
+
+    function testToCommandId(bytes32 name, address addr) external view returns (uint) {
+        return Ids.toCommand(Selectors.command(bytes32ToString(name)), addr);
+    }
+
+    function testToCommandSelector(bytes32 name) external pure returns (bytes4) {
+        return Selectors.command(bytes32ToString(name));
+    }
+
+    function testIsHost(uint id) external pure returns (bool) {
+        return Ids.isHost(id);
+    }
+
+    function testIsCommand(uint id) external pure returns (bool) {
+        return Ids.isCommand(id);
+    }
+
+    function testLocalNodeAddr(uint node) external view returns (address) {
+        return Ids.nodeAddr(node);
+    }
+
+    function testLocalHostAddr(uint host) external view returns (address) {
+        return Ids.hostAddr(host);
+    }
+
+    function testEnsureHost(uint id, address addr) external view returns (uint) {
+        return Ids.host(id, addr);
+    }
+
+    function testEnsureCommand(uint id) external pure returns (uint) {
+        return Ids.command(id);
+    }
+
+    function testApplyBps(uint amount, uint16 bps) external pure returns (uint) {
+        return applyBps(amount, bps);
+    }
+
+    function testBeforeBps(uint amount, uint16 bps) external pure returns (uint) {
+        return beforeBps(amount, bps);
+    }
+
+    function testIsFamily(uint value, uint24 family) external pure returns (bool) {
+        return isFamily(value, family);
+    }
+
+    function testIsLocal(uint value) external view returns (bool) {
+        return isLocal(value);
+    }
+
+    function testMatchesBase(bytes32 value, uint base) external pure returns (bool) {
+        return matchesBase(value, base);
+    }
+
+    function testToLocalBase(uint32 prefix) external view returns (uint) {
+        return toLocalBase(prefix);
+    }
+
+    function testMsgValue() external payable returns (uint) {
+        Values.Budget memory budget = Values.fromMsg();
+        return budget.remaining;
+    }
+
+    function testUseValue(uint amount, uint remaining) external pure returns (uint spent, uint remainingAfter) {
+        Values.Budget memory budget = Values.Budget({remaining: remaining});
+        spent = Values.use(budget, amount);
+        remainingAfter = budget.remaining;
+    }
+
+    function testBytes32ToString(bytes32 value) external pure returns (string memory) {
+        return bytes32ToString(value);
+    }
+
+    function testMax8(uint value) external pure returns (uint) {
+        return max8(value);
+    }
+
+    function testMax16(uint value) external pure returns (uint) {
+        return max16(value);
+    }
+
+    function testMax32(uint value) external pure returns (uint) {
+        return max32(value);
+    }
+
+    function testMax64(uint value) external pure returns (uint) {
+        return max64(value);
+    }
+
+    function testMax128(uint value) external pure returns (uint) {
+        return max128(value);
+    }
+
+    function testMax160(uint value) external pure returns (uint) {
+        return max160(value);
+    }
+}
+
+
+

package/contracts/test/TestValidator.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import { Validator } from "../core/Validator.sol";
+
+contract TestValidator is Validator {
+    function testVerify(bytes32 hash, uint192 nonce, bytes calldata proof) external returns (address) {
+        return verify(hash, nonce, proof);
+    }
+}
+
+
+

package/{utils → contracts/utils}/Accounts.sol

@@ -70,6 +70,17 @@ library Accounts {
         return account == toKeccak(raw);
     }
 
+    /// @notice Assert that `account` uses the Account layout tag and return it unchanged.
+    /// Ignores width, chain binding, and subtype details.
+    /// @param account Account ID to validate.
+    /// @return The same `account` value if valid.
+    function ensure(bytes32 account) internal pure returns (bytes32) {
+        if (uint8(uint(account) >> 232) != Layout.Account) {
+            revert InvalidAccount();
+        }
+        return account;
+    }
+
     /// @notice Assert that `account` belongs to the EVM account family and return it unchanged.
     /// @param account Account ID to validate.
     /// @return The same `account` value if valid.

package/package.json

@@ -1,17 +1,33 @@
-{
-  "name": "@rootzero/contracts",
-  "version": "0.4.0",
-  "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
-  "private": false,
-  "license": "GPL-3.0-only",
-  "type": "module",
-  "files": [
-    "**/*.sol",
-    "README.md",
-    "LICENSE",
-    "docs/GETTING_STARTED.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@rootzero/contracts",
+  "version": "0.5.0",
+  "description": "Solidity contracts and protocol building blocks for rootzero hosts and commands.",
+  "private": false,
+  "license": "GPL-3.0-only",
+  "type": "module",
+  "files": [
+    "*.sol",
+    "contracts/**/*.sol",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "prepublishOnly": "npm test",
+    "prepare:package": "node scripts/prepare-package.mjs",
+    "pack:package": "npm run prepare:package && npm pack ./dist/package",
+    "publish:package": "npm test && npm run prepare:package && npm publish ./dist/package --access public"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-mocha": "^3.0.13",
+    "chai": "^6.2.2",
+    "ethers": "^6.16.0",
+    "hardhat": "^3.1.7",
+    "mocha": "^11.7.5",
+    "typescript": "~5.8.0"
+  }
+}

package/blocks/Mem.sol

@@ -1,188 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import { HostAmount, Tx, Keys } from "./Schema.sol";
-import { Cursors } from "./Cursors.sol";
-
-/// @notice Reference to a single block inside a `bytes memory` buffer.
-/// Positions are byte offsets within the buffer (not absolute memory addresses).
-struct MemRef {
-    /// @dev Block type identifier read from the 4-byte header key.
-    bytes4 key;
-    /// @dev Payload start offset (byte immediately after the 8-byte header).
-    uint i;
-    /// @dev Payload end offset (equals `i + payloadLen`).
-    uint end;
-}
-
-/// @title Mem
-/// @notice Memory block stream parser for the rootzero protocol.
-/// Mirrors the calldata-oriented `Cursors` API but operates on `bytes memory`
-/// buffers, using `mcopy`/`mload` assembly instead of `msg.data` slices.
-library Mem {
-    /// @notice Parse a block header at offset `i` within `source`.
-    /// Returns an empty sentinel `MemRef` (all zeros) when `i` is at end-of-data.
-    /// @param source In-memory block stream buffer.
-    /// @param i Byte offset of the block header within `source`.
-    /// @return ref Parsed block reference with key, payload start, and payload end.
-    function from(bytes memory source, uint i) internal pure returns (MemRef memory ref) {
-        uint eod = source.length;
-        if (i == eod) return MemRef(bytes4(0), i, i);
-        if (i > eod) revert Cursors.MalformedBlocks();
-
-        unchecked {
-            ref.i = i + 8;
-        }
-        if (ref.i > eod) revert Cursors.MalformedBlocks();
-
-        // Read the 8-byte block header (key + payloadLen) in one mload.
-        bytes32 w;
-        assembly ("memory-safe") {
-            w := mload(add(add(source, 0x20), i))
-        }
-
-        ref.key = bytes4(w);
-        ref.end = ref.i + uint32(bytes4(w << 32));
-        if (ref.end > eod) revert Cursors.MalformedBlocks();
-    }
-
-    /// @notice Extract a byte range `[start, end)` from `source` into a new buffer.
-    /// @param source Source buffer.
-    /// @param start Inclusive start offset.
-    /// @param end Exclusive end offset.
-    /// @return out Copied slice as a new `bytes` value.
-    function slice(bytes memory source, uint start, uint end) internal pure returns (bytes memory out) {
-        if (end < start || end > source.length) revert Cursors.MalformedBlocks();
-        uint len = end - start;
-        out = new bytes(len);
-        if (len == 0) return out;
-
-        assembly ("memory-safe") {
-            mcopy(add(out, 0x20), add(add(source, 0x20), start), len)
-        }
-    }
-
-    /// @notice Count consecutive blocks of `key` starting at offset `i`.
-    /// @param source Source buffer.
-    /// @param i Starting byte offset.
-    /// @param key Block type to count.
-    /// @return total Number of consecutive matching blocks.
-    /// @return cursor Byte offset immediately after the last counted block.
-    function count(bytes memory source, uint i, bytes4 key) internal pure returns (uint total, uint cursor) {
-        cursor = i;
-        while (cursor < source.length) {
-            MemRef memory ref = from(source, cursor);
-            if (ref.key != key) break;
-            unchecked {
-                ++total;
-            }
-            cursor = ref.end;
-        }
-    }
-
-    /// @notice Scan forward from `i` up to `limit` for the first block matching `key`.
-    /// Returns an empty sentinel `MemRef` (key == 0, i == end == limit) if not found.
-    /// @param source Source buffer.
-    /// @param i Starting byte offset.
-    /// @param limit Exclusive upper bound for the search (must be ≤ `source.length`).
-    /// @param key Block type to find.
-    /// @return ref Reference to the first matching block, or the sentinel if absent.
-    function find(bytes memory source, uint i, uint limit, bytes4 key) internal pure returns (MemRef memory ref) {
-        if (limit > source.length) revert Cursors.MalformedBlocks();
-        while (i < limit) {
-            ref = from(source, i);
-            if (ref.end > limit) revert Cursors.MalformedBlocks();
-            if (ref.key == key) return ref;
-            i = ref.end;
-        }
-
-        return MemRef(bytes4(0), limit, limit);
-    }
-
-    /// @notice Assert that `ref` points to a block of the expected type.
-    /// @param ref Block reference to validate.
-    /// @param key Expected block type key.
-    function ensure(MemRef memory ref, bytes4 key) internal pure {
-        if (key == 0 || key != ref.key) revert Cursors.InvalidBlock();
-    }
-
-    /// @notice Assert that `ref` points to a block of the expected type with exact payload length.
-    /// @param ref Block reference to validate.
-    /// @param key Expected block type key.
-    /// @param len Expected payload byte length.
-    function ensure(MemRef memory ref, bytes4 key, uint len) internal pure {
-        if (key == 0 || key != ref.key || len != (ref.end - ref.i)) revert Cursors.InvalidBlock();
-    }
-
-    /// @notice Assert that `ref` points to a block of the expected type within a length range.
-    /// @param ref Block reference to validate.
-    /// @param key Expected block type key.
-    /// @param min Minimum payload length (inclusive).
-    /// @param max Maximum payload length (inclusive); 0 means unbounded.
-    function ensure(MemRef memory ref, bytes4 key, uint min, uint max) internal pure {
-        uint len = ref.end - ref.i;
-        if (key == 0 || key != ref.key || len < min || (max != 0 && len > max)) revert Cursors.InvalidBlock();
-    }
-
-    /// @notice Decode a BALANCE block payload from `source` using the given reference.
-    /// @param ref Block reference; must point to a BALANCE block with exactly 96 payload bytes.
-    /// @param source Buffer containing the block.
-    /// @return asset Asset identifier.
-    /// @return meta Asset metadata slot.
-    /// @return amount Token amount.
-    function unpackBalance(
-        MemRef memory ref,
-        bytes memory source
-    ) internal pure returns (bytes32 asset, bytes32 meta, uint amount) {
-        ensure(ref, Keys.Balance, 96);
-        uint i = ref.i;
-
-        // Read three contiguous 32-byte words from the payload.
-        assembly ("memory-safe") {
-            let p := add(add(source, 0x20), i)
-            asset := mload(p)
-            meta := mload(add(p, 0x20))
-            amount := mload(add(p, 0x40))
-        }
-    }
-
-    /// @notice Decode a CUSTODY block payload from `source` into a `HostAmount` struct.
-    /// @param ref Block reference; must point to a CUSTODY block with exactly 128 payload bytes.
-    /// @param source Buffer containing the block.
-    /// @return value Decoded host, asset, meta, and amount.
-    function toCustodyValue(
-        MemRef memory ref,
-        bytes memory source
-    ) internal pure returns (HostAmount memory value) {
-        ensure(ref, Keys.Custody, 128);
-        uint i = ref.i;
-
-        // Copy four 32-byte payload words directly into the struct memory slots.
-        assembly ("memory-safe") {
-            let p := add(add(source, 0x20), i)
-            mstore(value, mload(p))
-            mstore(add(value, 0x20), mload(add(p, 0x20)))
-            mstore(add(value, 0x40), mload(add(p, 0x40)))
-            mstore(add(value, 0x60), mload(add(p, 0x60)))
-        }
-    }
-
-    /// @notice Decode a TRANSACTION block payload from `source` into a `Tx` struct.
-    /// @param ref Block reference; must point to a TRANSACTION block with exactly 160 payload bytes.
-    /// @param source Buffer containing the block.
-    /// @return value Decoded from, to, asset, meta, and amount.
-    function toTxValue(MemRef memory ref, bytes memory source) internal pure returns (Tx memory value) {
-        ensure(ref, Keys.Transaction, 160);
-        uint i = ref.i;
-
-        // Copy five 32-byte payload words directly into the struct memory slots.
-        assembly ("memory-safe") {
-            let p := add(add(source, 0x20), i)
-            mstore(value, mload(p))
-            mstore(add(value, 0x20), mload(add(p, 0x20)))
-            mstore(add(value, 0x40), mload(add(p, 0x40)))
-            mstore(add(value, 0x60), mload(add(p, 0x60)))
-            mstore(add(value, 0x80), mload(add(p, 0x80)))
-        }
-    }
-}