@rootzero/contracts 1.22.0 → 1.24.0

package/ports/Assets.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.33;
+
+import {PortBase} from "./Base.sol";
+import {AllowAssetsHook} from "../commands/admin/AllowAssets.sol";
+import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
+import {Specs} from "../Codec.sol";
+import {Execution, Executions, Lanes} from "../execution/Execution.sol";
+
+using Executions for Execution;
+
+/// @title AllowAssetsPort
+/// @notice Port that permits a list of assets on behalf of a peer host.
+/// Each ASSET block in the input calls `allowAsset`. Restricted to trusted peers.
+abstract contract AllowAssetsPort is PortBase, AllowAssetsHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portAllowAssets", Specs.Asset, Specs.Empty, 0);
+    }
+
+    /// @notice Execute the allow-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portAllowAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+
+        while (exec.more()) {
+            bytes32 asset = exec.unpackAsset(Lanes.Input);
+            allowAsset(asset);
+        }
+
+        return "";
+    }
+}
+
+/// @title DenyAssetsPort
+/// @notice Port that blocks a list of assets on behalf of a peer host.
+/// Each ASSET block in the input calls `denyAsset`. Restricted to trusted peers.
+abstract contract DenyAssetsPort is PortBase, DenyAssetsHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portDenyAssets", Specs.Asset, Specs.Empty, 0);
+    }
+
+    /// @notice Execute the deny-assets peer call.
+    /// @param data ASSET block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portDenyAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+
+        while (exec.more()) {
+            bytes32 asset = exec.unpackAsset(Lanes.Input);
+            denyAsset(asset);
+        }
+
+        return "";
+    }
+}
+
+/// @notice Hook implemented by hosts that fulfill asset requests from peers.
+abstract contract RequestAssetHook {
+    /// @notice Override to handle one asset request from a peer host.
+    /// @dev The implementation is responsible for validating `asset`, enforcing
+    /// requester policy, and sending the approved amount to the requester.
+    /// @param peer Peer host node ID for this request.
+    /// @param asset Asset identifier supplied by the peer.
+    /// @param amount Amount requested in the asset's native units.
+    function requestAsset(uint peer, bytes32 asset, uint amount) internal virtual;
+}
+
+/// @title RequestAssetPort
+/// @notice Port that lets trusted peers request assets from the receiving host.
+/// Each AMOUNT block is scoped to the caller and passed unchanged to
+/// `requestAsset(peer, asset, amount)`. The hook validates support and performs
+/// any accounting and transfer required by the host.
+abstract contract RequestAssetPort is PortBase, RequestAssetHook {
+    uint private immutable descriptor;
+
+    constructor() {
+        (, descriptor) = port("portRequestAsset", Specs.Amount, Specs.Empty, 0);
+    }
+
+    /// @notice Request assets for the calling peer.
+    /// @param data AMOUNT block stream supplied by the trusted peer.
+    /// @return Empty response bytes.
+    function portRequestAsset(bytes calldata data) external onlyPeer returns (bytes memory) {
+        Execution memory exec = openInput(data, descriptor, 0);
+        uint peer = caller();
+
+        while (exec.more()) {
+            (bytes32 asset, uint amount) = exec.unpackAmount(Lanes.Input);
+            requestAsset(peer, asset, amount);
+        }
+
+        return "";
+    }
+}

package/utils/Cursors.sol

@@ -65,9 +65,9 @@ library Cursors {
     /// @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 |= max32(offset) << 32;
-        cur |= max32(len) << 64;
-        cur |= max16(items) << 96;
+        cur |= uint(max32(offset)) << 32;
+        cur |= uint(max32(len)) << 64;
+        cur |= uint(max16(items)) << 96;
         cur |= uint(flags) << 112;
         cur |= uint(tag) << 120;
     }

package/utils/Nodes.sol

@@ -198,7 +198,7 @@ library Nodes {
     /// @return node Command node ID embedding both the selector and address.
     function toCommand(string memory name, address target) internal view returns (uint node) {
         node = toLocalBase(Command) | uint(uint160(target));
-        node |= uint(uint32(toSelector(name, "(bytes32,bytes,bytes)"))) << 160;
+        node |= uint(uint32(toSelector(name, "(bytes)"))) << 160;
     }
 
     /// @notice Build a chain-local port ID for the given endpoint name and contract.

package/utils/Utils.sol

@@ -10,77 +10,79 @@ error ValueOverflow();
 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 unchanged.
-function max8(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint8 and return it as uint8.
+function max8(uint value) pure returns (uint8) {
     if (value > type(uint8).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint8(value);
 }
 
-/// @notice Assert that `value` fits in uint16 and return it unchanged.
-function max16(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint16 and return it as uint16.
+function max16(uint value) pure returns (uint16) {
     if (value > type(uint16).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint16(value);
 }
 
-/// @notice Assert that `value` fits in uint24 and return it unchanged.
-function max24(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint24 and return it as uint24.
+function max24(uint value) pure returns (uint24) {
     if (value > type(uint24).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint24(value);
 }
 
-/// @notice Assert that `value` fits in uint32 and return it unchanged.
-function max32(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint32 and return it as uint32.
+function max32(uint value) pure returns (uint32) {
     if (value > type(uint32).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint32(value);
 }
 
-/// @notice Assert that `value` fits in uint40 and return it unchanged.
-function max40(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint40 and return it as uint40.
+function max40(uint value) pure returns (uint40) {
     if (value > type(uint40).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint40(value);
 }
 
-/// @notice Assert that `value` fits in uint64 and return it unchanged.
-function max64(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint64 and return it as uint64.
+function max64(uint value) pure returns (uint64) {
     if (value > type(uint64).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint64(value);
 }
 
-/// @notice Assert that `value` fits in uint96 and return it unchanged.
-function max96(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint96 and return it as uint96.
+function max96(uint value) pure returns (uint96) {
     if (value > type(uint96).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint96(value);
 }
 
-/// @notice Assert that `value` fits in uint128 and return it unchanged.
-function max128(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint128 and return it as uint128.
+function max128(uint value) pure returns (uint128) {
     if (value > type(uint128).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint128(value);
 }
 
-/// @notice Assert that `value` fits in uint160 and return it unchanged.
-function max160(uint value) pure returns (uint) {
+/// @notice Assert that `value` fits in uint160 and return it as uint160.
+function max160(uint value) pure returns (uint160) {
     if (value > type(uint160).max) {
         revert ValueOverflow();
     }
-    return value;
+    return uint160(value);
 }
 
 // Packed fields
@@ -108,25 +110,25 @@ function clear64(uint value, uint shift) pure returns (uint) {
 /// @notice Replace the 8-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 8 bits.
 function replace8(uint value, uint shift, uint field) pure returns (uint) {
-    return clear8(value, shift) | (max8(field) << shift);
+    return clear8(value, shift) | (uint(max8(field)) << shift);
 }
 
 /// @notice Replace the 16-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 16 bits.
 function replace16(uint value, uint shift, uint field) pure returns (uint) {
-    return clear16(value, shift) | (max16(field) << shift);
+    return clear16(value, shift) | (uint(max16(field)) << shift);
 }
 
 /// @notice Replace the 32-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 32 bits.
 function replace32(uint value, uint shift, uint field) pure returns (uint) {
-    return clear32(value, shift) | (max32(field) << shift);
+    return clear32(value, shift) | (uint(max32(field)) << shift);
 }
 
 /// @notice Replace the 64-bit field beginning at `shift` with `field`.
 /// @dev Reverts when `field` does not fit in 64 bits.
 function replace64(uint value, uint shift, uint field) pure returns (uint) {
-    return clear64(value, shift) | (max64(field) << shift);
+    return clear64(value, shift) | (uint(max64(field)) << shift);
 }
 
 /// @notice Assert that `n` is evenly divisible by `divisor`.
@@ -146,6 +148,14 @@ function ensureAddr(address addr) pure returns (address) {
     return addr;
 }
 
+/// @notice Assert that `target` contains deployed bytecode and return it unchanged.
+/// @dev Rejects EOAs, zero and future deployment addresses, contracts currently
+/// under construction, and precompiles whose code length is zero.
+function ensureContract(address target) view returns (address) {
+    if (target.code.length == 0) revert InvalidContract();
+    return target;
+}
+
 /// @notice Convert a signed integer to its 32-byte two's-complement representation.
 function intToBytes32(int value) pure returns (bytes32) {
     return bytes32(uint(value));

package/events/Commander.sol

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {EventEmitter} from "./Emitter.sol";
-
-/// @notice Emitted when a commander is announced for a chain/domain.
-abstract contract CommanderEvent is EventEmitter {
-    string private constant ABI = "event Commander(uint indexed host, uint chain, bytes32 native, bytes32 admin)";
-
-    /// @param host Commander host node ID for the chain.
-    /// @param chain Chain/domain node ID.
-    /// @param native Native asset ID for the chain.
-    /// @param admin Admin account for the commander host on the chain.
-    event Commander(uint indexed host, uint chain, bytes32 native, bytes32 admin);
-
-    constructor() {
-        emit EventAbi(ABI);
-    }
-}

package/ports/AllowAssets.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {PortBase} from "./Base.sol";
-import {AllowAssetsHook} from "../commands/admin/AllowAssets.sol";
-import {Specs} from "../Codec.sol";
-import {Execution, Executions, Lanes} from "../execution/Execution.sol";
-
-using Executions for Execution;
-
-/// @title AllowAssetsPort
-/// @notice Port that permits a list of assets on behalf of a peer host.
-/// Each ASSET block in the input calls `allowAsset`. Restricted to trusted peers.
-abstract contract AllowAssetsPort is PortBase, AllowAssetsHook {
-    uint private immutable descriptor;
-
-    constructor() {
-        (, descriptor) = port("portAllowAssets", Specs.Asset, Specs.Empty, 0);
-    }
-
-    /// @notice Execute the allow-assets peer call.
-    /// @param data ASSET block stream supplied by the trusted peer.
-    /// @return Empty response bytes.
-    function portAllowAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
-        Execution memory exec = openInput(data, descriptor, 0);
-
-        while (exec.more()) {
-            bytes32 asset = exec.unpackAsset(Lanes.Input);
-            allowAsset(asset);
-        }
-        
-        return "";
-    }
-}

package/ports/DenyAssets.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-pragma solidity ^0.8.33;
-
-import {PortBase} from "./Base.sol";
-import {DenyAssetsHook} from "../commands/admin/DenyAssets.sol";
-import {Specs} from "../Codec.sol";
-import {Execution, Executions, Lanes} from "../execution/Execution.sol";
-
-using Executions for Execution;
-
-/// @title DenyAssetsPort
-/// @notice Port that blocks a list of assets on behalf of a peer host.
-/// Each ASSET block in the input calls `denyAsset`. Restricted to trusted peers.
-abstract contract DenyAssetsPort is PortBase, DenyAssetsHook {
-    uint private immutable descriptor;
-
-    constructor() {
-        (, descriptor) = port("portDenyAssets", Specs.Asset, Specs.Empty, 0);
-    }
-
-    /// @notice Execute the deny-assets peer call.
-    /// @param data ASSET block stream supplied by the trusted peer.
-    /// @return Empty response bytes.
-    function portDenyAssets(bytes calldata data) external onlyPeer returns (bytes memory) {
-        Execution memory exec = openInput(data, descriptor, 0);
-
-        while (exec.more()) {
-            bytes32 asset = exec.unpackAsset(Lanes.Input);
-            denyAsset(asset);
-        }
-        
-        return "";
-    }
-}