@skalenetwork/upgrade-tools 0.0.1-custom.7 → 0.0.1-develop.0

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/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/{deploy.js → src/deploy.js}

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContractFactory = exports.getManifestFile = exports.getContractKeyInAbiFile = void 0;
+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");
@@ -30,6 +30,7 @@ function deployLibraries(libraryNames) {
         return libraries;
     });
 }
+exports.deployLibraries = deployLibraries;
 function _linkBytecode(artifact, libraries) {
     let bytecode = artifact.bytecode;
     for (const [, fileReferences] of Object.entries(artifact.linkReferences)) {
@@ -56,6 +57,7 @@ function getLinkedContractFactory(contractName, libraries) {
         return ContractFactory;
     });
 }
+exports.getLinkedContractFactory = getLinkedContractFactory;
 function getContractKeyInAbiFile(contract) {
     return contract.replace(/([a-zA-Z])(?=[A-Z])/g, '$1_').toLowerCase();
 }

package/dist/{gnosis-safe.d.ts → 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/{gnosis-safe.js → 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/{index.d.ts → 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/{index.js → 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

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

@@ -0,0 +1,203 @@
+"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.upgrade = exports.getContractFactoryAndUpdateManifest = void 0;
+const deploy_1 = require("./deploy");
+const fs_1 = require("fs");
+const hardhat_1 = require("hardhat");
+const hardhat_2 = __importDefault(require("hardhat"));
+const upgrades_core_1 = require("@openzeppelin/upgrades-core");
+const chalk_1 = __importDefault(require("chalk"));
+const admin_1 = require("@openzeppelin/hardhat-upgrades/dist/admin");
+const version_1 = require("./version");
+const abi_1 = require("./abi");
+const verification_1 = require("./verification");
+const multiSend_1 = require("./multiSend");
+const gnosis_safe_1 = require("./gnosis-safe");
+function getContractFactoryAndUpdateManifest(contract) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const manifest = JSON.parse(yield fs_1.promises.readFile(yield (0, deploy_1.getManifestFile)(), "utf-8"));
+        const { linkReferences } = yield hardhat_1.artifacts.readArtifact(contract);
+        if (!Object.keys(linkReferences).length)
+            return yield hardhat_1.ethers.getContractFactory(contract);
+        const librariesToUpgrade = [];
+        const oldLibraries = {};
+        if (manifest.libraries === undefined) {
+            Object.assign(manifest, { libraries: {} });
+        }
+        for (const key of Object.keys(linkReferences)) {
+            const libraryName = Object.keys(linkReferences[key])[0];
+            const { bytecode } = yield hardhat_1.artifacts.readArtifact(libraryName);
+            if (manifest.libraries[libraryName] === undefined) {
+                librariesToUpgrade.push(libraryName);
+                continue;
+            }
+            const libraryBytecodeHash = manifest.libraries[libraryName].bytecodeHash;
+            if ((0, upgrades_core_1.hashBytecode)(bytecode) !== libraryBytecodeHash) {
+                librariesToUpgrade.push(libraryName);
+            }
+            else {
+                oldLibraries[libraryName] = manifest.libraries[libraryName].address;
+            }
+        }
+        const libraries = yield (0, deploy_1.deployLibraries)(librariesToUpgrade);
+        for (const [libraryName, libraryAddress] of libraries.entries()) {
+            const { bytecode } = yield hardhat_1.artifacts.readArtifact(libraryName);
+            manifest.libraries[libraryName] = { "address": libraryAddress, "bytecodeHash": (0, upgrades_core_1.hashBytecode)(bytecode) };
+        }
+        Object.assign(libraries, oldLibraries);
+        yield fs_1.promises.writeFile(yield (0, deploy_1.getManifestFile)(), JSON.stringify(manifest, null, 4));
+        return yield (0, deploy_1.getLinkedContractFactory)(contract, libraries);
+    });
+}
+exports.getContractFactoryAndUpdateManifest = getContractFactoryAndUpdateManifest;
+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"));
+            return;
+        }
+        const abiFilename = process.env.ABI;
+        const abi = JSON.parse(yield fs_1.promises.readFile(abiFilename, "utf-8"));
+        const proxyAdmin = yield (0, admin_1.getManifestAdmin)(hardhat_2.default);
+        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(abi);
+        const version = yield (0, version_1.getVersion)();
+        if (deployedVersion) {
+            if (deployedVersion !== targetVersion) {
+                console.log(chalk_1.default.red(`This script can't upgrade version ${deployedVersion} to ${version}`));
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Can't check currently deployed version of ${projectName}`));
+        }
+        console.log(`Will mark updated version as ${version}`);
+        const [deployer] = yield hardhat_1.ethers.getSigners();
+        let safe = yield proxyAdmin.owner();
+        const safeTransactions = [];
+        let safeMock = undefined;
+        if ((yield hardhat_1.ethers.provider.getCode(safe)) === "0x") {
+            console.log("Owner is not a contract");
+            if (deployer.address !== safe) {
+                console.log(chalk_1.default.red(`Used address does not have permissions to upgrade ${projectName}`));
+                process.exit(1);
+            }
+            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();
+            yield safeMock.deployTransaction.wait();
+            console.log(chalk_1.default.blue("Transfer ownership to SafeMock"));
+            safe = safeMock.address;
+            yield (yield proxyAdmin.transferOwnership(safe)).wait();
+            yield (yield contractManager.transferOwnership(safe)).wait();
+            for (const contractName of safeMockAccessRequirements) {
+                const contractFactory = yield getContractFactoryAndUpdateManifest(contractName);
+                const contractAddress = abi[(0, deploy_1.getContractKeyInAbiFile)(contractName) + "_address"];
+                const contract = contractFactory.attach(contractAddress);
+                console.log(chalk_1.default.blue(`Grant access to ${contractName}`));
+                yield (yield contract.grantRole(yield contract.DEFAULT_ADMIN_ROLE(), safe)).wait();
+            }
+        }
+        else {
+            try {
+                const safeMockFactory = yield hardhat_1.ethers.getContractFactory("SafeMock");
+                const checkSafeMock = safeMockFactory.attach(safe);
+                if (yield checkSafeMock.IS_SAFE_MOCK()) {
+                    safeMock = checkSafeMock;
+                }
+            }
+            catch (e) {
+                console.log(chalk_1.default.yellow("Owner is not SafeMock"));
+            }
+        }
+        // Deploy new contracts
+        yield deployNewContracts(safeTransactions, abi, contractManager);
+        // deploy new implementations
+        const contractsToUpgrade = [];
+        for (const contract of contractNamesToUpgrade) {
+            const contractFactory = yield getContractFactoryAndUpdateManifest(contract);
+            let _contract = contract;
+            if (contract === "BountyV2") {
+                if (!abi[(0, deploy_1.getContractKeyInAbiFile)(contract) + "_address"])
+                    _contract = "Bounty";
+            }
+            const proxyAddress = abi[(0, deploy_1.getContractKeyInAbiFile)(_contract) + "_address"];
+            console.log(`Prepare upgrade of ${contract}`);
+            const newImplementationAddress = yield hardhat_1.upgrades.prepareUpgrade(proxyAddress, contractFactory, {
+                unsafeAllowLinkedLibraries: true,
+                unsafeAllowRenames: true
+            });
+            const currentImplementationAddress = yield (0, upgrades_core_1.getImplementationAddress)(hardhat_1.network.provider, proxyAddress);
+            if (newImplementationAddress !== currentImplementationAddress) {
+                contractsToUpgrade.push({
+                    proxyAddress,
+                    implementationAddress: newImplementationAddress,
+                    name: contract,
+                    abi: (0, abi_1.getAbi)(contractFactory.interface)
+                });
+                yield (0, verification_1.verify)(contract, newImplementationAddress, []);
+            }
+            else {
+                console.log(chalk_1.default.gray(`Contract ${contract} is up to date`));
+            }
+        }
+        // Switch proxies to new implementations
+        for (const contract of contractsToUpgrade) {
+            console.log(chalk_1.default.yellowBright(`Prepare transaction to upgrade ${contract.name} at ${contract.proxyAddress} to ${contract.implementationAddress}`));
+            safeTransactions.push((0, multiSend_1.encodeTransaction)(0, proxyAdmin.address, 0, proxyAdmin.interface.encodeFunctionData("upgrade", [contract.proxyAddress, contract.implementationAddress])));
+            abi[(0, deploy_1.getContractKeyInAbiFile)(contract.name) + "_abi"] = contract.abi;
+        }
+        yield initialize(safeTransactions, abi, contractManager);
+        // write 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") {
+            // Don't have an information about private key
+            // Use random one because we most probable run tests
+            privateKey = hardhat_1.ethers.Wallet.createRandom().privateKey;
+        }
+        const safeTx = yield (0, gnosis_safe_1.createMultiSendTransaction)(hardhat_1.ethers, safe, privateKey, safeTransactions, safeMock !== undefined);
+        if (!safeMock) {
+            const chainId = (yield hardhat_1.ethers.provider.getNetwork()).chainId;
+            yield (0, gnosis_safe_1.sendSafeTransaction)(safe, chainId, safeTx);
+        }
+        else {
+            console.log(chalk_1.default.blue("Send upgrade transactions to safe mock"));
+            try {
+                yield (yield deployer.sendTransaction({
+                    to: safeMock.address,
+                    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"));
+                yield (yield safeMock.transferProxyAdminOwnership(contractManager.address, deployer.address)).wait();
+                yield (yield safeMock.transferProxyAdminOwnership(proxyAdmin.address, deployer.address)).wait();
+                if ((yield proxyAdmin.owner()) !== deployer.address) {
+                    console.log(chalk_1.default.blue("Something went wrong with ownership transfer"));
+                    process.exit(1);
+                }
+            }
+        }
+        yield fs_1.promises.writeFile(`data/${projectName}-${version}-${hardhat_1.network.name}-abi.json`, JSON.stringify(abi, null, 4));
+        console.log("Done");
+    });
+}
+exports.upgrade = upgrade;

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

@@ -0,0 +1,183 @@
+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 AccessControlEnumerableUpgradeableInterface extends utils.Interface {
+    contractName: "AccessControlEnumerableUpgradeable";
+    functions: {
+        "DEFAULT_ADMIN_ROLE()": FunctionFragment;
+        "getRoleAdmin(bytes32)": FunctionFragment;
+        "getRoleMember(bytes32,uint256)": FunctionFragment;
+        "getRoleMemberCount(bytes32)": FunctionFragment;
+        "grantRole(bytes32,address)": FunctionFragment;
+        "hasRole(bytes32,address)": FunctionFragment;
+        "renounceRole(bytes32,address)": FunctionFragment;
+        "revokeRole(bytes32,address)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+    };
+    encodeFunctionData(functionFragment: "DEFAULT_ADMIN_ROLE", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getRoleAdmin", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "getRoleMember", values: [BytesLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getRoleMemberCount", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "grantRole", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "hasRole", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "renounceRole", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "revokeRole", values: [BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
+    decodeFunctionResult(functionFragment: "DEFAULT_ADMIN_ROLE", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoleAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoleMember", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoleMemberCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceRole", data: BytesLike): Result;
+    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,
+    string
+], {
+    role: string;
+    previousAdminRole: string;
+    newAdminRole: string;
+}>;
+export declare type RoleAdminChangedEventFilter = TypedEventFilter<RoleAdminChangedEvent>;
+export declare type RoleGrantedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], {
+    role: string;
+    account: string;
+    sender: string;
+}>;
+export declare type RoleGrantedEventFilter = TypedEventFilter<RoleGrantedEvent>;
+export declare type RoleRevokedEvent = TypedEvent<[
+    string,
+    string,
+    string
+], {
+    role: string;
+    account: string;
+    sender: string;
+}>;
+export declare type RoleRevokedEventFilter = TypedEventFilter<RoleRevokedEvent>;
+export interface AccessControlEnumerableUpgradeable extends BaseContract {
+    contractName: "AccessControlEnumerableUpgradeable";
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AccessControlEnumerableUpgradeableInterface;
+    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: {
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
+        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<[BigNumber]>;
+        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<[boolean]>;
+        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+    };
+    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;
+    getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    grantRole(role: BytesLike, account: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<boolean>;
+    renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    callStatic: {
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
+        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;
+        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        grantRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
+        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<boolean>;
+        renounceRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
+        revokeRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<void>;
+        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;
+        RoleGranted(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter;
+        "RoleRevoked(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter;
+        RoleRevoked(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter;
+    };
+    estimateGas: {
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
+        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<BigNumber>;
+        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        grantRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        revokeRole(role: BytesLike, account: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/{upgrade.js → typechain-types/AccessControlEnumerableUpgradeable.js}

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