@skalenetwork/upgrade-tools 3.0.0-skale-contracts.9 → 3.0.0-update-skale-contracts.0

package/dist/src/version.js

@@ -4,10 +4,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVersion = void 0;
-const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const child_process_1 = require("child_process");
 const util_1 = __importDefault(require("util"));
 const exec = util_1.default.promisify(child_process_1.exec);
+class VersionNotFound extends Error {
+}
+const getVersionFilename = async (folder) => {
+    if (typeof folder === "undefined") {
+        return getVersionFilename((await exec("git rev-parse --show-toplevel")).stdout.trim());
+    }
+    const VERSION_FILENAME = "VERSION";
+    const path = `${folder}/${VERSION_FILENAME}`;
+    if ((0, fs_1.existsSync)(path)) {
+        return path;
+    }
+    for (const entry of await fs_1.promises.readdir(folder, {
+        "recursive": true,
+        "withFileTypes": true
+    })) {
+        if (entry.isFile() && entry.name === VERSION_FILENAME) {
+            return `${entry.path}/${entry.name}`;
+        }
+    }
+    throw new VersionNotFound("Can't find version file");
+};
 const getVersion = async () => {
     if (process.env.VERSION) {
         return process.env.VERSION;
@@ -17,7 +38,8 @@ const getVersion = async () => {
         return tag;
     }
     catch {
-        return (await fs_1.promises.readFile("VERSION", "utf-8")).trim();
+        return (await fs_1.promises.readFile(await getVersionFilename(), "utf-8")).trim();
     }
 };
 exports.getVersion = getVersion;
+//# sourceMappingURL=version.js.map

package/dist/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;;;;;AAAA,2BAA8C;AAC9C,iDAAgD;AAChD,gDAAwB;AAGxB,MAAM,IAAI,GAAG,cAAI,CAAC,SAAS,CAAC,oBAAS,CAAC,CAAC;AAEvC,MAAM,eAAgB,SAAQ,KAAK;CAAG;AAEtC,MAAM,kBAAkB,GAAG,KAAK,EAAE,MAAe,EAAmB,EAAE;IAClE,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QAC/B,OAAO,kBAAkB,CAAC,CACtB,MAAM,IAAI,CAAC,+BAA+B,CAAC,CAC9C,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;KACpB;IACD,MAAM,gBAAgB,GAAG,SAAS,CAAC;IACnC,MAAM,IAAI,GAAG,GAAG,MAAM,IAAI,gBAAgB,EAAE,CAAC;IAC7C,IAAI,IAAA,eAAU,EAAC,IAAI,CAAC,EAAE;QAClB,OAAO,IAAI,CAAC;KACf;IACD,KAAK,MAAM,KAAK,IAAI,MAAM,aAAE,CAAC,OAAO,CAChC,MAAM,EACN;QACI,WAAW,EAAE,IAAI;QACjB,eAAe,EAAE,IAAI;KACxB,CACJ,EAAE;QACC,IAAI,KAAK,CAAC,MAAM,EAAE,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB,EAAE;YACnD,OAAO,GAAG,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;SACxC;KACJ;IACD,MAAM,IAAI,eAAe,CAAC,yBAAyB,CAAC,CAAC;AACzD,CAAC,CAAC;AAEK,MAAM,UAAU,GAAG,KAAK,IAAI,EAAE;IACjC,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE;QACrB,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC;KAC9B;IACD,IAAI;QACA,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAC9D,OAAO,GAAG,CAAC;KACd;IAAC,MAAM;QACJ,OAAO,CAAC,MAAM,aAAE,CAAC,QAAQ,CACrB,MAAM,kBAAkB,EAAE,EAC1B,OAAO,CACV,CAAC,CAAC,IAAI,EAAE,CAAC;KACb;AACL,CAAC,CAAC;AAbW,QAAA,UAAU,cAarB"}

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

@@ -1,60 +1,65 @@
-import { BaseContract, Signer, utils } from "ethers";
-import { EventFragment } from "@ethersproject/abi";
-import { Listener, Provider } from "@ethersproject/providers";
-import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
-export interface AdminUpgradeabilityProxyInterface extends utils.Interface {
-    contractName: "AdminUpgradeabilityProxy";
-    functions: {};
-    events: {
-        "AdminChanged(address,address)": EventFragment;
-        "BeaconUpgraded(address)": EventFragment;
-        "Upgraded(address)": EventFragment;
-    };
-    getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "./common";
+export interface AdminUpgradeabilityProxyInterface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "AdminChanged" | "BeaconUpgraded" | "Upgraded"): EventFragment;
+}
+export declare namespace AdminChangedEvent {
+    type InputTuple = [previousAdmin: AddressLike, newAdmin: AddressLike];
+    type OutputTuple = [previousAdmin: string, newAdmin: string];
+    interface OutputObject {
+        previousAdmin: string;
+        newAdmin: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace BeaconUpgradedEvent {
+    type InputTuple = [beacon: AddressLike];
+    type OutputTuple = [beacon: string];
+    interface OutputObject {
+        beacon: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace UpgradedEvent {
+    type InputTuple = [implementation: AddressLike];
+    type OutputTuple = [implementation: string];
+    interface OutputObject {
+        implementation: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type AdminChangedEvent = TypedEvent<[
-    string,
-    string
-], {
-    previousAdmin: string;
-    newAdmin: string;
-}>;
-export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
-export type BeaconUpgradedEvent = TypedEvent<[string], {
-    beacon: string;
-}>;
-export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
-export type UpgradedEvent = TypedEvent<[string], {
-    implementation: string;
-}>;
-export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
 export interface AdminUpgradeabilityProxy extends BaseContract {
-    contractName: "AdminUpgradeabilityProxy";
-    connect(signerOrProvider: Signer | Provider | string): this;
-    attach(addressOrName: string): this;
-    deployed(): Promise<this>;
+    connect(runner?: ContractRunner | null): AdminUpgradeabilityProxy;
+    waitForDeployment(): Promise<this>;
     interface: AdminUpgradeabilityProxyInterface;
-    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: {};
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: "AdminChanged"): TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+    getEvent(key: "BeaconUpgraded"): TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
     filters: {
-        "AdminChanged(address,address)"(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
-        AdminChanged(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
-        "BeaconUpgraded(address)"(beacon?: string | null): BeaconUpgradedEventFilter;
-        BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;
-        "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
-        Upgraded(implementation?: string | null): UpgradedEventFilter;
+        "AdminChanged(address,address)": TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        AdminChanged: TypedContractEvent<AdminChangedEvent.InputTuple, AdminChangedEvent.OutputTuple, AdminChangedEvent.OutputObject>;
+        "BeaconUpgraded(address)": TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+        BeaconUpgraded: TypedContractEvent<BeaconUpgradedEvent.InputTuple, BeaconUpgradedEvent.OutputTuple, BeaconUpgradedEvent.OutputObject>;
+        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
     };
-    estimateGas: {};
-    populateTransaction: {};
 }

package/dist/typechain-types/AdminUpgradeabilityProxy.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AdminUpgradeabilityProxy.js.map

package/dist/typechain-types/AdminUpgradeabilityProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdminUpgradeabilityProxy.js","sourceRoot":"","sources":["../../typechain-types/AdminUpgradeabilityProxy.ts"],"names":[],"mappings":""}

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

@@ -1,27 +1,16 @@
-import { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
-import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
-import { Listener, Provider } from "@ethersproject/providers";
-import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
-export interface ProxyAdminInterface extends utils.Interface {
-    contractName: "ProxyAdmin";
-    functions: {
-        "changeProxyAdmin(address,address)": FunctionFragment;
-        "getProxyAdmin(address)": FunctionFragment;
-        "getProxyImplementation(address)": FunctionFragment;
-        "owner()": FunctionFragment;
-        "renounceOwnership()": FunctionFragment;
-        "transferOwnership(address)": FunctionFragment;
-        "upgrade(address,address)": FunctionFragment;
-        "upgradeAndCall(address,address,bytes)": FunctionFragment;
-    };
-    encodeFunctionData(functionFragment: "changeProxyAdmin", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "getProxyAdmin", values: [string]): string;
-    encodeFunctionData(functionFragment: "getProxyImplementation", values: [string]): string;
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "./common";
+export interface ProxyAdminInterface extends Interface {
+    getFunction(nameOrSignature: "changeProxyAdmin" | "getProxyAdmin" | "getProxyImplementation" | "owner" | "renounceOwnership" | "transferOwnership" | "upgrade" | "upgradeAndCall"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    encodeFunctionData(functionFragment: "changeProxyAdmin", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "getProxyAdmin", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getProxyImplementation", values: [AddressLike]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
-    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    encodeFunctionData(functionFragment: "upgrade", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "upgradeAndCall", values: [string, string, BytesLike]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgrade", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "upgradeAndCall", values: [AddressLike, AddressLike, BytesLike]): string;
     decodeFunctionResult(functionFragment: "changeProxyAdmin", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getProxyAdmin", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getProxyImplementation", data: BytesLike): Result;
@@ -30,124 +19,92 @@ export interface ProxyAdminInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "upgrade", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "upgradeAndCall", data: BytesLike): Result;
-    events: {
-        "OwnershipTransferred(address,address)": EventFragment;
-    };
-    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
-export type OwnershipTransferredEvent = TypedEvent<[
-    string,
-    string
-], {
-    previousOwner: string;
-    newOwner: string;
-}>;
-export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
 export interface ProxyAdmin extends BaseContract {
-    contractName: "ProxyAdmin";
-    connect(signerOrProvider: Signer | Provider | string): this;
-    attach(addressOrName: string): this;
-    deployed(): Promise<this>;
+    connect(runner?: ContractRunner | null): ProxyAdmin;
+    waitForDeployment(): Promise<this>;
     interface: ProxyAdminInterface;
-    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: {
-        changeProxyAdmin(proxy: string, newAdmin: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        getProxyAdmin(proxy: string, overrides?: CallOverrides): Promise<[string]>;
-        getProxyImplementation(proxy: string, overrides?: CallOverrides): Promise<[string]>;
-        owner(overrides?: CallOverrides): Promise<[string]>;
-        renounceOwnership(overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        upgrade(proxy: string, implementation: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        upgradeAndCall(proxy: string, implementation: string, data: BytesLike, overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-    };
-    changeProxyAdmin(proxy: string, newAdmin: string, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    getProxyAdmin(proxy: string, overrides?: CallOverrides): Promise<string>;
-    getProxyImplementation(proxy: string, overrides?: CallOverrides): Promise<string>;
-    owner(overrides?: CallOverrides): Promise<string>;
-    renounceOwnership(overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    transferOwnership(newOwner: string, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    upgrade(proxy: string, implementation: string, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    upgradeAndCall(proxy: string, implementation: string, data: BytesLike, overrides?: PayableOverrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    callStatic: {
-        changeProxyAdmin(proxy: string, newAdmin: string, overrides?: CallOverrides): Promise<void>;
-        getProxyAdmin(proxy: string, overrides?: CallOverrides): Promise<string>;
-        getProxyImplementation(proxy: string, overrides?: CallOverrides): Promise<string>;
-        owner(overrides?: CallOverrides): Promise<string>;
-        renounceOwnership(overrides?: CallOverrides): Promise<void>;
-        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
-        upgrade(proxy: string, implementation: string, overrides?: CallOverrides): Promise<void>;
-        upgradeAndCall(proxy: string, implementation: string, data: BytesLike, overrides?: CallOverrides): Promise<void>;
-    };
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    changeProxyAdmin: TypedContractMethod<[
+        proxy: AddressLike,
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getProxyAdmin: TypedContractMethod<[proxy: AddressLike], [string], "view">;
+    getProxyImplementation: TypedContractMethod<[
+        proxy: AddressLike
+    ], [
+        string
+    ], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgrade: TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    upgradeAndCall: TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "changeProxyAdmin"): TypedContractMethod<[
+        proxy: AddressLike,
+        newAdmin: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getProxyAdmin"): TypedContractMethod<[proxy: AddressLike], [string], "view">;
+    getFunction(nameOrSignature: "getProxyImplementation"): TypedContractMethod<[proxy: AddressLike], [string], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "upgrade"): TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "upgradeAndCall"): TypedContractMethod<[
+        proxy: AddressLike,
+        implementation: AddressLike,
+        data: BytesLike
+    ], [
+        void
+    ], "payable">;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
     filters: {
-        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
-        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
-    };
-    estimateGas: {
-        changeProxyAdmin(proxy: string, newAdmin: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        getProxyAdmin(proxy: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getProxyImplementation(proxy: string, overrides?: CallOverrides): Promise<BigNumber>;
-        owner(overrides?: CallOverrides): Promise<BigNumber>;
-        renounceOwnership(overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        upgrade(proxy: string, implementation: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        upgradeAndCall(proxy: string, implementation: string, data: BytesLike, overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-    };
-    populateTransaction: {
-        changeProxyAdmin(proxy: string, newAdmin: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        getProxyAdmin(proxy: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getProxyImplementation(proxy: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        renounceOwnership(overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        upgrade(proxy: string, implementation: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        upgradeAndCall(proxy: string, implementation: string, data: BytesLike, overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
     };
 }

package/dist/typechain-types/ProxyAdmin.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProxyAdmin.js.map

package/dist/typechain-types/ProxyAdmin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProxyAdmin.js","sourceRoot":"","sources":["../../typechain-types/ProxyAdmin.ts"],"names":[],"mappings":""}

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

@@ -1,21 +1,50 @@
-import type { Listener } from "@ethersproject/providers";
-import type { Event, EventFilter } from "ethers";
-export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
-    args: TArgsArray & TArgsObject;
+import type { FunctionFragment, Typed, EventFragment, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventLog, TransactionRequest, LogDescription } from "ethers";
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
 }
-export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {
+export interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
+    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: Partial<InputTuple>): EventFragment;
 }
-export interface TypedListener<TEvent extends TypedEvent> {
-    (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+export interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
 }
-type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
-export interface OnEvent<TRes> {
-    <TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>, listener: TypedListener<TEvent>): TRes;
-    (eventName: string, listener: Listener): TRes;
+export interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
 }
+export type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+]) => void;
 export type MinEthersFactory<C, ARGS> = {
     deploy(...a: ARGS[]): Promise<C>;
 };
 export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
 export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export type StateMutability = "nonpayable" | "payable" | "view";
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<BaseOverrides, "value" | "blockTag" | "enableCcipRead">;
+export type PayableOverrides = Omit<BaseOverrides, "blockTag" | "enableCcipRead">;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable" ? NonPayableOverrides : S extends "payable" ? PayableOverrides : ViewOverrides;
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
+export type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}, S>;
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+export interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = "payable"> {
+    (...args: ContractMethodArgs<A, S>): S extends "view" ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A, "view">): Promise<DefaultReturnType<R>>;
+    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
+}
 export {};

package/dist/typechain-types/common.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common.js.map

package/dist/typechain-types/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../typechain-types/common.ts"],"names":[],"mappings":""}