@rootzero/contracts 1.21.0 → 1.23.0

package/ports/Allowance.sol

@@ -2,35 +2,45 @@
 pragma solidity ^0.8.33;
 
 import {PortBase} from "./Base.sol";
-import {AllowanceHook} from "../commands/admin/Allowance.sol";
 import {Specs} from "../Codec.sol";
 import {Execution, Executions, Lanes} from "../execution/Execution.sol";
 
 using Executions for Execution;
 
-/// @title AllowancePort
-/// @notice Port that lets a trusted peer host input or refresh its own allowance.
-/// Each AMOUNT block in the input is scoped to the peer host and passed to the
-/// shared allowance hook as a host-scoped allowance. Restricted to trusted peers.
-abstract contract AllowancePort is PortBase, AllowanceHook {
+/// @notice Hook implemented by hosts that handle allowance requests from peers.
+abstract contract RequestAllowanceHook {
+    /// @notice Override to handle one allowance request from a peer host.
+    /// @dev The implementation is responsible for validating the request and
+    /// deciding what allowance, if any, to grant.
+    /// @param peer Peer host node ID requesting the allowance.
+    /// @param asset Asset identifier supplied by the peer.
+    /// @param amount Allowance amount requested in the asset's native units.
+    function requestAllowance(uint peer, bytes32 asset, uint amount) internal virtual;
+}
+
+/// @title RequestAllowancePort
+/// @notice Port that lets trusted peers request their own asset allowances.
+/// Each AMOUNT block is scoped to the caller and passed unchanged to
+/// `requestAllowance(peer, asset, amount)`.
+abstract contract RequestAllowancePort is PortBase, RequestAllowanceHook {
     uint private immutable descriptor;
 
     constructor() {
-        (, descriptor) = port("portAllowance", Specs.Amount, Specs.Empty, 0);
+        (, descriptor) = port("portRequestAllowance", Specs.Amount, Specs.Empty, 0);
     }
 
-    /// @notice Execute the allowance port call.
-    /// @param data AMOUNT block stream requested by the trusted peer.
+    /// @notice Request asset allowances for the calling peer.
+    /// @param data AMOUNT block stream supplied by the trusted peer.
     /// @return Empty response bytes.
-    function portAllowance(bytes calldata data) external onlyPeer returns (bytes memory) {
+    function portRequestAllowance(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);
-            allowance(peer, asset, amount);
+            requestAllowance(peer, asset, amount);
         }
-        
+
         return "";
     }
 }

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/ports/Dispatch.sol

@@ -11,7 +11,8 @@ using Executions for Execution;
 /// @notice Hook implemented by hosts that forward funded dispatch payloads.
 abstract contract DispatchPayableHook {
     /// @notice Override to dispatch an encoded payload to `portal`.
-    /// @param portal Destination portal identifier, often the destination host ID.
+    /// @param portal Destination portal implementation's host ID. Implementations
+    /// may validate or resolve it for their transport.
     /// @param resources Chain-specific destination resources. EVM adapters
     /// may interpret this as packed execution gas and destination value.
     /// @param payload Encoded payload ready for the transport layer.

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

@@ -11,76 +11,76 @@ error NotDivisible();
 /// @dev Thrown when an ID claims to carry an address but the embedded address is zero.
 error ZeroAddress();
 
-/// @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 +108,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`.