@skalenetwork/upgrade-tools 0.0.1-custom.1 → 0.0.1-custom.2

package/dist/abi.d.ts

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

package/dist/abi.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbi = void 0;
+function getAbi(contractInterface) {
+    const abi = JSON.parse(contractInterface.format("json"));
+    abi.forEach((obj) => {
+        if (obj.type === "function") {
+            const func = obj;
+            func.inputs.concat(func.outputs).forEach((output) => {
+                Object.assign(output, Object.assign({ name: "" }, output));
+            });
+        }
+    });
+    return abi;
+}
+exports.getAbi = getAbi;

package/dist/gnosis-safe.d.ts

@@ -0,0 +1,25 @@
+import type { ethers } from "ethers";
+import { HardhatEthersHelpers } from "@nomiclabs/hardhat-ethers/types";
+declare type Ethers = typeof ethers & HardhatEthersHelpers;
+interface SafeMultisigTransaction {
+    safe: string;
+    to: string;
+    value: number;
+    data?: string;
+    operation: number;
+    gasToken?: string;
+    safeTxGas: number;
+    baseGas: number;
+    gasPrice: number;
+    refundReceiver?: string;
+    nonce: number;
+    contractTransactionHash: string;
+    sender: string;
+    signature?: string;
+    origin?: string;
+}
+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 sendSafeTransaction(safe: string, chainId: number, safeTx: SafeMultisigTransaction): Promise<void>;
+export {};

package/dist/gnosis-safe.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.sendSafeTransaction = exports.createMultiSendTransaction = exports.getSafeRelayUrl = exports.getSafeTransactionUrl = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ethers_eip712_1 = require("ethers-eip712");
+const ethUtil = __importStar(require("ethereumjs-util"));
+const chalk_1 = __importDefault(require("chalk"));
+var Network;
+(function (Network) {
+    Network[Network["MAINNET"] = 1] = "MAINNET";
+    Network[Network["RINKEBY"] = 4] = "RINKEBY";
+    Network[Network["GANACHE"] = 1337] = "GANACHE";
+    Network[Network["HARDHAT"] = 31337] = "HARDHAT";
+})(Network || (Network = {}));
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const ADDRESSES = {
+    multiSend: {
+        [Network.MAINNET]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
+        [Network.RINKEBY]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
+    },
+};
+const URLS = {
+    safe_transaction: {
+        [Network.MAINNET]: "https://safe-transaction.mainnet.gnosis.io",
+        [Network.RINKEBY]: "https://safe-transaction.rinkeby.gnosis.io",
+    },
+    safe_relay: {
+        [Network.MAINNET]: "https://safe-relay.mainnet.gnosis.io",
+        [Network.RINKEBY]: "https://safe-relay.rinkeby.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 ZERO_ADDRESS;
+    }
+    else {
+        throw Error(`Can't get multiSend contract at network with chainId = ${chainId}`);
+    }
+}
+function getSafeTransactionUrl(chainId) {
+    if (chainId === Network.MAINNET) {
+        return URLS.safe_transaction[chainId];
+    }
+    else if (chainId === 4) {
+        return URLS.safe_transaction[chainId];
+    }
+    else {
+        throw Error(`Can't get safe-transaction url at network with chainId = ${chainId}`);
+    }
+}
+exports.getSafeTransactionUrl = getSafeTransactionUrl;
+function getSafeRelayUrl(chainId) {
+    if (chainId === 1) {
+        return URLS.safe_relay[chainId];
+    }
+    else if (chainId === 4) {
+        return URLS.safe_relay[chainId];
+    }
+    else {
+        throw Error(`Can't get safe-relay url at network with chainId = ${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) {
+    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);
+        let nonce = 0;
+        if (!isSafeMock) {
+            try {
+                const nonceResponse = yield axios_1.default.get(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/`);
+                nonce = nonceResponse.data.nonce;
+            }
+            catch (e) {
+                if (!(e instanceof Error) || !e.toString().startsWith("Error: Can't get safe-transaction url")) {
+                    throw e;
+                }
+            }
+        }
+        const tx = {
+            "safe": safeAddress,
+            "to": multiSend.address,
+            "value": 0,
+            "data": multiSend.interface.encodeFunctionData("multiSend", [concatTransactions(transactions)]),
+            "operation": 1,
+            "gasToken": ZERO_ADDRESS,
+            "safeTxGas": 0,
+            "baseGas": 0,
+            "gasPrice": 0,
+            "refundReceiver": ZERO_ADDRESS,
+            "nonce": nonce, // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
+        };
+        const typedData = {
+            types: {
+                EIP712Domain: [
+                    { name: "verifyingContract", type: "address" },
+                ],
+                SafeTx: [
+                    { type: "address", name: "to" },
+                    { type: "uint256", name: "value" },
+                    { type: "bytes", name: "data" },
+                    { type: "uint8", name: "operation" },
+                    { type: "uint256", name: "safeTxGas" },
+                    { type: "uint256", name: "baseGas" },
+                    { type: "uint256", name: "gasPrice" },
+                    { type: "address", name: "gasToken" },
+                    { type: "address", name: "refundReceiver" },
+                    { type: "uint256", name: "nonce" },
+                ]
+            },
+            primaryType: 'SafeTx',
+            domain: {
+                verifyingContract: safeAddress
+            },
+            message: Object.assign(Object.assign({}, tx), { data: ethers.utils.arrayify(tx.data) })
+        };
+        const digest = ethers_eip712_1.TypedDataUtils.encodeDigest(typedData);
+        const digestHex = ethers.utils.hexlify(digest);
+        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;
+    });
+}
+exports.createMultiSendTransaction = createMultiSendTransaction;
+function sendSafeTransaction(safe, chainId, safeTx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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);
+        }
+        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;
+        }
+    });
+}
+exports.sendSafeTransaction = sendSafeTransaction;

package/{src/hardhat.config.ts → dist/hardhat.config.d.ts}

@@ -1,6 +1,4 @@
 import { HardhatUserConfig } from "hardhat/config";
 import "@nomiclabs/hardhat-ethers";
-
-const config: HardhatUserConfig = {};
-
+declare const config: HardhatUserConfig;
 export default config;

package/dist/hardhat.config.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@nomiclabs/hardhat-ethers");
+const config = {};
+exports.default = config;

package/dist/multiSend.d.ts

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

package/{src/multiSend.ts → dist/multiSend.js}

@@ -1,33 +1,32 @@
-import { BigNumber } from "ethers";
-
-function padWithZeros(value: string, targetLength: number) {
+"use strict";
+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);
 }
-
-export function encodeTransaction(operation: 0 | 1, to: string, value: BigNumber | number, data: string) {
+function encodeTransaction(operation, to, value, data) {
     /// operation as a uint8 with 0 for a call or 1 for a delegatecall (=> 1 byte),
     /// to as a address (=> 20 bytes),
     /// value as a uint256 (=> 32 bytes),
     /// data length as a uint256 (=> 32 bytes),
     /// data as bytes.
-
     let _operation;
     if (operation === 0) {
         _operation = "00";
-    } else if (operation === 1) {
+    }
+    else if (operation === 1) {
         _operation = "01";
-    } else {
+    }
+    else {
         throw Error(`Operation has an incorrect value`);
     }
-
     let _to = to;
     if (to.startsWith("0x")) {
         _to = _to.slice(2);
     }
     _to = padWithZeros(_to, 20 * 2);
-
-    const _value = padWithZeros(BigNumber.from(value).toHexString().slice(2), 32 * 2);
-
+    const _value = padWithZeros(ethers_1.BigNumber.from(value).toHexString().slice(2), 32 * 2);
     let _data = data;
     if (data.startsWith("0x")) {
         _data = _data.slice(2);
@@ -35,9 +34,7 @@ export function encodeTransaction(operation: 0 | 1, to: string, value: BigNumber
     if (_data.length % 2 !== 0) {
         _data = "0" + _data;
     }
-
     const _dataLength = padWithZeros((_data.length / 2).toString(16), 32 * 2);
-
     return "0x" + [
         _operation,
         _to,
@@ -45,4 +42,5 @@ export function encodeTransaction(operation: 0 | 1, to: string, value: BigNumber
         _dataLength,
         _data,
     ].join("");
-}
+}
+exports.encodeTransaction = encodeTransaction;

package/{src/types.ts → dist/types.d.ts}

@@ -1,14 +1,12 @@
 import { ManifestData } from "@openzeppelin/upgrades-core";
-
 export interface SkaleManifestData extends ManifestData {
     libraries: {
         [libraryName: string]: {
-            address: string
-            bytecodeHash: string
-        }
-    }
+            address: string;
+            bytecodeHash: string;
+        };
+    };
 }
-
 export interface SkaleABIFile {
-    [key: string]: string | []
-}
+    [key: string]: string | [];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/upgrade.js

@@ -0,0 +1 @@
+"use strict";

package/dist/verification.d.ts

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

package/dist/verification.js

@@ -0,0 +1,53 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyProxy = exports.verify = void 0;
+const hardhat_1 = require("hardhat");
+const chalk_1 = __importDefault(require("chalk"));
+const upgrades_core_1 = require("@openzeppelin/upgrades-core");
+function verify(contractName, contractAddress, constructorArguments) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (![1337, 31337].includes((yield hardhat_1.ethers.provider.getNetwork()).chainId)) {
+            for (let retry = 0; retry <= 5; ++retry) {
+                try {
+                    yield (0, hardhat_1.run)("verify:verify", {
+                        address: contractAddress,
+                        constructorArguments
+                    });
+                    break;
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        if (e.toString().includes("Contract source code already verified")) {
+                            console.log(chalk_1.default.grey(`${contractName} is already verified`));
+                            return;
+                        }
+                        console.log(chalk_1.default.red(`Contract ${contractName} was not verified on etherscan`));
+                        console.log(e.toString());
+                    }
+                    else {
+                        console.log("Unknown exception type:", e);
+                    }
+                }
+            }
+        }
+    });
+}
+exports.verify = verify;
+function verifyProxy(contractName, proxyAddress, constructorArguments) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield verify(contractName, yield (0, upgrades_core_1.getImplementationAddress)(hardhat_1.network.provider, proxyAddress), constructorArguments);
+    });
+}
+exports.verifyProxy = verifyProxy;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function getVersion(): Promise<string>;

package/dist/version.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersion = void 0;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const exec = util_1.default.promisify(child_process_1.exec);
+function getVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (process.env.VERSION) {
+            return process.env.VERSION;
+        }
+        try {
+            const tag = (yield exec("git describe --tags")).stdout.trim();
+            return tag;
+        }
+        catch (_a) {
+            return (yield fs_1.promises.readFile("VERSION", "utf-8")).trim();
+        }
+    });
+}
+exports.getVersion = getVersion;

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@skalenetwork/upgrade-tools",
-  "version": "0.0.1-custom.1",
+  "version": "0.0.1-custom.2",
   "description": "Scripts to support upgrades of smart contracts",
+  "files": [
+    "dist/**/*"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "git@github.com:skalenetwork/upgrade-tools.git",

package/src/abi.ts

@@ -1,16 +0,0 @@
-import { Interface } from "ethers/lib/utils";
-
-export function getAbi(contractInterface: Interface) {
-    const abi = JSON.parse(contractInterface.format("json") as string) as [];
-
-    abi.forEach((obj: {type: string}) => {
-        if (obj.type === "function") {
-            const func = obj as {name: string, type: string, inputs: object[], outputs: object[]};
-            func.inputs.concat(func.outputs).forEach((output: object) => {
-                Object.assign(output, Object.assign({name: ""}, output));
-            })
-        }
-    });
-
-    return abi;
-}

package/src/gnosis-safe.ts

@@ -1,238 +0,0 @@
-import axios from "axios";
-import { TypedDataUtils } from "ethers-eip712";
-import * as ethUtil from 'ethereumjs-util';
-import chalk from "chalk";
-import type { ethers } from "ethers";
-import { HardhatEthersHelpers } from "@nomiclabs/hardhat-ethers/types";
-
-type Ethers = typeof ethers & HardhatEthersHelpers;
-
-enum Network {
-    MAINNET = 1,
-    RINKEBY = 4,
-    GANACHE = 1337,
-    HARDHAT = 31337,
-}
-
-const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-
-const ADDRESSES = {
-    multiSend: {
-        [Network.MAINNET]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
-        [Network.RINKEBY]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
-    },
-}
-
-const URLS = {
-    safe_transaction: {
-        [Network.MAINNET]: "https://safe-transaction.mainnet.gnosis.io",
-        [Network.RINKEBY]: "https://safe-transaction.rinkeby.gnosis.io",
-    },
-    safe_relay: {
-        [Network.MAINNET]: "https://safe-relay.mainnet.gnosis.io",
-        [Network.RINKEBY]: "https://safe-relay.rinkeby.gnosis.io",
-    }
-}
-
-interface SafeInfoResponse{
-    address: string,
-    nonce: number,
-    threshold: number,
-    owners:	string[],
-    masterCopy:	string,
-    modules: string[],
-    fallbackHandler: string,
-    guard: string,
-    version: string
-}
-
-interface SafeMultisigEstimateTx{
-    safe: string,
-    to:	string,
-    value: number,
-    data?: string
-    operation: number
-    gasToken?: string
-}
-
-interface SafeMultisigEstimateTxResponseV2 {
-    safeTxGas: string,
-    baseGas: string,
-    dataGas: string,
-    operationalGas: string,
-    gasPrice: string,
-    lastUsedNonce: number,
-    gasToken: string,
-    refundReceiver: string
-}
-
-interface SafeMultisigTransaction {
-    safe: string,
-    to: string,
-    value: number,
-    data?: string,
-    operation: number,
-    gasToken?: string,
-    safeTxGas: number,
-    baseGas: number,
-    gasPrice: number,
-    refundReceiver?: string,
-    nonce: number,
-    contractTransactionHash: string,
-    sender:	string,
-    signature?:	string,
-    origin?: string
-}
-
-function getMultiSendAddress(chainId: number) {
-    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 ZERO_ADDRESS;
-    } else {
-        throw Error(`Can't get multiSend contract at network with chainId = ${chainId}`);
-    }
-}
-
-export function getSafeTransactionUrl(chainId: number) {
-    if (chainId === Network.MAINNET) {
-        return URLS.safe_transaction[chainId];
-    } else if (chainId === 4) {
-        return URLS.safe_transaction[chainId];
-    } else {
-        throw Error(`Can't get safe-transaction url at network with chainId = ${chainId}`);
-    }
-}
-
-export function getSafeRelayUrl(chainId: number) {
-    if (chainId === 1) {
-        return URLS.safe_relay[chainId];
-    } else if (chainId === 4) {
-        return URLS.safe_relay[chainId];
-    } else {
-        throw Error(`Can't get safe-relay url at network with chainId = ${chainId}`);
-    }
-}
-
-function concatTransactions(transactions: string[]) {
-    return "0x" + transactions.map( (transaction) => {
-        if (transaction.startsWith("0x")) {
-            return transaction.slice(2);
-        } else {
-            return transaction;
-        }
-    }).join("");
-}
-
-export async function createMultiSendTransaction(ethers: Ethers, safeAddress: string, privateKey: string, transactions: string[], isSafeMock = false) {
-    const chainId = (await 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);
-
-    let nonce = 0;
-    if (!isSafeMock) {
-        try {
-            const nonceResponse = await axios.get<SafeInfoResponse>(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safeAddress}/`);
-            nonce = nonceResponse.data.nonce;
-        } catch (e) {
-            if (!(e instanceof Error) || !e.toString().startsWith("Error: Can't get safe-transaction url")) {
-                throw e;
-            }
-        }
-    }
-
-    const tx = {
-        "safe": safeAddress,
-        "to": multiSend.address,
-        "value": 0, // Value in wei
-        "data": multiSend.interface.encodeFunctionData("multiSend", [ concatTransactions(transactions) ]),
-        "operation": 1,  // 0 CALL, 1 DELEGATE_CALL
-        "gasToken": ZERO_ADDRESS, // Token address (hold by the Safe) to be used as a refund to the sender, if `null` is Ether
-        "safeTxGas": 0,  // Max gas to use in the transaction
-        "baseGas": 0,  // Gas costs not related to the transaction execution (signature check, refund payment...)
-        "gasPrice": 0,  // Gas price used for the refund calculation
-        "refundReceiver": ZERO_ADDRESS, // Address of receiver of gas payment (or `null` if tx.origin)
-        "nonce": nonce,  // Nonce of the Safe, transaction cannot be executed until Safe's nonce is not equal to this nonce
-    }
-
-    const typedData = {
-        types: {
-            EIP712Domain: [
-                {name: "verifyingContract", type: "address"},
-            ],
-            SafeTx: [
-                { type: "address", name: "to" },
-                { type: "uint256", name: "value" },
-                { type: "bytes", name: "data" },
-                { type: "uint8", name: "operation" },
-                { type: "uint256", name: "safeTxGas" },
-                { type: "uint256", name: "baseGas" },
-                { type: "uint256", name: "gasPrice" },
-                { type: "address", name: "gasToken" },
-                { type: "address", name: "refundReceiver" },
-                { type: "uint256", name: "nonce" },
-            ]
-        },
-        primaryType: 'SafeTx' as const,
-        domain: {
-          verifyingContract: safeAddress
-        },
-        message: {
-          ...tx,
-          data: ethers.utils.arrayify(tx.data)
-        }
-    }
-
-    const digest = TypedDataUtils.encodeDigest(typedData)
-    const digestHex = ethers.utils.hexlify(digest)
-
-    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: SafeMultisigTransaction = {
-        ...tx,
-        "contractTransactionHash": digestHex,  // Contract transaction hash calculated from all the field
-        // Owner of the Safe proposing the transaction. Must match one of the signatures
-        "sender": ethers.utils.getAddress(ethUtil.bufferToHex(ethUtil.privateToAddress(privateKeyBuffer))),
-        "signature": signature,  // One or more ethereum ECDSA signatures of the `contractTransactionHash` as an hex string
-        "origin": "Upgrade skale-manager"  // Give more information about the transaction, e.g. "My Custom Safe app"
-    }
-
-    return txToSend;
-}
-
-export async function sendSafeTransaction(safe: string, chainId: number, safeTx: SafeMultisigTransaction) {
-    try {
-        console.log("Estimate gas");
-        const estimateRequest: SafeMultisigEstimateTx = safeTx;
-
-        try {
-            const estimateResponse = await axios.post<SafeMultisigEstimateTxResponseV2>(
-                `${getSafeRelayUrl(chainId)}/api/v2/safes/${safe}/transactions/estimate/`,
-                estimateRequest
-            );
-            console.log(chalk.cyan(`Recommend to set gas limit to ${
-                parseInt(estimateResponse.data.safeTxGas, 10) + parseInt(estimateResponse.data.baseGas, 10)}`));
-        } catch (e) {
-            console.log(chalk.red("Failed to estimate gas"));
-            console.log(e);
-        }
-
-        console.log(chalk.green("Send transaction to gnosis safe"));
-        await axios.post(`${getSafeTransactionUrl(chainId)}/api/v1/safes/${safe}/multisig-transactions/`, safeTx)
-    } catch (e) {
-        if (axios.isAxiosError(e)) {
-            if (e.response) {
-                console.log(JSON.stringify(e.response.data, null, 4))
-                console.log(chalk.red(`Request failed with ${e.response.status} code`));
-            } else {
-                console.log(chalk.red("Request failed with unknown reason"));
-            }
-        }
-        throw e;
-    }
-}

package/src/verification.ts

@@ -1,32 +0,0 @@
-import { ethers, run, network } from "hardhat";
-import chalk from "chalk";
-import { getImplementationAddress } from "@openzeppelin/upgrades-core";
-
-export async function verify(contractName: string, contractAddress: string, constructorArguments: object) {
-    if (![1337, 31337].includes((await ethers.provider.getNetwork()).chainId)) {
-        for (let retry = 0; retry <= 5; ++retry) {
-            try {
-                await run("verify:verify", {
-                    address: contractAddress,
-                    constructorArguments
-                });
-                break;
-            } catch (e) {
-                if (e instanceof Error) {
-                    if (e.toString().includes("Contract source code already verified")) {
-                        console.log(chalk.grey(`${contractName} is already verified`));
-                        return;
-                    }
-                    console.log(chalk.red(`Contract ${contractName} was not verified on etherscan`));
-                    console.log(e.toString());
-                } else {
-                    console.log("Unknown exception type:", e)
-                }
-            }
-        }
-    }
-}
-
-export async function verifyProxy(contractName: string, proxyAddress: string, constructorArguments: object) {
-    await verify(contractName, await getImplementationAddress(network.provider, proxyAddress), constructorArguments);
-}

package/src/version.ts

@@ -1,16 +0,0 @@
-import { promises as fs } from 'fs';
-import { exec as asyncExec } from "child_process";
-import util from 'util';
-const exec = util.promisify(asyncExec);
-
-export async function getVersion() {
-    if (process.env.VERSION) {
-        return process.env.VERSION;
-    }
-    try {
-        const tag = (await exec("git describe --tags")).stdout.trim();
-        return tag;
-    } catch {
-        return (await fs.readFile("VERSION", "utf-8")).trim();
-    }
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "@tsconfig/recommended/tsconfig.json",
-
-  "compilerOptions": {
-      "outDir": "./dist",
-      "declaration": true,
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}