@skalenetwork/upgrade-tools 3.0.0-linter.4 → 3.0.0-linter.5

package/dist/src/abi.d.ts

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

package/dist/src/abi.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAbi = void 0;
-function getAbi(contractInterface) {
+const getAbi = (contractInterface) => {
     const abi = JSON.parse(contractInterface.format("json"));
     abi.forEach((obj) => {
         if (obj.type === "function") {
@@ -15,5 +15,5 @@ function getAbi(contractInterface) {
         }
     });
     return abi;
-}
+};
 exports.getAbi = getAbi;

package/dist/src/deploy.d.ts

@@ -1,4 +1,4 @@
-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>;
+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>;

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");
-async function _deployLibrary(libraryName) {
+const _deployLibrary = async (libraryName) => {
     const Library = await hardhat_1.ethers.getContractFactory(libraryName);
     const library = await Library.deploy();
     await library.deployed();
     return library.address;
-}
-async function deployLibraries(libraryNames) {
+};
+const deployLibraries = async (libraryNames) => {
     const libraries = new Map();
     for (const libraryName of libraryNames) {
         libraries.set(libraryName, await _deployLibrary(libraryName));
     }
     return libraries;
-}
+};
 exports.deployLibraries = deployLibraries;
-function _linkBytecode(artifact, libraries) {
+const _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,17 @@ function _linkBytecode(artifact, libraries) {
         }
     }
     return bytecode;
-}
-async function getLinkedContractFactory(contractName, libraries) {
+};
+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);
     return ContractFactory;
-}
+};
 exports.getLinkedContractFactory = getLinkedContractFactory;
-async function getManifestFile() {
-    return (await upgrades_core_1.Manifest.forNetwork(hardhat_1.ethers.provider)).file;
-}
+const getManifestFile = async () => (await upgrades_core_1.Manifest.forNetwork(hardhat_1.ethers.provider)).file;
 exports.getManifestFile = getManifestFile;
-async function getContractFactory(contract) {
+const getContractFactory = async (contract) => {
     const { linkReferences } = await hardhat_1.artifacts.readArtifact(contract);
     if (!Object.keys(linkReferences).length) {
         return await hardhat_1.ethers.getContractFactory(contract);
@@ -57,7 +55,7 @@ async function getContractFactory(contract) {
         const libraryName = Object.keys(linkReferences[key])[0];
         libraryNames.push(libraryName);
     }
-    const libraries = await deployLibraries(libraryNames);
+    const libraries = await (0, exports.deployLibraries)(libraryNames);
     const libraryArtifacts = {};
     for (const [libraryName, libraryAddress] of libraries.entries()) {
         const { bytecode } = await hardhat_1.artifacts.readArtifact(libraryName);
@@ -68,15 +66,15 @@ async function getContractFactory(contract) {
     }
     let manifest;
     try {
-        manifest = JSON.parse(await fs_1.promises.readFile(await getManifestFile(), "utf-8"));
+        manifest = JSON.parse(await fs_1.promises.readFile(await (0, exports.getManifestFile)(), "utf-8"));
         Object.assign(libraryArtifacts, manifest.libraries);
     }
     finally {
         if (manifest !== undefined) {
             Object.assign(manifest, { "libraries": libraryArtifacts });
         }
-        await fs_1.promises.writeFile(await getManifestFile(), JSON.stringify(manifest, null, 4));
+        await fs_1.promises.writeFile(await (0, exports.getManifestFile)(), JSON.stringify(manifest, null, 4));
     }
-    return await getLinkedContractFactory(contract, libraries);
-}
+    return await (0, exports.getLinkedContractFactory)(contract, libraries);
+};
 exports.getContractFactory = getContractFactory;

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

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

package/dist/src/gnosis-safe.js

@@ -46,7 +46,7 @@ const URLS = {
     }
 };
 // Public functions
-async function createMultiSendTransaction(safeAddress, transactions) {
+const createMultiSendTransaction = async (safeAddress, transactions) => {
     const safeTransactionData = [];
     for (const transaction of transactions) {
         safeTransactionData.push({
@@ -80,10 +80,10 @@ async function createMultiSendTransaction(safeAddress, transactions) {
         options });
     await estimateSafeTransaction(safeAddress, safeTransactionData);
     await proposeTransaction(safeAddress, safeTransaction);
-}
+};
 exports.createMultiSendTransaction = createMultiSendTransaction;
 // Private functions
-async function estimateSafeTransaction(safeAddress, safeTransactionData) {
+const estimateSafeTransaction = async (safeAddress, safeTransactionData) => {
     console.log("Estimate gas");
     const safeService = await getSafeService();
     for (const transaction of safeTransactionData) {
@@ -96,8 +96,8 @@ async function estimateSafeTransaction(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"));
-}
-async function proposeTransaction(safeAddress, safeTransaction) {
+};
+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,
@@ -112,16 +112,16 @@ async function proposeTransaction(safeAddress, safeTransaction) {
         "senderAddress": safeOwner.address,
         "senderSignature": senderSignature.data
     });
-}
-async function getEthAdapter() {
+};
+const getEthAdapter = async () => {
     const [safeOwner] = await hardhat_1.ethers.getSigners();
     const ethAdapter = new protocol_kit_1.EthersAdapter({
         ethers: hardhat_1.ethers,
         "signerOrProvider": safeOwner
     });
     return ethAdapter;
-}
-async function getSafeService() {
+};
+const getSafeService = async () => {
     const { chainId } = await hardhat_1.ethers.provider.getNetwork();
     const ethAdapter = await getEthAdapter();
     const safeService = new api_kit_1.default({
@@ -129,10 +129,10 @@ async function getSafeService() {
         ethAdapter
     });
     return safeService;
-}
-function getSafeTransactionUrl(chainId) {
+};
+const 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}`);
-}
+};

package/dist/src/multiSend.d.ts

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

package/dist/src/multiSend.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeTransaction = void 0;
 const ethers_1 = require("ethers");
-function padWithZeros(value, targetLength) {
-    return ("0".repeat(targetLength) + value).slice(-targetLength);
-}
-function encodeTransaction(operation, to, value, data) {
+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),
@@ -43,5 +41,5 @@ function encodeTransaction(operation, to, value, data) {
         _dataLength,
         _data
     ].join("")}`;
-}
+};
 exports.encodeTransaction = encodeTransaction;

package/dist/src/verification.d.ts

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

package/dist/src/verification.js

@@ -8,7 +8,7 @@ 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");
-async function verify(contractName, contractAddress, constructorArguments) {
+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) {
@@ -34,9 +34,9 @@ async function verify(contractName, contractAddress, constructorArguments) {
             }
         }
     }
-}
+};
 exports.verify = verify;
-async function verifyProxy(contractName, proxyAddress, constructorArguments) {
-    await verify(contractName, await (0, upgrades_core_1.getImplementationAddress)(hardhat_1.network.provider, proxyAddress), constructorArguments);
-}
+const verifyProxy = async (contractName, proxyAddress, constructorArguments) => {
+    await (0, exports.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 {
 }
-async function getVersionFilename(folder) {
+const getVersionFilename = async (folder) => {
     if (folder === undefined) {
         return getVersionFilename((await exec("git rev-parse --show-toplevel")).stdout.trim());
     }
@@ -19,14 +19,16 @@ async function getVersionFilename(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.4",
+  "version": "3.0.0-linter.5",
   "description": "Scripts to support upgrades of smart contracts",
   "files": [
     "dist/**/*"