Cleanup caller / global owner confusion

Add a sensible minimum value for dst gas limit

src/adapters/BaseSenderAdapter.sol

@@ -25,8 +25,8 @@ abstract contract BaseSenderAdapter is IBridgeSenderAdapter {
         _;
     }
 
-    modifier onlyCaller() {
-        if (!gac.isPrivilegedCaller(msg.sender)) {
+    modifier onlyGlobalOwner() {
+        if (!gac.isGlobalOwner(msg.sender)) {
             revert Error.INVALID_PRIVILEGED_CALLER();
         }
         _;
@@ -53,7 +53,7 @@ abstract contract BaseSenderAdapter is IBridgeSenderAdapter {
     function updateReceiverAdapter(uint256[] calldata _dstChainIds, address[] calldata _receiverAdapters)
         external
         override
-        onlyCaller
+        onlyGlobalOwner
     {
         uint256 arrLength = _dstChainIds.length;
 

src/adapters/Celer/CelerReceiverAdapter.sol

@@ -46,9 +46,9 @@ contract CelerReceiverAdapter is IBridgeReceiverAdapter, IMessageReceiverApp {
     /*/////////////////////////////////////////////////////////////////
                                  MODIFIER
     ////////////////////////////////////////////////////////////////*/
-    modifier onlyCaller() {
-        if (!gac.isPrivilegedCaller(msg.sender)) {
-            revert Error.INVALID_PRIVILEGED_CALLER();
+    modifier onlyGlobalOwner() {
+        if (!gac.isGlobalOwner(msg.sender)) {
+            revert Error.CALLER_NOT_OWNER();
         }
         _;
     }
@@ -73,7 +73,7 @@ contract CelerReceiverAdapter is IBridgeReceiverAdapter, IMessageReceiverApp {
     ////////////////////////////////////////////////////////////////*/
 
     /// @inheritdoc IBridgeReceiverAdapter
-    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyCaller {
+    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyGlobalOwner {
         uint64 _senderChainDecoded = abi.decode(_senderChain, (uint64));
 
         if (_senderChainDecoded == 0) {

src/adapters/Wormhole/WormholeReceiverAdapter.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0-only
+/// SPDX-License-Identifier: GPL-3.0-only
 pragma solidity >=0.8.9;
 
 /// library imports
@@ -36,9 +36,9 @@ contract WormholeReceiverAdapter is IBridgeReceiverAdapter, IWormholeReceiver {
     /*/////////////////////////////////////////////////////////////////
                                  MODIFIER
     ////////////////////////////////////////////////////////////////*/
-    modifier onlyCaller() {
-        if (!gac.isPrivilegedCaller(msg.sender)) {
-            revert Error.INVALID_PRIVILEGED_CALLER();
+    modifier onlyGlobalOwner() {
+        if (!gac.isGlobalOwner(msg.sender)) {
+            revert Error.CALLER_NOT_OWNER();
         }
         _;
     }
@@ -67,7 +67,7 @@ contract WormholeReceiverAdapter is IBridgeReceiverAdapter, IWormholeReceiver {
     ////////////////////////////////////////////////////////////////*/
 
     /// @inheritdoc IBridgeReceiverAdapter
-    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyCaller {
+    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyGlobalOwner {
         uint16 _senderChainDecoded = abi.decode(_senderChain, (uint16));
 
         if (_senderChainDecoded == 0) {
@@ -88,7 +88,7 @@ contract WormholeReceiverAdapter is IBridgeReceiverAdapter, IWormholeReceiver {
     /// @dev maps the MMA chain id to bridge specific chain id
     /// @dev _origIds is the chain's native chain id
     /// @dev _whIds are the bridge allocated chain id
-    function setChainIdMap(uint256[] calldata _origIds, uint16[] calldata _whIds) external onlyCaller {
+    function setChainIdMap(uint256[] calldata _origIds, uint16[] calldata _whIds) external onlyGlobalOwner {
         uint256 arrLength = _origIds.length;
 
         if (arrLength != _whIds.length) {

src/adapters/Wormhole/WormholeSenderAdapter.sol

@@ -69,7 +69,7 @@ contract WormholeSenderAdapter is BaseSenderAdapter {
     /// @dev maps the MMA chain id to bridge specific chain id
     /// @dev _origIds is the chain's native chain id
     /// @dev _whIds are the bridge allocated chain id
-    function setChainIdMap(uint256[] calldata _origIds, uint16[] calldata _whIds) external onlyCaller {
+    function setChainIdMap(uint256[] calldata _origIds, uint16[] calldata _whIds) external onlyGlobalOwner {
         uint256 arrLength = _origIds.length;
 
         if (arrLength != _whIds.length) {

src/adapters/axelar/AxelarReceiverAdapter.sol

@@ -36,9 +36,9 @@ contract AxelarReceiverAdapter is IAxelarExecutable, IBridgeReceiverAdapter {
     /*/////////////////////////////////////////////////////////////////
                                  MODIFIER
     ////////////////////////////////////////////////////////////////*/
-    modifier onlyCaller() {
-        if (!gac.isPrivilegedCaller(msg.sender)) {
-            revert Error.INVALID_PRIVILEGED_CALLER();
+    modifier onlyGlobalOwner() {
+        if (!gac.isGlobalOwner(msg.sender)) {
+            revert Error.CALLER_NOT_OWNER();
         }
         _;
     }
@@ -56,7 +56,7 @@ contract AxelarReceiverAdapter is IAxelarExecutable, IBridgeReceiverAdapter {
     ////////////////////////////////////////////////////////////////*/
 
     /// @inheritdoc IBridgeReceiverAdapter
-    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyCaller {
+    function updateSenderAdapter(bytes memory _senderChain, address _senderAdapter) external override onlyGlobalOwner {
         string memory _senderChainDecoded = abi.decode(_senderChain, (string));
 
         if (keccak256(abi.encode(_senderChainDecoded)) == keccak256(abi.encode(""))) {

src/adapters/axelar/AxelarSenderAdapter.sol

@@ -72,7 +72,7 @@ contract AxelarSenderAdapter is BaseSenderAdapter {
     /// @dev maps the MMA chain id to bridge specific chain id
     /// @dev _origIds is the chain's native chain id
     /// @dev _axlIds are the bridge allocated chain id
-    function setChainIdMap(uint256[] calldata _origIds, string[] calldata _axlIds) external onlyCaller {
+    function setChainIdMap(uint256[] calldata _origIds, string[] calldata _axlIds) external onlyGlobalOwner {
         uint256 arrLength = _origIds.length;
 
         if (arrLength != _axlIds.length) {

src/controllers/GAC.sol

@@ -11,6 +11,11 @@ import {Error} from "../libraries/Error.sol";
 
 /// @dev is the global access control contract for bridge adapters
 contract GAC is IGAC, Ownable {
+    /*///////////////////////////////////////////////////////////////
+                             CONSTANTS
+    //////////////////////////////////////////////////////////////*/
+    uint256 public constant MINIMUM_DST_GAS_LIMIT = 50000;
+
     /*///////////////////////////////////////////////////////////////
                             STATE VARIABLES
     //////////////////////////////////////////////////////////////*/
@@ -76,6 +81,10 @@ contract GAC is IGAC, Ownable {
 
     /// @inheritdoc IGAC
     function setGlobalMsgDeliveryGasLimit(uint256 _gasLimit) external override onlyOwner {
+        if (_gasLimit < MINIMUM_DST_GAS_LIMIT) {
+            revert Error.INVALID_DST_GAS_LIMIT_MIN();
+        }
+
         uint256 oldLimit = dstGasLimit;
         dstGasLimit = _gasLimit;
 
@@ -96,7 +105,7 @@ contract GAC is IGAC, Ownable {
     //////////////////////////////////////////////////////////////*/
 
     /// @inheritdoc IGAC
-    function isPrivilegedCaller(address _caller) external view override returns (bool) {
+    function isGlobalOwner(address _caller) external view override returns (bool) {
         if (_caller == owner()) {
             return true;
         }

src/interfaces/IGAC.sol

@@ -47,7 +47,7 @@ interface IGAC {
     /// @dev returns `true` if the caller is global access controller
     /// @param _caller is the msg.sender to validate
     /// @return boolean indicating the validity of the caller
-    function isPrivilegedCaller(address _caller) external view returns (bool);
+    function isGlobalOwner(address _caller) external view returns (bool);
 
     /// @dev returns the global owner address
     /// @return _owner is the global owner address

src/libraries/Error.sol

@@ -165,4 +165,10 @@ library Error {
 
     /// @dev is thrown if transaction is expired
     error TX_EXPIRED();
+
+    /*/////////////////////////////////////////////////////////////////
+                            GAC ERRORS
+    ////////////////////////////////////////////////////////////////*/
+    /// @dev is thrown if the gas limit is less than minimum
+    error INVALID_DST_GAS_LIMIT_MIN();
 }

test/unit-tests/GAC.t.sol

@@ -159,29 +159,12 @@ contract GACTest is Setup {
         gac.setGlobalMsgDeliveryGasLimit(420000);
     }
 
-    /// @dev sets message expiry time
-    function test_set_msg_expiry_time() public {
+    /// @dev cannot set a gas limit lower than the minimum
+    function test_set_global_msg_delivery_gas_limit_lower_than_min() public {
         vm.startPrank(owner);
 
-        gac.setMsgExpiryTime(42000);
-
-        assertEq(gac.getMsgExpiryTime(), 42000);
-    }
-
-    /// @dev only owner can set message expiry time
-    function test_set_msg_expiry_time_only_owner() public {
-        vm.startPrank(caller);
-
-        vm.expectRevert("Ownable: caller is not the owner");
-        gac.setMsgExpiryTime(42000);
-    }
-
-    /// @dev cannot set message expiry time to zero
-    function test_set_msg_expiry_time_zero() public {
-        vm.startPrank(owner);
-
-        vm.expectRevert(Error.ZERO_EXPIRATION_TIME.selector);
-        gac.setMsgExpiryTime(0);
+        vm.expectRevert(Error.INVALID_DST_GAS_LIMIT_MIN.selector);
+        gac.setGlobalMsgDeliveryGasLimit(30000);
     }
 
     /// @dev sets refund address
@@ -209,10 +192,10 @@ contract GACTest is Setup {
         gac.setRefundAddress(address(0));
     }
 
-    /// @dev only owner is privileged caller
-    function test_is_privileged_caller() public {
-        assertTrue(gac.isPrivilegedCaller(owner));
-        assertFalse(gac.isPrivilegedCaller(caller));
+    /// @dev checks if address is the global owner
+    function test_is_global_owner() public {
+        assertTrue(gac.isGlobalOwner(owner));
+        assertFalse(gac.isGlobalOwner(caller));
     }
 
     /// @dev gets the global owner