Script: map anima token and refactor factory scripts

script/20240308-maptoken-aperios/20240308-maptoken-aperios-mainchain.s.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import "../factories/factory-maptoken-mainchain.s.sol";
+import "../factories/mainchain/factory-maptoken-mainchain-ethereum.s.sol";
 import "./base-maptoken.s.sol";
 
-contract Migration__20240308_MapTokenAperiosMainchain is Base__MapToken, Factory__MapTokensMainchain {
+contract Migration__20240308_MapTokenAperiosMainchain is Base__MapToken, Factory__MapTokensMainchain_Ethereum {
   function _initCaller() internal override(Base__MapToken, Factory__MapTokensMainchain) returns (address) {
     return Base__MapToken._initCaller();
   }

script/20240308-maptoken-aperios/20240308-maptoken-aperios-roninchain.s.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.19;
 
 import { console2 } from "forge-std/console2.sol";
-import "../factories/factory-maptoken-roninchain.s.sol";
+import "../factories/roninchain/factory-maptoken-ronin-mainnet.s.sol";
 import "./base-maptoken.s.sol";
 
-contract Migration__20240308_MapTokenAperiosRoninchain is Base__MapToken, Factory__MapTokensRoninchain {
+contract Migration__20240308_MapTokenAperiosRoninchain is Base__MapToken, Factory__MapTokensRonin_Mainnet {
   function _initCaller() internal override(Base__MapToken, Factory__MapTokensRoninchain) returns (address) {
     return Base__MapToken._initCaller();
   }

script/20240308-maptoken-aperios/caller-configs.s.sol

@@ -2,5 +2,5 @@
 pragma solidity ^0.8.19;
 
 contract Migration__Caller_Config {
-  address internal SM_GOVERNOR = 0xe880802580a1fbdeF67ACe39D1B21c5b2C74f059; // TODO: replace by address of the SV governor
+  address internal SM_GOVERNOR = 0xd24D87DDc1917165435b306aAC68D99e0F49A3Fa; // TODO: replace by address of the SV governor
 }

script/20240626-maptoken-anima/20240626-maptoken-anima-mainchain.s.sol

@@ -4,14 +4,13 @@ pragma solidity ^0.8.19;
 import "../factories/mainchain/factory-maptoken-mainchain-sepolia.s.sol";
 import "./base-maptoken.s.sol";
 import "@ronin/contracts/libraries/Ballot.sol";
-import { console2 } from "forge-std/console2.sol";
 import { StdStyle } from "forge-std/StdStyle.sol";
 import { MainchainBridgeAdminUtils } from "test/helpers/MainchainBridgeAdminUtils.t.sol";
 import { SignatureConsumer } from "@ronin/contracts/interfaces/consumers/SignatureConsumer.sol";
 import { Proposal } from "@ronin/contracts/libraries/Proposal.sol";
 import { MainchainBridgeManager } from "@ronin/contracts/mainchain/MainchainBridgeManager.sol";
 
-contract Migration__20242606_MapTokenAnimaMainchain is Base__MapToken, Factory__MapTokensMainchainSepolia {
+contract Migration__20242606_MapTokenAnimaMainchain is Base__MapToken, Factory__MapTokensMainchain_Sepolia {
   MainchainBridgeAdminUtils _mainchainProposalUtils;
 
   function _initCaller() internal override(Base__MapToken, Factory__MapTokensMainchain) returns (address) {
@@ -22,15 +21,15 @@ contract Migration__20242606_MapTokenAnimaMainchain is Base__MapToken, Factory__
     return Base__MapToken._initTokenList();
   }
 
-  function _initGovernors() internal override(Base__MapToken, Factory__MapTokensMainchainSepolia) returns (address[] memory) {
+  function _initGovernors() internal override(Base__MapToken, Factory__MapTokensMainchain_Sepolia) returns (address[] memory) {
     return Base__MapToken._initGovernors();
   }
 
-  function _initGovernorPKs() internal override(Base__MapToken, Factory__MapTokensMainchainSepolia) returns (uint256[] memory) {
+  function _initGovernorPKs() internal override(Base__MapToken, Factory__MapTokensMainchain_Sepolia) returns (uint256[] memory) {
     return Base__MapToken._initGovernorPKs();
   }
 
   function run() public override {
-    super.run();
+    Factory__MapTokensMainchain_Sepolia.run();
   }
 }

script/20240626-maptoken-anima/20240626-maptoken-anima-ronin-testnet.s.sol

@@ -20,6 +20,6 @@ contract Migration__20242606_MapTokenAnimaRoninTestnet is Base__MapToken, Factor
   }
 
   function run() public override {
-    super.run();
+    Factory__MapTokensRonin_Testnet.run();
   }
 }

script/20240626-maptoken-anima/governors-configs.s.sol

@@ -7,14 +7,14 @@ contract Migration__Governors_Config {
 
   constructor() {
     // TODO: replace by address of the testnet governors
-    governors[3] = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
-    governors[2] = 0x90F79bf6EB2c4f870365E785982E1f101E93b906;
-    governors[0] = 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC;
-    governors[1] = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;
+    governors[3] = 0xd24D87DDc1917165435b306aAC68D99e0F49A3Fa;
+    governors[2] = 0xb033ba62EC622dC54D0ABFE0254e79692147CA26;
+    governors[0] = 0x087D08e3ba42e64E3948962dd1371F906D1278b9;
+    governors[1] = 0x52ec2e6BBcE45AfFF8955Da6410bb13812F4289F;
     // TODO: replace by private key of the testnet governors
-    governorPks[3] = 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80;
-    governorPks[2] = 0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6;
-    governorPks[0] = 0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a;
-    governorPks[1] = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
+    governorPks[3] = 0x0;
+    governorPks[2] = 0x0;
+    governorPks[0] = 0x0;
+    governorPks[1] = 0x0;
   }
 }

script/20240626-maptoken-anima/maptoken-anima-configs.s.sol

@@ -2,13 +2,15 @@
 pragma solidity ^0.8.19;
 
 import { MapTokenInfo } from "../libraries/MapTokenInfo.sol";
+import { LibTokenInfo, TokenStandard } from "@ronin/contracts/libraries/LibTokenInfo.sol";
 
 contract Migration__MapToken_Anima_Config {
   MapTokenInfo _animaInfo;
 
   constructor() {
     _animaInfo.roninToken = address(0x9F6a5cDc477e9f667d60424bFdb4E82089d9d72c);
     _animaInfo.mainchainToken = address(0xEd52E203D2D44FAaEA0D9fB6A40220A63c743c80);
+    _animaInfo.standard = TokenStandard.ERC20;
     _animaInfo.minThreshold = 100 ether;
     _animaInfo.highTierThreshold = 20_000_000 ether;
     _animaInfo.lockedThreshold = 100_000_000 ether;

script/factories/mainchain/factory-maptoken-mainchain-ethereum.s.sol

@@ -8,22 +8,24 @@ import { Proposal } from "@ronin/contracts/libraries/Proposal.sol";
 import { Contract } from "../../utils/Contract.sol";
 import { MainchainBridgeManager } from "@ronin/contracts/mainchain/MainchainBridgeManager.sol";
 import "./factory-maptoken-mainchain.s.sol";
+import "../simulation/factory-maptoken-simulation-mainchain.s.sol";
 
-abstract contract Factory__MapTokensMainchainEthereum is Factory__MapTokensMainchain {
+abstract contract Factory__MapTokensMainchain_Ethereum is Factory__MapTokensMainchain {
   using LibCompanionNetwork for *;
 
   function setUp() public override {
     super.setUp();
-
     _roninBridgeManager = RoninBridgeManager(config.getAddressFromCurrentNetwork(Contract.RoninBridgeManager.key()));
     _mainchainGatewayV3 = config.getAddress(network().companionNetwork(), Contract.MainchainGatewayV3.key());
     _mainchainBridgeManager = config.getAddress(network().companionNetwork(), Contract.MainchainBridgeManager.key());
-
-    _governor = _initCaller();
   }
 
   function run() public virtual override {
-    Proposal.ProposalDetail memory proposal = _createAndVerifyProposal(block.chainid, 0);
+    uint256 chainId = network().companionChainId();
+    uint256 nonce = _roninBridgeManager.round(chainId) + 1;
+    Proposal.ProposalDetail memory proposal = _createAndVerifyProposalOnMainchain(chainId, nonce);
+    // Simulate relay proposal
+    new Factory__MapTokensSimulation_Mainchain().simulate(proposal);
     _propose(proposal);
   }
 }

script/factories/mainchain/factory-maptoken-mainchain-sepolia.s.sol

@@ -1,18 +1,17 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import { LibCompanionNetwork } from "script/shared/libraries/LibCompanionNetwork.sol";
 import { Network, TNetwork } from "../../utils/Network.sol";
-import { console2 } from "forge-std/console2.sol";
+import { console2 as console } from "forge-std/console2.sol";
+import { StdStyle } from "forge-std/StdStyle.sol";
 import { LibProposal } from "script/shared/libraries/LibProposal.sol";
 import { Proposal } from "@ronin/contracts/libraries/Proposal.sol";
 import { Contract } from "../../utils/Contract.sol";
 import { MainchainBridgeManager } from "@ronin/contracts/mainchain/MainchainBridgeManager.sol";
 import "./factory-maptoken-mainchain.s.sol";
+import "../simulation/factory-maptoken-simulation-mainchain.s.sol";
 
-abstract contract Factory__MapTokensMainchainSepolia is Factory__MapTokensMainchain {
-  using LibCompanionNetwork for *;
-
+abstract contract Factory__MapTokensMainchain_Sepolia is Factory__MapTokensMainchain {
   function setUp() public override {
     super.setUp();
     _mainchainGatewayV3 = config.getAddressFromCurrentNetwork(Contract.MainchainGatewayV3.key());
@@ -23,18 +22,23 @@ abstract contract Factory__MapTokensMainchainSepolia is Factory__MapTokensMainch
   function _initGovernors() internal virtual returns (address[] memory);
 
   function run() public virtual override {
-    address[] memory governorsM = _initGovernors();
-    uint256[] memory governorsPksM = _initGovernorPKs();
+    address[] memory mGovernors;
+    uint256[] memory mGovernorsPk;
+
+    mGovernors = _initGovernors();
+    mGovernorsPk = _initGovernorPKs();
 
-    for (uint256 i; i < governorsM.length; ++i) {
-      _governors.push(governorsM[i]);
-      _governorPKs.push(governorsPksM[i]);
+    for (uint256 i; i < mGovernors.length; ++i) {
+      _governors.push(mGovernors[i]);
+      _governorPKs.push(mGovernorsPk[i]);
     }
-    _cheatStorage(_governors);
 
     uint256 chainId = block.chainid;
     uint256 nonce = MainchainBridgeManager(_mainchainBridgeManager).round(chainId) + 1;
-    Proposal.ProposalDetail memory proposal = _createAndVerifyProposal(chainId, nonce);
+
+    Proposal.ProposalDetail memory proposal = _createAndVerifyProposalOnMainchain(chainId, nonce);
+    // Simulate relay proposal
+    new Factory__MapTokensSimulation_Mainchain().simulate(proposal);
     _relayProposal(proposal);
   }
 }

script/factories/mainchain/factory-maptoken-mainchain.s.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.19;
 
 import "@ronin/contracts/libraries/Ballot.sol";
-import { console2 } from "forge-std/console2.sol";
+import { console2 as console } from "forge-std/console2.sol";
 import { StdStyle } from "forge-std/StdStyle.sol";
 import { RoninBridgeManager } from "@ronin/contracts/ronin/gateway/RoninBridgeManager.sol";
 import { IMainchainGatewayV3 } from "@ronin/contracts/interfaces/IMainchainGatewayV3.sol";
@@ -19,23 +19,31 @@ import { LibCompanionNetwork } from "script/shared/libraries/LibCompanionNetwork
 import { MainchainBridgeAdminUtils } from "test/helpers/MainchainBridgeAdminUtils.t.sol";
 import { MainchainBridgeManager } from "@ronin/contracts/mainchain/MainchainBridgeManager.sol";
 import { LibProposal } from "script/shared/libraries/LibProposal.sol";
+import { Network, TNetwork } from "../../utils/Network.sol";
+import { IBridgeManager } from "@ronin/contracts/interfaces/bridge/IBridgeManager.sol";
+import { DefaultNetwork } from "@fdk/utils/DefaultNetwork.sol";
 
 abstract contract Factory__MapTokensMainchain is Migration {
   using LibCompanionNetwork for *;
 
   RoninBridgeManager internal _roninBridgeManager;
   address internal _mainchainGatewayV3;
   address internal _mainchainBridgeManager;
-  address internal _governor;
+  address internal _specifiedCaller;
   address[] internal _governors;
   uint256[] internal _governorPKs;
 
+  function setUp() public virtual override {
+    super.setUp();
+    _specifiedCaller = _initCaller();
+  }
+
   function run() public virtual;
   function _initCaller() internal virtual returns (address);
   function _initTokenList() internal virtual returns (uint256 totalToken, MapTokenInfo[] memory infos);
 
   function _propose(Proposal.ProposalDetail memory proposal) internal virtual {
-    vm.broadcast(_governor);
+    vm.broadcast(_specifiedCaller);
     _roninBridgeManager.propose(
       proposal.chainId, proposal.expiryTimestamp, proposal.executor, proposal.targets, proposal.values, proposal.calldatas, proposal.gasAmounts
     );
@@ -59,15 +67,29 @@ abstract contract Factory__MapTokensMainchain is Migration {
       gasAmounts += proposal.gasAmounts[i];
     }
 
-    vm.broadcast(_governors[0]);
+    vm.broadcast(_specifiedCaller);
     MainchainBridgeManager(_mainchainBridgeManager).relayProposal{ gas: gasAmounts }(proposal, supports_, signatures);
   }
 
-  function _createAndVerifyProposal(uint256 chainId, uint256 nonce) internal returns (Proposal.ProposalDetail memory proposal) {
-    (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards, uint256[][4] memory thresholds) =
-      _prepareMapTokensAndThresholds();
-    bytes memory innerData = abi.encodeCall(IMainchainGatewayV3.mapTokensAndThresholds, (mainchainTokens, roninTokens, standards, thresholds));
-    bytes memory proxyData = abi.encodeWithSignature("functionDelegateCall(bytes)", innerData);
+  function _createAndVerifyProposalOnMainchain(uint256 chainId, uint256 nonce) internal returns (Proposal.ProposalDetail memory proposal) {
+    (uint256 N, MapTokenInfo[] memory tokenInfos) = _initTokenList();
+    require(tokenInfos.length > 0, "Number of tokens required to map cannot be 0.");
+
+    bytes memory innerData;
+    bytes memory proxyData;
+
+    if (tokenInfos[0].standard == TokenStandard.ERC20) {
+      (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards, uint256[][4] memory thresholds) =
+        _prepareMapTokensAndThresholds(N, tokenInfos);
+
+      innerData = abi.encodeCall(IMainchainGatewayV3.mapTokensAndThresholds, (mainchainTokens, roninTokens, standards, thresholds));
+      proxyData = abi.encodeWithSignature("functionDelegateCall(bytes)", innerData);
+    } else {
+      (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards) = _prepareMapTokens(N, tokenInfos);
+
+      innerData = abi.encodeCall(IMainchainGatewayV3.mapTokens, (mainchainTokens, roninTokens, standards));
+      proxyData = abi.encodeWithSignature("functionDelegateCall(bytes)", innerData);
+    }
 
     uint256 expiredTime = block.timestamp + 14 days;
     address[] memory targets = new address[](1);
@@ -80,13 +102,15 @@ abstract contract Factory__MapTokensMainchain is Migration {
     calldatas[0] = proxyData;
     gasAmounts[0] = 1_000_000;
 
-    // Verify gas when call from mainchain.
-    LibProposal.verifyProposalGasAmount(address(_mainchainBridgeManager), targets, values, calldatas, gasAmounts);
-
-    // // Verify gas when call from ronin.
-    // (uint256 companionChainId, TNetwork companionNetwork) = network().companionNetworkData();
-    // address companionManager = config.getAddress(companionNetwork, Contract.MainchainBridgeManager.key());
-    // LibProposal.verifyMainchainProposalGasAmount(companionNetwork, companionManager, targets, values, calldatas, gasAmounts);
+    if (network() == DefaultNetwork.RoninMainnet.key() || network() == DefaultNetwork.RoninMainnet.key()) {
+      // Verify gas amount for ronin targets.
+      (uint256 companionChainId, TNetwork companionNetwork) = network().companionNetworkData();
+      address companionManager = config.getAddress(companionNetwork, Contract.MainchainBridgeManager.key());
+      LibProposal.verifyMainchainProposalGasAmount(companionNetwork, companionManager, targets, values, calldatas, gasAmounts);
+    } else {
+      // Verify gas amount for mainchain targets.
+      LibProposal.verifyProposalGasAmount(address(_mainchainBridgeManager), targets, values, calldatas, gasAmounts);
+    }
 
     proposal = Proposal.ProposalDetail({
       nonce: nonce,
@@ -100,17 +124,16 @@ abstract contract Factory__MapTokensMainchain is Migration {
     });
   }
 
-  function _prepareMapTokensAndThresholds()
-    internal
-    returns (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards, uint256[][4] memory thresholds)
-  {
+  function _prepareMapTokensAndThresholds(
+    uint256 N,
+    MapTokenInfo[] memory tokenInfos
+  ) internal returns (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards, uint256[][4] memory thresholds) {
     // function mapTokensAndThresholds(
     //   address[] calldata _mainchainTokens,
     //   address[] calldata _roninTokens,
     //   TokenStandard.ERC20[] calldata _standards,
     //   uint256[][4] calldata _thresholds
     // )
-    (uint256 N, MapTokenInfo[] memory tokenInfos) = _initTokenList();
 
     mainchainTokens = new address[](N);
     roninTokens = new address[](N);
@@ -124,37 +147,33 @@ abstract contract Factory__MapTokensMainchain is Migration {
     for (uint256 i; i < N; ++i) {
       mainchainTokens[i] = tokenInfos[i].mainchainToken;
       roninTokens[i] = tokenInfos[i].roninToken;
-      standards[i] = TokenStandard.ERC20;
+      standards[i] = tokenInfos[i].standard;
+
       thresholds[0][i] = tokenInfos[i].highTierThreshold;
       thresholds[1][i] = tokenInfos[i].lockedThreshold;
       thresholds[2][i] = tokenInfos[i].unlockFeePercentages;
       thresholds[3][i] = tokenInfos[i].dailyWithdrawalLimit;
     }
   }
 
-  function _cheatStorage(address[] memory governors) internal {
-    bytes32 governorsSlot = keccak256(abi.encode(0xc648703095712c0419b6431ae642c061f0a105ac2d7c3d9604061ef4ebc38300));
-    uint256 length = governors.length;
-    //cheat governors addresses
-    for (uint256 i; i < length; ++i) {
-      bytes32 governorSlotId = bytes32(uint256(governorsSlot) + uint256(i));
-      vm.store(_mainchainBridgeManager, governorSlotId, bytes32(uint256(uint160(governors[i]))));
-    }
-    //after cheat
-    for (uint256 i; i < length; ++i) {
-      bytes32 governorSlotId = bytes32(uint256(governorsSlot) + uint256(i));
-      bytes32 afterCheatData = vm.load(_mainchainBridgeManager, bytes32(uint256(governorsSlot) + uint256(i)));
+  function _prepareMapTokens(
+    uint256 N,
+    MapTokenInfo[] memory tokenInfos
+  ) internal returns (address[] memory mainchainTokens, address[] memory roninTokens, TokenStandard[] memory standards) {
+    //  function mapTokens(
+    //    address[] calldata _mainchainTokens,
+    //    address[] calldata _roninTokens,
+    //    TokenStandard[] calldata _standards
+    // );
 
-      assertEq(afterCheatData, bytes32(uint256(uint160(governors[i]))));
-    }
+    mainchainTokens = new address[](N);
+    roninTokens = new address[](N);
+    standards = new TokenStandard[](N);
 
-    //cheat governors weights
-    bytes32 governorsWeightSlot = bytes32(uint256(0xc648703095712c0419b6431ae642c061f0a105ac2d7c3d9604061ef4ebc38300) + uint256(2));
-    for (uint256 i; i < length; ++i) {
-      address key = governors[i];
-      bytes32 valueSlot = keccak256(abi.encode(key, governorsWeightSlot));
-      vm.store(_mainchainBridgeManager, valueSlot, bytes32(uint256(uint96(100))));
+    for (uint256 i; i < N; ++i) {
+      mainchainTokens[i] = tokenInfos[i].mainchainToken;
+      roninTokens[i] = tokenInfos[i].roninToken;
+      standards[i] = tokenInfos[i].standard;
     }
-    bytes32 governorsWeightData = vm.load(_mainchainBridgeManager, keccak256(abi.encode(0x087D08e3ba42e64E3948962dd1371F906D1278b9, governorsWeightSlot)));
   }
 }