SYN-94: deploy new implementation

foundry.toml

@@ -52,33 +52,4 @@ op_sepolia = "${OP_SEPOLIA_API}"
 scroll_sepolia = "${SCROLL_SEPOLIA_API}"
 
 [etherscan]
-# Chains that are not currently using etherscan are commented out
-arbitrum = { key = "${ARBITRUM_ETHERSCAN_KEY}", url = "${ARBITRUM_ETHERSCAN_URL}", chain = 42161 }
-# aurora = { key = "", url = "${AURORA_BLOCKSCOUT_URL}" }
-avalanche = { key = "${AVALANCHE_ETHERSCAN_KEY}", url = "${AVALANCHE_ETHERSCAN_URL}", chain = 43114 }
-base = { key = "${BASE_ETHERSCAN_KEY}", url = "${BASE_ETHERSCAN_URL}", chain = 8453 }
-blast = { key = "${BLAST_ETHERSCAN_KEY}", url = "${BLAST_ETHERSCAN_URL}", chain = 81457 }
-# boba = { key = "${BOBA_ETHERSCAN_KEY}", url = "${BOBA_ETHERSCAN_URL}" }
-bsc = { key = "${BSC_ETHERSCAN_KEY}", url = "${BSC_ETHERSCAN_URL}", chain = 56 }
-# canto = { key = "", url = "${CANTO_BLOCKSCOUT_URL}" }
-cronos = { key = "${CRONOS_ETHERSCAN_KEY}", url = "${CRONOS_ETHERSCAN_URL}", chain = 25 }
-# DFK is using Sourcify for verification
-# dogechain = { key = "", url = "${DOGECHAIN_BLOCKSCOUT_URL}" }
-# fantom = { key = "${FANTOM_ETHERSCAN_KEY}", url = "${FANTOM_ETHERSCAN_URL}" }
-# Harmony doesn't have an endpoint for verification, and Sourcify does not support Harmony
-# Klaytn doesn't have an endpoint for verification, and doesn't support Sourcify yet
-linea = { key = "${LINEA_ETHERSCAN_KEY}", url = "${LINEA_ETHERSCAN_URL}", chain = 59144 }
-mainnet = { key = "${MAINNET_ETHERSCAN_KEY}", url = "${MAINNET_ETHERSCAN_URL}", chain = 1 }
-# metis = { key = "", url = "${METIS_BLOCKSCOUT_URL}" }
-moonbeam = { key = "${MOONBEAM_ETHERSCAN_KEY}", url = "${MOONBEAM_ETHERSCAN_URL}", chain = 1284 }
-moonriver = { key = "${MOONRIVER_ETHERSCAN_KEY}", url = "${MOONRIVER_ETHERSCAN_URL}", chain = 1285 }
-optimism = { key = "${OPTIMISM_ETHERSCAN_KEY}", url = "${OPTIMISM_ETHERSCAN_URL}", chain = 10 }
-polygon = { key = "${POLYGON_ETHERSCAN_KEY}", url = "${POLYGON_ETHERSCAN_URL}", chain = 137 }
-scroll = { key = "${SCROLL_ETHERSCAN_KEY}", url = "${SCROLL_ETHERSCAN_URL}", chain = 534532 }
-zkevm = { key = "${ZKEVM_ETHERSCAN_KEY}", url = "${ZKEVM_ETHERSCAN_URL}", chain = 1101 }
-# Testnets
-arb_sepolia = { key = "${ARB_SEPOLIA_ETHERSCAN_KEY}", url = "${ARB_SEPOLIA_ETHERSCAN_URL}" }
-base_sepolia = { key = "${BASE_SEPOLIA_ETHERSCAN_KEY}", url = "${BASE_SEPOLIA_ETHERSCAN_URL}" }
-eth_sepolia = { key = "${ETH_SEPOLIA_ETHERSCAN_KEY}", url = "${ETH_SEPOLIA_ETHERSCAN_URL}" }
-op_sepolia = { key = "${OP_SEPOLIA_ETHERSCAN_KEY}", url = "${OP_SEPOLIA_ETHERSCAN_URL}" }
-scroll_sepolia = { key = "${SCROLL_SEPOLIA_ETHERSCAN_KEY}", url = "${SCROLL_SEPOLIA_ETHERSCAN_URL}" }
+# No entries required with Etherscan V2

script/bridge/DeploySynapseBridge.s.sol

@@ -2,33 +2,36 @@
 pragma solidity 0.6.12;
 pragma experimental ABIEncoderV2;
 
-import {SynapseBridge} from "../../contracts/bridge/SynapseBridge.sol";
-
 import {BasicSynapseScript, StringUtils} from "../templates/BasicSynapse.s.sol";
 
 contract DeploySynapseBridge is BasicSynapseScript {
     using StringUtils for string;
 
-    // TODO: mine a create2 salt for this
-    bytes32 internal salt = 0;
+    bytes32 internal salt = 0x60b37663118720d6c967cd1be94aa5218f2440a06e95254b16d80a5ed3224c4c;
+    address internal predicted = 0x5B0000258c622551A1c7C45b9f860Ef90200005B;
 
     function run() external {
         // Setup the BasicSynapseScript
         setUp();
+        if (activeChain.equals("zkevm")) {
+            printLog("🟡 Skipping: zkevm doesn't have an active deployment");
+            return;
+        }
         address bridge = tryGetDeploymentAddress("SynapseBridge");
         if (bridge == address(0)) {
             printLog(StringUtils.concat("🟡 Skipping: SynapseBridge is not deployed on ", activeChain));
             return;
         }
         vm.startBroadcast();
-        address predicted = predictAddress(type(SynapseBridge).creationCode, salt);
         printLog(StringUtils.concat("Predicted address: ", vm.toString(predicted)));
+        setDeploymentSalt(salt);
         address deployed = deployAndSaveAs({
             contractName: "SynapseBridge",
             contractAlias: "SynapseBridge.Implementation",
             constructorArgs: "",
             deployCode: deployCreate2
         });
+        assertContractCodeExists("SynapseBridge.Implementation", deployed);
         if (predicted != deployed) {
             printLog(TAB.concat("❌ Predicted address mismatch"));
             assert(false);

script/networks.json

@@ -2,7 +2,7 @@
   "forgeOptions": {
     "aurora": "--legacy --slow",
     "boba": "--legacy --skip-simulation --slow",
-    "canto": "--legacy --slow",
+    "canto": "--legacy --skip-simulation --slow",
     "cronos": "--slow",
     "dfk": "--slow",
     "dogechain": "--legacy --slow",

script/utils/DeployScript.sol

@@ -98,14 +98,13 @@ abstract contract DeployScript is SynapseScript {
         sortJSON(freshFN);
         // Then, initiate the jq command to add "abi" as the next key
         // This makes sure that "address" value is printed first later
+        // Example: jq .abi=$data[0].abi --slurpfile data path/to/input.json path/to/output.json
         string[] memory inputs = new string[](6);
         inputs[0] = "jq";
-        // Read the full artifact file into $artifact variable
-        inputs[1] = "--argfile";
-        inputs[2] = "artifact";
-        inputs[3] = _artifactPath(contractName);
-        // Set value for ".abi" key to artifact's ABI
-        inputs[4] = ".abi = $artifact.abi";
+        inputs[1] = ".abi = $artifact.abi";
+        inputs[2] = "--slurpfile";
+        inputs[3] = "data";
+        inputs[4] = _artifactPath(contractName);
         inputs[5] = freshFN;
         bytes memory full = vm.ffi(inputs);
         // Finally, print the updated deployment JSON

test/bridge/legacy/SynapseBridge.Upgrade.t.sol

@@ -4,6 +4,7 @@ pragma experimental ABIEncoderV2;
 
 import {SynapseBridge} from "../../../contracts/bridge/SynapseBridge.sol";
 
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/ProxyAdmin.sol";
 import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol";
 import {Test} from "forge-std/Test.sol";
 
@@ -14,7 +15,10 @@ contract SynapseBridgeUpgradeArbitrumTest is Test {
     uint256 internal blockNumber = 344210000;
     address payable internal bridge = 0x6F4e8eBa4D337f874Ab57478AcC2Cb5BACdc19c9;
     address internal proxyAdmin = 0x432036208d2717394d2614d6697c46DF3Ed69540;
+    address internal implementation = 0x97a7af2A0323e2a40B866Df3A5F1F389427C9b68;
 
+    uint256 internal expectedStartBlockNumber = 13219011;
+    address internal expectedWethAddress = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
     uint256 internal expectedBridgeVersion = 6;
     uint256 internal expectedChainGasAmount = 0.00001 ether;
     string internal rpcUrl = "https://arbitrum-one.public.blastapi.io";
@@ -37,17 +41,26 @@ contract SynapseBridgeUpgradeArbitrumTest is Test {
         roleAdmin = SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).DEFAULT_ADMIN_ROLE(), 0);
         governance = SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).GOVERNANCE_ROLE(), 0);
         nodeGroup = SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).NODEGROUP_ROLE(), 0);
+
+        vm.label(bridge, "SynapseBridge");
+        vm.label(proxyAdmin, "ProxyAdmin");
+        vm.label(implementation, "OldImplementation");
+        vm.label(newBridgeImplementation, "NewImplementation");
     }
 
     function upgrade() public {
-        vm.prank(proxyAdmin);
-        TransparentUpgradeableProxy(bridge).upgradeTo(newBridgeImplementation);
+        address owner = ProxyAdmin(proxyAdmin).owner();
+        vm.prank(owner);
+        ProxyAdmin(proxyAdmin).upgrade(TransparentUpgradeableProxy(bridge), newBridgeImplementation);
     }
 
     function test_getters() public {
         assertEq(SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).DEFAULT_ADMIN_ROLE(), 0), roleAdmin);
         assertEq(SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).GOVERNANCE_ROLE(), 0), governance);
         assertEq(SynapseBridge(bridge).getRoleMember(SynapseBridge(bridge).NODEGROUP_ROLE(), 0), nodeGroup);
+        assertNotEq(roleAdmin, address(0));
+        assertNotEq(governance, address(0));
+        assertNotEq(nodeGroup, address(0));
 
         assertEq(SynapseBridge(bridge).bridgeVersion(), expectedBridgeVersion);
         assertEq(SynapseBridge(bridge).chainGasAmount(), expectedChainGasAmount);
@@ -57,13 +70,23 @@ contract SynapseBridgeUpgradeArbitrumTest is Test {
 
         assertTrue(SynapseBridge(bridge).kappaExists(kappa));
         assertFalse(SynapseBridge(bridge).kappaExists(kappa ^ bytes32(uint256(1))));
+
+        assertEq(SynapseBridge(bridge).startBlockNumber(), expectedStartBlockNumber);
+        assertEq(SynapseBridge(bridge).WETH_ADDRESS(), expectedWethAddress);
+        assertFalse(SynapseBridge(bridge).paused());
     }
 
     function test_upgrade() public {
+        assertEq(getImplementation(), implementation);
         upgrade();
+        assertEq(getImplementation(), newBridgeImplementation);
         expectedBridgeVersion = 8;
         expectedChainGasAmount = 0;
         test_getters();
         assertFalse(SynapseBridge(bridge).isLegacySendDisabled());
     }
+
+    function getImplementation() internal view returns (address) {
+        return ProxyAdmin(proxyAdmin).getProxyImplementation(TransparentUpgradeableProxy(bridge));
+    }
 }