@skalenetwork/upgrade-tools 3.0.0-linter.11 → 3.0.0-linter.3

package/dist/hardhat.config.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("@typechain/hardhat");
 require("@nomiclabs/hardhat-ethers");
 require("@openzeppelin/hardhat-upgrades");
-const coreArtifacts = "node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json";
 const config = {
     "typechain": {
         "target": "ethers-v5",
-        "externalArtifacts": [coreArtifacts]
+        "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,7 +1,7 @@
 "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") {
@@ -15,5 +15,5 @@ const getAbi = (contractInterface) => {
         }
     });
     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,21 +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) => {
+async function _deployLibrary(libraryName) {
     const Library = await hardhat_1.ethers.getContractFactory(libraryName);
     const 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) => {
+function _linkBytecode(artifact, libraries) {
     let { bytecode } = artifact;
     for (const [, fileReferences] of Object.entries(artifact.linkReferences)) {
         for (const [libName, fixups] of Object.entries(fileReferences)) {
@@ -35,19 +35,19 @@ const _linkBytecode = (artifact, libraries) => {
         }
     }
     return bytecode;
-};
-const getLinkedContractFactory = async (contractName, libraries) => {
+}
+async function getLinkedContractFactory(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);
     return ContractFactory;
-};
+}
 exports.getLinkedContractFactory = getLinkedContractFactory;
-const getManifestFile = async function getManifestFile() {
+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) {
         return await hardhat_1.ethers.getContractFactory(contract);
@@ -57,7 +57,7 @@ const getContractFactory = async (contract) => {
         const libraryName = Object.keys(linkReferences[key])[0];
         libraryNames.push(libraryName);
     }
-    const libraries = await (0, exports.deployLibraries)(libraryNames);
+    const libraries = await deployLibraries(libraryNames);
     const libraryArtifacts = {};
     for (const [libraryName, libraryAddress] of libraries.entries()) {
         const { bytecode } = await hardhat_1.artifacts.readArtifact(libraryName);
@@ -66,14 +66,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

@@ -46,7 +46,7 @@ const URLS = {
     }
 };
 // Public functions
-const createMultiSendTransaction = async (safeAddress, transactions) => {
+async function createMultiSendTransaction(safeAddress, transactions) {
     const safeTransactionData = [];
     for (const transaction of transactions) {
         safeTransactionData.push({
@@ -66,38 +66,24 @@ const createMultiSendTransaction = async (safeAddress, transactions) => {
     const 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
+        nonce // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
     };
     const ethAdapter = await getEthAdapter();
     const safeSdk = await protocol_kit_1.default.create({ ethAdapter,
         safeAddress });
-    const safeTransaction = await safeSdk.createTransaction({
-        safeTransactionData,
-        options
-    });
+    const safeTransaction = await safeSdk.createTransaction({ safeTransactionData,
+        options });
     await estimateSafeTransaction(safeAddress, safeTransactionData);
     await proposeTransaction(safeAddress, safeTransaction);
-};
+}
 exports.createMultiSendTransaction = createMultiSendTransaction;
 // Private functions
-const estimateSafeTransaction = async (safeAddress, safeTransactionData) => {
+async function estimateSafeTransaction(safeAddress, safeTransactionData) {
     console.log("Estimate gas");
     const safeService = await getSafeService();
     for (const transaction of safeTransactionData) {
@@ -110,8 +96,8 @@ const estimateSafeTransaction = async (safeAddress, safeTransactionData) => {
         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) => {
+}
+async function proposeTransaction(safeAddress, safeTransaction) {
     const [safeOwner] = await hardhat_1.ethers.getSigners();
     const ethAdapter = await getEthAdapter();
     const safeSdk = await protocol_kit_1.default.create({ ethAdapter,
@@ -126,16 +112,16 @@ const proposeTransaction = async (safeAddress, safeTransaction) => {
         "senderAddress": safeOwner.address,
         "senderSignature": senderSignature.data
     });
-};
-const getEthAdapter = async () => {
+}
+async function getEthAdapter() {
     const [safeOwner] = await hardhat_1.ethers.getSigners();
     const ethAdapter = new protocol_kit_1.EthersAdapter({
         ethers: hardhat_1.ethers,
         "signerOrProvider": safeOwner
     });
     return ethAdapter;
-};
-const getSafeService = async () => {
+}
+async function getSafeService() {
     const { chainId } = await hardhat_1.ethers.provider.getNetwork();
     const ethAdapter = await getEthAdapter();
     const safeService = new api_kit_1.default({
@@ -143,11 +129,10 @@ const getSafeService = async () => {
         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}`);
-};
+    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,19 +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 as a uint8 with 0 for a call
- * or 1 for a delegatecall (=> 1 byte)
- */
-operation, 
-// To as a address (=> 20 bytes)
-to, 
-// Value as a uint256 (=> 32 bytes)
-value, 
-// Data as bytes.
-data) => {
-    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";
     }
@@ -46,5 +43,5 @@ data) => {
         _dataLength,
         _data
     ].join("")}`;
-};
+}
 exports.encodeTransaction = encodeTransaction;

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

@@ -3,7 +3,6 @@ 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;

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

@@ -43,61 +43,59 @@ class AutoSubmitter extends submitter_1.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();
         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 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
+                 *     )
+                 * }
+                 */
+                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);
     }
+    // Private
     static async _getImaInstance() {
         if (!process.env.IMA) {
-            console.log(chalk_1.default.red("Set target IMA alias" +
-                " to IMA environment variable"));
+            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);
@@ -106,8 +104,7 @@ class AutoSubmitter extends submitter_1.Submitter {
     }
     static _getSafeAddress() {
         if (!process.env.SAFE_ADDRESS) {
-            console.log(chalk_1.default.red("Set Gnosis Safe owner address" +
-                " to SAFE_ADDRESS environment variable"));
+            console.log(chalk_1.default.red("Set Gnosis Safe owner address to SAFE_ADDRESS environment variable"));
             process.exit(1);
         }
         return process.env.SAFE_ADDRESS;
@@ -116,10 +113,8 @@ class AutoSubmitter extends submitter_1.Submitter {
         // 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"));
+                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");
             }
             else {
@@ -132,10 +127,8 @@ class AutoSubmitter extends submitter_1.Submitter {
     }
     static _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"));
+            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");
         }
         else {
@@ -176,8 +169,7 @@ class AutoSubmitter extends submitter_1.Submitter {
         }
         catch {
             /*
-             * Otherwise (revert) we assume
-             * that there is no entry in the jump table
+             * 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.js

@@ -18,8 +18,7 @@ class EoaSubmitter extends submitter_1.Submitter {
                 "value": transaction.value,
                 "data": transaction.data
             });
-            console.log("Waiting for a transaction" +
-                ` with nonce ${response.nonce}`);
+            console.log(`Waiting for a transaction with nonce ${response.nonce}`);
             await response.wait();
             console.log("The transaction was sent");
         }

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

@@ -25,8 +25,7 @@ class SafeToImaSubmitter extends safe_submitter_1.SafeSubmitter {
     }
     async _getMessageProxyForMainnet() {
         if (this._messageProxyForMainnet === undefined) {
-            this._messageProxyForMainnet =
-                await this.imaInstance.getContract("MessageProxyForMainnet");
+            this._messageProxyForMainnet = await this.imaInstance.getContract("MessageProxyForMainnet");
         }
         return this._messageProxyForMainnet;
     }

package/dist/src/submitters/submitter.js

@@ -9,10 +9,8 @@ class Submitter {
     // Protected
     static _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"));
+            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"));
             process.exit(1);
         }
         else {

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

@@ -14,5 +14,5 @@ export declare abstract class Upgrader {
     deployNewContracts?: () => Promise<void>;
     initialize?: () => Promise<void>;
     upgrade(): Promise<void>;
-    private static getContractFactoryAndUpdateManifest;
+    private static _getContractFactoryAndUpdateManifest;
 }

package/dist/src/upgrader.js

@@ -36,15 +36,12 @@ class Upgrader {
                 deployedVersion += "-stable.0";
             }
             if (deployedVersion !== this.targetVersion) {
-                const cannotUpgradeMessage = `This script can't upgrade version ${deployedVersion}` +
-                    ` to ${version}`;
-                console.log(chalk_1.default.red(cannotUpgradeMessage));
+                console.log(chalk_1.default.red(`This script can't upgrade version ${deployedVersion} to ${version}`));
                 process.exit(1);
             }
         }
         else {
-            const cannotCheckMessage = `Can't check currently deployed version of ${this.projectName}`;
-            console.log(chalk_1.default.yellow(cannotCheckMessage));
+            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) {
@@ -54,7 +51,7 @@ class Upgrader {
         // Deploy new implementations
         const contractsToUpgrade = [];
         for (const contract of this.contractNamesToUpgrade) {
-            const contractFactory = await Upgrader.getContractFactoryAndUpdateManifest(contract);
+            const contractFactory = await Upgrader._getContractFactoryAndUpdateManifest(contract);
             const 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);
@@ -75,10 +72,7 @@ class Upgrader {
         }
         // Switch proxies to new implementations
         for (const contract of contractsToUpgrade) {
-            const infoMessage = `Prepare transaction to upgrade ${contract.name}` +
-                ` at ${contract.proxyAddress}` +
-                ` to ${contract.implementationAddress}`;
-            console.log(chalk_1.default.yellowBright(infoMessage));
+            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", [
@@ -106,7 +100,7 @@ class Upgrader {
         console.log("Done");
     }
     // Private
-    static async getContractFactoryAndUpdateManifest(contract) {
+    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) {
@@ -115,7 +109,7 @@ class Upgrader {
         const librariesToUpgrade = [];
         const 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];
@@ -129,8 +123,7 @@ class Upgrader {
                 librariesToUpgrade.push(libraryName);
             }
             else {
-                oldLibraries[libraryName] =
-                    manifest.libraries[libraryName].address;
+                oldLibraries[libraryName] = manifest.libraries[libraryName].address;
             }
         }
         const libraries = await (0, deploy_1.deployLibraries)(librariesToUpgrade);

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,41 +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) => {
+async function verify(contractName, contractAddress, constructorArguments) {
     const { chainId } = await hardhat_1.ethers.provider.getNetwork();
-    if (!chain_config_1.builtinChains.map((chain) => chain.chainId).includes(chainId)) {
-        const errorMessage = "Verification on this network is not supported";
-        console.log(chalk_1.default.grey(errorMessage));
-        return;
-    }
-    for (let retry = 0; retry <= 5; retry += 1) {
-        try {
-            await (0, hardhat_1.run)("verify:verify", {
-                "address": contractAddress,
-                constructorArguments
-            });
-            break;
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                const alreadyVerifiedErrorLine = "Contract source code already verified";
-                if (error.toString().includes(alreadyVerifiedErrorLine)) {
-                    const infoMessage = `${contractName} is already verified`;
-                    console.log(chalk_1.default.grey(infoMessage));
-                    return;
-                }
-                const errorMessage = `Contract ${contractName} was not verified on etherscan`;
-                console.log(chalk_1.default.red(errorMessage));
-                console.log(error.toString());
+    if (chain_config_1.builtinChains.find((chain) => chain.chainId === chainId) !== undefined) {
+        for (let retry = 0; retry <= 5; retry += 1) {
+            try {
+                await (0, hardhat_1.run)("verify:verify", {
+                    "address": contractAddress,
+                    constructorArguments
+                });
+                break;
             }
-            else {
-                console.log("Unknown exception type:", error);
+            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(e.toString());
+                }
+                else {
+                    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,7 +10,7 @@ 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());
     }
@@ -19,16 +19,14 @@ const getVersionFilename = async (folder) => {
     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.11",
+  "version": "3.0.0-linter.3",
   "description": "Scripts to support upgrades of smart contracts",
   "files": [
     "dist/**/*"