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

package/README.md

@@ -4,19 +4,74 @@ Scripts to support upgrades of smart contracts. The package contains common used
 
 ## Upgrade scripts
 
-To write upgrade script import `upgrade` function.
+To write an upgrade script extend `Upgrader` class.
 
 ```typescript
-import { upgrade } from "@skalenetwork/upgrade-tools"
+import { Upgrader } from "@skalenetwork/upgrade-tools";
+
+class ExampleContractUpgrader extends Upgrader {
+
+    getDeployedVersion = async () => {
+        return await (await this.getExampleContract()).version();
+    };
+
+    setVersion = async (newVersion: string) => {
+        const exampleContract = await this.getExampleContract();
+        const setVersionTransaction = {
+            to: exampleContract.address,
+            data: exampleContract.interface.encodeFunctionData("setVersion", [newVersion])
+        };
+        this.transactions.push(setVersionTransaction);
+    }
+
+    async getExampleContract() {
+        return await ethers.getContractAt("ExampleContract", this.abi["example_contract_address"] as string);
+    }
+}
+
+async function main() {
+    const abi = JSON.parse(await fs.readFile(process.env.ABI, "utf-8")) as SkaleABIFile;
+
+    const upgrader = new ExampleContractUpgrader(
+        "ExampleContract",
+        "1.0.0",
+        abi,
+        ["ExampleContract"]
+    );
+
+    await upgrader.upgrade();
+}
+
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch(error => {
+            console.error(error);
+            process.exit(1);
+        });
+}
+```
+
+### Abstract functions
+
+The `Upgrader` has 2 abstract functions. It's mandatory to override them:
+
+```typescript
+abstract getDeployedVersion: () => Promise<string | undefined>
+abstract setVersion: (newVersion: string) => Promise<void>
 ```
 
-Then call it with parameters below:
+- `getDeployedVersion` returns string representing a deployed version of the contract
+- `setVersion` creates a transaction to set a new version of the contract
+
+### Protected functions
+
+There are functions that may be overridden to customize an upgrade process
+
+```typescript
+deployNewContracts = () => { return Promise.resolve() };
+initialize = () => { return Promise.resolve() };
+```
 
-- `projectName` - project name
-- `targetVersion` - version of smart contracts that can be upgraded by the script
-- `getDeployedVersion` - a function to request current version from smart contracts
-- `setVersion` - function that sets version to smart contracts
-- `safeMockAccessRequirements` - list of smart contracts that requires ownership changing for successful upgrade (when EOA + SafeMock are used during upgrade)
-- `contractNamesToUpgrade` - list of smart contracts to upgrade
-- `deployNewContracts` - optional - a function that deploys new smart contracts
-- `initialize` - optional - a function that setup smart contracts after upgrade
+- `deployNewContracts` is called before proxies upgrade and is used to deploy new instances
+- `initialize` is called after proxies upgrade and is used to send initializing transactions

package/dist/hardhat.config.js

@@ -18,6 +18,7 @@ const config = {
         ]
     },
     typechain: {
+        target: "ethers-v5",
         externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json']
     }
 };

package/dist/src/deploy.js

@@ -1,34 +1,21 @@
 "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.getContractFactory = exports.getManifestFile = exports.getLinkedContractFactory = exports.deployLibraries = void 0;
 const upgrades_core_1 = require("@openzeppelin/upgrades-core");
 const hardhat_1 = require("hardhat");
 const fs_1 = require("fs");
-function _deployLibrary(libraryName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const Library = yield hardhat_1.ethers.getContractFactory(libraryName);
-        const library = yield Library.deploy();
-        yield library.deployed();
-        return library.address;
-    });
+async function _deployLibrary(libraryName) {
+    const Library = await hardhat_1.ethers.getContractFactory(libraryName);
+    const library = await Library.deploy();
+    await library.deployed();
+    return library.address;
 }
-function deployLibraries(libraryNames) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const libraries = new Map();
-        for (const libraryName of libraryNames) {
-            libraries.set(libraryName, yield _deployLibrary(libraryName));
-        }
-        return libraries;
-    });
+async function deployLibraries(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) {
@@ -49,49 +36,43 @@ function _linkBytecode(artifact, libraries) {
     }
     return bytecode;
 }
-function getLinkedContractFactory(contractName, libraries) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const cArtifact = yield hardhat_1.artifacts.readArtifact(contractName);
-        const linkedBytecode = _linkBytecode(cArtifact, libraries);
-        const ContractFactory = yield hardhat_1.ethers.getContractFactory(cArtifact.abi, linkedBytecode);
-        return ContractFactory;
-    });
+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;
-function getManifestFile() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield 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;
-function getContractFactory(contract) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { linkReferences } = yield hardhat_1.artifacts.readArtifact(contract);
-        if (!Object.keys(linkReferences).length)
-            return yield 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 = yield deployLibraries(libraryNames);
-        const libraryArtifacts = {};
-        for (const [libraryName, libraryAddress] of libraries.entries()) {
-            const { bytecode } = yield hardhat_1.artifacts.readArtifact(libraryName);
-            libraryArtifacts[libraryName] = { "address": libraryAddress, "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode) };
-        }
-        let manifest;
-        try {
-            manifest = JSON.parse(yield fs_1.promises.readFile(yield getManifestFile(), "utf-8"));
-            Object.assign(libraryArtifacts, manifest.libraries);
-        }
-        finally {
-            if (manifest !== undefined) {
-                Object.assign(manifest, { libraries: libraryArtifacts });
-            }
-            yield fs_1.promises.writeFile(yield getManifestFile(), JSON.stringify(manifest, null, 4));
+async function getContractFactory(contract) {
+    const { linkReferences } = await hardhat_1.artifacts.readArtifact(contract);
+    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 deployLibraries(libraryNames);
+    const libraryArtifacts = {};
+    for (const [libraryName, libraryAddress] of libraries.entries()) {
+        const { bytecode } = await hardhat_1.artifacts.readArtifact(libraryName);
+        libraryArtifacts[libraryName] = { "address": libraryAddress, "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode) };
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(await fs_1.promises.readFile(await getManifestFile(), "utf-8"));
+        Object.assign(libraryArtifacts, manifest.libraries);
+    }
+    finally {
+        if (manifest !== undefined) {
+            Object.assign(manifest, { libraries: libraryArtifacts });
         }
-        return yield getLinkedContractFactory(contract, libraries);
-    });
+        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,6 +1,6 @@
 import { ethers } from "ethers";
 import { HardhatEthersHelpers } from "@nomiclabs/hardhat-ethers/types";
-declare type Ethers = typeof ethers & HardhatEthersHelpers;
+type Ethers = typeof ethers & HardhatEthersHelpers;
 interface SafeMultisigTransaction {
     safe: string;
     to: string;
@@ -20,6 +20,6 @@ interface SafeMultisigTransaction {
 }
 export declare function getSafeTransactionUrl(chainId: number): string;
 export declare function getSafeRelayUrl(chainId: number): string;
-export declare function createMultiSendTransaction(ethers: Ethers, safeAddress: string, privateKey: string, transactions: string[], nonce?: number): Promise<SafeMultisigTransaction>;
+export declare function createMultiSendTransaction(ethers: Ethers, safeAddress: string, privateKey: string, transactions: string[], chainId: number, nonce?: number): Promise<SafeMultisigTransaction>;
 export declare function sendSafeTransaction(safe: string, chainId: number, safeTx: SafeMultisigTransaction): Promise<void>;
 export {};

package/dist/src/gnosis-safe.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -87,102 +78,99 @@ function getSafeRelayUrl(chainId) {
     }
 }
 exports.getSafeRelayUrl = getSafeRelayUrl;
-function createMultiSendTransaction(ethers, safeAddress, privateKey, transactions, nonce) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const chainId = (yield ethers.provider.getNetwork()).chainId;
-        const multiSendAddress = getMultiSendAddress(chainId);
-        const multiSendAbi = [{ "constant": false, "inputs": [{ "internalType": "bytes", "name": "transactions", "type": "bytes" }], "name": "multiSend", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }];
-        const multiSend = new ethers.Contract(multiSendAddress, new ethers.utils.Interface(multiSendAbi), ethers.provider);
-        const safeAbi = [{ "constant": true, "inputs": [{ "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "value", "type": "uint256" }, { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "enum Enum.Operation", "name": "operation", "type": "uint8" }, { "internalType": "uint256", "name": "safeTxGas", "type": "uint256" }, { "internalType": "uint256", "name": "baseGas", "type": "uint256" }, { "internalType": "uint256", "name": "gasPrice", "type": "uint256" }, { "internalType": "address", "name": "gasToken", "type": "address" }, { "internalType": "address", "name": "refundReceiver", "type": "address" }, { "internalType": "uint256", "name": "_nonce", "type": "uint256" }], "name": "getTransactionHash", "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }], "payable": false, "stateMutability": "view", "type": "function" }];
-        const safe = new ethers.Contract(safeAddress, new ethers.utils.Interface(safeAbi), ethers.provider);
-        let nonceValue = 0;
-        if (nonce === undefined) {
-            try {
-                if (process.env.NONCE) {
-                    // NONCE variable is set
-                    if (isNaN(Number.parseInt(process.env.NONCE))) {
-                        // NONCE variable is not a number
-                        if (process.env.NONCE.toLowerCase() === "pending") {
-                            nonceValue = yield getSafeNonceWithPending(chainId, safeAddress);
-                        }
-                        else {
-                            nonceValue = yield getSafeNonce(chainId, safeAddress);
-                        }
+async function createMultiSendTransaction(ethers, safeAddress, privateKey, transactions, chainId, nonce) {
+    const multiSendAddress = getMultiSendAddress(chainId);
+    const multiSendAbi = [{ "constant": false, "inputs": [{ "internalType": "bytes", "name": "transactions", "type": "bytes" }], "name": "multiSend", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }];
+    const multiSend = new ethers.Contract(multiSendAddress, new ethers.utils.Interface(multiSendAbi), ethers.provider);
+    let nonceValue = 0;
+    if (nonce === undefined) {
+        try {
+            if (process.env.NONCE) {
+                // NONCE variable is set
+                if (isNaN(Number.parseInt(process.env.NONCE))) {
+                    // NONCE variable is not a number
+                    if (process.env.NONCE.toLowerCase() === "pending") {
+                        nonceValue = await getSafeNonceWithPending(chainId, safeAddress);
                     }
                     else {
-                        // NONCE variable is a number
-                        nonceValue = Number.parseInt(process.env.NONCE);
+                        nonceValue = await getSafeNonce(chainId, safeAddress);
                     }
                 }
                 else {
-                    // NONCE variable is not set
-                    nonceValue = yield getSafeNonce(chainId, safeAddress);
+                    // NONCE variable is a number
+                    nonceValue = Number.parseInt(process.env.NONCE);
                 }
             }
-            catch (e) {
-                if (!(e instanceof Error) || !e.toString().startsWith("Error: Can't get safe-transaction url")) {
-                    throw e;
-                }
+            else {
+                // NONCE variable is not set
+                nonceValue = await getSafeNonce(chainId, safeAddress);
             }
         }
-        else {
-            nonceValue = nonce;
+        catch (e) {
+            if (!(e instanceof Error) || !e.toString().startsWith("Error: Can't get safe-transaction url")) {
+                throw e;
+            }
         }
-        console.log("Will send tx to Gnosis with nonce", nonceValue);
-        const tx = {
-            "safe": safeAddress,
-            "to": multiSend.address,
-            "value": 0,
-            "data": multiSend.interface.encodeFunctionData("multiSend", [concatTransactions(transactions)]),
-            "operation": 1,
-            "gasToken": ethers.constants.AddressZero,
-            "safeTxGas": 0,
-            "baseGas": 0,
-            "gasPrice": 0,
-            "refundReceiver": ethers.constants.AddressZero,
-            "nonce": nonceValue, // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
-        };
-        const digestHex = yield safe.getTransactionHash(tx.to, tx.value, tx.data, tx.operation, tx.safeTxGas, tx.baseGas, tx.gasPrice, tx.gasToken, tx.refundReceiver, tx.nonce);
-        const privateKeyBuffer = ethUtil.toBuffer(privateKey);
-        const { r, s, v } = ethUtil.ecsign(ethUtil.toBuffer(digestHex), privateKeyBuffer);
-        const signature = ethUtil.toRpcSig(v, r, s).toString();
-        const txToSend = Object.assign(Object.assign({}, tx), { "contractTransactionHash": digestHex, 
-            // Owner of the Safe proposing the transaction. Must match one of the signatures
-            "sender": ethers.utils.getAddress(ethUtil.bufferToHex(ethUtil.privateToAddress(privateKeyBuffer))), "signature": signature, "origin": "Upgrade skale-manager" // Give more information about the transaction, e.g. "My Custom Safe app"
-         });
-        return txToSend;
-    });
+    }
+    else {
+        nonceValue = nonce;
+    }
+    console.log("Will send tx to Gnosis with nonce", nonceValue);
+    const tx = {
+        "safe": safeAddress,
+        "to": multiSend.address,
+        "value": 0,
+        "data": multiSend.interface.encodeFunctionData("multiSend", [concatTransactions(transactions)]),
+        "operation": 1,
+        "gasToken": ethers.constants.AddressZero,
+        "safeTxGas": 0,
+        "baseGas": 0,
+        "gasPrice": 0,
+        "refundReceiver": ethers.constants.AddressZero,
+        "nonce": nonceValue, // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
+    };
+    const digestHex = getTransactionHash(tx.to, tx.value, tx.data, tx.operation, tx.safeTxGas, tx.baseGas, tx.gasPrice, tx.gasToken, tx.refundReceiver, tx.nonce, safeAddress, chainId);
+    const privateKeyBuffer = ethUtil.toBuffer(privateKey);
+    const { r, s, v } = ethUtil.ecsign(ethUtil.toBuffer(digestHex), privateKeyBuffer);
+    const signature = ethUtil.toRpcSig(v, r, s).toString();
+    const txToSend = {
+        ...tx,
+        "contractTransactionHash": digestHex,
+        // Owner of the Safe proposing the transaction. Must match one of the signatures
+        "sender": ethers.utils.getAddress(ethUtil.bufferToHex(ethUtil.privateToAddress(privateKeyBuffer))),
+        "signature": signature,
+        "origin": "Upgrade skale-manager" // Give more information about the transaction, e.g. "My Custom Safe app"
+    };
+    return txToSend;
 }
 exports.createMultiSendTransaction = createMultiSendTransaction;
-function sendSafeTransaction(safe, chainId, safeTx) {
-    return __awaiter(this, void 0, void 0, function* () {
+async function sendSafeTransaction(safe, chainId, safeTx) {
+    try {
+        console.log("Estimate gas");
+        const estimateRequest = safeTx;
         try {
-            console.log("Estimate gas");
-            const estimateRequest = safeTx;
-            try {
-                const estimateResponse = yield axios_1.default.post(`${getSafeRelayUrl(chainId)}/api/v2/safes/${safe}/transactions/estimate/`, estimateRequest);
-                console.log(chalk_1.default.cyan(`Recommend to set gas limit to ${parseInt(estimateResponse.data.safeTxGas, 10) + parseInt(estimateResponse.data.baseGas, 10)}`));
-            }
-            catch (e) {
-                console.log(chalk_1.default.red("Failed to estimate gas"));
-                console.log(e);
-            }
-            console.log(chalk_1.default.green("Send transaction to gnosis safe"));
-            yield axios_1.default.post(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safe}/multisig-transactions/`, safeTx);
+            const estimateResponse = await axios_1.default.post(`${getSafeRelayUrl(chainId)}/api/v2/safes/${safe}/transactions/estimate/`, estimateRequest);
+            console.log(chalk_1.default.cyan(`Recommend to set gas limit to ${parseInt(estimateResponse.data.safeTxGas, 10) + parseInt(estimateResponse.data.baseGas, 10)}`));
         }
         catch (e) {
-            if (axios_1.default.isAxiosError(e)) {
-                if (e.response) {
-                    console.log(JSON.stringify(e.response.data, null, 4));
-                    console.log(chalk_1.default.red(`Request failed with ${e.response.status} code`));
-                }
-                else {
-                    console.log(chalk_1.default.red("Request failed with unknown reason"));
-                }
+            console.log(chalk_1.default.red("Failed to estimate gas"));
+            console.log(e);
+        }
+        console.log(chalk_1.default.green("Send transaction to gnosis safe"));
+        await axios_1.default.post(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safe}/multisig-transactions/`, safeTx);
+    }
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            if (e.response) {
+                console.log(JSON.stringify(e.response.data, null, 4));
+                console.log(chalk_1.default.red(`Request failed with ${e.response.status} code`));
+            }
+            else {
+                console.log(chalk_1.default.red("Request failed with unknown reason"));
             }
-            throw e;
         }
-    });
+        throw e;
+    }
 }
 exports.sendSafeTransaction = sendSafeTransaction;
 // private functions
@@ -207,20 +195,58 @@ function concatTransactions(transactions) {
         }
     }).join("");
 }
-function getSafeNonce(chainId, safeAddress) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const safeInfo = yield axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/`);
-        return safeInfo.data.nonce;
-    });
+async function getSafeNonce(chainId, safeAddress) {
+    const safeInfo = await axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/`);
+    return safeInfo.data.nonce;
 }
-function getSafeNonceWithPending(chainId, safeAddress) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const allTransactions = yield axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/all-transactions/?executed=false&queued=true&trusted=true`);
-        if (allTransactions.data.results.length > 0) {
-            return allTransactions.data.results[0].nonce + 1;
-        }
-        else {
-            return 0;
-        }
-    });
+async function getSafeNonceWithPending(chainId, safeAddress) {
+    const allTransactions = await axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/all-transactions/?executed=false&queued=true&trusted=true`);
+    if (allTransactions.data.results.length > 0) {
+        return allTransactions.data.results[0].nonce + 1;
+    }
+    else {
+        return 0;
+    }
+}
+function getDomainSeparator(safeAddress, chainId) {
+    const DOMAIN_SEPARATOR_TYPEHASH = "0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218";
+    return ethers_1.ethers.utils.solidityKeccak256(["bytes"], [
+        ethers_1.ethers.utils.defaultAbiCoder.encode(["bytes32", "uint256", "address"], [DOMAIN_SEPARATOR_TYPEHASH, chainId, safeAddress])
+    ]);
+}
+function encodeTransactionData(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce, safeAddress, chainId) {
+    const dataHash = ethers_1.ethers.utils.solidityKeccak256(["bytes"], [data]);
+    const SAFE_TX_TYPEHASH = "0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8";
+    const encoded = ethers_1.ethers.utils.defaultAbiCoder.encode([
+        "bytes32",
+        "address",
+        "uint256",
+        "bytes32",
+        "uint256",
+        "uint256",
+        "uint256",
+        "uint256",
+        "address",
+        "address",
+        "uint256"
+    ], [
+        SAFE_TX_TYPEHASH,
+        to,
+        value,
+        dataHash,
+        operation,
+        safeTxGas,
+        baseGas,
+        gasPrice,
+        gasToken,
+        refundReceiver,
+        _nonce
+    ]);
+    const encodedHash = ethers_1.ethers.utils.solidityKeccak256(["bytes"], [encoded]);
+    return ethers_1.ethers.utils.solidityPack(["bytes1", "bytes1", "bytes32", "bytes32"], ["0x19", "0x01", getDomainSeparator(safeAddress, chainId), encodedHash]);
+}
+function getTransactionHash(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce, safeAddress, chainId) {
+    return ethers_1.ethers.utils.solidityKeccak256(["bytes"], [
+        encodeTransactionData(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce, safeAddress, chainId)
+    ]);
 }

package/dist/src/index.d.ts

@@ -2,7 +2,7 @@ export * from "./abi";
 export * from "./deploy";
 export * from "./gnosis-safe";
 export * from "./multiSend";
-export * from "./upgrade";
+export * from "./submitters";
 export * from "./verification";
 export * from "./version";
 export * from "./upgrader";

package/dist/src/index.js

@@ -18,7 +18,7 @@ __exportStar(require("./abi"), exports);
 __exportStar(require("./deploy"), exports);
 __exportStar(require("./gnosis-safe"), exports);
 __exportStar(require("./multiSend"), exports);
-__exportStar(require("./upgrade"), exports);
+__exportStar(require("./submitters"), exports);
 __exportStar(require("./verification"), exports);
 __exportStar(require("./version"), exports);
 __exportStar(require("./upgrader"), exports);

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

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