@skalenetwork/upgrade-tools 3.0.0-linter.9 → 3.0.0-merge-stable.1

package/dist/hardhat.config.d.ts

@@ -1,5 +1,5 @@
 import { HardhatUserConfig } from "hardhat/config";
-import "@typechain/hardhat";
+import '@typechain/hardhat';
 import "@nomiclabs/hardhat-ethers";
 import "@openzeppelin/hardhat-upgrades";
 declare const config: HardhatUserConfig;

package/dist/hardhat.config.js

@@ -4,9 +4,9 @@ require("@typechain/hardhat");
 require("@nomiclabs/hardhat-ethers");
 require("@openzeppelin/hardhat-upgrades");
 const config = {
-    "typechain": {
-        "target": "ethers-v5",
-        "externalArtifacts": ["node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json"]
+    typechain: {
+        target: "ethers-v5",
+        externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json']
     }
 };
 exports.default = config;

package/dist/src/abi.d.ts

@@ -1,2 +1,2 @@
 import { Interface } from "ethers/lib/utils";
-export declare const getAbi: (contractInterface: Interface) => [];
+export declare function getAbi(contractInterface: Interface): [];

package/dist/src/abi.js

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAbi = void 0;
-const getAbi = (contractInterface) => {
+function getAbi(contractInterface) {
     const abi = JSON.parse(contractInterface.format("json"));
     abi.forEach((obj) => {
         if (obj.type === "function") {
             const func = obj;
             func.inputs.concat(func.outputs).forEach((output) => {
-                Object.assign(output, {
-                    "name": "",
-                    ...output
-                });
+                Object.assign(output, Object.assign({ name: "" }, output));
             });
         }
     });
     return abi;
-};
+}
 exports.getAbi = getAbi;

package/dist/src/deploy.d.ts

@@ -1,4 +1,4 @@
-export declare const deployLibraries: (libraryNames: string[]) => Promise<Map<string, string>>;
-export declare const getLinkedContractFactory: (contractName: string, libraries: Map<string, string>) => Promise<import("ethers").ContractFactory>;
-export declare const getManifestFile: () => Promise<string>;
-export declare const getContractFactory: (contract: string) => Promise<import("ethers").ContractFactory>;
+export declare function deployLibraries(libraryNames: string[]): Promise<Map<string, string>>;
+export declare function getLinkedContractFactory(contractName: string, libraries: Map<string, string>): Promise<import("ethers").ContractFactory>;
+export declare function getManifestFile(): Promise<string>;
+export declare function getContractFactory(contract: string): Promise<import("ethers").ContractFactory>;

package/dist/src/deploy.js

@@ -4,22 +4,21 @@ exports.getContractFactory = exports.getManifestFile = exports.getLinkedContract
 const upgrades_core_1 = require("@openzeppelin/upgrades-core");
 const hardhat_1 = require("hardhat");
 const fs_1 = require("fs");
-const _deployLibrary = async (libraryName) => {
-    const Library = await hardhat_1.ethers.getContractFactory(libraryName);
-    const library = await Library.deploy();
+async function _deployLibrary(libraryName) {
+    const Library = await hardhat_1.ethers.getContractFactory(libraryName), library = await Library.deploy();
     await library.deployed();
     return library.address;
-};
-const deployLibraries = async (libraryNames) => {
+}
+async function deployLibraries(libraryNames) {
     const libraries = new Map();
     for (const libraryName of libraryNames) {
         libraries.set(libraryName, await _deployLibrary(libraryName));
     }
     return libraries;
-};
+}
 exports.deployLibraries = deployLibraries;
-const _linkBytecode = (artifact, libraries) => {
-    let { bytecode } = artifact;
+function _linkBytecode(artifact, libraries) {
+    let bytecode = artifact.bytecode;
     for (const [, fileReferences] of Object.entries(artifact.linkReferences)) {
         for (const [libName, fixups] of Object.entries(fileReferences)) {
             const addr = libraries.get(libName);
@@ -35,28 +34,26 @@ const _linkBytecode = (artifact, libraries) => {
         }
     }
     return bytecode;
-};
-const getLinkedContractFactory = async (contractName, libraries) => {
-    const cArtifact = await hardhat_1.artifacts.readArtifact(contractName);
-    const linkedBytecode = _linkBytecode(cArtifact, libraries);
-    const ContractFactory = await hardhat_1.ethers.getContractFactory(cArtifact.abi, linkedBytecode);
+}
+async function getLinkedContractFactory(contractName, libraries) {
+    const cArtifact = await hardhat_1.artifacts.readArtifact(contractName), linkedBytecode = _linkBytecode(cArtifact, libraries), ContractFactory = await hardhat_1.ethers.getContractFactory(cArtifact.abi, linkedBytecode);
     return ContractFactory;
-};
+}
 exports.getLinkedContractFactory = getLinkedContractFactory;
-const getManifestFile = async () => (await upgrades_core_1.Manifest.forNetwork(hardhat_1.ethers.provider)).file;
+async function getManifestFile() {
+    return (await upgrades_core_1.Manifest.forNetwork(hardhat_1.ethers.provider)).file;
+}
 exports.getManifestFile = getManifestFile;
-const getContractFactory = async (contract) => {
+async function getContractFactory(contract) {
     const { linkReferences } = await hardhat_1.artifacts.readArtifact(contract);
-    if (!Object.keys(linkReferences).length) {
+    if (!Object.keys(linkReferences).length)
         return await hardhat_1.ethers.getContractFactory(contract);
-    }
     const libraryNames = [];
     for (const key of Object.keys(linkReferences)) {
         const libraryName = Object.keys(linkReferences[key])[0];
         libraryNames.push(libraryName);
     }
-    const libraries = await (0, exports.deployLibraries)(libraryNames);
-    const libraryArtifacts = {};
+    const libraries = await deployLibraries(libraryNames), libraryArtifacts = {};
     for (const [libraryName, libraryAddress] of libraries.entries()) {
         const { bytecode } = await hardhat_1.artifacts.readArtifact(libraryName);
         libraryArtifacts[libraryName] = {
@@ -64,14 +61,17 @@ const getContractFactory = async (contract) => {
             "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode)
         };
     }
-    const manifest = JSON.parse(await fs_1.promises.readFile(await (0, exports.getManifestFile)(), "utf-8"));
-    if (manifest.libraries === undefined) {
-        Object.assign(manifest, { "libraries": libraryArtifacts });
-    }
-    else {
+    let manifest;
+    try {
+        manifest = JSON.parse(await fs_1.promises.readFile(await getManifestFile(), "utf-8"));
         Object.assign(libraryArtifacts, manifest.libraries);
     }
-    await fs_1.promises.writeFile(await (0, exports.getManifestFile)(), JSON.stringify(manifest, null, 4));
-    return await (0, exports.getLinkedContractFactory)(contract, libraries);
-};
+    finally {
+        if (manifest !== undefined) {
+            Object.assign(manifest, { libraries: libraryArtifacts });
+        }
+        await fs_1.promises.writeFile(await getManifestFile(), JSON.stringify(manifest, null, 4));
+    }
+    return await getLinkedContractFactory(contract, libraries);
+}
 exports.getContractFactory = getContractFactory;

package/dist/src/gnosis-safe.d.ts

@@ -1,2 +1,2 @@
 import { UnsignedTransaction } from "ethers";
-export declare const createMultiSendTransaction: (safeAddress: string, transactions: UnsignedTransaction[]) => Promise<void>;
+export declare function createMultiSendTransaction(safeAddress: string, transactions: UnsignedTransaction[]): Promise<void>;

package/dist/src/gnosis-safe.js

@@ -27,7 +27,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMultiSendTransaction = void 0;
-const chalk_1 = __importDefault(require("chalk"));
 const hardhat_1 = require("hardhat");
 const api_kit_1 = __importDefault(require("@safe-global/api-kit"));
 const protocol_kit_1 = __importStar(require("@safe-global/protocol-kit"));
@@ -38,107 +37,67 @@ var Network;
     Network[Network["GANACHE"] = 1337] = "GANACHE";
     Network[Network["HARDHAT"] = 31337] = "HARDHAT";
 })(Network || (Network = {}));
-// Constants
+// constants
 const URLS = {
-    "safe_transaction": {
+    safe_transaction: {
         [Network.MAINNET]: "https://safe-transaction-mainnet.safe.global",
-        [Network.GOERLI]: "https://safe-transaction-goerli.safe.global"
+        [Network.GOERLI]: "https://safe-transaction-goerli.safe.global",
     }
 };
-// Public functions
-const createMultiSendTransaction = async (safeAddress, transactions) => {
+// public functions
+async function createMultiSendTransaction(safeAddress, transactions) {
     const safeTransactionData = [];
     for (const transaction of transactions) {
         safeTransactionData.push({
-            "to": transaction.to
-                ? transaction.to
-                : hardhat_1.ethers.constants.AddressZero,
-            "data": transaction.data
-                ? transaction.data.toString()
-                : "0x",
-            "value": transaction.value
-                ? transaction.value.toString()
-                : "0",
-            "operation": 0
+            to: transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero,
+            data: transaction.data ? transaction.data.toString() : "0x",
+            value: transaction.value ? transaction.value.toString() : "0",
+            operation: 0,
         });
     }
-    const safeService = await getSafeService();
-    const nonce = await safeService.getNextNonce(safeAddress);
+    const safeService = await getSafeService(), nonce = await safeService.getNextNonce(safeAddress);
     console.log("Will send tx to Gnosis with nonce", nonce);
     const options = {
-        // Max gas to use in the transaction
-        "safeTxGas": "0",
-        // Gas costs not related to the transaction execution (signature check, refund payment...)
-        "baseGas": "0",
-        // Gas price used for the refund calculation
-        "gasPrice": "0",
-        // Token address (hold by the Safe) to be used as a refund to the sender, if `null` is Ether
-        "gasToken": hardhat_1.ethers.constants.AddressZero,
-        // Address of receiver of gas payment (or `null` if tx.origin)
-        "refundReceiver": hardhat_1.ethers.constants.AddressZero,
-        // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
-        nonce
-    };
-    const ethAdapter = await getEthAdapter();
-    const safeSdk = await protocol_kit_1.default.create({ ethAdapter,
-        safeAddress });
-    const safeTransaction = await safeSdk.createTransaction({ safeTransactionData,
-        options });
-    await estimateSafeTransaction(safeAddress, safeTransactionData);
+        safeTxGas: "0",
+        baseGas: "0",
+        gasPrice: "0",
+        gasToken: hardhat_1.ethers.constants.AddressZero,
+        refundReceiver: hardhat_1.ethers.constants.AddressZero,
+        nonce: nonce // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
+    }, ethAdapter = await getEthAdapter(), safeSdk = await protocol_kit_1.default.create({ ethAdapter, safeAddress }), safeTransaction = await safeSdk.createTransaction({ safeTransactionData, options });
     await proposeTransaction(safeAddress, safeTransaction);
-};
+}
 exports.createMultiSendTransaction = createMultiSendTransaction;
-// Private functions
-const estimateSafeTransaction = async (safeAddress, safeTransactionData) => {
-    console.log("Estimate gas");
-    const safeService = await getSafeService();
-    for (const transaction of safeTransactionData) {
-        const estimateResponse = await safeService.estimateSafeTransaction(safeAddress, {
-            "to": transaction.to,
-            "value": transaction.value,
-            "data": transaction.data,
-            "operation": transaction.operation || 0
-        });
-        console.log(chalk_1.default.cyan(`Recommend to set gas limit to ${parseInt(estimateResponse.safeTxGas, 10)}`));
-    }
-    console.log(chalk_1.default.green("Send transaction to gnosis safe"));
-};
-const proposeTransaction = async (safeAddress, safeTransaction) => {
-    const [safeOwner] = await hardhat_1.ethers.getSigners();
-    const ethAdapter = await getEthAdapter();
-    const safeSdk = await protocol_kit_1.default.create({ ethAdapter,
-        safeAddress });
-    const safeTxHash = await safeSdk.getTransactionHash(safeTransaction);
-    const senderSignature = await safeSdk.signTransactionHash(safeTxHash);
-    const safeService = await getSafeService();
+// private functions
+async function proposeTransaction(safeAddress, safeTransaction) {
+    const [safeOwner] = await hardhat_1.ethers.getSigners(), ethAdapter = await getEthAdapter(), safeSdk = await protocol_kit_1.default.create({ ethAdapter, safeAddress }), safeTxHash = await safeSdk.getTransactionHash(safeTransaction), senderSignature = await safeSdk.signTransactionHash(safeTxHash), safeService = await getSafeService();
     await safeService.proposeTransaction({
         safeAddress,
-        "safeTransactionData": safeTransaction.data,
+        safeTransactionData: safeTransaction.data,
         safeTxHash,
-        "senderAddress": safeOwner.address,
-        "senderSignature": senderSignature.data
+        senderAddress: safeOwner.address,
+        senderSignature: senderSignature.data
     });
-};
-const getEthAdapter = async () => {
-    const [safeOwner] = await hardhat_1.ethers.getSigners();
-    const ethAdapter = new protocol_kit_1.EthersAdapter({
+}
+async function getEthAdapter() {
+    const [safeOwner] = await hardhat_1.ethers.getSigners(), ethAdapter = new protocol_kit_1.EthersAdapter({
         ethers: hardhat_1.ethers,
-        "signerOrProvider": safeOwner
+        signerOrProvider: safeOwner
     });
     return ethAdapter;
-};
-const getSafeService = async () => {
-    const { chainId } = await hardhat_1.ethers.provider.getNetwork();
-    const ethAdapter = await getEthAdapter();
-    const safeService = new api_kit_1.default({
-        "txServiceUrl": getSafeTransactionUrl(chainId),
+}
+async function getSafeService() {
+    const chainId = (await hardhat_1.ethers.provider.getNetwork()).chainId, ethAdapter = await getEthAdapter(), safeService = new api_kit_1.default({
+        txServiceUrl: getSafeTransactionUrl(chainId),
         ethAdapter
     });
     return safeService;
-};
-const getSafeTransactionUrl = (chainId) => {
+}
+function getSafeTransactionUrl(chainId) {
     if (Object.keys(URLS.safe_transaction).includes(chainId.toString())) {
         return URLS.safe_transaction[chainId];
     }
-    throw Error(`Can't get safe-transaction url at network with chainId = ${chainId}`);
-};
+    else {
+        throw Error(`Can't get safe-transaction url at network with chainId = ${chainId}`);
+    }
+}

package/dist/src/multiSend.d.ts

@@ -1,2 +1,2 @@
 import { BigNumber } from "ethers";
-export declare const encodeTransaction: (operation: 0 | 1, to: string, value: BigNumber | number, data: string) => string;
+export declare function encodeTransaction(operation: 0 | 1, to: string, value: BigNumber | number, data: string): string;

package/dist/src/multiSend.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeTransaction = void 0;
 const ethers_1 = require("ethers");
-const padWithZeros = (value, targetLength) => ("0".repeat(targetLength) + value).slice(-targetLength);
-const encodeTransaction = (operation, to, value, data) => {
-    // / operation as a uint8 with 0 for a call or 1 for a delegatecall (=> 1 byte),
-    // / to as a address (=> 20 bytes),
-    // / value as a uint256 (=> 32 bytes),
-    // / data length as a uint256 (=> 32 bytes),
-    // / data as bytes.
-    let _operation = "";
+function padWithZeros(value, targetLength) {
+    return ("0".repeat(targetLength) + value).slice(-targetLength);
+}
+function encodeTransaction(operation, to, value, data) {
+    /// operation as a uint8 with 0 for a call or 1 for a delegatecall (=> 1 byte),
+    /// to as a address (=> 20 bytes),
+    /// value as a uint256 (=> 32 bytes),
+    /// data length as a uint256 (=> 32 bytes),
+    /// data as bytes.
+    let _operation;
     if (operation === 0) {
         _operation = "00";
     }
@@ -17,29 +19,28 @@ const encodeTransaction = (operation, to, value, data) => {
         _operation = "01";
     }
     else {
-        throw Error("Operation has an incorrect value");
+        throw Error(`Operation has an incorrect value`);
     }
     let _to = to;
     if (to.startsWith("0x")) {
         _to = _to.slice(2);
     }
     _to = padWithZeros(_to, 20 * 2);
-    const _value = padWithZeros(ethers_1.BigNumber.from(value).toHexString().
-        slice(2), 32 * 2);
+    const _value = padWithZeros(ethers_1.BigNumber.from(value).toHexString().slice(2), 32 * 2);
     let _data = data;
     if (data.startsWith("0x")) {
         _data = _data.slice(2);
     }
     if (_data.length % 2 !== 0) {
-        _data = `0${_data}`;
+        _data = "0" + _data;
     }
     const _dataLength = padWithZeros((_data.length / 2).toString(16), 32 * 2);
-    return `0x${[
+    return "0x" + [
         _operation,
         _to,
         _value,
         _dataLength,
-        _data
-    ].join("")}`;
-};
+        _data,
+    ].join("");
+}
 exports.encodeTransaction = encodeTransaction;

package/dist/src/submitters/auto-submitter.d.ts

@@ -1,12 +1,10 @@
 import { Transaction } from "ethers";
 import { Submitter } from "./submitter";
 export declare class AutoSubmitter extends Submitter {
-    name: string;
     submit(transactions: Transaction[]): Promise<void>;
-    private static getSubmitter;
-    private static _getImaInstance;
-    private static _getSafeAddress;
-    private static _getSchainHash;
-    private static _getMainnetChainId;
-    private static _versionFunctionExists;
+    _getImaInstance(): Promise<import("@skalenetwork/skale-contracts/lib/instance").Instance<import("ethers").BaseContract>>;
+    _getSafeAddress(): string;
+    _getSchainHash(): string;
+    _getMainnetChainId(): number;
+    _versionFunctionExists(): Promise<boolean>;
 }

package/dist/src/submitters/auto-submitter.js

@@ -37,83 +37,73 @@ const safe_ima_legacy_marionette_submitter_1 = require("./safe-ima-legacy-marion
 const marionette_1 = require("./types/marionette");
 const skale_contracts_ethers_v5_1 = require("@skalenetwork/skale-contracts-ethers-v5");
 class AutoSubmitter extends submitter_1.Submitter {
-    constructor() {
-        super(...arguments);
-        this.name = "Auto Submitter";
-    }
     async submit(transactions) {
-        console.log(`Submit via ${this.name}`);
-        const submitter = await AutoSubmitter.getSubmitter();
-        await submitter.submit(transactions);
-    }
-    // Private
-    static async getSubmitter() {
+        let submitter;
         // TODO: remove unknown when move everything to ethers 6
-        const proxyAdmin = await (0, admin_1.getManifestAdmin)(hardhat_1.default);
-        const owner = await proxyAdmin.owner();
+        const proxyAdmin = await (0, admin_1.getManifestAdmin)(hardhat_1.default), owner = await proxyAdmin.owner();
         if (await hardhat_1.default.ethers.provider.getCode(owner) === "0x") {
             console.log("Owner is not a contract");
-            return new eoa_submitter_1.EoaSubmitter();
+            submitter = new eoa_submitter_1.EoaSubmitter();
         }
-        console.log("Owner is a contract");
-        if (hardhat_1.ethers.utils.getAddress(owner) === hardhat_1.ethers.utils.getAddress(marionette_1.MARIONETTE_ADDRESS)) {
-            console.log("Marionette owner is detected");
-            const imaInstance = await AutoSubmitter._getImaInstance();
-            const mainnetChainId = AutoSubmitter._getMainnetChainId();
-            const safeAddress = AutoSubmitter._getSafeAddress();
-            const schainHash = AutoSubmitter._getSchainHash();
-            /*
-            * TODO: after marionette has multiSend functionality
-            * query version and properly select a submitter
-            * based on it
-            *
-            * if (await this._versionFunctionExists()) {
-            *     console.log("version() function was found. Use normal Marionette")
-            *     submitter = new SafeImaMarionetteSubmitter(
-            *         safeAddress,
-            *         imaAbi,
-            *         schainHash,
-            *         mainnetChainId
-            *     )
-            * } else {
-            *     console.log("No version() function was found. Use legacy Marionette")
-            *     submitter = new SafeImaLegacyMarionetteSubmitter(
-            *         safeAddress,
-            *         imaAbi,
-            *         schainHash,
-            *         mainnetChainId
-            *     )
-            * }
-            */
-            return new safe_ima_legacy_marionette_submitter_1.SafeImaLegacyMarionetteSubmitter(safeAddress, imaInstance, schainHash, mainnetChainId);
+        else {
+            console.log("Owner is a contract");
+            if (hardhat_1.ethers.utils.getAddress(owner) == hardhat_1.ethers.utils.getAddress(marionette_1.MARIONETTE_ADDRESS)) {
+                console.log("Marionette owner is detected");
+                const imaInstance = await this._getImaInstance(), mainnetChainId = this._getMainnetChainId(), safeAddress = this._getSafeAddress(), schainHash = this._getSchainHash();
+                // TODO: after marionette has multiSend functionality
+                // query version and properly select a submitter
+                // based on it
+                //
+                // if (await this._versionFunctionExists()) {
+                //     console.log("version() function was found. Use normal Marionette")
+                //     submitter = new SafeImaMarionetteSubmitter(
+                //         safeAddress,
+                //         imaAbi,
+                //         schainHash,
+                //         mainnetChainId
+                //     )
+                // } else {
+                //     console.log("No version() function was found. Use legacy Marionette")
+                //     submitter = new SafeImaLegacyMarionetteSubmitter(
+                //         safeAddress,
+                //         imaAbi,
+                //         schainHash,
+                //         mainnetChainId
+                //     )
+                // }
+                submitter = new safe_ima_legacy_marionette_submitter_1.SafeImaLegacyMarionetteSubmitter(safeAddress, imaInstance, schainHash, mainnetChainId);
+            }
+            else {
+                // assuming owner is a Gnosis Safe
+                console.log("Using Gnosis Safe");
+                submitter = new safe_submitter_1.SafeSubmitter(owner);
+            }
         }
-        // Assuming owner is a Gnosis Safe
-        console.log("Using Gnosis Safe");
-        return new safe_submitter_1.SafeSubmitter(owner);
+        await submitter.submit(transactions);
     }
-    static async _getImaInstance() {
+    // private
+    async _getImaInstance() {
         if (!process.env.IMA) {
             console.log(chalk_1.default.red("Set target IMA alias to IMA environment variable"));
             process.exit(1);
         }
-        const network = await skale_contracts_ethers_v5_1.skaleContracts.getNetworkByProvider(hardhat_1.ethers.provider);
-        const ima = await network.getProject("ima");
+        const network = await skale_contracts_ethers_v5_1.skaleContracts.getNetworkByProvider(hardhat_1.ethers.provider), ima = await network.getProject("ima");
         return await ima.getInstance(process.env.IMA);
     }
-    static _getSafeAddress() {
+    _getSafeAddress() {
         if (!process.env.SAFE_ADDRESS) {
             console.log(chalk_1.default.red("Set Gnosis Safe owner address to SAFE_ADDRESS environment variable"));
             process.exit(1);
         }
         return process.env.SAFE_ADDRESS;
     }
-    static _getSchainHash() {
-        // Query Context to get schain hash
+    _getSchainHash() {
+        // query Context to get schain hash
         if (!process.env.SCHAIN_HASH) {
             if (!process.env.SCHAIN_NAME) {
                 console.log(chalk_1.default.red("Set schain name to SCHAIN_NAME environment variable"));
                 console.log(chalk_1.default.red("or schain hash to SCHAIN_HASH environment variable"));
-                throw Error("Schain is not set");
+                process.exit(1);
             }
             else {
                 return hardhat_1.ethers.utils.solidityKeccak256(["string"], [process.env.SCHAIN_NAME]);
@@ -123,27 +113,24 @@ class AutoSubmitter extends submitter_1.Submitter {
             return process.env.SCHAIN_HASH;
         }
     }
-    static _getMainnetChainId() {
+    _getMainnetChainId() {
         if (!process.env.MAINNET_CHAIN_ID) {
             console.log(chalk_1.default.red("Set chainId of mainnet to MAINNET_CHAIN_ID environment variable"));
             console.log(chalk_1.default.red("Use 1 for Ethereum mainnet or 5 for Goerli"));
-            throw Error("Mainnet chainId is not set");
+            process.exit(1);
         }
         else {
             return Number.parseInt(process.env.MAINNET_CHAIN_ID);
         }
     }
-    static async _versionFunctionExists() {
+    async _versionFunctionExists() {
         const bytecode = await hardhat_1.default.ethers.provider.getCode(marionette_1.MARIONETTE_ADDRESS);
-        /*
-         * If the bytecode doesn't include the function selector version()
-         * is definitely not present
-         */
+        // If the bytecode doesn't include the function selector version()
+        // is definitely not present
         if (!bytecode.includes(hardhat_1.ethers.utils.id("version()").slice(2, 10))) {
             return false;
         }
-        const marionette = new hardhat_1.ethers.Contract(marionette_1.MARIONETTE_ADDRESS, [
-            {
+        const marionette = new hardhat_1.ethers.Contract(marionette_1.MARIONETTE_ADDRESS, [{
                 "inputs": [],
                 "name": "version",
                 "outputs": [
@@ -155,21 +142,16 @@ class AutoSubmitter extends submitter_1.Submitter {
                 ],
                 "stateMutability": "view",
                 "type": "function"
-            }
-        ], hardhat_1.default.ethers.provider);
-        /*
-         * If gas estimation doesn't revert then an execution is possible
-         * given the provided function selector
-         */
+            }], hardhat_1.default.ethers.provider);
+        // If gas estimation doesn't revert then an execution is possible
+        // given the provided function selector
         try {
             await marionette.estimateGas.version();
             return true;
         }
         catch {
-            /*
-             * Otherwise (revert) we assume that there is no entry in the jump table
-             * meaning that the contract doesn't include version()
-             */
+            // Otherwise (revert) we assume that there is no entry in the jump table
+            // meaning that the contract doesn't include version()
             return false;
         }
     }

package/dist/src/submitters/eoa-submitter.d.ts

@@ -1,6 +1,5 @@
 import { UnsignedTransaction } from "ethers";
 import { Submitter } from "./submitter";
 export declare class EoaSubmitter extends Submitter {
-    name: string;
     submit(transactions: UnsignedTransaction[]): Promise<void>;
 }

package/dist/src/submitters/eoa-submitter.js

@@ -4,19 +4,15 @@ exports.EoaSubmitter = void 0;
 const hardhat_1 = require("hardhat");
 const submitter_1 = require("./submitter");
 class EoaSubmitter extends submitter_1.Submitter {
-    constructor() {
-        super(...arguments);
-        this.name = "EOA Submitter";
-    }
     async submit(transactions) {
-        EoaSubmitter._atomicityWarning();
+        this._atomicityWarning();
         const [deployer] = await hardhat_1.ethers.getSigners();
         for (const transaction of transactions) {
-            console.log(`Send transaction via ${this.name}`);
+            console.log("Send transaction");
             const response = await deployer.sendTransaction({
-                "to": transaction.to,
-                "value": transaction.value,
-                "data": transaction.data
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data
             });
             console.log(`Waiting for a transaction with nonce ${response.nonce}`);
             await response.wait();

package/dist/src/submitters/safe-ima-legacy-marionette-submitter.js

@@ -41,20 +41,14 @@ class SafeImaLegacyMarionetteSubmitter extends safe_to_ima_submitter_1.SafeToIma
     }
     async submit(transactions) {
         if (transactions.length > 1) {
-            SafeImaLegacyMarionetteSubmitter._atomicityWarning();
+            this._atomicityWarning();
         }
         const transactionsToMarionette = [];
         for (const transaction of transactions) {
             transactionsToMarionette.push({
-                "to": this.marionette.address,
+                to: this.marionette.address,
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                "data": await this.marionette.encodeFunctionCall(transaction.to
-                    ? transaction.to
-                    : hardhat_1.ethers.constants.AddressZero, transaction.value
-                    ? transaction.value
-                    : 0, transaction.data
-                    ? transaction.data
-                    : "0x")
+                data: await this.marionette.encodeFunctionCall(transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero, transaction.value ? transaction.value : 0, transaction.data ? transaction.data : "0x")
             });
         }
         await super.submit(transactionsToMarionette);

package/dist/src/submitters/safe-ima-marionette-submitter.js

@@ -50,21 +50,15 @@ class SafeImaMarionetteSubmitter extends safe_to_ima_submitter_1.SafeToImaSubmit
         const functionCalls = [];
         for (const transaction of transactions) {
             functionCalls.push({
-                "receiver": transaction.to
-                    ? transaction.to
-                    : hardhat_1.ethers.constants.AddressZero,
-                "value": transaction.value
-                    ? transaction.value
-                    : 0,
-                "data": transaction.data
-                    ? transaction.data
-                    : "0x"
+                receiver: transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero,
+                value: transaction.value ? transaction.value : 0,
+                data: (transaction.data ? transaction.data : "0x")
             });
         }
         await super.submit([
             {
-                "to": this.marionette.address,
-                "data": await this.marionette.encodeFunctionCalls(functionCalls)
+                to: this.marionette.address,
+                data: await this.marionette.encodeFunctionCalls(functionCalls)
             }
         ]);
     }

package/dist/src/submitters/safe-to-ima-submitter.js

@@ -10,17 +10,14 @@ class SafeToImaSubmitter extends safe_submitter_1.SafeSubmitter {
     }
     async submit(transactions) {
         if (transactions.length > 1) {
-            SafeToImaSubmitter._atomicityWarning();
+            this._atomicityWarning();
         }
-        const messageProxyForMainnet = await this._getMessageProxyForMainnet();
-        const transactionsToIma = transactions.map((transaction) => ({
-            "to": messageProxyForMainnet.address,
-            "data": messageProxyForMainnet.interface.encodeFunctionData("postOutgoingMessage", [
-                this.targetSchainHash,
-                transaction.to,
-                transaction.data
-            ])
-        }));
+        const messageProxyForMainnet = await this._getMessageProxyForMainnet(), transactionsToIma = transactions.map((transaction) => {
+            return {
+                to: messageProxyForMainnet.address,
+                data: messageProxyForMainnet.interface.encodeFunctionData("postOutgoingMessage", [this.targetSchainHash, transaction.to, transaction.data])
+            };
+        });
         await super.submit(transactionsToIma);
     }
     async _getMessageProxyForMainnet() {

package/dist/src/submitters/submitter.d.ts

@@ -1,5 +1,5 @@
 import { UnsignedTransaction } from "ethers";
 export declare abstract class Submitter {
     abstract submit(transactions: UnsignedTransaction[]): Promise<void>;
-    protected static _atomicityWarning(): void;
+    _atomicityWarning(): void;
 }

package/dist/src/submitters/submitter.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Submitter = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 class Submitter {
-    // Protected
-    static _atomicityWarning() {
+    // private
+    _atomicityWarning() {
         if (!process.env.ALLOW_NOT_ATOMIC_UPGRADE) {
             console.log(chalk_1.default.red("The upgrade will consist of multiple transactions and will not be atomic"));
             console.log(chalk_1.default.red("If not atomic upgrade is OK set ALLOW_NOT_ATOMIC_UPGRADE environment variable"));

package/dist/src/types/SkaleManifestData.d.ts

@@ -1,6 +1,6 @@
 import { ManifestData } from "@openzeppelin/upgrades-core";
 export interface SkaleManifestData extends ManifestData {
-    libraries?: {
+    libraries: {
         [libraryName: string]: {
             address: string;
             bytecodeHash: string;

package/dist/src/upgrader.d.ts

@@ -11,8 +11,8 @@ export declare abstract class Upgrader {
     constructor(projectName: string, targetVersion: string, instance: Instance, contractNamesToUpgrade: string[], submitter?: Submitter);
     abstract getDeployedVersion: () => Promise<string | undefined>;
     abstract setVersion: (newVersion: string) => Promise<void>;
-    deployNewContracts?: () => Promise<void>;
-    initialize?: () => Promise<void>;
+    deployNewContracts: () => Promise<void>;
+    initialize: () => Promise<void>;
     upgrade(): Promise<void>;
-    private static _getContractFactoryAndUpdateManifest;
+    _getContractFactoryAndUpdateManifest(contract: string): Promise<import("ethers").ContractFactory>;
 }

package/dist/src/upgrader.js

@@ -16,9 +16,12 @@ const verification_1 = require("./verification");
 const auto_submitter_1 = require("./submitters/auto-submitter");
 class Upgrader {
     constructor(projectName, targetVersion, instance, contractNamesToUpgrade, submitter = new auto_submitter_1.AutoSubmitter()) {
+        // protected
+        this.deployNewContracts = () => { return Promise.resolve(); };
+        this.initialize = () => { return Promise.resolve(); };
         this.targetVersion = targetVersion;
-        if (!targetVersion.includes("-")) {
-            this.targetVersion = `${targetVersion}-stable.0`;
+        if (!targetVersion.includes('-')) {
+            this.targetVersion = targetVersion + '-stable.0';
         }
         this.instance = instance;
         this.contractNamesToUpgrade = contractNamesToUpgrade;
@@ -26,14 +29,14 @@ class Upgrader {
         this.transactions = [];
         this.submitter = submitter;
     }
-    // Public
+    // public
     async upgrade() {
         const proxyAdmin = await (0, admin_1.getManifestAdmin)(hardhat_1.default);
         let deployedVersion = await this.getDeployedVersion();
         const version = await (0, version_1.getVersion)();
         if (deployedVersion) {
-            if (!deployedVersion.includes("-")) {
-                deployedVersion += "-stable.0";
+            if (!deployedVersion.includes('-')) {
+                deployedVersion = deployedVersion + '-stable.0';
             }
             if (deployedVersion !== this.targetVersion) {
                 console.log(chalk_1.default.red(`This script can't upgrade version ${deployedVersion} to ${version}`));
@@ -44,26 +47,22 @@ class Upgrader {
             console.log(chalk_1.default.yellow(`Can't check currently deployed version of ${this.projectName}`));
         }
         console.log(`Will mark updated version as ${version}`);
-        if (this.deployNewContracts !== undefined) {
-            // Deploy new contracts
-            await this.deployNewContracts();
-        }
+        // Deploy new contracts
+        await this.deployNewContracts();
         // Deploy new implementations
         const contractsToUpgrade = [];
         for (const contract of this.contractNamesToUpgrade) {
-            const contractFactory = await Upgrader._getContractFactoryAndUpdateManifest(contract);
-            const proxyAddress = (await this.instance.getContract(contract)).address;
+            const contractFactory = await this._getContractFactoryAndUpdateManifest(contract), proxyAddress = (await this.instance.getContract(contract)).address;
             console.log(`Prepare upgrade of ${contract}`);
-            const currentImplementationAddress = await (0, upgrades_core_1.getImplementationAddress)(hardhat_2.network.provider, proxyAddress);
-            const newImplementationAddress = await hardhat_2.upgrades.prepareUpgrade(proxyAddress, contractFactory, {
-                "unsafeAllowLinkedLibraries": true,
-                "unsafeAllowRenames": true
+            const currentImplementationAddress = await (0, upgrades_core_1.getImplementationAddress)(hardhat_2.network.provider, proxyAddress), newImplementationAddress = await hardhat_2.upgrades.prepareUpgrade(proxyAddress, contractFactory, {
+                unsafeAllowLinkedLibraries: true,
+                unsafeAllowRenames: true
             });
             if (newImplementationAddress !== currentImplementationAddress) {
                 contractsToUpgrade.push({
                     proxyAddress,
-                    "implementationAddress": newImplementationAddress,
-                    "name": contract
+                    implementationAddress: newImplementationAddress,
+                    name: contract
                 });
             }
             else {
@@ -74,17 +73,12 @@ class Upgrader {
         for (const contract of contractsToUpgrade) {
             console.log(chalk_1.default.yellowBright(`Prepare transaction to upgrade ${contract.name} at ${contract.proxyAddress} to ${contract.implementationAddress}`));
             this.transactions.push({
-                "to": proxyAdmin.address,
-                "data": proxyAdmin.interface.encodeFunctionData("upgrade", [
-                    contract.proxyAddress,
-                    contract.implementationAddress
-                ])
+                to: proxyAdmin.address,
+                data: proxyAdmin.interface.encodeFunctionData("upgrade", [contract.proxyAddress, contract.implementationAddress])
             });
         }
-        if (this.initialize !== undefined) {
-            await this.initialize();
-        }
-        // Write version
+        await this.initialize();
+        // write version
         await this.setVersion(version);
         await fs_1.promises.writeFile(`data/transactions-${version}-${hardhat_2.network.name}.json`, JSON.stringify(this.transactions, null, 4));
         await this.submitter.submit(this.transactions);
@@ -99,21 +93,17 @@ class Upgrader {
         }
         console.log("Done");
     }
-    // Private
-    static async _getContractFactoryAndUpdateManifest(contract) {
-        const { linkReferences } = await hardhat_2.artifacts.readArtifact(contract);
-        const manifest = JSON.parse(await fs_1.promises.readFile(await (0, deploy_1.getManifestFile)(), "utf-8"));
-        if (!Object.keys(linkReferences).length) {
+    // private
+    async _getContractFactoryAndUpdateManifest(contract) {
+        const { linkReferences } = await hardhat_2.artifacts.readArtifact(contract), manifest = JSON.parse(await fs_1.promises.readFile(await (0, deploy_1.getManifestFile)(), "utf-8"));
+        if (!Object.keys(linkReferences).length)
             return await hardhat_2.ethers.getContractFactory(contract);
-        }
-        const librariesToUpgrade = [];
-        const oldLibraries = {};
+        const librariesToUpgrade = [], oldLibraries = {};
         if (manifest.libraries === undefined) {
-            manifest.libraries = {};
+            Object.assign(manifest, { libraries: {} });
         }
         for (const key of Object.keys(linkReferences)) {
-            const libraryName = Object.keys(linkReferences[key])[0];
-            const { bytecode } = await hardhat_2.artifacts.readArtifact(libraryName);
+            const libraryName = Object.keys(linkReferences[key])[0], { bytecode } = await hardhat_2.artifacts.readArtifact(libraryName);
             if (manifest.libraries[libraryName] === undefined) {
                 librariesToUpgrade.push(libraryName);
                 continue;
@@ -129,8 +119,7 @@ class Upgrader {
         const libraries = await (0, deploy_1.deployLibraries)(librariesToUpgrade);
         for (const [libraryName, libraryAddress] of libraries.entries()) {
             const { bytecode } = await hardhat_2.artifacts.readArtifact(libraryName);
-            manifest.libraries[libraryName] = { "address": libraryAddress,
-                "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode) };
+            manifest.libraries[libraryName] = { "address": libraryAddress, "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode) };
         }
         Object.assign(libraries, oldLibraries);
         await fs_1.promises.writeFile(await (0, deploy_1.getManifestFile)(), JSON.stringify(manifest, null, 4));

package/dist/src/verification.d.ts

@@ -1,2 +1,2 @@
-export declare const verify: (contractName: string, contractAddress: string, constructorArguments: object) => Promise<void>;
-export declare const verifyProxy: (contractName: string, proxyAddress: string, constructorArguments: object) => Promise<void>;
+export declare function verify(contractName: string, contractAddress: string, constructorArguments: object): Promise<void>;
+export declare function verifyProxy(contractName: string, proxyAddress: string, constructorArguments: object): Promise<void>;

package/dist/src/verification.js

@@ -8,35 +8,35 @@ const hardhat_1 = require("hardhat");
 const chain_config_1 = require("@nomicfoundation/hardhat-verify/internal/chain-config");
 const chalk_1 = __importDefault(require("chalk"));
 const upgrades_core_1 = require("@openzeppelin/upgrades-core");
-const verify = async (contractName, contractAddress, constructorArguments) => {
-    const { chainId } = await hardhat_1.ethers.provider.getNetwork();
-    if (chain_config_1.builtinChains.find((chain) => chain.chainId === chainId) !== undefined) {
-        for (let retry = 0; retry <= 5; retry += 1) {
+async function verify(contractName, contractAddress, constructorArguments) {
+    const chainId = (await hardhat_1.ethers.provider.getNetwork()).chainId;
+    if (chain_config_1.builtinChains.find(chain => chain.chainId === chainId) !== undefined) {
+        for (let retry = 0; retry <= 5; ++retry) {
             try {
                 await (0, hardhat_1.run)("verify:verify", {
-                    "address": contractAddress,
+                    address: contractAddress,
                     constructorArguments
                 });
                 break;
             }
-            catch (error) {
-                if (error instanceof Error) {
-                    if (error.toString().includes("Contract source code already verified")) {
+            catch (e) {
+                if (e instanceof Error) {
+                    if (e.toString().includes("Contract source code already verified")) {
                         console.log(chalk_1.default.grey(`${contractName} is already verified`));
                         return;
                     }
                     console.log(chalk_1.default.red(`Contract ${contractName} was not verified on etherscan`));
-                    console.log(error.toString());
+                    console.log(e.toString());
                 }
                 else {
-                    console.log("Unknown exception type:", error);
+                    console.log("Unknown exception type:", e);
                 }
             }
         }
     }
-};
+}
 exports.verify = verify;
-const verifyProxy = async (contractName, proxyAddress, constructorArguments) => {
-    await (0, exports.verify)(contractName, await (0, upgrades_core_1.getImplementationAddress)(hardhat_1.network.provider, proxyAddress), constructorArguments);
-};
+async function verifyProxy(contractName, proxyAddress, constructorArguments) {
+    await verify(contractName, await (0, upgrades_core_1.getImplementationAddress)(hardhat_1.network.provider, proxyAddress), constructorArguments);
+}
 exports.verifyProxy = verifyProxy;

package/dist/src/version.js

@@ -10,25 +10,21 @@ const util_1 = __importDefault(require("util"));
 const exec = util_1.default.promisify(child_process_1.exec);
 class VersionNotFound extends Error {
 }
-const getVersionFilename = async (folder) => {
+async function getVersionFilename(folder) {
     if (folder === undefined) {
         return getVersionFilename((await exec("git rev-parse --show-toplevel")).stdout.trim());
     }
-    const VERSION_FILENAME = "VERSION";
-    const path = `${folder}/${VERSION_FILENAME}`;
+    const VERSION_FILENAME = 'VERSION', path = `${folder}/${VERSION_FILENAME}`;
     if ((0, fs_1.existsSync)(path)) {
         return path;
     }
-    for (const entry of await fs_1.promises.readdir(folder, {
-        "withFileTypes": true,
-        "recursive": true
-    })) {
+    for (const entry of await fs_1.promises.readdir(folder, { withFileTypes: true, recursive: true })) {
         if (entry.isFile() && entry.name === VERSION_FILENAME) {
             return `${entry.path}/${entry.name}`;
         }
     }
     throw new VersionNotFound("Can't find version file");
-};
+}
 const getVersion = async () => {
     if (process.env.VERSION) {
         return process.env.VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skalenetwork/upgrade-tools",
-  "version": "3.0.0-linter.9",
+  "version": "3.0.0-merge-stable.1",
   "description": "Scripts to support upgrades of smart contracts",
   "files": [
     "dist/**/*"
@@ -52,6 +52,6 @@
     "@openzeppelin/upgrades-core": "^1.27.1",
     "@types/mocha": "^9.1.0",
     "ethers": "^5.7.2",
-    "hardhat": "2.8.3 - 2.16.1"
+    "hardhat": "^2.16.1"
   }
 }