@skalenetwork/upgrade-tools 1.0.0 → 2.0.0-develop.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,7 +18,7 @@ const config = {
         ]
     },
     typechain: {
-        externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/*.json']
+        externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json']
     }
 };
 exports.default = config;

package/dist/src/deploy.d.ts

@@ -1,5 +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 getContractKeyInAbiFile(contract: string): string;
 export declare function getManifestFile(): Promise<string>;
 export declare function getContractFactory(contract: string): Promise<import("ethers").ContractFactory>;

package/dist/src/deploy.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractFactory = exports.getManifestFile = exports.getContractKeyInAbiFile = exports.getLinkedContractFactory = exports.deployLibraries = void 0;
+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");
@@ -58,10 +58,6 @@ function getLinkedContractFactory(contractName, libraries) {
     });
 }
 exports.getLinkedContractFactory = getLinkedContractFactory;
-function getContractKeyInAbiFile(contract) {
-    return contract.replace(/([a-zA-Z])(?=[A-Z])/g, '$1_').toLowerCase();
-}
-exports.getContractKeyInAbiFile = getContractKeyInAbiFile;
 function getManifestFile() {
     return __awaiter(this, void 0, void 0, function* () {
         return (yield upgrades_core_1.Manifest.forNetwork(hardhat_1.ethers.provider)).file;
@@ -90,7 +86,9 @@ function getContractFactory(contract) {
             Object.assign(libraryArtifacts, manifest.libraries);
         }
         finally {
-            Object.assign(manifest, { libraries: libraryArtifacts });
+            if (manifest !== undefined) {
+                Object.assign(manifest, { libraries: libraryArtifacts });
+            }
             yield fs_1.promises.writeFile(yield getManifestFile(), JSON.stringify(manifest, null, 4));
         }
         return yield getLinkedContractFactory(contract, libraries);

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

@@ -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[], isSafeMock?: boolean): 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

@@ -44,44 +44,33 @@ var Network;
 (function (Network) {
     Network[Network["MAINNET"] = 1] = "MAINNET";
     Network[Network["RINKEBY"] = 4] = "RINKEBY";
+    Network[Network["GOERLI"] = 5] = "GOERLI";
     Network[Network["GANACHE"] = 1337] = "GANACHE";
     Network[Network["HARDHAT"] = 31337] = "HARDHAT";
 })(Network || (Network = {}));
+// constants
 const ADDRESSES = {
     multiSend: {
         [Network.MAINNET]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
         [Network.RINKEBY]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
+        [Network.GOERLI]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
     },
 };
 const URLS = {
     safe_transaction: {
         [Network.MAINNET]: "https://safe-transaction.mainnet.gnosis.io",
         [Network.RINKEBY]: "https://safe-transaction.rinkeby.gnosis.io",
+        [Network.GOERLI]: "https://safe-transaction.goerli.gnosis.io",
     },
     safe_relay: {
         [Network.MAINNET]: "https://safe-relay.mainnet.gnosis.io",
         [Network.RINKEBY]: "https://safe-relay.rinkeby.gnosis.io",
+        [Network.GOERLI]: "https://safe-relay.goerli.gnosis.io",
     }
 };
-function getMultiSendAddress(chainId) {
-    if (chainId === Network.MAINNET) {
-        return ADDRESSES.multiSend[chainId];
-    }
-    else if (chainId === Network.RINKEBY) {
-        return ADDRESSES.multiSend[chainId];
-    }
-    else if ([Network.GANACHE, Network.HARDHAT].includes(chainId)) {
-        return ethers_1.ethers.constants.AddressZero;
-    }
-    else {
-        throw Error(`Can't get multiSend contract at network with chainId = ${chainId}`);
-    }
-}
+// public functions
 function getSafeTransactionUrl(chainId) {
-    if (chainId === Network.MAINNET) {
-        return URLS.safe_transaction[chainId];
-    }
-    else if (chainId === 4) {
+    if (Object.keys(URLS.safe_transaction).includes(chainId.toString())) {
         return URLS.safe_transaction[chainId];
     }
     else {
@@ -90,10 +79,7 @@ function getSafeTransactionUrl(chainId) {
 }
 exports.getSafeTransactionUrl = getSafeTransactionUrl;
 function getSafeRelayUrl(chainId) {
-    if (chainId === 1) {
-        return URLS.safe_relay[chainId];
-    }
-    else if (chainId === 4) {
+    if (Object.keys(URLS.safe_relay).includes(chainId.toString())) {
         return URLS.safe_relay[chainId];
     }
     else {
@@ -101,29 +87,34 @@ function getSafeRelayUrl(chainId) {
     }
 }
 exports.getSafeRelayUrl = getSafeRelayUrl;
-function concatTransactions(transactions) {
-    return "0x" + transactions.map((transaction) => {
-        if (transaction.startsWith("0x")) {
-            return transaction.slice(2);
-        }
-        else {
-            return transaction;
-        }
-    }).join("");
-}
-function createMultiSendTransaction(ethers, safeAddress, privateKey, transactions, isSafeMock = false) {
+function createMultiSendTransaction(ethers, safeAddress, privateKey, transactions, chainId, 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 nonce = 0;
-        if (!isSafeMock) {
+        let nonceValue = 0;
+        if (nonce === undefined) {
             try {
-                const nonceResponse = yield axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/`);
-                nonce = nonceResponse.data.nonce;
+                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);
+                        }
+                    }
+                    else {
+                        // NONCE variable is a number
+                        nonceValue = Number.parseInt(process.env.NONCE);
+                    }
+                }
+                else {
+                    // NONCE variable is not set
+                    nonceValue = yield getSafeNonce(chainId, safeAddress);
+                }
             }
             catch (e) {
                 if (!(e instanceof Error) || !e.toString().startsWith("Error: Can't get safe-transaction url")) {
@@ -131,6 +122,10 @@ function createMultiSendTransaction(ethers, safeAddress, privateKey, transaction
                 }
             }
         }
+        else {
+            nonceValue = nonce;
+        }
+        console.log("Will send tx to Gnosis with nonce", nonceValue);
         const tx = {
             "safe": safeAddress,
             "to": multiSend.address,
@@ -142,9 +137,9 @@ function createMultiSendTransaction(ethers, safeAddress, privateKey, transaction
             "baseGas": 0,
             "gasPrice": 0,
             "refundReceiver": ethers.constants.AddressZero,
-            "nonce": nonce, // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
+            "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 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();
@@ -187,3 +182,84 @@ function sendSafeTransaction(safe, chainId, safeTx) {
     });
 }
 exports.sendSafeTransaction = sendSafeTransaction;
+// private functions
+function getMultiSendAddress(chainId) {
+    if ([Network.GANACHE, Network.HARDHAT].includes(chainId)) {
+        return ethers_1.ethers.constants.AddressZero;
+    }
+    else if (Object.keys(ADDRESSES.multiSend).includes(chainId.toString())) {
+        return ADDRESSES.multiSend[chainId];
+    }
+    else {
+        throw Error(`Can't get multiSend contract at network with chainId = ${chainId}`);
+    }
+}
+function concatTransactions(transactions) {
+    return "0x" + transactions.map((transaction) => {
+        if (transaction.startsWith("0x")) {
+            return transaction.slice(2);
+        }
+        else {
+            return transaction;
+        }
+    }).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;
+    });
+}
+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;
+        }
+    });
+}
+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 "./types";
+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("./types"), 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

@@ -0,0 +1,11 @@
+import { UnsignedTransaction } from "ethers";
+import { Submitter } from "./submitter";
+import { SkaleABIFile } from "../types/SkaleABIFile";
+export declare class AutoSubmitter extends Submitter {
+    submit(transactions: UnsignedTransaction[]): Promise<void>;
+    _getImaAbi(): Promise<SkaleABIFile>;
+    _getSafeAddress(): string;
+    _getSchainHash(): string;
+    _getMainnetChainId(): number;
+    _versionFunctionExists(): Promise<boolean>;
+}

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

@@ -0,0 +1,176 @@
+"use strict";
+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 __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 };
+};
+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 = __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 fs_1 = require("fs");
+const marionette_1 = require("./types/marionette");
+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();
+            }
+            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 imaAbi = yield this._getImaAbi();
+                    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, imaAbi, schainHash, mainnetChainId);
+                }
+                else {
+                    // assuming owner is a Gnosis Safe
+                    console.log("Using Gnosis Safe");
+                    submitter = new safe_submitter_1.SafeSubmitter(owner);
+                }
+            }
+            yield submitter.submit(transactions);
+        });
+    }
+    // private
+    _getImaAbi() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!process.env.IMA_ABI) {
+                console.log(chalk_1.default.red("Set path to ima abi to IMA_ABI environment variable"));
+                process.exit(1);
+            }
+            return JSON.parse(yield fs_1.promises.readFile(process.env.IMA_ABI, "utf-8"));
+        });
+    }
+    _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);
+        }
+    }
+    _versionFunctionExists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bytecode = yield 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 {
+                yield marionette.estimateGas.version();
+                return true;
+            }
+            catch (_a) {
+                // 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.d.ts

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

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

@@ -0,0 +1,34 @@
+"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");
+            }
+        });
+    }
+}
+exports.EoaSubmitter = EoaSubmitter;

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

@@ -0,0 +1,6 @@
+export * from "./auto-submitter";
+export * from "./eoa-submitter";
+export * from "./safe-ima-legacy-marionette-submitter";
+export * from "./safe-submitter";
+export * from "./safe-to-ima-submitter";
+export * from "./submitter";

package/dist/src/submitters/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auto-submitter"), exports);
+__exportStar(require("./eoa-submitter"), exports);
+__exportStar(require("./safe-ima-legacy-marionette-submitter"), exports);
+__exportStar(require("./safe-submitter"), exports);
+__exportStar(require("./safe-to-ima-submitter"), exports);
+__exportStar(require("./submitter"), exports);

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

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