Test factory

solidity/contracts/isms/routing/DomainRoutingIsm.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 // ============ External Imports ============
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 // ============ Internal Imports ============
 import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
@@ -11,7 +11,7 @@ import {Message} from "../../libs/Message.sol";
 /**
  * @title DomainRoutingIsm
  */
-contract DomainRoutingIsm is AbstractRoutingIsm, Ownable {
+contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
     // ============ Public Storage ============
     mapping(uint32 => IInterchainSecurityModule) public modules;
 
@@ -24,27 +24,34 @@ contract DomainRoutingIsm is AbstractRoutingIsm, Ownable {
      */
     event ModuleSet(uint32 indexed domain, IInterchainSecurityModule module);
 
-    // ============ Constructor ============
-
-    // solhint-disable-next-line no-empty-blocks
-    constructor() Ownable() {}
-
     // ============ External Functions ============
 
+    /**
+     * @param _owner The owner of the contract.
+     */
+    function initialize(address _owner) public initializer {
+        __Ownable_init();
+        _transferOwnership(_owner);
+    }
+
     /**
      * @notice Sets the ISMs to be used for the specified origin domains
+     * @param _owner The owner of the contract.
      * @param _domains The origin domains
      * @param _modules The ISMs to use to verify messages
      */
-    function set(
+    function initialize(
+        address _owner,
         uint32[] calldata _domains,
         IInterchainSecurityModule[] calldata _modules
-    ) external onlyOwner {
+    ) public initializer {
+        __Ownable_init();
         require(_domains.length == _modules.length, "length mismatch");
         uint256 _length = _domains.length;
         for (uint256 i = 0; i < _length; ++i) {
             _set(_domains[i], _modules[i]);
         }
+        _transferOwnership(_owner);
     }
 
     /**

solidity/contracts/isms/routing/DomainRoutingIsmFactory.sol

@@ -29,10 +29,11 @@ contract DomainRoutingIsmFactory {
     function deploy(
         uint32[] calldata _domains,
         IInterchainSecurityModule[] calldata _modules
-    ) external {
+    ) external returns (DomainRoutingIsm) {
         DomainRoutingIsm _ism = DomainRoutingIsm(
             MinimalProxy.create(_implementation)
         );
-        _ism.set(_domains, _modules);
+        _ism.initialize(msg.sender, _domains, _modules);
+        return _ism;
     }
 }

solidity/test/isms/DomainRoutingIsm.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import "forge-std/Test.sol";
 
 import {DomainRoutingIsm} from "../../contracts/isms/routing/DomainRoutingIsm.sol";
+import {DomainRoutingIsmFactory} from "../../contracts/isms/routing/DomainRoutingIsmFactory.sol";
 import {IInterchainSecurityModule} from "../../contracts/interfaces/IInterchainSecurityModule.sol";
 import {MessageUtils, TestIsm} from "./IsmTestUtils.sol";
 
@@ -14,6 +15,7 @@ contract DomainRoutingIsmTest is Test {
 
     function setUp() public {
         ism = new DomainRoutingIsm();
+        ism.initialize(address(this));
     }
 
     function deployTestIsm(uint32 domain, bytes32 requiredMetadata)
@@ -36,12 +38,13 @@ contract DomainRoutingIsmTest is Test {
         assertEq(address(ism.modules(domain)), address(_ism));
     }
 
-    function testSetMany(
+    function testSetManyViaFactory(
         uint8 count,
         uint32 domain,
         IInterchainSecurityModule _ism
     ) public {
         vm.assume(domain > count && uint160(address(_ism)) > count);
+        DomainRoutingIsmFactory factory = new DomainRoutingIsmFactory();
         uint32[] memory _domains = new uint32[](count);
         IInterchainSecurityModule[]
             memory _isms = new IInterchainSecurityModule[](count);
@@ -53,7 +56,7 @@ contract DomainRoutingIsmTest is Test {
             vm.expectEmit(true, true, false, true);
             emit ModuleSet(_domains[i], _isms[i]);
         }
-        ism.set(_domains, _isms);
+        ism = factory.deploy(_domains, _isms);
         for (uint256 i = 0; i < count; ++i) {
             assertEq(address(ism.modules(_domains[i])), address(_isms[i]));
         }