@skalenetwork/upgrade-tools 2.0.0-refactor.9 → 3.0.0-skale-contracts.0

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

@@ -1,12 +1,26 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -15,26 +29,136 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoSubmitter = void 0;
 const admin_1 = require("@openzeppelin/hardhat-upgrades/dist/admin");
 const submitter_1 = require("./submitter");
-const hardhat_1 = __importDefault(require("hardhat"));
+const hardhat_1 = __importStar(require("hardhat"));
 const eoa_submitter_1 = require("./eoa-submitter");
 const safe_submitter_1 = require("./safe-submitter");
+const chalk_1 = __importDefault(require("chalk"));
+const safe_ima_legacy_marionette_submitter_1 = require("./safe-ima-legacy-marionette-submitter");
+const marionette_1 = require("./types/marionette");
+const skale_contracts_1 = require("@skalenetwork/skale-contracts");
 class AutoSubmitter extends submitter_1.Submitter {
-    submit(transactions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let submitter;
-            const proxyAdmin = yield (0, admin_1.getManifestAdmin)(hardhat_1.default);
-            const owner = yield proxyAdmin.owner();
-            if ((yield hardhat_1.default.ethers.provider.getCode(owner)) === "0x") {
-                console.log("Owner is not a contract");
-                submitter = new eoa_submitter_1.EoaSubmitter();
+    async submit(transactions) {
+        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");
+            submitter = new eoa_submitter_1.EoaSubmitter();
+        }
+        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();
+                const safeAddress = this._getSafeAddress();
+                const schainHash = this._getSchainHash();
+                const mainnetChainId = this._getMainnetChainId();
+                // 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 {
-                console.log("Owner is a contract");
-                // TODO: add support of Marionette
+                // assuming owner is a Gnosis Safe
+                console.log("Using Gnosis Safe");
                 submitter = new safe_submitter_1.SafeSubmitter(owner);
             }
-            yield submitter.submit(transactions);
-        });
+        }
+        await submitter.submit(transactions);
+    }
+    // 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_1.skaleContracts.getNetworkByChainId((await hardhat_1.ethers.provider.getNetwork()).chainId);
+        const ima = await network.getProject("ima");
+        return await ima.getInstance(process.env.IMA);
+    }
+    _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;
+    }
+    _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"));
+                process.exit(1);
+            }
+            else {
+                return hardhat_1.ethers.utils.solidityKeccak256(["string"], [process.env.SCHAIN_NAME]);
+            }
+        }
+        else {
+            return process.env.SCHAIN_HASH;
+        }
+    }
+    _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"));
+            process.exit(1);
+        }
+        else {
+            return Number.parseInt(process.env.MAINNET_CHAIN_ID);
+        }
+    }
+    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 (!bytecode.includes(hardhat_1.ethers.utils.id("version()").slice(2, 10))) {
+            return false;
+        }
+        const marionette = new hardhat_1.ethers.Contract(marionette_1.MARIONETTE_ADDRESS, [{
+                "inputs": [],
+                "name": "version",
+                "outputs": [
+                    {
+                        "internalType": "string",
+                        "name": "",
+                        "type": "string"
+                    }
+                ],
+                "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
+        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()
+            return false;
+        }
     }
 }
 exports.AutoSubmitter = AutoSubmitter;

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

@@ -1,34 +1,23 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EoaSubmitter = void 0;
 const hardhat_1 = require("hardhat");
 const submitter_1 = require("./submitter");
 class EoaSubmitter extends submitter_1.Submitter {
-    submit(transactions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._atomicityWarning();
-            const [deployer] = yield hardhat_1.ethers.getSigners();
-            for (const transaction of transactions) {
-                console.log("Send transaction");
-                const response = yield deployer.sendTransaction({
-                    to: transaction.to,
-                    value: transaction.value,
-                    data: transaction.data
-                });
-                console.log(`Waiting for a transaction with nonce ${response.nonce}`);
-                yield response.wait();
-                console.log("The transaction was sent");
-            }
-        });
+    async submit(transactions) {
+        this._atomicityWarning();
+        const [deployer] = await hardhat_1.ethers.getSigners();
+        for (const transaction of transactions) {
+            console.log("Send transaction");
+            const response = await deployer.sendTransaction({
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data
+            });
+            console.log(`Waiting for a transaction with nonce ${response.nonce}`);
+            await response.wait();
+            console.log("The transaction was sent");
+        }
     }
 }
 exports.EoaSubmitter = EoaSubmitter;

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

@@ -1,21 +1,13 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SafeImaLegacyMarionetteSubmitter = void 0;
 const hardhat_1 = require("hardhat");
 const safe_to_ima_submitter_1 = require("./safe-to-ima-submitter");
+const marionette_1 = require("./types/marionette");
 class SafeImaLegacyMarionetteSubmitter extends safe_to_ima_submitter_1.SafeToImaSubmitter {
     constructor() {
         super(...arguments);
-        this.marionette = new hardhat_1.ethers.Contract("0xD2c0DeFACe000000000000000000000000000000", new hardhat_1.ethers.utils.Interface([
+        this.marionette = new hardhat_1.ethers.Contract(marionette_1.MARIONETTE_ADDRESS, new hardhat_1.ethers.utils.Interface([
             {
                 "inputs": [
                     {
@@ -45,25 +37,21 @@ class SafeImaLegacyMarionetteSubmitter extends safe_to_ima_submitter_1.SafeToIma
                 "stateMutability": "pure",
                 "type": "function"
             }
-        ]));
+        ]), hardhat_1.ethers.provider);
     }
-    submit(transactions) {
-        const _super = Object.create(null, {
-            submit: { get: () => super.submit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (transactions.length > 1) {
-                this._atomicityWarning();
-            }
-            const transactionsToMarionette = [];
-            for (const transaction of transactions) {
-                transactionsToMarionette.push({
-                    to: this.marionette.address,
-                    data: yield this.marionette.functions["encodeFunctionCall"].call(transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero, transaction.value ? transaction.value : 0, transaction.data ? transaction.data : "0x")
-                });
-            }
-            yield _super.submit.call(this, transactionsToMarionette);
-        });
+    async submit(transactions) {
+        if (transactions.length > 1) {
+            this._atomicityWarning();
+        }
+        const transactionsToMarionette = [];
+        for (const transaction of transactions) {
+            transactionsToMarionette.push({
+                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")
+            });
+        }
+        await super.submit(transactionsToMarionette);
     }
 }
 exports.SafeImaLegacyMarionetteSubmitter = SafeImaLegacyMarionetteSubmitter;

package/dist/src/submitters/safe-ima-marionette-submitter.d.ts

@@ -0,0 +1,7 @@
+import { UnsignedTransaction } from "ethers";
+import { SafeToImaSubmitter } from "./safe-to-ima-submitter";
+import { Marionette } from "./types/marionette";
+export declare class SafeImaMarionetteSubmitter extends SafeToImaSubmitter {
+    marionette: Marionette;
+    submit(transactions: UnsignedTransaction[]): Promise<void>;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeImaMarionetteSubmitter = void 0;
+const hardhat_1 = require("hardhat");
+const safe_to_ima_submitter_1 = require("./safe-to-ima-submitter");
+const marionette_1 = require("./types/marionette");
+class SafeImaMarionetteSubmitter extends safe_to_ima_submitter_1.SafeToImaSubmitter {
+    constructor() {
+        super(...arguments);
+        this.marionette = new hardhat_1.ethers.Contract(marionette_1.MARIONETTE_ADDRESS, new hardhat_1.ethers.utils.Interface([
+            {
+                "inputs": [
+                    {
+                        "components": [
+                            {
+                                "internalType": "address",
+                                "name": "receiver",
+                                "type": "address"
+                            },
+                            {
+                                "internalType": "uint256",
+                                "name": "value",
+                                "type": "uint256"
+                            },
+                            {
+                                "internalType": "bytes",
+                                "name": "data",
+                                "type": "bytes"
+                            }
+                        ],
+                        "internalType": "struct IMarionette.FunctionCall[]",
+                        "name": "functionCalls",
+                        "type": "tuple[]"
+                    }
+                ],
+                "name": "encodeFunctionCalls",
+                "outputs": [
+                    {
+                        "internalType": "bytes",
+                        "name": "",
+                        "type": "bytes"
+                    }
+                ],
+                "stateMutability": "pure",
+                "type": "function"
+            }
+        ]), hardhat_1.ethers.provider);
+    }
+    async submit(transactions) {
+        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")
+            });
+        }
+        await super.submit([
+            {
+                to: this.marionette.address,
+                data: await this.marionette.encodeFunctionCalls(functionCalls)
+            }
+        ]);
+    }
+}
+exports.SafeImaMarionetteSubmitter = SafeImaMarionetteSubmitter;

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SafeSubmitter = void 0;
 const ethers_1 = require("ethers");
@@ -21,24 +12,22 @@ class SafeSubmitter extends submitter_1.Submitter {
         this.safeAddress = safeAddress;
         this.chainId = chainId;
     }
-    submit(transactions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const safeTransactions = [];
-            for (const transaction of transactions) {
-                safeTransactions.push((0, multiSend_1.encodeTransaction)(0, transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero, transaction.value ? ethers_1.BigNumber.from(transaction.value) : 0, transaction.data ? transaction.data.toString() : "0x"));
-            }
-            let privateKey = hardhat_1.network.config.accounts[0];
-            if (hardhat_1.network.config.accounts === "remote") {
-                // Don't have an information about private key
-                // Use random one because we most probable run tests
-                privateKey = hardhat_1.ethers.Wallet.createRandom().privateKey;
-            }
-            const safeTx = yield (0, gnosis_safe_1.createMultiSendTransaction)(hardhat_1.ethers, this.safeAddress, privateKey, safeTransactions);
-            if (!this.chainId) {
-                this.chainId = (yield hardhat_1.ethers.provider.getNetwork()).chainId;
-            }
-            yield (0, gnosis_safe_1.sendSafeTransaction)(this.safeAddress, this.chainId, safeTx);
-        });
+    async submit(transactions) {
+        const safeTransactions = [];
+        for (const transaction of transactions) {
+            safeTransactions.push((0, multiSend_1.encodeTransaction)(0, transaction.to ? transaction.to : hardhat_1.ethers.constants.AddressZero, transaction.value ? ethers_1.BigNumber.from(transaction.value) : 0, transaction.data ? transaction.data.toString() : "0x"));
+        }
+        let privateKey = hardhat_1.network.config.accounts[0];
+        if (hardhat_1.network.config.accounts === "remote") {
+            // Don't have an information about private key
+            // Use random one because we most probable run tests
+            privateKey = hardhat_1.ethers.Wallet.createRandom().privateKey;
+        }
+        if (!this.chainId) {
+            this.chainId = (await hardhat_1.ethers.provider.getNetwork()).chainId;
+        }
+        const safeTx = await (0, gnosis_safe_1.createMultiSendTransaction)(hardhat_1.ethers, this.safeAddress, privateKey, safeTransactions, this.chainId);
+        await (0, gnosis_safe_1.sendSafeTransaction)(this.safeAddress, this.chainId, safeTx);
     }
 }
 exports.SafeSubmitter = SafeSubmitter;

package/dist/src/submitters/safe-to-ima-submitter.d.ts

@@ -1,9 +1,11 @@
-import { BytesLike, Contract, UnsignedTransaction } from "ethers";
-import { SkaleABIFile } from "../types/SkaleABIFile";
+import { BytesLike, UnsignedTransaction } from "ethers";
 import { SafeSubmitter } from "./safe-submitter";
+import { Instance } from "@skalenetwork/skale-contracts";
 export declare class SafeToImaSubmitter extends SafeSubmitter {
-    messageProxyForMainnet: Contract;
+    imaInstance: Instance;
     targetSchainHash: BytesLike;
-    constructor(safeAddress: string, imaAbi: SkaleABIFile, targetSchainHash: BytesLike, chainId?: number);
+    private _messageProxyForMainnet;
+    constructor(safeAddress: string, imaInstance: Instance, targetSchainHash: BytesLike, chainId?: number);
     submit(transactions: UnsignedTransaction[]): Promise<void>;
+    private _getMessageProxyForMainnet;
 }

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

@@ -1,39 +1,31 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SafeToImaSubmitter = void 0;
-const hardhat_1 = require("hardhat");
 const safe_submitter_1 = require("./safe-submitter");
 class SafeToImaSubmitter extends safe_submitter_1.SafeSubmitter {
-    constructor(safeAddress, imaAbi, targetSchainHash, chainId) {
+    constructor(safeAddress, imaInstance, targetSchainHash, chainId) {
         super(safeAddress, chainId);
-        this.messageProxyForMainnet = new hardhat_1.ethers.Contract(imaAbi["message_proxy_mainnet_address"], new hardhat_1.ethers.utils.Interface(imaAbi["message_proxy_mainnet_address"]));
+        this.imaInstance = imaInstance;
         this.targetSchainHash = targetSchainHash;
     }
-    submit(transactions) {
-        const _super = Object.create(null, {
-            submit: { get: () => super.submit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (transactions.length > 1) {
-                this._atomicityWarning();
-            }
-            const transactionsToIma = transactions.map((transaction) => {
-                return {
-                    to: this.messageProxyForMainnet.address,
-                    data: this.messageProxyForMainnet.interface.encodeFunctionData("postOutgoingMessage", [this.targetSchainHash, transaction.to, transaction.data])
-                };
-            });
-            yield _super.submit.call(this, transactionsToIma);
+    async submit(transactions) {
+        if (transactions.length > 1) {
+            this._atomicityWarning();
+        }
+        const messageProxyForMainnet = await this._getMessageProxyForMainnet();
+        const 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() {
+        if (this._messageProxyForMainnet === undefined) {
+            this._messageProxyForMainnet = await this.imaInstance.getContract("MessageProxyForMainnet");
+        }
+        return this._messageProxyForMainnet;
     }
 }
 exports.SafeToImaSubmitter = SafeToImaSubmitter;

package/dist/src/submitters/types/marionette.d.ts

@@ -0,0 +1,13 @@
+import { BigNumberish, BytesLike } from "ethers";
+import { ethers as RawEthers } from "ethers";
+export declare const MARIONETTE_ADDRESS = "0xD2c0DeFACe000000000000000000000000000000";
+type FunctionCallStruct = {
+    receiver: string;
+    value: BigNumberish;
+    data: BytesLike;
+};
+export interface Marionette extends RawEthers.Contract {
+    encodeFunctionCalls(functionCalls: FunctionCallStruct[]): Promise<BytesLike>;
+    version(): Promise<string>;
+}
+export {};

package/dist/src/submitters/types/marionette.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARIONETTE_ADDRESS = void 0;
+exports.MARIONETTE_ADDRESS = "0xD2c0DeFACe000000000000000000000000000000";

package/dist/src/upgrader.d.ts

@@ -1,19 +1,18 @@
 import { UnsignedTransaction } from "ethers";
-import { SkaleABIFile } from "./types/SkaleABIFile";
 import { Submitter } from "./submitters/submitter";
+import { Instance } from "@skalenetwork/skale-contracts/lib/instance";
 export declare abstract class Upgrader {
-    abi: SkaleABIFile;
+    instance: Instance;
     targetVersion: string;
     contractNamesToUpgrade: string[];
     projectName: string;
     transactions: UnsignedTransaction[];
     submitter: Submitter;
-    constructor(projectName: string, targetVersion: string, abi: SkaleABIFile, contractNamesToUpgrade: string[], submitter?: Submitter);
+    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>;
     upgrade(): Promise<void>;
     _getContractFactoryAndUpdateManifest(contract: string): Promise<import("ethers").ContractFactory>;
-    _getContractKeyInAbiFile(contract: string): string;
 }