feat(core): batch set/add/remove on DomainRoutingIsm

paulbalaji · paulbalaji · commit 223a8966f26d · 2026-04-22T18:11:11.000+01:00
Adds setBatch, add, addBatch and removeBatch external functions plus ModuleSet and ModuleRemoved events to DomainRoutingIsm. add/addBatch revert if a domain is already enrolled, enabling distinct role-based access control by function selector. setBatch/removeBatch let owners enroll or remove many domains in a single transaction. Re-opens the idea from #5219 against main.
diff --git a/.changeset/routing-ism-batch-ops.md b/.changeset/routing-ism-batch-ops.md
@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/core': minor
+---
+
+Added `setBatch`, `add`, `addBatch`, and `removeBatch` external functions to `DomainRoutingIsm`, plus `ModuleSet` and `ModuleRemoved` events. `add`/`addBatch` revert if a domain is already enrolled, enabling distinct role-based access control via function selectors. `setBatch`/`removeBatch` let owners enroll or remove many domains in a single transaction, which avoids the need to enroll one domain per transaction after routing ISM initialization.
diff --git a/solidity/contracts/isms/routing/DomainRoutingIsm.sol b/solidity/contracts/isms/routing/DomainRoutingIsm.sol
@@ -29,9 +29,19 @@ contract DomainRoutingIsm is
     using Address for address;
     using Strings for uint32;
 
+    // ============ Events ============
+    event ModuleSet(uint32 indexed domain, address module);
+    event ModuleRemoved(uint32 indexed domain);
+
     // ============ Mutable Storage ============
     EnumerableMapExtended.UintToBytes32Map internal _modules;
 
+    // ============ Structs ============
+    struct DomainModule {
+        uint32 domain;
+        IInterchainSecurityModule module;
+    }
+
     // ============ External Functions ============
 
     /**
@@ -74,6 +84,43 @@ contract DomainRoutingIsm is
         _set(_domain, address(_module));
     }
 
+    /**
+     * @notice Sets the ISMs to be used for the specified origin domains
+     * @param _domainModules The origin domains and ISMs to enroll
+     */
+    function setBatch(
+        DomainModule[] calldata _domainModules
+    ) external onlyOwner {
+        _set(_domainModules);
+    }
+
+    /**
+     * @notice Adds the specified origin domain
+     * @dev Reverts if the domain already exists
+     * @dev Behavior similar to set but useful for distinguishing by selector
+     * @param _domain The origin domain
+     * @param _module The ISM to use to verify messages
+     */
+    function add(
+        uint32 _domain,
+        IInterchainSecurityModule _module
+    ) external onlyOwner {
+        _add(_domain, address(_module));
+    }
+
+    /**
+     * @notice Adds the specified origin domains
+     * @dev Reverts if any domain already exists
+     * @param _domainModules The origin domains and ISMs to enroll
+     */
+    function addBatch(
+        DomainModule[] calldata _domainModules
+    ) external onlyOwner {
+        for (uint256 i = 0; i < _domainModules.length; ++i) {
+            _add(_domainModules[i].domain, address(_domainModules[i].module));
+        }
+    }
+
     /**
      * @notice Removes the specified origin domain
      * @param _domain The origin domain
@@ -82,6 +129,16 @@ contract DomainRoutingIsm is
         _remove(_domain);
     }
 
+    /**
+     * @notice Removes the specified origin domains
+     * @param _domains The origin domains to remove
+     */
+    function removeBatch(uint32[] calldata _domains) external onlyOwner {
+        for (uint256 i = 0; i < _domains.length; ++i) {
+            _remove(_domains[i]);
+        }
+    }
+
     function domains() external view returns (uint256[] memory) {
         return _modules.keys();
     }
@@ -117,6 +174,7 @@ contract DomainRoutingIsm is
      */
     function _remove(uint32 _domain) internal virtual {
         require(_modules.remove(_domain), _originNotFoundError(_domain));
+        emit ModuleRemoved(_domain);
     }
 
     function _originNotFoundError(
@@ -125,6 +183,17 @@ contract DomainRoutingIsm is
         return string.concat("No ISM found for origin: ", _origin.toString());
     }
 
+    function _set(DomainModule[] calldata _domainModules) internal {
+        for (uint256 i = 0; i < _domainModules.length; ++i) {
+            _set(_domainModules[i].domain, address(_domainModules[i].module));
+        }
+    }
+
+    function _add(uint32 _domain, address _module) internal {
+        require(!_modules.contains(_domain), "Domain already exists");
+        _set(_domain, _module);
+    }
+
     /**
      * @notice Sets the ISM to be used for the specified origin domain
      * @param _domain The origin domain
@@ -133,5 +202,6 @@ contract DomainRoutingIsm is
     function _set(uint32 _domain, address _module) internal virtual {
         require(_module.isContract(), "ISM must be a contract");
         _modules.set(_domain, _module.addressToBytes32());
+        emit ModuleSet(_domain, _module);
     }
 }
diff --git a/solidity/test/isms/DomainRoutingIsm.t.sol b/solidity/test/isms/DomainRoutingIsm.t.sol
@@ -27,26 +27,130 @@ contract DomainRoutingIsmTest is Test {
         return new TestIsm(abi.encode(requiredMetadata));
     }
 
+    function deployTestIsms(
+        uint256 count
+    ) internal returns (IInterchainSecurityModule[] memory isms) {
+        isms = new IInterchainSecurityModule[](count);
+        for (uint32 i = 0; i < count; ++i) {
+            isms[i] = IInterchainSecurityModule(deployTestIsm(bytes32(0)));
+        }
+    }
+
+    function uniqueDomains(
+        uint32 domain,
+        uint256 count
+    ) internal pure returns (uint32[] memory) {
+        uint32[] memory domains = new uint32[](count);
+        for (uint32 i = 0; i < count; ++i) {
+            unchecked {
+                domains[i] = domain + i;
+            }
+        }
+        return domains;
+    }
+
+    function buildDomainModules(
+        uint32[] memory domains,
+        IInterchainSecurityModule[] memory modules
+    ) internal pure returns (DomainRoutingIsm.DomainModule[] memory) {
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = new DomainRoutingIsm.DomainModule[](
+                domains.length
+            );
+        for (uint256 i = 0; i < domains.length; ++i) {
+            domainModules[i] = DomainRoutingIsm.DomainModule({
+                domain: domains[i],
+                module: modules[i]
+            });
+        }
+        return domainModules;
+    }
+
     function getMetadata(uint32 domain) internal view returns (bytes memory) {
         return TestIsm(address(ism.module(domain))).requiredMetadata();
     }
 
     function testSet(uint32 domain) public {
+        vm.expectRevert("ISM must be a contract");
+        ism.set(domain, IInterchainSecurityModule(address(0x0)));
+
         TestIsm _ism = deployTestIsm(bytes32(0));
+        vm.expectEmit(true, false, false, true);
+        emit DomainRoutingIsm.ModuleSet(domain, address(_ism));
         ism.set(domain, _ism);
         assertEq(address(ism.module(domain)), address(_ism));
     }
 
+    function testSetBatch(uint32 domain, uint8 count) public {
+        vm.assume(count > 0);
+        uint32[] memory domains = uniqueDomains(domain, count);
+        IInterchainSecurityModule[] memory modules = deployTestIsms(count);
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = buildDomainModules(domains, modules);
+
+        ism.setBatch(domainModules);
+        for (uint256 i = 0; i < count; ++i) {
+            assertEq(address(ism.module(domains[i])), address(modules[i]));
+        }
+    }
+
+    function testAdd(uint32 domain) public virtual {
+        vm.expectRevert("ISM must be a contract");
+        ism.add(domain, IInterchainSecurityModule(address(0x0)));
+
+        TestIsm _ism = deployTestIsm(bytes32(0));
+        vm.expectEmit(true, false, false, true);
+        emit DomainRoutingIsm.ModuleSet(domain, address(_ism));
+        ism.add(domain, _ism);
+        assertEq(address(ism.module(domain)), address(_ism));
+
+        vm.expectRevert("Domain already exists");
+        ism.add(domain, _ism);
+    }
+
+    function testAddBatch(uint32 domain, uint8 count) public virtual {
+        vm.assume(count > 0);
+        uint32[] memory domains = uniqueDomains(domain, count);
+        IInterchainSecurityModule[] memory modules = deployTestIsms(count);
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = buildDomainModules(domains, modules);
+
+        ism.addBatch(domainModules);
+        for (uint256 i = 0; i < count; ++i) {
+            assertEq(address(ism.module(domains[i])), address(modules[i]));
+        }
+        vm.expectRevert("Domain already exists");
+        ism.addBatch(domainModules);
+    }
+
     function testRemove(uint32 domain) public virtual {
         vm.expectRevert();
         ism.remove(domain);
 
         TestIsm _ism = deployTestIsm(bytes32(0));
         ism.set(domain, _ism);
+        vm.expectEmit(true, false, false, false);
+        emit DomainRoutingIsm.ModuleRemoved(domain);
         ism.remove(domain);
     }
 
-    function testSetManyViaFactory(uint8 count, uint32 domain) public {
+    function testRemoveBatch(uint32 domain, uint8 count) public virtual {
+        vm.assume(count > 0);
+        uint32[] memory domains = uniqueDomains(domain, count);
+        IInterchainSecurityModule[] memory modules = deployTestIsms(count);
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = buildDomainModules(domains, modules);
+
+        ism.addBatch(domainModules);
+        ism.removeBatch(domains);
+        for (uint256 i = 0; i < count; ++i) {
+            vm.expectRevert();
+            ism.module(domains[i]);
+        }
+    }
+
+    function testSetManyViaFactory(uint8 count, uint32 domain) public virtual {
+        vm.assume(count > 0);
         vm.assume(domain > count);
         DomainRoutingIsmFactory factory = new DomainRoutingIsmFactory();
         uint32[] memory _domains = new uint32[](count);
@@ -60,6 +164,9 @@ contract DomainRoutingIsmTest is Test {
         for (uint256 i = 0; i < count; ++i) {
             assertEq(address(ism.module(_domains[i])), address(_isms[i]));
         }
+        uint32[] memory shortDomains = new uint32[](count - 1);
+        vm.expectRevert("length mismatch");
+        factory.deploy(address(this), shortDomains, _isms);
     }
 
     function testSetNonOwner(
@@ -71,6 +178,53 @@ contract DomainRoutingIsmTest is Test {
         ism.set(domain, _ism);
     }
 
+    function testSetBatchNonOwner(uint32 domain) public {
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = new DomainRoutingIsm.DomainModule[](1);
+        domainModules[0] = DomainRoutingIsm.DomainModule({
+            domain: domain,
+            module: IInterchainSecurityModule(address(0))
+        });
+        vm.prank(NON_OWNER);
+        vm.expectRevert("Ownable: caller is not the owner");
+        ism.setBatch(domainModules);
+    }
+
+    function testAddNonOwner(
+        uint32 domain,
+        IInterchainSecurityModule _ism
+    ) public {
+        vm.prank(NON_OWNER);
+        vm.expectRevert("Ownable: caller is not the owner");
+        ism.add(domain, _ism);
+    }
+
+    function testAddBatchNonOwner(uint32 domain) public {
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = new DomainRoutingIsm.DomainModule[](1);
+        domainModules[0] = DomainRoutingIsm.DomainModule({
+            domain: domain,
+            module: IInterchainSecurityModule(address(0))
+        });
+        vm.prank(NON_OWNER);
+        vm.expectRevert("Ownable: caller is not the owner");
+        ism.addBatch(domainModules);
+    }
+
+    function testRemoveNonOwner(uint32 domain) public {
+        vm.prank(NON_OWNER);
+        vm.expectRevert("Ownable: caller is not the owner");
+        ism.remove(domain);
+    }
+
+    function testRemoveBatchNonOwner(uint32 domain) public {
+        uint32[] memory domains = new uint32[](1);
+        domains[0] = domain;
+        vm.prank(NON_OWNER);
+        vm.expectRevert("Ownable: caller is not the owner");
+        ism.removeBatch(domains);
+    }
+
     function testVerify(uint32 domain, bytes32 seed) public {
         ism.set(domain, deployTestIsm(seed));
 
@@ -123,6 +277,20 @@ contract DefaultFallbackRoutingIsmTest is DomainRoutingIsmTest {
         new DefaultFallbackRoutingIsm(address(0));
     }
 
+    function testRemoveBatch(uint32 domain, uint8 count) public override {
+        vm.assume(count > 0);
+        uint32[] memory domains = uniqueDomains(domain, count);
+        IInterchainSecurityModule[] memory modules = deployTestIsms(count);
+        DomainRoutingIsm.DomainModule[]
+            memory domainModules = buildDomainModules(domains, modules);
+
+        ism.addBatch(domainModules);
+        ism.removeBatch(domains);
+        for (uint256 i = 0; i < count; ++i) {
+            assertEq(address(ism.module(domains[i])), address(defaultIsm));
+        }
+    }
+
     function testVerifyNoIsm(uint32 domain, bytes32 seed) public override {
         vm.assume(domain > 0);
         ism.set(domain, deployTestIsm(seed));
diff --git a/solidity/test/isms/IncrementalDomainRoutingIsm.t.sol b/solidity/test/isms/IncrementalDomainRoutingIsm.t.sol
@@ -5,6 +5,7 @@ import "forge-std/Test.sol";
 
 import {IncrementalDomainRoutingIsm} from "../../contracts/isms/routing/IncrementalDomainRoutingIsm.sol";
 import {IncrementalDomainRoutingIsmFactory} from "../../contracts/isms/routing/IncrementalDomainRoutingIsmFactory.sol";
+import {DomainRoutingIsm} from "../../contracts/isms/routing/DomainRoutingIsm.sol";
 import {DomainRoutingIsmTest} from "./DomainRoutingIsm.t.sol";
 import {IInterchainSecurityModule} from "../../contracts/interfaces/IInterchainSecurityModule.sol";
 import {TestIsm} from "./IsmTestUtils.sol";
@@ -29,6 +30,13 @@ contract IncrementalDomainRoutingIsmTest is DomainRoutingIsmTest {
         ism.remove(domain);
     }
 
+    function testRemoveBatch(uint32 domain, uint8 count) public override {
+        vm.assume(count > 0);
+        uint32[] memory domains = uniqueDomains(domain, count);
+        vm.expectRevert("IncrementalDomainRoutingIsm: removal not supported");
+        ism.removeBatch(domains);
+    }
+
     function testSetTwiceReverts(uint32 domain) public {
         TestIsm _ism = deployTestIsm(bytes32(0));
         TestIsm _ism2 = deployTestIsm(bytes32(uint256(1)));

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@hyperlane-xyz/core': minor
 +---
++
 +Added `setBatch`, `add`, `addBatch`, and `removeBatch` external functions to `DomainRoutingIsm`, plus `ModuleSet` and `ModuleRemoved` events. `add`/`addBatch` revert if a domain is already enrolled, enabling distinct role-based access control via function selectors. `setBatch`/`removeBatch` let owners enroll or remove many domains in a single transaction, which avoids the need to enroll one domain per transaction after routing ISM initialization.