test(RoninGatewayV3): test deposit vote

script/BaseMigrationV2.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "foundry-deployment-kit/BaseMigration.s.sol";
+
+abstract contract BaseMigrationV2 is BaseMigration {
+  using StdStyle for *;
+  using LibString for bytes32;
+  using LibProxy for address payable;
+
+  function _deployProxy(TContract contractType, bytes memory args)
+    internal
+    virtual
+    override
+    logFn(string.concat("_deployProxy ", TContract.unwrap(contractType).unpackOne()))
+    returns (address payable deployed)
+  {
+    string memory contractName = CONFIG.getContractName(contractType);
+
+    address logic = _deployLogic(contractType);
+    string memory proxyAbsolutePath = "TransparentUpgradeableProxyV2.sol:TransparentUpgradeableProxyV2";
+    uint256 proxyNonce;
+    address proxyAdmin = _getProxyAdmin();
+    assertTrue(proxyAdmin != address(0x0), "BaseMigration: Null ProxyAdmin");
+
+    (deployed, proxyNonce) = _deployRaw(proxyAbsolutePath, abi.encode(logic, proxyAdmin, args));
+
+    // validate proxy admin
+    address actualProxyAdmin = deployed.getProxyAdmin();
+    assertEq(
+      actualProxyAdmin,
+      proxyAdmin,
+      string.concat(
+        "BaseMigration: Invalid proxy admin\n",
+        "Actual: ",
+        vm.toString(actualProxyAdmin),
+        "\nExpected: ",
+        vm.toString(proxyAdmin)
+      )
+    );
+
+    CONFIG.setAddress(network(), contractType, deployed);
+    ARTIFACT_FACTORY.generateArtifact(
+      sender(), deployed, proxyAbsolutePath, string.concat(contractName, "Proxy"), args, proxyNonce
+    );
+  }
+}

script/Migration.s.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import { BaseMigration } from "foundry-deployment-kit/BaseMigration.s.sol";
+import { BaseMigrationV2 } from "./BaseMigrationV2.sol";
 import { DefaultNetwork } from "foundry-deployment-kit/utils/DefaultNetwork.sol";
 import { GeneralConfig } from "./GeneralConfig.sol";
 import { ISharedArgument } from "./interfaces/ISharedArgument.sol";
@@ -12,7 +12,7 @@ import { GlobalProposal } from "@ronin/contracts/libraries/GlobalProposal.sol";
 import { Token } from "@ronin/contracts/libraries/Token.sol";
 import { LibArray } from "./libraries/LibArray.sol";
 
-contract Migration is BaseMigration, Utils {
+contract Migration is BaseMigrationV2, Utils {
   ISharedArgument public constant config = ISharedArgument(address(CONFIG));
 
   function _configByteCode() internal virtual override returns (bytes memory) {
@@ -21,6 +21,7 @@ contract Migration is BaseMigration, Utils {
 
   function _sharedArguments() internal virtual override returns (bytes memory rawArgs) {
     ISharedArgument.SharedParameter memory param;
+    param.test.numberOfBlocksInEpoch = 600;
     param.test.proxyAdmin = makeAddr("proxy-admin");
     param.test.dposGA = makeAddr("governance-admin");
     param.test.mainchainChainId = Network.EthLocal.chainId();

script/interfaces/ISharedArgument.sol

@@ -89,6 +89,7 @@ interface ISharedArgument is IGeneralConfig {
 
   struct UnitTestParam {
     address proxyAdmin;
+    uint256 numberOfBlocksInEpoch;
     address dposGA;
     uint256 mainchainChainId;
     uint256 roninChainId;

src/mocks/ronin/MockValidatorContract_OnlyTiming_ForHardhatTest.sol

@@ -46,7 +46,7 @@ contract MockValidatorContract_OnlyTiming_ForHardhatTest {
   }
 
   function epochEndingAt(uint256 _block) public view returns (bool) {
-    for (uint _i = 0; _i < _epochs.length; _i++) {
+    for (uint256 _i = 0; _i < _epochs.length; _i++) {
       if (_block == _epochs[_i]) {
         return true;
       }
@@ -77,6 +77,10 @@ contract MockValidatorContract_OnlyTiming_ForHardhatTest {
     return _lastUpdatedPeriod;
   }
 
+  function setCurrentPeriod(uint256 period) external {
+    _lastUpdatedPeriod = period;
+  }
+
   function currentPeriodStartAtBlock() public view returns (uint256) {
     return _currentPeriodStartAtBlock;
   }

src/mocks/token/MockWrappedToken.sol

@@ -42,6 +42,13 @@ contract MockWrappedToken {
     emit Withdrawal(msg.sender, wad);
   }
 
+  function mint(address account, uint256 amount) public {
+    require(account != address(0), "ERC20: mint to the zero address");
+
+    balanceOf[account] += amount;
+    emit Transfer(address(0), account, amount);
+  }
+
   function totalSupply() public view returns (uint256) {
     return address(this).balance;
   }

test/bridge/integration/BaseIntegration.t.sol

@@ -26,6 +26,9 @@ import { Ballot } from "@ronin/contracts/libraries/Ballot.sol";
 import { GlobalCoreGovernance } from "@ronin/contracts/extensions/sequential-governance/GlobalCoreGovernance.sol";
 import { IHasContracts } from "@ronin/contracts/interfaces/collections/IHasContracts.sol";
 import { ContractType } from "@ronin/contracts/utils/ContractType.sol";
+import { TransparentUpgradeableProxyV2 } from "@ronin/contracts/extensions/TransparentUpgradeableProxyV2.sol";
+import { MockValidatorContract_OnlyTiming_ForHardhatTest } from
+  "@ronin/contracts/mocks/ronin/MockValidatorContract_OnlyTiming_ForHardhatTest.sol";
 
 import { RoninBridgeManagerDeploy } from "@ronin/script/contracts/RoninBridgeManagerDeploy.s.sol";
 import { RoninGatewayV3Deploy } from "@ronin/script/contracts/RoninGatewayV3Deploy.s.sol";
@@ -41,7 +44,7 @@ import { SLPDeploy } from "@ronin/script/contracts/token/SLPDeploy.s.sol";
 import { USDCDeploy } from "@ronin/script/contracts/token/USDCDeploy.s.sol";
 
 import { ProposalUtils } from "test/helpers/ProposalUtils.t.sol";
-import { MockValidatorSet_ForFoundryTest } from "test/mocks/MockValidatorSet_ForFoundryTest.sol";
+import { RoninBridgeAdminUtils } from "test/helpers/RoninBridgeAdminUtils.t.sol";
 
 contract BaseIntegration_Test is Base_Test {
   IGeneralConfig _config;
@@ -67,9 +70,9 @@ contract BaseIntegration_Test is Base_Test {
   MockERC20 _mainchainSlp;
   MockERC20 _mainchainUsdc;
 
-  MockValidatorSet_ForFoundryTest _validatorSet;
+  MockValidatorContract_OnlyTiming_ForHardhatTest _validatorSet;
 
-  ProposalUtils _roninProposalUtils;
+  RoninBridgeAdminUtils _roninProposalUtils;
   ProposalUtils _mainchainProposalUtils;
 
   uint256 _roninNonce = 1;
@@ -83,6 +86,9 @@ contract BaseIntegration_Test is Base_Test {
 
     _initializeRonin();
     _initializeMainchain();
+
+    _changeAdminOnRonin();
+    _changeAdminOnMainchain();
   }
 
   function _deployContractsOnRonin() internal {
@@ -101,10 +107,11 @@ contract BaseIntegration_Test is Base_Test {
     _roninSlp = new SLPDeploy().run();
     _roninUsdc = new USDCDeploy().run();
 
-    _validatorSet = new MockValidatorSet_ForFoundryTest();
-
     _param = ISharedArgument(LibSharedAddress.CONFIG).sharedArguments();
-    _roninProposalUtils = new ProposalUtils(_param.test.roninChainId);
+    _roninProposalUtils = new RoninBridgeAdminUtils(
+      _param.test.roninChainId, _param.test.governorPKs, _roninBridgeManager, _param.roninBridgeManager.governors[0]
+    );
+    _validatorSet = new MockValidatorContract_OnlyTiming_ForHardhatTest(_param.test.numberOfBlocksInEpoch);
   }
 
   function _deployContractsOnMainchain() internal {
@@ -121,7 +128,7 @@ contract BaseIntegration_Test is Base_Test {
     _mainchainUsdc = new USDCDeploy().run();
 
     _param = ISharedArgument(LibSharedAddress.CONFIG).sharedArguments();
-    _mainchainProposalUtils = new ProposalUtils(_param.test.roninChainId);
+    _mainchainProposalUtils = new ProposalUtils(_param.test.roninChainId, _param.test.governorPKs);
   }
 
   function _initializeRonin() internal {
@@ -159,8 +166,8 @@ contract BaseIntegration_Test is Base_Test {
     roninTokens[0] = address(_roninWeth);
     roninTokens[1] = address(_roninWron);
     roninTokens[2] = address(_roninAxs);
-    roninTokens[4] = address(_roninSlp);
-    roninTokens[3] = address(_roninUsdc);
+    roninTokens[3] = address(_roninSlp);
+    roninTokens[4] = address(_roninUsdc);
   }
 
   function _bridgeRewardInitialize() internal {
@@ -194,10 +201,12 @@ contract BaseIntegration_Test is Base_Test {
     ISharedArgument.BridgeTrackingParam memory param = _param.bridgeTracking;
 
     _bridgeTracking.initialize(param.bridgeContract, param.validatorContract, param.startedAtBlock);
-    _bridgeTracking.initializeV2();
+    // _bridgeTracking.initializeV2(); NOT INITIALIZE V2
     _bridgeTracking.initializeV3(
       address(_roninBridgeManager), address(_bridgeSlash), address(_bridgeReward), _param.test.dposGA
     );
+    vm.prank(_param.test.dposGA);
+    _bridgeTracking.initializeREP2();
   }
 
   function _bridgeSlashInitialize() internal {
@@ -417,6 +426,25 @@ contract BaseIntegration_Test is Base_Test {
     _mainchainGatewayV3.initializeV2(address(_mainchainBridgeManager));
   }
 
+  function _changeAdminOnRonin() internal {
+    _config.switchTo(Network.RoninLocal.key());
+
+    vm.startPrank(_param.test.proxyAdmin);
+    TransparentUpgradeableProxyV2(payable(address(_roninGatewayV3))).changeAdmin(address(_roninBridgeManager));
+    TransparentUpgradeableProxyV2(payable(address(_bridgeReward))).changeAdmin(address(_roninBridgeManager));
+    TransparentUpgradeableProxyV2(payable(address(_bridgeSlash))).changeAdmin(address(_roninBridgeManager));
+    TransparentUpgradeableProxyV2(payable(address(_bridgeTracking))).changeAdmin(address(_roninBridgeManager));
+    vm.stopPrank();
+  }
+
+  function _changeAdminOnMainchain() internal {
+    _config.switchTo(Network.EthLocal.key());
+
+    vm.startPrank(_param.test.proxyAdmin);
+    TransparentUpgradeableProxyV2(payable(address(_mainchainGatewayV3))).changeAdmin(address(_mainchainBridgeManager));
+    vm.stopPrank();
+  }
+
   function _deployGeneralConfig() internal {
     vm.makePersistent(LibSharedAddress.CONFIG);
     vm.allowCheatcodes(LibSharedAddress.CONFIG);

test/bridge/integration/ronin-gateway/depositVote.RoninGatewayV3.t.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import { Transfer } from "@ronin/contracts/libraries/Transfer.sol";
+import { Token } from "@ronin/contracts/libraries/Token.sol";
+import { ContractType } from "@ronin/contracts/utils/ContractType.sol";
+import { IsolatedGovernance } from "@ronin/contracts/libraries/IsolatedGovernance.sol";
+import { VoteStatusConsumer } from "@ronin/contracts/interfaces/consumers/VoteStatusConsumer.sol";
+import { MockRoninGatewayV3Extended } from "@ronin/contracts/mocks/ronin/MockRoninGatewayV3Extended.sol";
+import "../BaseIntegration.t.sol";
+
+contract DepositVote_RoninGatewayV3_Test is BaseIntegration_Test {
+  using Transfer for Transfer.Receipt;
+
+  Transfer.Receipt[] _depositReceipts;
+
+  function setUp() public virtual override {
+    super.setUp();
+    _config.switchTo(Network.RoninLocal.key());
+
+    bytes memory calldata_ =
+      abi.encodeCall(IHasContracts.setContract, (ContractType.BRIDGE_TRACKING, address(_bridgeTracking)));
+    _roninProposalUtils.functionDelegateCallGlobal(
+      GlobalProposal.TargetOption.GatewayContract, _roninNonce++, calldata_
+    );
+
+    vm.etch(address(_roninGatewayV3), address(new MockRoninGatewayV3Extended()).code);
+  }
+
+  function test_depositVote() public {
+    Transfer.Receipt memory receipt = Transfer.Receipt({
+      id: 0,
+      kind: Transfer.Kind.Deposit,
+      ronin: Token.Owner({ addr: makeAddr("recipient"), tokenAddr: address(_roninWeth), chainId: _param.test.roninChainId }),
+      mainchain: Token.Owner({
+        addr: makeAddr("requester"),
+        tokenAddr: address(_mainchainWeth),
+        chainId: _param.test.mainchainChainId
+      }),
+      info: Token.Info({ erc: Token.Standard.ERC20, id: 0, quantity: 100 })
+    });
+
+    _depositReceipts.push(receipt);
+    receipt.id = 1;
+    _depositReceipts.push(receipt);
+
+    for (uint256 i; i < _param.roninBridgeManager.num - 1; i++) {
+      vm.prank(_param.roninBridgeManager.bridgeOperators[i]);
+      _roninGatewayV3.tryBulkDepositFor(_depositReceipts);
+    }
+
+    for (uint256 i = 0; i < _depositReceipts.length; i++) {
+      (VoteStatusConsumer.VoteStatus status,,,) =
+        _roninGatewayV3.depositVote(_depositReceipts[i].mainchain.chainId, _depositReceipts[i].id);
+
+      assertEq(uint256(uint8(status)), uint256(uint8(VoteStatusConsumer.VoteStatus.Pending)));
+
+      uint256 totalWeight = MockRoninGatewayV3Extended(payable(address(_roninGatewayV3))).getDepositVoteWeight(
+        _depositReceipts[i].mainchain.chainId, i, Transfer.hash(_depositReceipts[i])
+      );
+      assertEq(totalWeight, (_param.roninBridgeManager.num - 1) * 100);
+    }
+  }
+}

test/helpers/ProposalUtils.t.sol

@@ -16,11 +16,16 @@ contract ProposalUtils is Utils, Test {
   using Proposal for Proposal.ProposalDetail;
 
   uint256 _roninChainId;
+  uint256[] _signerPKs;
   bytes32 _domain;
 
-  constructor(uint256 roninChainId) {
+  constructor(uint256 roninChainId, uint256[] memory signerPKs) {
     _roninChainId = roninChainId;
     _domain = getBridgeManagerDomain(roninChainId);
+
+    for (uint256 i; i < signerPKs.length; i++) {
+      _signerPKs.push(signerPKs[i]);
+    }
   }
 
   function createProposal(
@@ -80,6 +85,14 @@ contract ProposalUtils is Utils, Test {
     return generateSignatures(proposal, signerPKs, Ballot.VoteType.For);
   }
 
+  function generateSignatures(Proposal.ProposalDetail memory proposal)
+    public
+    view
+    returns (SignatureConsumer.Signature[] memory sigs)
+  {
+    return generateSignatures(proposal, _signerPKs, Ballot.VoteType.For);
+  }
+
   function generateSignaturesGlobal(
     GlobalProposal.GlobalProposalDetail memory proposal,
     uint256[] memory signerPKs,
@@ -97,10 +110,13 @@ contract ProposalUtils is Utils, Test {
     return generateSignaturesGlobal(proposal, signerPKs, Ballot.VoteType.For);
   }
 
-  function defaultExpiryTimestamp() public view returns (uint256) { }
-
-  function functionDelegateCallGlobal() public view { }
-  function upgradeGlobal() public view { }
+  function generateSignaturesGlobal(GlobalProposal.GlobalProposalDetail memory proposal)
+    public
+    view
+    returns (SignatureConsumer.Signature[] memory sigs)
+  {
+    return generateSignaturesGlobal(proposal, _signerPKs, Ballot.VoteType.For);
+  }
 
   function getBridgeManagerDomain(uint256 roninChainId) public pure returns (bytes32) {
     return keccak256(