@skalenetwork/upgrade-tools 0.0.1-custom.4 → 0.0.1-custom.8

package/dist/deploy.d.ts

@@ -0,0 +1,5 @@
+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/deploy.js

@@ -0,0 +1,99 @@
+"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.getContractKeyInAbiFile = 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;
+    });
+}
+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;
+    });
+}
+exports.deployLibraries = deployLibraries;
+function _linkBytecode(artifact, libraries) {
+    let bytecode = artifact.bytecode;
+    for (const [, fileReferences] of Object.entries(artifact.linkReferences)) {
+        for (const [libName, fixups] of Object.entries(fileReferences)) {
+            const addr = libraries.get(libName);
+            if (addr === undefined) {
+                continue;
+            }
+            for (const fixup of fixups) {
+                bytecode =
+                    bytecode.substr(0, 2 + fixup.start * 2) +
+                        addr.substr(2) +
+                        bytecode.substr(2 + (fixup.start + fixup.length) * 2);
+            }
+        }
+    }
+    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;
+    });
+}
+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;
+    });
+}
+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 {
+            Object.assign(manifest, { libraries: libraryArtifacts });
+            yield fs_1.promises.writeFile(yield getManifestFile(), JSON.stringify(manifest, null, 4));
+        }
+        return yield getLinkedContractFactory(contract, libraries);
+    });
+}
+exports.getContractFactory = getContractFactory;

package/dist/hardhat.config.d.ts

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

package/dist/hardhat.config.js

@@ -1,5 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("@typechain/hardhat");
 require("@nomiclabs/hardhat-ethers");
-const config = {};
+require("@openzeppelin/hardhat-upgrades");
+const config = {
+    solidity: {
+        compilers: [
+            {
+                version: '0.8.11',
+                settings: {
+                    optimizer: {
+                        enabled: true,
+                        runs: 200
+                    }
+                }
+            }
+        ]
+    },
+    typechain: {
+        externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/*.json']
+    }
+};
 exports.default = config;

package/dist/index.d.ts

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

package/dist/index.js

@@ -10,4 +10,10 @@ 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("./"), exports);
+__exportStar(require("./abi"), exports);
+__exportStar(require("./deploy"), exports);
+__exportStar(require("./gnosis-safe"), exports);
+__exportStar(require("./multiSend"), exports);
+__exportStar(require("./upgrade"), exports);
+__exportStar(require("./verification"), exports);
+__exportStar(require("./version"), exports);

package/dist/src/abi.d.ts

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

package/dist/src/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/src/deploy.d.ts

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

@@ -0,0 +1,99 @@
+"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.getContractKeyInAbiFile = 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;
+    });
+}
+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;
+    });
+}
+exports.deployLibraries = deployLibraries;
+function _linkBytecode(artifact, libraries) {
+    let bytecode = artifact.bytecode;
+    for (const [, fileReferences] of Object.entries(artifact.linkReferences)) {
+        for (const [libName, fixups] of Object.entries(fileReferences)) {
+            const addr = libraries.get(libName);
+            if (addr === undefined) {
+                continue;
+            }
+            for (const fixup of fixups) {
+                bytecode =
+                    bytecode.substr(0, 2 + fixup.start * 2) +
+                        addr.substr(2) +
+                        bytecode.substr(2 + (fixup.start + fixup.length) * 2);
+            }
+        }
+    }
+    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;
+    });
+}
+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;
+    });
+}
+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 {
+            Object.assign(manifest, { libraries: libraryArtifacts });
+            yield fs_1.promises.writeFile(yield getManifestFile(), JSON.stringify(manifest, null, 4));
+        }
+        return yield getLinkedContractFactory(contract, libraries);
+    });
+}
+exports.getContractFactory = getContractFactory;

package/dist/src/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/src/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/dist/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,19 @@
+"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 __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("./abi"), exports);
+__exportStar(require("./deploy"), exports);
+__exportStar(require("./gnosis-safe"), exports);
+__exportStar(require("./multiSend"), exports);
+__exportStar(require("./upgrade"), exports);
+__exportStar(require("./verification"), exports);
+__exportStar(require("./version"), exports);

package/dist/src/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/dist/src/multiSend.js

@@ -0,0 +1,46 @@
+"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);
+}
+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) {
+        _operation = "01";
+    }
+    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(ethers_1.BigNumber.from(value).toHexString().slice(2), 32 * 2);
+    let _data = data;
+    if (data.startsWith("0x")) {
+        _data = _data.slice(2);
+    }
+    if (_data.length % 2 !== 0) {
+        _data = "0" + _data;
+    }
+    const _dataLength = padWithZeros((_data.length / 2).toString(16), 32 * 2);
+    return "0x" + [
+        _operation,
+        _to,
+        _value,
+        _dataLength,
+        _data,
+    ].join("");
+}
+exports.encodeTransaction = encodeTransaction;

package/dist/src/types.d.ts

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

package/dist/src/types.js

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

package/dist/src/upgrade.d.ts

@@ -0,0 +1,6 @@
+import { SkaleABIFile } from "./types";
+import { Contract } from "ethers";
+export declare function getContractFactoryAndUpdateManifest(contract: string): Promise<import("ethers").ContractFactory>;
+declare type DeploymentAction<ContractManagerType extends Contract> = (safeTransactions: string[], abi: SkaleABIFile, contractManager: ContractManagerType) => Promise<void>;
+export declare function upgrade<ContractManagerType extends Contract>(projectName: string, targetVersion: string, contractNamesToUpgrade: string[], deployNewContracts: DeploymentAction<ContractManagerType>, initialize: DeploymentAction<ContractManagerType>, getDeployedVersion: () => Promise<string | undefined>, setVersion: (version: string) => Promise<void>, safeMockAccessRequirements: string[]): Promise<void>;
+export {};