@rootzero/contracts 0.2.0

package/contracts/test/TestUtils.sol

@@ -0,0 +1,169 @@
+// 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 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 testEnsureAssetRef(bytes32 asset, bytes32 meta) external pure returns (bytes32) {
+        return Assets.ensureRef(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,10 @@
+// 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/contracts/utils/Accounts.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Layout} from "./Layout.sol";
+import {isFamily, toLocalBase, toUnspecifiedBase} from "./Utils.sol";
+
+library Accounts {
+    error InvalidAccount();
+
+    uint24 constant Family = (uint24(Layout.Evm32) << 8) | uint24(Layout.Account);
+    uint32 constant Admin = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Account) << 8) | uint32(Layout.Admin);
+    uint32 constant User = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Account) << 8) | uint32(Layout.User);
+
+    function prefix(bytes32 account) internal pure returns (uint32) {
+        return uint32(uint(account) >> 224);
+    }
+
+    function isAdmin(bytes32 account) internal pure returns (bool) {
+        return prefix(account) == Admin;
+    }
+
+    function toAdmin(address addr) internal view returns (bytes32) {
+        return bytes32(toLocalBase(Admin) | (uint(uint160(addr)) << 32));
+    }
+
+    function toUser(address addr) internal pure returns (bytes32) {
+        return bytes32(toUnspecifiedBase(User) | (uint(uint160(addr)) << 32));
+    }
+
+    function ensureEvm(bytes32 account) internal pure returns (bytes32) {
+        if (!isFamily(uint(account), Family)) {
+            revert InvalidAccount();
+        }
+        return account;
+    }
+
+    function addrEvm(bytes32 account) internal pure returns (address) {
+        return address(uint160(uint(ensureEvm(account)) >> 32));
+    }
+}

package/contracts/utils/Assets.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Layout} from "./Layout.sol";
+import {matchesBase, toLocalBase} from "./Utils.sol";
+
+library Assets {
+    error InvalidAsset();
+
+    uint32 constant Value = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Value);
+    uint32 constant Erc20 = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Erc20);
+    uint32 constant Erc721 = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Asset) << 8) | uint32(Layout.Erc721);
+
+    function is32(bytes32 asset) internal pure returns (bool) {
+        return bytes1(asset) == 0x20;
+    }
+
+    function toValue() internal view returns (bytes32) {
+        return bytes32(toLocalBase(Value));
+    }
+
+    function toErc20(address addr) internal view returns (bytes32) {
+        return bytes32(toLocalBase(Erc20) | (uint(uint160(addr)) << 32));
+    }
+
+    function toErc721(address issuer) internal view returns (bytes32) {
+        return bytes32(toLocalBase(Erc721) | (uint(uint160(issuer)) << 32));
+    }
+
+    function ensureRef(bytes32 asset, bytes32 meta) internal pure returns (bytes32) {
+        if (asset == 0 || (bytes1(asset) == 0x20 && meta != 0)) revert InvalidAsset();
+        return bytes1(asset) == 0x20 ? asset : keccak256(bytes.concat(asset, meta));
+    }
+
+    function erc20Addr(bytes32 asset) internal view returns (address) {
+        if (!matchesBase(asset, toLocalBase(Erc20))) revert InvalidAsset();
+        return address(uint160(uint(asset) >> 32));
+    }
+
+    function erc721Issuer(bytes32 asset) internal view returns (address) {
+        if (!matchesBase(asset, toLocalBase(Erc721))) revert InvalidAsset();
+        return address(uint160(uint(asset) >> 32));
+    }
+}
+
+library Amounts {
+    error ZeroAmount();
+    error BadAmount(uint amount);
+
+    function ensure(uint amount) internal pure returns (uint) {
+        if (amount == 0) {
+            revert ZeroAmount();
+        }
+        return amount;
+    }
+
+    function ensure(uint amount, uint min, uint max) internal pure returns (uint) {
+        if (amount < min || amount > max) {
+            revert BadAmount(amount);
+        }
+        return amount;
+    }
+
+    function ensureRef(bytes32 asset, bytes32 meta, uint amount) internal pure returns (bytes32 ref) {
+        ensure(amount);
+        return Assets.ensureRef(asset, meta);
+    }
+
+    function resolve(uint available, uint min, uint max) internal pure returns (uint) {
+        uint amount = available > max ? max : available;
+        if (amount < min) {
+            revert BadAmount(amount);
+        }
+        return amount;
+    }
+}

package/contracts/utils/Channels.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+library Channels {
+    uint8 constant Setup = 0x0001;
+    uint8 constant Steps = 0x0002;
+    uint8 constant Balances = 0x0003;
+    uint8 constant Transactions = 0x0004;
+    uint8 constant Custodies = 0x0005;
+    uint8 constant Claims = 0x0006;
+}

package/contracts/utils/ECDSA.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+library ECDSA {
+    uint256 internal constant MALLEABILITY_THRESHOLD =
+        0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0;
+
+    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 digest) {
+        assembly ("memory-safe") {
+            mstore(0x00, "\x19Ethereum Signed Message:\n32")
+            mstore(0x1c, hash)
+            digest := keccak256(0x00, 0x3c)
+        }
+    }
+
+    function tryRecoverCalldata(bytes32 hash, bytes calldata signature) internal pure returns (address signer) {
+        if (signature.length != 65) return address(0);
+
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
+        assembly ("memory-safe") {
+            let offset := signature.offset
+            r := calldataload(offset)
+            s := calldataload(add(offset, 0x20))
+            v := byte(0, calldataload(add(offset, 0x40)))
+        }
+
+        if (v < 27) v += 27;
+        if (v != 27 && v != 28) return address(0);
+        if (uint256(s) > MALLEABILITY_THRESHOLD) return address(0);
+
+        return ecrecover(hash, v, r, s);
+    }
+}

package/contracts/utils/Ids.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {Layout} from "./Layout.sol";
+import {isLocalFamily, matchesBase, toLocalBase} from "./Utils.sol";
+
+library Ids {
+    error InvalidId();
+
+    uint24 constant Node = (uint24(Layout.Evm32) << 8) | uint24(Layout.Node);
+    uint32 constant Host = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Host);
+    uint32 constant Command = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Command);
+    uint32 constant Peer = (uint32(Layout.Evm32) << 16) | (uint32(Layout.Node) << 8) | uint32(Layout.Peer);
+
+    function isHost(uint id) internal pure returns (bool) {
+        return uint32(id >> 224) == Host;
+    }
+
+    function isCommand(uint id) internal pure returns (bool) {
+        return uint32(id >> 224) == Command;
+    }
+
+    function isPeer(uint id) internal pure returns (bool) {
+        return uint32(id >> 224) == Peer;
+    }
+
+    function command(uint id) internal pure returns (uint cid) {
+        if (!isCommand(id)) revert InvalidId();
+        return id;
+    }
+
+    function host(uint id, address target) internal view returns (uint hid) {
+        if (id != toHost(target)) revert InvalidId();
+        return id;
+    }
+
+    function toHost(address target) internal view returns (uint) {
+        return toLocalBase(Host) | uint(uint160(target));
+    }
+
+    function toCommand(bytes4 selector, address target) internal view returns (uint) {
+        uint id = toLocalBase(Command) | uint(uint160(target));
+        id |= uint(uint32(selector)) << 160;
+        return id;
+    }
+
+    function toPeer(bytes4 selector, address target) internal view returns (uint) {
+        uint id = toLocalBase(Peer) | uint(uint160(target));
+        id |= uint(uint32(selector)) << 160;
+        return id;
+    }
+
+    function nodeAddr(uint id) internal view returns (address) {
+        if (!isLocalFamily(id, Node)) revert InvalidId();
+        return address(uint160(id));
+    }
+
+    function hostAddr(uint id) internal view returns (address) {
+        if (!matchesBase(bytes32(id), toLocalBase(Host))) revert InvalidId();
+        return address(uint160(id));
+    }
+}
+
+library Selectors {
+    string constant CommandArgs = "((uint256,bytes32,bytes,bytes))";
+    string constant PeerArgs = "(bytes)";
+
+    function command(string memory name) internal pure returns (bytes4) {
+        return bytes4(keccak256(bytes.concat(bytes(name), bytes(CommandArgs))));
+    }
+
+    function peer(string memory name) internal pure returns (bytes4) {
+        return bytes4(keccak256(bytes.concat(bytes(name), bytes(PeerArgs))));
+    }
+}

package/contracts/utils/Layout.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+library Layout {
+    uint16 constant Evm32 = 0x2001;
+    uint16 constant Evm64 = 0x4001;
+
+    uint8 constant Account = 0x01;
+    uint8 constant Node = 0x02;
+    uint8 constant Asset = 0x03;
+
+    uint8 constant Admin = 0x01;
+    uint8 constant User = 0x02;
+
+    uint8 constant Host = 0x01;
+    uint8 constant Command = 0x02;
+    uint8 constant Peer = 0x03;
+
+    uint8 constant Value = 0x01;
+    uint8 constant Erc20 = 0x02;
+    uint8 constant Erc721 = 0x03;
+}

package/contracts/utils/Utils.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+uint16 constant MAX_BPS = 10_000;
+
+error ValueOverflow();
+
+function max8(uint value) pure returns (uint) {
+    if (value > type(uint8).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max16(uint value) pure returns (uint) {
+    if (value > type(uint16).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max24(uint value) pure returns (uint) {
+    if (value > type(uint24).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max32(uint value) pure returns (uint) {
+    if (value > type(uint32).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max40(uint value) pure returns (uint) {
+    if (value > type(uint40).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max64(uint value) pure returns (uint) {
+    if (value > type(uint64).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max96(uint value) pure returns (uint) {
+    if (value > type(uint96).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max128(uint value) pure returns (uint) {
+    if (value > type(uint128).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function max160(uint value) pure returns (uint) {
+    if (value > type(uint160).max) {
+        revert ValueOverflow();
+    }
+    return value;
+}
+
+function addrOr(address addr, address or) pure returns (address) {
+    return addr == address(0) ? or : addr;
+}
+
+function bytes32ToString(bytes32 value) pure returns (string memory result) {
+    uint len;
+    while (len < 32 && value[len] != 0) {
+        unchecked {
+            ++len;
+        }
+    }
+
+    result = new string(len);
+    assembly ("memory-safe") {
+        mstore(add(result, 0x20), value)
+    }
+}
+
+function toLocalBase(uint32 prefix) view returns (uint) {
+    return (uint(prefix) << 224) | (uint(max32(block.chainid)) << 192);
+}
+
+function toLocalFamily(uint24 family) view returns (uint) {
+    return (uint(family) << 232) | (uint(max32(block.chainid)) << 192);
+}
+
+function toUnspecifiedBase(uint32 prefix) pure returns (uint) {
+    return uint(prefix) << 224;
+}
+
+function isFamily(uint value, uint24 family) pure returns (bool) {
+    return uint24(value >> 232) == family;
+}
+
+function isLocal(uint value) view returns (bool) {
+    return uint32(value >> 192) == block.chainid;
+}
+
+function isLocalFamily(uint value, uint24 family) view returns (bool) {
+    return isFamily(value, family) && isLocal(value);
+}
+
+function matchesBase(bytes32 value, uint base) pure returns (bool) {
+    return uint64(uint(value) >> 192) == uint64(base >> 192);
+}
+
+function applyBps(uint amount, uint16 bps) pure returns (uint) {
+    if (amount == 0 || bps == 0) return 0;
+    return (amount * bps) / MAX_BPS;
+}
+
+function beforeBps(uint amount, uint16 bps) pure returns (uint) {
+    if (amount == 0 || bps == 0) return 0;
+    return (amount * MAX_BPS) / (MAX_BPS + bps);
+}
+

package/contracts/utils/Value.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+library Values {
+    error InsufficientValue();
+
+    struct Budget {
+        uint remaining;
+    }
+
+    function fromMsg() internal view returns (Budget memory) {
+        return Budget({remaining: msg.value});
+    }
+
+    function use(Budget memory budget, uint amount) internal pure returns (uint) {
+        if (amount > budget.remaining) revert InsufficientValue();
+        budget.remaining -= amount;
+        return amount;
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@rootzero/contracts",
+  "version": "0.2.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"
+  }
+}