@fastish/contracts 0.1.0

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 {COMMAND, EVM32, HOST, NODE, PEER} from "./Layout.sol";
+import {bytes32ToString} from "./Strings.sol";
+import {isLocalFamily, matchesBase, toLocalBase} from "./Utils.sol";
+
+error InvalidId();
+
+uint24 constant NODE_FAMILY = (uint24(EVM32) << 8) | uint24(NODE);
+uint32 constant HOST_PREFIX = (uint32(EVM32) << 16) | (uint32(NODE) << 8) | uint32(HOST);
+uint32 constant COMMAND_PREFIX = (uint32(EVM32) << 16) | (uint32(NODE) << 8) | uint32(COMMAND);
+uint32 constant PEER_PREFIX = (uint32(EVM32) << 16) | (uint32(NODE) << 8) | uint32(PEER);
+string constant COMMAND_ARGS = "((uint256,bytes32,bytes,bytes))";
+string constant PEER_ARGS = "(bytes)";
+
+function isHost(uint id) pure returns (bool) {
+    return uint32(id >> 224) == HOST_PREFIX;
+}
+
+function isCommand(uint id) pure returns (bool) {
+    return uint32(id >> 224) == COMMAND_PREFIX;
+}
+
+function isPeer(uint id) pure returns (bool) {
+    return uint32(id >> 224) == PEER_PREFIX;
+}
+
+function toHostId(address addr) view returns (uint) {
+    return toLocalBase(HOST_PREFIX) | uint(uint160(addr));
+}
+
+function toCommandSelector(string memory name) pure returns (bytes4) {
+    return bytes4(keccak256(bytes.concat(bytes(name), bytes(COMMAND_ARGS))));
+}
+
+function toCommandSelector(bytes32 name) pure returns (bytes4) {
+    return toCommandSelector(bytes32ToString(name));
+}
+
+function toPeerSelector(string memory name) pure returns (bytes4) {
+    return bytes4(keccak256(bytes.concat(bytes(name), bytes(PEER_ARGS))));
+}
+
+function toCommandId(bytes4 selector, address addr) view returns (uint) {
+    uint id = toLocalBase(COMMAND_PREFIX) | uint(uint160(addr));
+    id |= uint(uint32(selector)) << 160;
+    return id;
+}
+
+function toPeerId(bytes4 selector, address addr) view returns (uint) {
+    uint id = toLocalBase(PEER_PREFIX) | uint(uint160(addr));
+    id |= uint(uint32(selector)) << 160;
+    return id;
+}
+
+function ensureHost(uint id, address addr) view returns (uint) {
+    if (id != toHostId(addr)) revert InvalidId();
+    return id;
+}
+
+function ensureCommand(uint id) pure returns (uint cid) {
+    if (!isCommand(id)) revert InvalidId();
+    return id;
+}
+
+function localNodeAddr(uint node) view returns (address) {
+    if (!isLocalFamily(node, NODE_FAMILY)) revert InvalidId();
+    return address(uint160(node));
+}
+
+function localHostAddr(uint host) view returns (address) {
+    if (!matchesBase(bytes32(host), toLocalBase(HOST_PREFIX))) revert InvalidId();
+    return address(uint160(host));
+}

package/contracts/utils/Layout.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+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/Strings.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+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)
+    }
+}

package/contracts/utils/Utils.sol

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {ROUTE_EMPTY} from "../blocks/Schema.sol";
+
+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 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);
+}
+
+function routeSchema1(string memory maybeRoute, string memory a) pure returns (string memory) {
+    return string.concat(bytes(maybeRoute).length == 0 ? ROUTE_EMPTY : maybeRoute, ">", a);
+}
+
+function routeSchema2(string memory maybeRoute, string memory a, string memory b) pure returns (string memory) {
+    return string.concat(bytes(maybeRoute).length == 0 ? ROUTE_EMPTY : maybeRoute, ">", a, ">", b);
+}

package/contracts/utils/Value.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+struct ValueBudget {
+    uint remaining;
+}
+
+error InsufficientValue();
+
+function msgValue() view returns (ValueBudget memory) {
+    return ValueBudget({remaining: msg.value});
+}
+
+function useValue(uint amount, ValueBudget memory budget) pure returns (uint) {
+    if (amount > budget.remaining) revert InsufficientValue();
+    budget.remaining -= amount;
+    return amount;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@fastish/contracts",
+  "version": "0.1.0",
+  "description": "Solidity contracts and protocol building blocks for Fastish hosts and commands.",
+  "private": false,
+  "license": "GPL-3.0-only",
+  "type": "module",
+  "files": [
+    "contracts/**/*.sol",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "prepublishOnly": "npm test"
+  },
+  "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"
+  }
+}