feat: additional migration feature and stake factory event with minimum changes (#56)

* feat: add function to deploy a new module

* feat: include deployment methods and utility functions

* build: deploy new migration contracts

* ci: remove CODEOWNERS to unblock code review process

* feat: include NewHoprNodeStakeModuleForSafe in every safe-module pair deployment

* build: deploy new StakeFactory and bump the version

* fix: various typos

* fix: lint

* fix: attempt to fix multi version of hopr-bindings

* fix: more lint and remove unnecessary dependency on the internal type to avoid circular dependency

* fix: remove unnecessary hopr-crypto-types dependency

* refactor: improve error handling

* refactor: remove unwrap() s

* chore: Cleanup unused env_logger

* docs: add code comments

* feat: remove extra features to first unblock blokli tests

* chore(owners): return codeowners

---------

Co-authored-by: Tibor Csóka <csokat@gmail.com>

Author: QYuQianchen

Cargo.lock

@@ -15,9 +15,17 @@ alloy = { version = "=1.0.42", default-features = false, features = [
 ] }
 anyhow = "1.0.100"
 const_format = "0.2.35"
+hex-literal = "1.1.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_with = { version = "3.16.1" }
 serde_json = { version = "1.0.145" }
+thiserror = "2.0.17"
+tokio = { version = "1.48.0", features = [
+  "rt-multi-thread",
+  "macros",
+  "tracing",
+] }
+tracing = { version = "0.1.43" }
 
 hopr-bindings = { path = "ethereum/bindings", default-features = false }
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hopr-bindings"
-version = "4.2.0"
+version = "4.3.0"
 description = "This package only exists to automate the export and generation of Rust bindings into the HOPR project"
 edition = "2021"
 homepage = "https://hoprnet.org/"
@@ -16,5 +16,9 @@ const_format = { workspace = true }
 alloy = { workspace = true, default-features = false, features = ["contract"] }
 anyhow = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+hex-literal = { workspace = true }
 serde_with = { workspace = true }
 serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }

ethereum/bindings/Cargo.toml

@@ -21,9 +21,9 @@
         "announcements": "0x5afe60f4f74159f8F68dadCE6202b938cDa80Dad",
         "channels": "0x5bD809bDBAa8D3d5f37743Ae86BFef766dEE56b6",
         "module_implementation": "0x1167FB204298799B0B9E98896D58958cAEd164B0",
-        "node_safe_migration": "0xe95b481AA95e1d071a4B250Ea5F9dD498A19646b",
+        "node_safe_migration": "0x74dfCdF50340b772696cAeF3F3Bc4cD776D37E8A",
         "node_safe_registry": "0x0e4e1a2D851663462523bF38Ca56259aceCCBc76",
-        "node_stake_factory": "0x878Ea9591726E70AA06f820c3bA5142A0C8ab58B",
+        "node_stake_factory": "0xE9A9cf50534Eb0817F9fBb115E00Bf8463E973Db",
         "ticket_price_oracle": "0x147899Ca57111d9081df125C2bcbd839981f04c2",
         "token": "0xD4fdec44DB9D44B8f2b6d529620f9C0C7066A2c1",
         "winning_probability_oracle": "0x74329f8153cBb33aABdEd79Ee84748fE8923c5E3"
@@ -37,9 +37,9 @@
         "announcements": "0x191Ee0D1494eB159A5F758bC7c05E434cFaFF6e1",
         "channels": "0x7a33eb3900DB3e02A4C149E49dBc1F0359921B16",
         "module_implementation": "0x3b008Cb90D252b731ceB8952a6Ed78B84Ab31Ea3",
-        "node_safe_migration": "0x06E01A5CEbAD283C0F00f857c06fbd804B054910",
+        "node_safe_migration": "0x593eA8942E8b1D36F7714a15D43b5914DEF7B449",
         "node_safe_registry": "0x7b8E16ADa4720EB87b8000B9D5700EebbB6b1b5C",
-        "node_stake_factory": "0x63e44a4e1349D1c3f0cfC52C4Dae7710A6345761",
+        "node_stake_factory": "0x8E9e7BEDAe175D57054D15e8870E00E5bc66d954",
         "ticket_price_oracle": "0x95566eFB62b7D1e95a9BA05E1E43042a95Da1e42",
         "token": "0xD4fdec44DB9D44B8f2b6d529620f9C0C7066A2c1",
         "winning_probability_oracle": "0x3C5CbDfc873a6a52093c1d3801E29c2D78b26c7f"

ethereum/bindings/contracts-addresses.json

@@ -7,6 +7,7 @@
 mod codegen;
 
 pub mod config;
+pub mod constants;
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
 pub use codegen::*;

ethereum/bindings/src/constants.rs

@@ -426,6 +426,7 @@ contract HoprNodeStakeFactory is HoprNodeStakeFactoryEvents, Ownable2Step, IERC7
             _prepareSafeTx(safeProxyAddr, swapOwnerData);
         }
 
+        emit NewHoprNodeStakeModuleForSafe(moduleProxy, safeProxyAddr);
         return (moduleProxy, safeProxyAddr);
     }
 
@@ -493,6 +494,7 @@ contract HoprNodeStakeFactory is HoprNodeStakeFactoryEvents, Ownable2Step, IERC7
             _prepareSafeTx(safeProxyAddr, swapOwnerData);
         }
 
+        emit NewHoprNodeStakeModuleForSafe(moduleProxy, safeProxyAddr);
         return (moduleProxy, safeProxyAddr);
     }
 

ethereum/bindings/src/lib.rs

@@ -26,6 +26,7 @@ abstract contract HoprNodeSafeMigrationEvents {
      */
     event SafeAndModuleMigrationCompleted(address safeProxy, address oldModuleProxy, address newModuleProxy);
     event ChangedModuleImplementation(address moduleProxy);
+    event DeployedNewV4Module(address newModuleProxy);
 }
 
 /**
@@ -159,4 +160,25 @@ contract HoprNodeSafeMigration is HoprNodeSafeMigrationEvents, SafeMigration, Ex
 
         emit SafeAndModuleMigrationCompleted(address(this), oldModuleProxy, newModuleProxy);
     }
+
+    /**
+     * @notice Deploy a new v4 module and enable it in the Safe, without removing the old module.
+     * @param defaultTarget Default target address for the new module
+     * @param nonce Nonce for the new module deployment
+     * @param nodes List of node addresses to be included in the new module
+     * @return newModuleProxy Address of the newly deployed module proxy
+     */
+    function deployNewV4Module(bytes32 defaultTarget, uint256 nonce, address[] memory nodes)
+        public
+        onlyDelegateCall
+        returns (address newModuleProxy)
+    {
+        // deploy a new module contract
+        newModuleProxy = IHoprNodeStakeFactory(FACTORY_ADDRESS).deployModule(address(this), defaultTarget, nonce);
+        // add all the nodes to the new module
+        IHoprNodeManagementModule(newModuleProxy).includeNodes(nodes);
+        // enable the newly deployed module
+        IAvatar(address(this)).enableModule(newModuleProxy);
+        emit DeployedNewV4Module(newModuleProxy);
+    }
 }

ethereum/contracts/src/node-stake/NodeStakeFactory.sol

@@ -191,12 +191,6 @@ contract NodeSafeMigrationTest is
 
         // migrate the module singleton to the new version via delegatecall from the safe, using delegatecall
         vm.prank(caller);
-        // vm.expectEmit(false, false, false, true, safeAddress);
-        // emit SafeAndModuleMigrationCompleted(
-        // safeAddress,
-        // oldModuleProxy,
-        // newModuleProxyPrediction
-        //);
         _helperSafeTxnDelegateCall(address(migrationContract), IAvatar(safeAddress), callerPrivateKey, data);
 
         // check the module is now upgraded to the new singleton
@@ -270,12 +264,6 @@ contract NodeSafeMigrationTest is
 
         // migrate the module singleton to the new version via delegatecall from the safe, using delegatecall
         vm.prank(caller);
-        // vm.expectEmit(false, false, false, true, safeAddress);
-        // emit SafeAndModuleMigrationCompleted(
-        // safeAddress,
-        // oldModuleProxy,
-        // newModuleProxyPrediction
-        //);
         _helperSafeTxnDelegateCall(address(migrationContract), IAvatar(safeAddress), callerPrivateKey, data);
 
         // check the module is now upgraded to the new singleton
@@ -292,6 +280,62 @@ contract NodeSafeMigrationTest is
         vm.clearMockedCalls();
     }
 
+    function test_DeployNewV4Module() public mockTokenChannel {
+        uint256 callerPrivateKey = 0xCAFE;
+        address caller = vm.addr(callerPrivateKey);
+        address[] memory admins = new address[](1);
+        admins[0] = caller;
+        address[] memory nodes = new address[](3);
+        nodes[0] = address(0xCAB1);
+        nodes[1] = address(0xCAB2);
+        nodes[2] = address(0xCAB3);
+        uint256 nonce = 999;
+        uint256 newNonce = nonce + 1;
+
+        // create a safe via the old factory
+        vm.prank(caller);
+        (address oldModuleProxy, address payable safeAddress) = oldFactory.clone(nonce, OLD_DEFAULT_TARGET, admins);
+        // check the safe is created with the old module
+        assertTrue(IAvatar(safeAddress).isModuleEnabled(address(oldModuleProxy)));
+        // module proxy uses old implementation, at the implementation slot
+        assertEq(
+            vm.load(address(oldModuleProxy), _IMPLEMENTATION_SLOT),
+            bytes32(uint256(uint160(address(oldModuleSingleton))))
+        );
+        // check the safe is owned by the old factory
+        assertEq(IAvatar(safeAddress).getOwners().length, 1);
+        assertEq(IAvatar(safeAddress).getOwners()[0], address(caller));
+        // check the module is owned by the safe
+        assertEq(IOwner(address(oldModuleProxy)).owner(), safeAddress);
+
+        // prepare safe transaction data for migration. Caller should call
+        // deployNewV4Module(bytes32,uint256,address[] memory)
+        // on the migration contract via delegatecall from the safe
+        bytes memory data =
+            abi.encodeWithSelector(migrationContract.deployNewV4Module.selector, NEW_DEFAULT_TARGET, newNonce, nodes);
+        // predict the new module deployment address
+        address newModuleProxyPrediction =
+            newFactory.predictModuleAddress(safeAddress, newNonce, safeAddress, NEW_DEFAULT_TARGET);
+
+        // migrate the module singleton to the new version via delegatecall from the safe, using delegatecall
+        vm.prank(caller);
+        _helperSafeTxnDelegateCall(address(migrationContract), IAvatar(safeAddress), callerPrivateKey, data);
+
+        // check the module is now upgraded to the new singleton
+        // new module is now owned by the safe
+        assertEq(IOwner(address(newModuleProxyPrediction)).owner(), safeAddress);
+        // new module is enabled in the safe
+        assertTrue(IAvatar(safeAddress).isModuleEnabled(address(newModuleProxyPrediction)));
+        // old module is STILL enabled in the safe
+        assertTrue(IAvatar(safeAddress).isModuleEnabled(address(oldModuleProxy)));
+        assertEq(
+            vm.load(address(newModuleProxyPrediction), _IMPLEMENTATION_SLOT),
+            bytes32(uint256(uint160(address(newModuleSingleton))))
+        );
+
+        vm.clearMockedCalls();
+    }
+
     function _helperSafeTxnDelegateCall(address to, IAvatar safeInstance, uint256 senderPrivateKey, bytes memory data)
         private
     {