fix bug commit from IndirectCall items not having access control + make bridge NFTs

Author: Amxx

contracts/crosschain/ERC7802Bridge.sol

@@ -8,72 +8,106 @@ import {IERC7802} from "@openzeppelin/contracts/interfaces/draft-IERC7802.sol";
 import {IERC7786GatewaySource, IERC7786Receiver} from "../interfaces/IERC7786.sol";
 
 // Utilities
+import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol";
 import {BitMaps} from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
 import {Bytes} from "@openzeppelin/contracts/utils/Bytes.sol";
 import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
 import {InteroperableAddress} from "@openzeppelin/contracts/utils/draft-InteroperableAddress.sol";
-import {IndirectCall} from "../utils/IndirectCall.sol";
 
-contract ERC7802Bridge is IERC7786Receiver {
+contract ERC7802BridgeSatellite {
+    address private immutable _bridge = msg.sender;
+
+    fallback(bytes calldata data) external payable returns (bytes memory) {
+        require(msg.sender == _bridge && data.length >= 20);
+
+        (bool success, bytes memory returndata) = address(bytes20(data)).call{value: msg.value}(data[20:]);
+
+        if (!success) {
+            assembly ("memory-safe") {
+                revert(add(returndata, 0x20), mload(returndata))
+            }
+        } else {
+            return returndata;
+        }
+    }
+}
+
+contract ERC7802Bridge is ERC721("ERC7802Bridge", "ERC7802Bridge"), IERC7786Receiver {
     using BitMaps for BitMaps.BitMap;
     using InteroperableAddress for bytes;
-
     struct BridgeMetadata {
         address token;
+        bool isPaused;
         bool isCustodial;
         mapping(bytes chain => address) gateway;
         mapping(bytes chain => bytes) remote;
     }
 
+    address private immutable _satellite = address(new ERC7802BridgeSatellite());
     mapping(bytes32 bridgeId => BridgeMetadata) private _bridges;
     BitMaps.BitMap private _processed;
 
     event Sent(address token, address from, bytes to, uint256 amount);
     event Received(address token, bytes from, address to, uint256 amount);
-    event NewBridge(bytes32 indexed bridgeId, address indexed token);
-    event NewBridgeLink(bytes32 indexed bridgeId, address gateway, bytes remote);
+    event BridgePaused(bytes32 indexed bridgeId, bool isPaused);
+    event BridgeLinkSet(bytes32 indexed bridgeId, address gateway, bytes remote);
 
+    error ERC7802BridgePaused(bytes32 bridgeId);
     error ERC7802BridgeInvalidBidgeId(bytes32 bridgeId);
     error ERC7802BridgeMissingGateway(bytes32 bridgeId, bytes chain);
     error ERC7802BridgeMissingRemote(bytes32 bridgeId, bytes chain);
     error ERC7802BridgeDuplicate();
     error ERC7802BridgeInvalidGateway();
     error ERC7802BridgeInvalidSender();
 
-    function getBridgeEndpoint(bytes32 bridgeId) public returns (address) {
-        return IndirectCall.getRelayer(bridgeId);
+    modifier bridgeAdminRestricted(bytes32 bridgeId) {
+        _checkAuthorized(ownerOf(uint256(bridgeId)), msg.sender, uint256(bridgeId));
+        _;
+    }
+
+    // ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+    // │                                                   Getters                                                   │
+    // └─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
+    function getBridgeEndpoint(bytes32 bridgeId) public view returns (address) {
+        return Clones.predictDeterministicAddress(_satellite, bridgeId);
     }
 
     function getBridgeToken(bytes32 bridgeId) public view returns (address token, bool isCustodial) {
-        token = _bridges[bridgeId].token;
-        isCustodial = _bridges[bridgeId].isCustodial;
-        if (token == address(0)) revert ERC7802BridgeInvalidBidgeId(bridgeId);
+        _requireOwned(uint256(bridgeId));
+        return (_bridges[bridgeId].token, _bridges[bridgeId].isCustodial);
     }
 
     function getBridgeGateway(bytes32 bridgeId, bytes memory chain) public view returns (address) {
-        address result = _bridges[bridgeId].gateway[chain];
-        if (result == address(0)) revert ERC7802BridgeMissingGateway(bridgeId, chain);
-        return result;
+        _requireOwned(uint256(bridgeId));
+        return _bridges[bridgeId].gateway[chain];
     }
 
     function getBridgeRemote(bytes32 bridgeId, bytes memory chain) public view returns (bytes memory) {
-        bytes memory result = _bridges[bridgeId].remote[chain];
-        if (result.length == 0) revert ERC7802BridgeMissingRemote(bridgeId, chain);
-        return result;
+        _requireOwned(uint256(bridgeId));
+        return _bridges[bridgeId].remote[chain];
     }
 
+    // ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+    // │                                     Bridge creation and administration                                      │
+    // └─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
     struct Foreign {
         bytes32 id;
         address gateway;
         bytes remote;
     }
-    function createBridge(address token, bool isCustodial, Foreign[] calldata foreign) public returns (bytes32) {
+
+    function createBridge(
+        address token,
+        address admin,
+        bool isCustodial,
+        Foreign[] calldata foreign
+    ) public returns (bytes32) {
         bytes32[] memory ids = new bytes32[](foreign.length + 1);
         bytes32[] memory links = new bytes32[](foreign.length);
         for (uint256 i = 0; i < foreign.length; ++i) {
-            require(foreign[i].gateway != address(0));
-            require(foreign[i].remote.length > 0);
+            require(foreign[i].gateway != address(0) && foreign[i].remote.length > 0);
             ids[i] = foreign[i].id;
             links[i] = keccak256(
                 abi.encode(InteroperableAddress.formatEvmV1(block.chainid, foreign[i].gateway), foreign[i].remote)
@@ -82,7 +116,7 @@ contract ERC7802Bridge is IERC7786Receiver {
         ids[foreign.length] = keccak256(
             abi.encode(
                 InteroperableAddress.formatEvmV1(block.chainid, token), // bytes token
-                bytes32(SafeCast.toUint(isCustodial)), // bytes32 tokenOptions
+                bytes32(bytes20(admin)) | bytes32(SafeCast.toUint(isCustodial)), // bytes32 tokenOptions
                 Arrays.sort(links)
             )
         );
@@ -94,7 +128,8 @@ contract ERC7802Bridge is IERC7786Receiver {
         details.token = token;
         details.isCustodial = isCustodial;
 
-        emit NewBridge(bridgeId, token);
+        Clones.cloneDeterministic(_satellite, bridgeId);
+        _safeMint(admin == address(0) ? address(1) : admin, uint256(bridgeId));
 
         for (uint256 i = 0; i < foreign.length; ++i) {
             (bytes2 chainType, bytes memory chainReference, ) = foreign[i].remote.parseV1();
@@ -103,27 +138,51 @@ contract ERC7802Bridge is IERC7786Receiver {
             details.gateway[chain] = foreign[i].gateway;
             details.remote[chain] = foreign[i].remote;
 
-            emit NewBridgeLink(bridgeId, foreign[i].gateway, foreign[i].remote);
+            emit BridgeLinkSet(bridgeId, foreign[i].gateway, foreign[i].remote);
         }
 
         return bridgeId;
     }
 
+    function setPaused(bytes32 bridgeId, bool isPaused) public bridgeAdminRestricted(bridgeId) {
+        _bridges[bridgeId].isPaused = isPaused;
+        emit BridgePaused(bridgeId, isPaused);
+    }
+
+    function updateGateway(
+        bytes32 bridgeId,
+        bytes calldata chain,
+        address gateway,
+        bytes calldata remote
+    ) public bridgeAdminRestricted(bridgeId) {
+        require(gateway != address(0) && remote.length > 0);
+        _bridges[bridgeId].gateway[chain] = gateway;
+        _bridges[bridgeId].remote[chain] = remote;
+        emit BridgeLinkSet(bridgeId, gateway, remote);
+    }
+
+    // ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+    // │                                            Send / Receive tokens                                            │
+    // └─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
     function send(
         bytes32 bridgeId,
         bytes memory to,
         uint256 amount,
         bytes[] memory attributes
     ) public payable virtual returns (bytes32) {
+        _requireOwned(uint256(bridgeId));
+
+        require(!_bridges[bridgeId].isPaused, ERC7802BridgePaused(bridgeId));
+
         address token = _fetchTokens(bridgeId, msg.sender, amount);
 
         // identify destination chain
         (bytes2 chainType, bytes memory chainReference, bytes memory recipient) = to.parseV1();
         bytes memory destChain = InteroperableAddress.formatV1(chainType, chainReference, "");
 
         // get details for that bridge: gateway, remote bridge, remote token
-        address gateway = getBridgeGateway(bridgeId, destChain);
-        bytes memory bridge = getBridgeRemote(bridgeId, destChain);
+        address gateway = _bridges[bridgeId].gateway[destChain];
+        bytes memory bridge = _bridges[bridgeId].remote[destChain];
 
         // prepare payload
         bytes memory payload = abi.encode(
@@ -156,12 +215,14 @@ contract ERC7802Bridge is IERC7786Receiver {
             (bytes32, bytes, bytes, uint256)
         );
 
+        _requireOwned(uint256(bridgeId));
+
         // identify source chain and validate corresponding gateway
         (bytes2 chainType, bytes memory chainReference, ) = from.parseV1();
         bytes memory srcChain = InteroperableAddress.formatV1(chainType, chainReference, "");
 
-        require(msg.sender == getBridgeGateway(bridgeId, srcChain), ERC7802BridgeInvalidGateway());
-        require(Bytes.equal(sender, getBridgeRemote(bridgeId, srcChain)), ERC7802BridgeInvalidSender());
+        require(msg.sender == _bridges[bridgeId].gateway[srcChain], ERC7802BridgeInvalidGateway());
+        require(Bytes.equal(sender, _bridges[bridgeId].remote[srcChain]), ERC7802BridgeInvalidSender());
 
         // get recipient
         address to = address(bytes20(recipient));
@@ -173,40 +234,35 @@ contract ERC7802Bridge is IERC7786Receiver {
         return IERC7786Receiver.executeMessage.selector;
     }
 
-    function _fetchTokens(bytes32 bridgeId, address from, uint256 amount) internal virtual returns (address) {
-        (address token, bool isCustodial) = getBridgeToken(bridgeId);
-        if (isCustodial) {
-            (bool success, bytes memory returndata) = IndirectCall.indirectCall(
-                token,
-                abi.encodeCall(IERC20.transferFrom, (from, getBridgeEndpoint(bridgeId), amount)),
-                bridgeId
+    function _fetchTokens(bytes32 bridgeId, address from, uint256 amount) private returns (address) {
+        address token = _bridges[bridgeId].token;
+        if (_bridges[bridgeId].isCustodial) {
+            (bool success, bytes memory returndata) = getBridgeEndpoint(bridgeId).call(
+                abi.encodePacked(
+                    token,
+                    abi.encodeCall(IERC20.transferFrom, (from, getBridgeEndpoint(bridgeId), amount))
+                )
             );
             require(success && (returndata.length == 0 ? token.code.length == 0 : uint256(bytes32(returndata)) == 1));
         } else {
-            (bool success, ) = IndirectCall.indirectCall(
-                token,
-                abi.encodeCall(IERC7802.crosschainBurn, (from, amount)),
-                bridgeId
+            (bool success, ) = getBridgeEndpoint(bridgeId).call(
+                abi.encodePacked(token, abi.encodeCall(IERC7802.crosschainBurn, (from, amount)))
             );
             require(success);
         }
         return token;
     }
 
-    function _distributeTokens(bytes32 bridgeId, address to, uint256 amount) internal virtual returns (address) {
-        (address token, bool isCustodial) = getBridgeToken(bridgeId);
-        if (isCustodial) {
-            (bool success, bytes memory returndata) = IndirectCall.indirectCall(
-                token,
-                abi.encodeCall(IERC20.transfer, (to, amount)),
-                bridgeId
+    function _distributeTokens(bytes32 bridgeId, address to, uint256 amount) private returns (address) {
+        address token = _bridges[bridgeId].token;
+        if (_bridges[bridgeId].isCustodial) {
+            (bool success, bytes memory returndata) = getBridgeEndpoint(bridgeId).call(
+                abi.encodePacked(token, abi.encodeCall(IERC20.transfer, (to, amount)))
             );
             require(success && (returndata.length == 0 ? token.code.length == 0 : uint256(bytes32(returndata)) == 1));
         } else {
-            (bool success, ) = IndirectCall.indirectCall(
-                token,
-                abi.encodeCall(IERC7802.crosschainMint, (to, amount)),
-                bridgeId
+            (bool success, ) = getBridgeEndpoint(bridgeId).call(
+                abi.encodePacked(token, abi.encodeCall(IERC7802.crosschainMint, (to, amount)))
             );
             require(success);
         }