@skalenetwork/upgrade-tools 0.0.1-custom.8 → 0.0.1-develop.1

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

@@ -1,4 +1,4 @@
-import type { ethers } from "ethers";
+import { ethers } from "ethers";
 import { HardhatEthersHelpers } from "@nomiclabs/hardhat-ethers/types";
 declare type Ethers = typeof ethers & HardhatEthersHelpers;
 interface SafeMultisigTransaction {

package/dist/src/gnosis-safe.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -33,9 +37,9 @@ var __importDefault = (this && this.__importDefault) || function (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"));
+const ethers_1 = require("ethers");
 var Network;
 (function (Network) {
     Network[Network["MAINNET"] = 1] = "MAINNET";
@@ -43,7 +47,6 @@ var Network;
     Network[Network["GANACHE"] = 1337] = "GANACHE";
     Network[Network["HARDHAT"] = 31337] = "HARDHAT";
 })(Network || (Network = {}));
-const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 const ADDRESSES = {
     multiSend: {
         [Network.MAINNET]: "0x8D29bE29923b68abfDD21e541b9374737B49cdAD",
@@ -68,7 +71,7 @@ function getMultiSendAddress(chainId) {
         return ADDRESSES.multiSend[chainId];
     }
     else if ([Network.GANACHE, Network.HARDHAT].includes(chainId)) {
-        return ZERO_ADDRESS;
+        return ethers_1.ethers.constants.AddressZero;
     }
     else {
         throw Error(`Can't get multiSend contract at network with chainId = ${chainId}`);
@@ -114,6 +117,8 @@ function createMultiSendTransaction(ethers, safeAddress, privateKey, transaction
         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) {
             try {
@@ -132,39 +137,14 @@ function createMultiSendTransaction(ethers, safeAddress, privateKey, transaction
             "value": 0,
             "data": multiSend.interface.encodeFunctionData("multiSend", [concatTransactions(transactions)]),
             "operation": 1,
-            "gasToken": ZERO_ADDRESS,
+            "gasToken": ethers.constants.AddressZero,
             "safeTxGas": 0,
             "baseGas": 0,
             "gasPrice": 0,
-            "refundReceiver": ZERO_ADDRESS,
+            "refundReceiver": ethers.constants.AddressZero,
             "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 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();

package/dist/src/index.d.ts

@@ -3,5 +3,6 @@ export * from "./deploy";
 export * from "./gnosis-safe";
 export * from "./multiSend";
 export * from "./upgrade";
+export * from "./types";
 export * from "./verification";
 export * from "./version";

package/dist/src/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -15,5 +19,6 @@ __exportStar(require("./deploy"), exports);
 __exportStar(require("./gnosis-safe"), exports);
 __exportStar(require("./multiSend"), exports);
 __exportStar(require("./upgrade"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("./verification"), exports);
 __exportStar(require("./version"), exports);

package/dist/src/upgrade.d.ts

@@ -1,6 +1,7 @@
 import { SkaleABIFile } from "./types";
 import { Contract } from "ethers";
+import { OwnableUpgradeable } from "../typechain-types";
 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 declare function upgrade<ContractManagerType extends OwnableUpgradeable>(projectName: string, targetVersion: string, getDeployedVersion: (abi: SkaleABIFile) => Promise<string | undefined>, setVersion: (safeTransaction: string[], abi: SkaleABIFile, newVersion: string) => Promise<void>, safeMockAccessRequirements: string[], contractNamesToUpgrade: string[], deployNewContracts: DeploymentAction<ContractManagerType>, initialize: DeploymentAction<ContractManagerType>): Promise<void>;
 export {};

package/dist/src/upgrade.js

@@ -62,7 +62,7 @@ function getContractFactoryAndUpdateManifest(contract) {
     });
 }
 exports.getContractFactoryAndUpdateManifest = getContractFactoryAndUpdateManifest;
-function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewContracts, initialize, getDeployedVersion, setVersion, safeMockAccessRequirements) {
+function upgrade(projectName, targetVersion, getDeployedVersion, setVersion, safeMockAccessRequirements, contractNamesToUpgrade, deployNewContracts, initialize) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!process.env.ABI) {
             console.log(chalk_1.default.red("Set path to file with ABI and addresses to ABI environment variables"));
@@ -74,7 +74,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
         const contractManagerName = "ContractManager";
         const contractManagerFactory = yield hardhat_1.ethers.getContractFactory(contractManagerName);
         const contractManager = (contractManagerFactory.attach(abi[(0, deploy_1.getContractKeyInAbiFile)(contractManagerName) + "_address"]));
-        const deployedVersion = yield getDeployedVersion();
+        const deployedVersion = yield getDeployedVersion(abi);
         const version = yield (0, version_1.getVersion)();
         if (deployedVersion) {
             if (deployedVersion !== targetVersion) {
@@ -89,7 +89,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
         const [deployer] = yield hardhat_1.ethers.getSigners();
         let safe = yield proxyAdmin.owner();
         const safeTransactions = [];
-        let safeMock;
+        let safeMock = undefined;
         if ((yield hardhat_1.ethers.provider.getCode(safe)) === "0x") {
             console.log("Owner is not a contract");
             if (deployer.address !== safe) {
@@ -98,7 +98,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
             }
             console.log(chalk_1.default.blue("Deploy SafeMock to simulate upgrade via multisig"));
             const safeMockFactory = yield hardhat_1.ethers.getContractFactory("SafeMock");
-            safeMock = (yield safeMockFactory.deploy());
+            safeMock = yield safeMockFactory.deploy();
             yield safeMock.deployTransaction.wait();
             console.log(chalk_1.default.blue("Transfer ownership to SafeMock"));
             safe = safeMock.address;
@@ -115,7 +115,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
         else {
             try {
                 const safeMockFactory = yield hardhat_1.ethers.getContractFactory("SafeMock");
-                const checkSafeMock = (safeMockFactory.attach(safe));
+                const checkSafeMock = safeMockFactory.attach(safe);
                 if (yield checkSafeMock.IS_SAFE_MOCK()) {
                     safeMock = checkSafeMock;
                 }
@@ -163,7 +163,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
         }
         yield initialize(safeTransactions, abi, contractManager);
         // write version
-        yield setVersion(version);
+        yield setVersion(safeTransactions, abi, version);
         yield fs_1.promises.writeFile(`data/transactions-${version}-${hardhat_1.network.name}.json`, JSON.stringify(safeTransactions, null, 4));
         let privateKey = hardhat_1.network.config.accounts[0];
         if (hardhat_1.network.config.accounts === "remote") {
@@ -184,6 +184,7 @@ function upgrade(projectName, targetVersion, contractNamesToUpgrade, deployNewCo
                     value: safeTx.value,
                     data: safeTx.data,
                 })).wait();
+                console.log(chalk_1.default.blue("Transactions have been sent"));
             }
             finally {
                 console.log(chalk_1.default.blue("Return ownership to wallet"));

package/dist/typechain-types/AccessControlEnumerableUpgradeable.d.ts

@@ -34,14 +34,20 @@ export interface AccessControlEnumerableUpgradeableInterface extends utils.Inter
     decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
     events: {
+        "Initialized(uint8)": EventFragment;
         "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
         "RoleGranted(bytes32,address,address)": EventFragment;
         "RoleRevoked(bytes32,address,address)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
 }
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
 export declare type RoleAdminChangedEvent = TypedEvent<[
     string,
     string,
@@ -131,6 +137,8 @@ export interface AccessControlEnumerableUpgradeable extends BaseContract {
         supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
     };
     filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
         "RoleAdminChanged(bytes32,bytes32,bytes32)"(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter;
         RoleAdminChanged(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter;
         "RoleGranted(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter;

package/dist/typechain-types/AccessControlUpgradeable.d.ts

@@ -28,14 +28,20 @@ export interface AccessControlUpgradeableInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
     events: {
+        "Initialized(uint8)": EventFragment;
         "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
         "RoleGranted(bytes32,address,address)": EventFragment;
         "RoleRevoked(bytes32,address,address)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
 }
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
 export declare type RoleAdminChangedEvent = TypedEvent<[
     string,
     string,
@@ -119,6 +125,8 @@ export interface AccessControlUpgradeable extends BaseContract {
         supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
     };
     filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
         "RoleAdminChanged(bytes32,bytes32,bytes32)"(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter;
         RoleAdminChanged(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter;
         "RoleGranted(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter;

package/dist/typechain-types/ContextUpgradeable.d.ts

@@ -0,0 +1,40 @@
+import { BaseContract, Signer, utils } from "ethers";
+import { EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface ContextUpgradeableInterface extends utils.Interface {
+    contractName: "ContextUpgradeable";
+    functions: {};
+    events: {
+        "Initialized(uint8)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface ContextUpgradeable extends BaseContract {
+    contractName: "ContextUpgradeable";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ContextUpgradeableInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {};
+    callStatic: {};
+    filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/dist/typechain-types/ERC165Upgradeable.d.ts

@@ -1,5 +1,5 @@
 import { BaseContract, BigNumber, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
-import { FunctionFragment, Result } from "@ethersproject/abi";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
 export interface ERC165UpgradeableInterface extends utils.Interface {
@@ -9,8 +9,15 @@ export interface ERC165UpgradeableInterface extends utils.Interface {
     };
     encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
     decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
-    events: {};
+    events: {
+        "Initialized(uint8)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
 }
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
 export interface ERC165Upgradeable extends BaseContract {
     contractName: "ERC165Upgradeable";
     connect(signerOrProvider: Signer | Provider | string): this;
@@ -33,7 +40,10 @@ export interface ERC165Upgradeable extends BaseContract {
     callStatic: {
         supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
     };
-    filters: {};
+    filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+    };
     estimateGas: {
         supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
     };

package/dist/typechain-types/ISafeMock.d.ts

@@ -1,15 +1,29 @@
-import { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
 import { FunctionFragment, Result } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
 export interface ISafeMockInterface extends utils.Interface {
     contractName: "ISafeMock";
     functions: {
+        "getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)": FunctionFragment;
         "multiSend(bytes)": FunctionFragment;
         "transferProxyAdminOwnership(address,address)": FunctionFragment;
     };
+    encodeFunctionData(functionFragment: "getTransactionHash", values: [
+        string,
+        BigNumberish,
+        BytesLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        string,
+        BigNumberish
+    ]): string;
     encodeFunctionData(functionFragment: "multiSend", values: [BytesLike]): string;
     encodeFunctionData(functionFragment: "transferProxyAdminOwnership", values: [string, string]): string;
+    decodeFunctionResult(functionFragment: "getTransactionHash", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "multiSend", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferProxyAdminOwnership", data: BytesLike): Result;
     events: {};
@@ -30,6 +44,7 @@ export interface ISafeMock extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
@@ -37,6 +52,7 @@ export interface ISafeMock extends BaseContract {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
     };
+    getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<string>;
     multiSend(transactions: BytesLike, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
@@ -44,11 +60,13 @@ export interface ISafeMock extends BaseContract {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
     callStatic: {
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<string>;
         multiSend(transactions: BytesLike, overrides?: CallOverrides): Promise<void>;
         transferProxyAdminOwnership(proxyAdmin: string, newOwner: string, overrides?: CallOverrides): Promise<void>;
     };
     filters: {};
     estimateGas: {
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
@@ -57,6 +75,7 @@ export interface ISafeMock extends BaseContract {
         }): Promise<BigNumber>;
     };
     populateTransaction: {
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;

package/dist/typechain-types/Initializable.d.ts

@@ -0,0 +1,40 @@
+import { BaseContract, Signer, utils } from "ethers";
+import { EventFragment } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface InitializableInterface extends utils.Interface {
+    contractName: "Initializable";
+    functions: {};
+    events: {
+        "Initialized(uint8)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface Initializable extends BaseContract {
+    contractName: "Initializable";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: InitializableInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {};
+    callStatic: {};
+    filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+    };
+    estimateGas: {};
+    populateTransaction: {};
+}

package/dist/typechain-types/Initializable.js

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

package/dist/typechain-types/OwnableUpgradeable.d.ts

@@ -16,10 +16,16 @@ export interface OwnableUpgradeableInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     events: {
+        "Initialized(uint8)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
 export declare type OwnershipTransferredEvent = TypedEvent<[
     string,
     string
@@ -65,6 +71,8 @@ export interface OwnableUpgradeable extends BaseContract {
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
     };

package/dist/typechain-types/SafeMock.d.ts

@@ -1,34 +1,60 @@
-import { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
 import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
 export interface SafeMockInterface extends utils.Interface {
     contractName: "SafeMock";
     functions: {
+        "DOMAIN_SEPARATOR_TYPE_HASH()": FunctionFragment;
         "IS_SAFE_MOCK()": FunctionFragment;
+        "SAFE_TX_TYPE_HASH()": FunctionFragment;
+        "getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)": FunctionFragment;
         "multiSend(bytes)": FunctionFragment;
         "owner()": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
         "transferProxyAdminOwnership(address,address)": FunctionFragment;
     };
+    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR_TYPE_HASH", values?: undefined): string;
     encodeFunctionData(functionFragment: "IS_SAFE_MOCK", values?: undefined): string;
+    encodeFunctionData(functionFragment: "SAFE_TX_TYPE_HASH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getTransactionHash", values: [
+        string,
+        BigNumberish,
+        BytesLike,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        string,
+        string,
+        BigNumberish
+    ]): string;
     encodeFunctionData(functionFragment: "multiSend", values: [BytesLike]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
     encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
     encodeFunctionData(functionFragment: "transferProxyAdminOwnership", values: [string, string]): string;
+    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR_TYPE_HASH", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "IS_SAFE_MOCK", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "SAFE_TX_TYPE_HASH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTransactionHash", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "multiSend", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferProxyAdminOwnership", data: BytesLike): Result;
     events: {
+        "Initialized(uint8)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
+export declare type InitializedEvent = TypedEvent<[number], {
+    version: number;
+}>;
+export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
 export declare type OwnershipTransferredEvent = TypedEvent<[
     string,
     string
@@ -53,7 +79,10 @@ export interface SafeMock extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        DOMAIN_SEPARATOR_TYPE_HASH(overrides?: CallOverrides): Promise<[string]>;
         IS_SAFE_MOCK(overrides?: CallOverrides): Promise<[boolean]>;
+        SAFE_TX_TYPE_HASH(overrides?: CallOverrides): Promise<[string]>;
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
@@ -68,7 +97,10 @@ export interface SafeMock extends BaseContract {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
     };
+    DOMAIN_SEPARATOR_TYPE_HASH(overrides?: CallOverrides): Promise<string>;
     IS_SAFE_MOCK(overrides?: CallOverrides): Promise<boolean>;
+    SAFE_TX_TYPE_HASH(overrides?: CallOverrides): Promise<string>;
+    getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<string>;
     multiSend(transactions: BytesLike, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
@@ -83,7 +115,10 @@ export interface SafeMock extends BaseContract {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
     callStatic: {
+        DOMAIN_SEPARATOR_TYPE_HASH(overrides?: CallOverrides): Promise<string>;
         IS_SAFE_MOCK(overrides?: CallOverrides): Promise<boolean>;
+        SAFE_TX_TYPE_HASH(overrides?: CallOverrides): Promise<string>;
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<string>;
         multiSend(transactions: BytesLike, overrides?: CallOverrides): Promise<void>;
         owner(overrides?: CallOverrides): Promise<string>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
@@ -91,11 +126,16 @@ export interface SafeMock extends BaseContract {
         transferProxyAdminOwnership(proxyAdmin: string, newOwner: string, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
     };
     estimateGas: {
+        DOMAIN_SEPARATOR_TYPE_HASH(overrides?: CallOverrides): Promise<BigNumber>;
         IS_SAFE_MOCK(overrides?: CallOverrides): Promise<BigNumber>;
+        SAFE_TX_TYPE_HASH(overrides?: CallOverrides): Promise<BigNumber>;
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
@@ -111,7 +151,10 @@ export interface SafeMock extends BaseContract {
         }): Promise<BigNumber>;
     };
     populateTransaction: {
+        DOMAIN_SEPARATOR_TYPE_HASH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         IS_SAFE_MOCK(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        SAFE_TX_TYPE_HASH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getTransactionHash(to: string, value: BigNumberish, data: BytesLike, operation: BigNumberish, safeTxGas: BigNumberish, baseGas: BigNumberish, gasPrice: BigNumberish, gasToken: string, refundReceiver: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         multiSend(transactions: BytesLike, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;

package/dist/typechain-types/factories/AccessControlEnumerableUpgradeable__factory.js

@@ -6,6 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccessControlEnumerableUpgradeable__factory = void 0;
 const ethers_1 = require("ethers");
 const _abi = [
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "uint8",
+                name: "version",
+                type: "uint8",
+            },
+        ],
+        name: "Initialized",
+        type: "event",
+    },
     {
         anonymous: false,
         inputs: [