Tech debt

contracts/schain/tokens/ERC721OnChain.sol

@@ -104,7 +104,7 @@ contract ERC721OnChain is
     )
         public
         view
-        override(AccessControlEnumerableUpgradeable, ERC721Upgradeable)
+        override(AccessControlEnumerableUpgradeable, ERC721Upgradeable, ERC721URIStorageUpgradeable)
         returns (bool)
     {
         return super.supportsInterface(interfaceId);

hardhat.config.ts

@@ -1,6 +1,6 @@
 import { HardhatUserConfig } from "hardhat/config";
-import "@nomiclabs/hardhat-etherscan";
-import "@nomiclabs/hardhat-waffle";
+import "@nomicfoundation/hardhat-verify";
+import "@nomicfoundation/hardhat-chai-matchers";
 import "@openzeppelin/hardhat-upgrades";
 import "@typechain/hardhat";
 import "solidity-coverage";

migrations/deploySchain.ts

@@ -19,9 +19,12 @@
  */
 
 /**
- * @file deploySchain.js
+ * @file deploySchain.ts
  * @copyright SKALE Labs 2019-Present
  */
+// TODO: Remove this line after closing issue https://github.com/skalenetwork/IMA/issues/1720 
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
 import { promises as fs } from 'fs';
 import { Interface } from "ethers/lib/utils";
 import { ethers, upgrades } from "hardhat";

migrations/deploySkaleManagerComponents.ts

@@ -24,7 +24,7 @@
  */
 import { promises as fs } from 'fs';
 import { ethers } from "hardhat";
-import { getAbi, getContractFactory } from '@skalenetwork/upgrade-tools';
+import { getAbi } from '@skalenetwork/upgrade-tools';
 import { Manifest } from "@openzeppelin/upgrades-core";
 import { KeyStorageMock } from '../typechain';
 import { Wallet } from 'ethers';
@@ -59,64 +59,64 @@ async function main() {
     const schainName = process.env.CHAIN_NAME_SCHAIN;
 
     console.log("Deploy ContractManager");
-    const contractManagerFactory = await getContractFactory("ContractManager");
+    const contractManagerFactory = await ethers.getContractFactory("ContractManager");
     const contractManager = await contractManagerFactory.deploy();
-    console.log("Contract ContractManager deployed to", contractManager.address);
+    console.log("Contract ContractManager deployed to", await contractManager.getAddress());
 
     console.log("Deploy Schains");
-    const schainsFactory = await getContractFactory("Schains");
+    const schainsFactory = await ethers.getContractFactory("Schains");
     const schains = await schainsFactory.deploy();
-    console.log("Contract Schains deployed to", schains.address);
+    console.log("Contract Schains deployed to", await schains.getAddress());
 
     console.log("Deploy SchainsInternal");
-    const schainsInternalFactory = await getContractFactory("SchainsInternal");
+    const schainsInternalFactory = await ethers.getContractFactory("SchainsInternal");
     const schainsInternal = await schainsInternalFactory.deploy();
-    console.log("Contract SchainsInternal deployed to", schainsInternal.address);
+    console.log("Contract SchainsInternal deployed to", await schainsInternal.getAddress());
 
     console.log("Deploy Wallets");
-    const walletsFactory = await getContractFactory("Wallets");
+    const walletsFactory = await ethers.getContractFactory("Wallets");
     const wallets = await walletsFactory.deploy();
-    console.log("Contract Wallets deployed to", wallets.address);
+    console.log("Contract Wallets deployed to", await wallets.getAddress());
 
     console.log("Deploy SkaleVerifier");
-    const skaleVerifierFactory = await getContractFactory("SkaleVerifierMock");
+    const skaleVerifierFactory = await ethers.getContractFactory("SkaleVerifierMock");
     const skaleVerifier = await skaleVerifierFactory.deploy();
-    console.log("Contract SkaleVerifier deployed to", skaleVerifier.address);
-
+    console.log("Contract SkaleVerifier deployed to", await skaleVerifier.getAddress());
+    
     console.log("Deploy KeyStorage");
-    const keyStorageFactory = await getContractFactory("KeyStorageMock");
+    const keyStorageFactory = await ethers.getContractFactory("KeyStorageMock");
     const keyStorage = await keyStorageFactory.deploy() as KeyStorageMock;
-    console.log("Contract KeyStorage deployed to", keyStorage.address);
+    console.log("Contract KeyStorage deployed to", await keyStorage.getAddress());
 
     console.log("Deploy Nodes");
-    const nodesFactory = await getContractFactory("Nodes");
+    const nodesFactory = await ethers.getContractFactory("Nodes");
     const nodes = await nodesFactory.deploy();
-    console.log("Contract Nodes deployed to", nodes.address);
+    console.log("Contract Nodes deployed to", await nodes.getAddress());
 
     console.log("Will set dependencies");
 
-    await schains.addContractManager( contractManager.address );
-    console.log("Add ContractManager address", contractManager.address, "as ContractManager to Contract Schains", schains.address, "\n");
-    await schainsInternal.addContractManager( contractManager.address );
-    console.log("Add ContractManager address", contractManager.address, "as ContractManager to Contract SchainsInternal", schainsInternal.address, "\n");
-    await wallets.addContractManager( contractManager.address );
-    console.log("Add ContractManager address", contractManager.address, "as ContractManager to Contract Wallets", wallets.address, "\n");
-    await contractManager.setContractsAddress( "Schains", schains.address );
-    console.log("Set Schains", schains.address, "to ContractManager", contractManager.address, "\n");
-    await contractManager.setContractsAddress( "SchainsInternal", schainsInternal.address );
-    console.log("Set SchainsInternal", schainsInternal.address, "to ContractManager", contractManager.address, "\n");
-    await contractManager.setContractsAddress( "Wallets", wallets.address );
-    console.log("Set Wallets", wallets.address, "to ContractManager", contractManager.address, "\n");
-    await contractManager.setContractsAddress( "SkaleVerifier", skaleVerifier.address );
-    console.log("Set SkaleVerifier", skaleVerifier.address, "to ContractManager", contractManager.address, "\n");
-    await contractManager.setContractsAddress( "KeyStorage", keyStorage.address );
-    console.log("Set KeyStorage", keyStorage.address, "to ContractManager", contractManager.address, "\n");
-    await contractManager.setContractsAddress( "Nodes", nodes.address );
-    console.log("Set Nodes", nodes.address, "to ContractManager", contractManager.address, "\n");
+    await schains.addContractManager( await contractManager.getAddress() );
+    console.log("Add ContractManager address", await contractManager.getAddress(), "as ContractManager to Contract Schains", await schains.getAddress(), "\n");
+    await schainsInternal.addContractManager( await contractManager.getAddress() );
+    console.log("Add ContractManager address", await contractManager.getAddress(), "as ContractManager to Contract SchainsInternal", await schainsInternal.getAddress(), "\n");
+    await wallets.addContractManager( await contractManager.getAddress() );
+    console.log("Add ContractManager address", await contractManager.getAddress(), "as ContractManager to Contract Wallets", await wallets.getAddress(), "\n");
+    await contractManager.setContractsAddress( "Schains", await schains.getAddress() );
+    console.log("Set Schains", await schains.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
+    await contractManager.setContractsAddress( "SchainsInternal", await schainsInternal.getAddress() );
+    console.log("Set SchainsInternal", await schainsInternal.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
+    await contractManager.setContractsAddress( "Wallets", await wallets.getAddress() );
+    console.log("Set Wallets", await wallets.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
+    await contractManager.setContractsAddress( "SkaleVerifier", await skaleVerifier.getAddress() );
+    console.log("Set SkaleVerifier", await skaleVerifier.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
+    await contractManager.setContractsAddress( "KeyStorage", await keyStorage.getAddress() );
+    console.log("Set KeyStorage", await keyStorage.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
+    await contractManager.setContractsAddress( "Nodes", await nodes.getAddress() );
+    console.log("Set Nodes", await nodes.getAddress(), "to ContractManager", await contractManager.getAddress(), "\n");
     const nodeAddress1 = new Wallet(process.env.PRIVATE_KEY_FOR_ETHEREUM).connect(ethers.provider);
     const nodeAddress2 = new Wallet(process.env.PRIVATE_KEY_FOR_SCHAIN).connect(ethers.provider);
-    await owner.sendTransaction({to: nodeAddress1.address, value: ethers.utils.parseEther("1")});
-    await owner.sendTransaction({to: nodeAddress2.address, value: ethers.utils.parseEther("1")});
+    await owner.sendTransaction({to: nodeAddress1.address, value: ethers.parseEther("1")});
+    await owner.sendTransaction({to: nodeAddress2.address, value: ethers.parseEther("1")});
 
     const nodeCreationParams1 = {
         port: 1337,
@@ -142,7 +142,7 @@ async function main() {
     console.log("Create Node 1 with address", nodeAddress2.address, "\n");
     await schainsInternal.initializeSchain( schainName, owner.address, 1, 1 );
     console.log("Initialize Schain", schainName, "with address", owner.address, "\n");
-    await schainsInternal.connect(owner).addNodesToSchainsGroups(ethers.utils.id(schainName), [0, 1]);
+    await schainsInternal.connect(owner).addNodesToSchainsGroups(ethers.id(schainName), [0, 1]);
     console.log("Add Nodes 0 and 1 to schain", schainName, "\n");
     const BLSPublicKey = {
         x: {
@@ -155,18 +155,18 @@ async function main() {
         }
     };
     await keyStorage.setBlsCommonPublicKeyForSchain( stringKeccak256(schainName), BLSPublicKey );
-    console.log("Set common public key in KeyStorage contract", keyStorage.address, "\n");
+    console.log("Set common public key in KeyStorage contract", await keyStorage.getAddress(), "\n");
     await wallets.rechargeSchainWallet( stringKeccak256(schainName), { value: "10000000000000000000" } ); // originally it was 1000000000000000000 = 1ETH
-    console.log("Recharge schain wallet in Wallets contract", wallets.address, "\n");
+    console.log("Recharge schain wallet in Wallets contract", await wallets.getAddress(), "\n");
 
     const jsonObject = {
-        contract_manager_address: contractManager.address,
+        contract_manager_address: await contractManager.getAddress(),
         contract_manager_abi: getAbi(contractManager.interface),
-        schains_internal_address: schainsInternal.address,
+        schains_internal_address: await schainsInternal.getAddress(),
         schains_internal_abi: getAbi(schainsInternal.interface),
-        key_storage_address: keyStorage.address,
+        key_storage_address: await keyStorage.getAddress(),
         key_storage_abi: getAbi(keyStorage.interface),
-        wallets_address: wallets.address,
+        wallets_address: await wallets.getAddress(),
         wallets_abi: getAbi(wallets.interface)
     };
 

migrations/generateManifest.ts

@@ -135,7 +135,7 @@ export async function importAddresses(manifest: ManifestData, abi: {[ key in str
 
 export async function manifestSetup(pathToManifest: string) {
     const chainId = (await ethers.provider.getNetwork()).chainId;
-    const manifestName = networkNames[chainId] ?? `unknown-${chainId}`;
+    const manifestName = networkNames[Number(chainId)] ?? `unknown-${chainId}`;
     const correctManifestPath = `.openzeppelin/${manifestName}.json`;
     if (pathToManifest === "" || pathToManifest === correctManifestPath) {
         await fs.access(correctManifestPath);

migrations/upgradeMainnet.ts

@@ -1,30 +1,43 @@
 import chalk from "chalk";
 import { ethers } from "hardhat";
-import { promises as fs } from "fs";
-import { AutoSubmitter, Upgrader } from "@skalenetwork/upgrade-tools";
-import { SkaleABIFile } from "@skalenetwork/upgrade-tools/dist/src/types/SkaleABIFile";
-import { contracts, contractsToDeploy, getContractKeyInAbiFile } from "./deployMainnet";
+import { Interface, Transaction } from "ethers";
+import { Submitter, Upgrader } from "@skalenetwork/upgrade-tools";
+import { skaleContracts, Instance } from "@skalenetwork/skale-contracts-ethers-v6";
 import { MessageProxyForMainnet } from "../typechain";
-import { Interface } from "@ethersproject/abi";
+import { contracts } from "./deployMainnet";
 
 
+async function getImaMainnetInstance() {
+    if (!process.env.TARGET) {
+        console.log(chalk.red("Specify desired mainnet-ima instance"));
+        console.log(chalk.red("Set instance alias or MessageProxyForMainnet address to TARGET environment variable"));
+        process.exit(1);
+    }
+    const network = await skaleContracts.getNetworkByProvider(ethers.provider);
+    const project = network.getProject("mainnet-ima");
+    return await project.getInstance(process.env.TARGET);
+}
+
 class ImaMainnetUpgrader extends Upgrader {
 
     constructor(
         targetVersion: string,
-        abi: SkaleABIFile,
+        instance: Instance,
         contractNamesToUpgrade: string[],
-        submitter = new AutoSubmitter()) {
+        submitter?: Submitter) {
             super(
-                "proxyMainnet",
-                targetVersion,
-                abi,
-                contractNamesToUpgrade,
-                submitter);
+                {
+                    contractNamesToUpgrade,
+                    instance,
+                    name: "proxyMainnet",
+                    version: targetVersion,
+                },
+                submitter
+            );
         }
 
-    async getMessageProxyForMainnet() {
-        return await ethers.getContractAt("MessageProxyForMainnet", this.abi.message_proxy_mainnet_address as string) as MessageProxyForMainnet;
+    getMessageProxyForMainnet = async () => {
+        return await this.instance.getContract("MessageProxyForMainnet") as MessageProxyForMainnet;
     }
 
     getDeployedVersion = async () => {
@@ -38,14 +51,14 @@ class ImaMainnetUpgrader extends Upgrader {
 
     setVersion = async (newVersion: string) => {
         const messageProxyForMainnet = await this.getMessageProxyForMainnet();
-        this.transactions.push({
-            to: messageProxyForMainnet.address,
+        this.transactions.push(Transaction.from({
+            to: await messageProxyForMainnet.getAddress(),
             data: messageProxyForMainnet.interface.encodeFunctionData("setVersion", [newVersion])
-        });
+        }));
     }
 
     // deployNewContracts = () => { };
-
+    
     initialize = async () => {
         const contractManagerAddress = await (await this.getMessageProxyForMainnet()).contractManagerOfSkaleManager();
         const contractManagerInterface = new Interface([{
@@ -89,22 +102,23 @@ class ImaMainnetUpgrader extends Upgrader {
             contractManagerInterface,
             ethers.provider
         )
-        for (const contractName of contractsToDeploy) {
+        for (const contractName of contracts) {
             try {
                 const contractAddress = await contractManager.getContract(contractName);
                 console.log(`Address of ${contractName} is set to ${contractAddress}`);
             } catch {
+
                 // getContract failed because the contract is not set
-                const contractAddress = this.abi[`${getContractKeyInAbiFile(contractName)}_address`] as string;
-                this.transactions.push(
+                const contractAddress = await this.instance.getContract(contractName);
+                this.transactions.push(Transaction.from(
                     {
-                        to: contractManager.address,
+                        to: await contractManager.getAddress(),
                         data: contractManager.interface.encodeFunctionData(
                             "setContractsAddress",
                             [contractAddress]
                         )
                     }
-                )
+                ))
                 console.log(`Set ${contractName} address to ${contractAddress}`);
             }
         }
@@ -118,19 +132,10 @@ class ImaMainnetUpgrader extends Upgrader {
     }
 }
 
-async function getImaMainnetAbiAndAddress(): Promise<SkaleABIFile> {
-    if (!process.env.ABI) {
-        console.log(chalk.red("Set path to file with ABI and addresses to ABI environment variables"));
-        process.exit(1);
-    }
-    const abiFilename = process.env.ABI;
-    return JSON.parse(await fs.readFile(abiFilename, "utf-8"));
-}
-
 async function main() {
     const upgrader = new ImaMainnetUpgrader(
         "2.1.0",
-        await getImaMainnetAbiAndAddress(),
+        await getImaMainnetInstance(),
         contracts
     );
     await upgrader.upgrade();

package.json

@@ -7,8 +7,8 @@
         "compile": "npx hardhat compile",
         "cleanCompile": "npx hardhat clean && yarn compile",
         "deploy-to-both-chains": "yarn deploy-to-mainnet && yarn deploy-to-schain",
-        "deploy-to-mainnet": "VERSION=$(cat ../VERSION) npx hardhat run migrations/deployMainnet.ts --network mainnet",
-        "deploy-to-schain": "VERSION=$(cat ../VERSION) npx hardhat run migrations/deploySchain.ts --network schain",
+        "deploy-to-mainnet": "VERSION=$(cat ./VERSION) npx hardhat run migrations/deployMainnet.ts --network mainnet",
+        "deploy-to-schain": "VERSION=$(cat ./VERSION) npx hardhat run migrations/deploySchain.ts --network schain",
         "deploy-skale-manager-components": "npx hardhat run migrations/deploySkaleManagerComponents.ts --network mainnet",
         "eslint": "npx eslint .",
         "lint": "npx solhint \"contracts/**/*.sol\"",
@@ -21,23 +21,24 @@
         "no-hooks": "git config core.hooksPath .git/hooks"
     },
     "dependencies": {
-        "@nomiclabs/hardhat-ethers": "^2.1.0",
+        "@nomicfoundation/hardhat-ethers": "^3.0.8",
         "@openzeppelin/contracts-upgradeable": "^4.7.1",
-        "@openzeppelin/hardhat-upgrades": "^1.14.0",
+        "@openzeppelin/hardhat-upgrades": "^3.1.1",
+        "@safe-global/api-kit": "2.5.4",
         "@skalenetwork/etherbase-interfaces": "^0.0.1-develop.20",
         "@skalenetwork/ima-interfaces": "2.0.0",
         "@skalenetwork/skale-manager-interfaces": "2.0.0",
-        "@skalenetwork/upgrade-tools": "^2.0.2",
+        "@skalenetwork/upgrade-tools": "3.0.0-develop.33",
         "axios": "^0.21.4",
         "dotenv": "^16.0.0",
-        "ethers": "^5.7.2",
-        "hardhat": "2.11.0 - 2.16.1"
+        "ethers": "^6.1.0",
+        "hardhat": "^2.22.15"
     },
     "devDependencies": {
-        "@nomiclabs/hardhat-etherscan": "^3.1.0",
-        "@nomiclabs/hardhat-waffle": "^2.0.2",
-        "@typechain/ethers-v5": "^11.1.1",
-        "@typechain/hardhat": "^7.0.0",
+        "@nomicfoundation/hardhat-chai-matchers": "^2.0.8",
+        "@nomicfoundation/hardhat-verify": "^1.1.1",
+        "@typechain/ethers-v6": "^0.5.1",
+        "@typechain/hardhat": "^9.1.0",
         "@types/chai": "^4.2.12",
         "@types/chai-almost": "^1.0.1",
         "@types/chai-as-promised": "^7.1.3",
@@ -52,7 +53,6 @@
         "chai-as-promised": "^7.1.1",
         "cspell": "^8.14.4",
         "eslint": "^8.46.0",
-        "ethereum-waffle": "^4.0.10",
         "ganache": "7.9.2",
         "solhint": "3.3.6",
         "solidity-coverage": "^0.8.4",

scripts/test_deploy.sh

@@ -15,6 +15,8 @@ export PRIVATE_KEY_FOR_ETHEREUM=$PRIVATE_KEY
 export PRIVATE_KEY_FOR_SCHAIN=$PRIVATE_KEY
 
 yarn deploy-skale-manager-components
-yarn deploy-to-both-chains
+yarn deploy-to-mainnet
+# TODO: Uncomment after fixing deploy script for schain, related issue https://github.com/skalenetwork/IMA/issues/1720
+# yarn deploy-to-both-chains
 
 npx ganache instances stop "$GANACHE"