@raac/rpc 1.1.0-beta.8 → 1.1.0-beta.80

package/dist/types/typechain-types/contracts/mocks/core/oracles/MockChainlinkAggregator.d.ts

@@ -0,0 +1,151 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface MockChainlinkAggregatorInterface extends Interface {
+    getFunction(nameOrSignature: "decimals" | "description" | "getRoundData" | "latestRoundData" | "updateAnswer" | "updateAnswerWithTimestamp" | "version"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AnswerUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "description", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getRoundData", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "latestRoundData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateAnswer", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "updateAnswerWithTimestamp", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "version", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "description", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoundData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestRoundData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateAnswer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateAnswerWithTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+export declare namespace AnswerUpdatedEvent {
+    type InputTuple = [
+        current: BigNumberish,
+        roundId: BigNumberish,
+        updatedAt: BigNumberish
+    ];
+    type OutputTuple = [
+        current: bigint,
+        roundId: bigint,
+        updatedAt: bigint
+    ];
+    interface OutputObject {
+        current: bigint;
+        roundId: bigint;
+        updatedAt: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface MockChainlinkAggregator extends BaseContract {
+    connect(runner?: ContractRunner | null): MockChainlinkAggregator;
+    waitForDeployment(): Promise<this>;
+    interface: MockChainlinkAggregatorInterface;
+    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>;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    description: TypedContractMethod<[], [string], "view">;
+    getRoundData: TypedContractMethod<[
+        roundId: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            id: bigint;
+            answer: bigint;
+            startedAt: bigint;
+            updatedAt: bigint;
+            answeredInRound: bigint;
+        }
+    ], "view">;
+    latestRoundData: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            roundId: bigint;
+            answer: bigint;
+            startedAt: bigint;
+            updatedAt: bigint;
+            answeredInRound: bigint;
+        }
+    ], "view">;
+    updateAnswer: TypedContractMethod<[
+        newAnswer: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    updateAnswerWithTimestamp: TypedContractMethod<[
+        newAnswer: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    version: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "description"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getRoundData"): TypedContractMethod<[
+        roundId: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            id: bigint;
+            answer: bigint;
+            startedAt: bigint;
+            updatedAt: bigint;
+            answeredInRound: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "latestRoundData"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            roundId: bigint;
+            answer: bigint;
+            startedAt: bigint;
+            updatedAt: bigint;
+            answeredInRound: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "updateAnswer"): TypedContractMethod<[newAnswer: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "updateAnswerWithTimestamp"): TypedContractMethod<[
+        newAnswer: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "version"): TypedContractMethod<[], [bigint], "view">;
+    getEvent(key: "AnswerUpdated"): TypedContractEvent<AnswerUpdatedEvent.InputTuple, AnswerUpdatedEvent.OutputTuple, AnswerUpdatedEvent.OutputObject>;
+    filters: {
+        "AnswerUpdated(int256,uint256,uint256)": TypedContractEvent<AnswerUpdatedEvent.InputTuple, AnswerUpdatedEvent.OutputTuple, AnswerUpdatedEvent.OutputObject>;
+        AnswerUpdated: TypedContractEvent<AnswerUpdatedEvent.InputTuple, AnswerUpdatedEvent.OutputTuple, AnswerUpdatedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/{interfaces/IHousePrices.d.ts → mocks/core/oracles/MockCurveEMA.sol/ICrvUsdCurveOracle.d.ts}

@@ -1,14 +1,14 @@
 import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../common";
-export interface IHousePricesInterface extends Interface {
-    getFunction(nameOrSignature: "tokenToHousePrice"): FunctionFragment;
-    encodeFunctionData(functionFragment: "tokenToHousePrice", values: [BigNumberish]): string;
-    decodeFunctionResult(functionFragment: "tokenToHousePrice", data: BytesLike): Result;
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../../common";
+export interface ICrvUsdCurveOracleInterface extends Interface {
+    getFunction(nameOrSignature: "price_oracle"): FunctionFragment;
+    encodeFunctionData(functionFragment: "price_oracle", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "price_oracle", data: BytesLike): Result;
 }
-export interface IHousePrices extends BaseContract {
-    connect(runner?: ContractRunner | null): IHousePrices;
+export interface ICrvUsdCurveOracle extends BaseContract {
+    connect(runner?: ContractRunner | null): ICrvUsdCurveOracle;
     waitForDeployment(): Promise<this>;
-    interface: IHousePricesInterface;
+    interface: ICrvUsdCurveOracleInterface;
     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>;
@@ -18,12 +18,8 @@ export interface IHousePrices extends BaseContract {
     listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
-    tokenToHousePrice: TypedContractMethod<[
-        tokenId: BigNumberish
-    ], [
-        bigint
-    ], "view">;
+    price_oracle: TypedContractMethod<[k: BigNumberish], [bigint], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: "tokenToHousePrice"): TypedContractMethod<[tokenId: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "price_oracle"): TypedContractMethod<[k: BigNumberish], [bigint], "view">;
     filters: {};
 }

package/dist/types/typechain-types/contracts/mocks/core/oracles/MockCurveEMA.sol/MockCurveEMA.d.ts

@@ -0,0 +1,59 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../../common";
+export interface MockCurveEMAInterface extends Interface {
+    getFunction(nameOrSignature: "lastUpdated" | "price" | "price_oracle" | "setLastUpdated" | "setPrice" | "setPriceWithTime"): FunctionFragment;
+    encodeFunctionData(functionFragment: "lastUpdated", values?: undefined): string;
+    encodeFunctionData(functionFragment: "price", values?: undefined): string;
+    encodeFunctionData(functionFragment: "price_oracle", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setLastUpdated", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setPrice", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setPriceWithTime", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "lastUpdated", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "price", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "price_oracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLastUpdated", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPriceWithTime", data: BytesLike): Result;
+}
+export interface MockCurveEMA extends BaseContract {
+    connect(runner?: ContractRunner | null): MockCurveEMA;
+    waitForDeployment(): Promise<this>;
+    interface: MockCurveEMAInterface;
+    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>;
+    lastUpdated: TypedContractMethod<[], [bigint], "view">;
+    price: TypedContractMethod<[], [bigint], "view">;
+    price_oracle: TypedContractMethod<[k: BigNumberish], [bigint], "view">;
+    setLastUpdated: TypedContractMethod<[
+        _lastUpdated: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setPrice: TypedContractMethod<[_price: BigNumberish], [void], "nonpayable">;
+    setPriceWithTime: TypedContractMethod<[
+        _price: BigNumberish,
+        _lastUpdated: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "lastUpdated"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "price"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "price_oracle"): TypedContractMethod<[k: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "setLastUpdated"): TypedContractMethod<[_lastUpdated: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPrice"): TypedContractMethod<[_price: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPriceWithTime"): TypedContractMethod<[
+        _price: BigNumberish,
+        _lastUpdated: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/core/oracles/MockCurveEMA.sol/index.d.ts

@@ -0,0 +1,2 @@
+export type { ICrvUsdCurveOracle } from "./ICrvUsdCurveOracle";
+export type { MockCurveEMA } from "./MockCurveEMA";

package/dist/types/typechain-types/contracts/mocks/core/oracles/{MockERC20PriceOracle.sol/MockERC20PriceOracle.d.ts → MockERC20PriceOracle.d.ts}

@@ -1,5 +1,5 @@
 import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../../common";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
 export interface MockERC20PriceOracleInterface extends Interface {
     getFunction(nameOrSignature: "getLatestPrice" | "setLatestPrice"): FunctionFragment;
     encodeFunctionData(functionFragment: "getLatestPrice", values?: undefined): string;

package/dist/types/typechain-types/contracts/mocks/core/oracles/MockRAACNFTVaultAdapterNAVOracle.d.ts

@@ -0,0 +1,169 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface MockRAACNFTVaultAdapterNAVOracleInterface extends Interface {
+    getFunction(nameOrSignature: "decimals" | "getNAV" | "getOracleStatus" | "owner" | "recover" | "renounceOwnership" | "revertMessage" | "setNAV" | "setRevertBehavior" | "shouldRevert" | "simulateTemporaryFailure" | "timestamp" | "transferOwnership"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "NAVUpdated" | "OwnershipTransferred" | "RevertBehaviorChanged"): EventFragment;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getNAV", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getOracleStatus", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "recover", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "revertMessage", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setNAV", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setRevertBehavior", values: [boolean, string]): string;
+    encodeFunctionData(functionFragment: "shouldRevert", values?: undefined): string;
+    encodeFunctionData(functionFragment: "simulateTemporaryFailure", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "timestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getNAV", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOracleStatus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recover", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "revertMessage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setNAV", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRevertBehavior", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "shouldRevert", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "simulateTemporaryFailure", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "timestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+}
+export declare namespace NAVUpdatedEvent {
+    type InputTuple = [
+        previousValue: BigNumberish,
+        newValue: BigNumberish,
+        updatedBy: AddressLike
+    ];
+    type OutputTuple = [
+        previousValue: bigint,
+        newValue: bigint,
+        updatedBy: string
+    ];
+    interface OutputObject {
+        previousValue: bigint;
+        newValue: bigint;
+        updatedBy: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+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 declare namespace RevertBehaviorChangedEvent {
+    type InputTuple = [shouldRevert: boolean, message: string];
+    type OutputTuple = [shouldRevert: boolean, message: string];
+    interface OutputObject {
+        shouldRevert: boolean;
+        message: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface MockRAACNFTVaultAdapterNAVOracle extends BaseContract {
+    connect(runner?: ContractRunner | null): MockRAACNFTVaultAdapterNAVOracle;
+    waitForDeployment(): Promise<this>;
+    interface: MockRAACNFTVaultAdapterNAVOracleInterface;
+    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>;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    getNAV: TypedContractMethod<[], [[bigint, bigint, bigint]], "view">;
+    getOracleStatus: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            boolean,
+            string
+        ] & {
+            currentNAV: bigint;
+            willRevert: boolean;
+            message: string;
+        }
+    ], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    recover: TypedContractMethod<[], [void], "nonpayable">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    revertMessage: TypedContractMethod<[], [string], "view">;
+    setNAV: TypedContractMethod<[_newNAV: BigNumberish], [void], "nonpayable">;
+    setRevertBehavior: TypedContractMethod<[
+        _shouldRevert: boolean,
+        _revertMessage: string
+    ], [
+        void
+    ], "nonpayable">;
+    shouldRevert: TypedContractMethod<[], [boolean], "view">;
+    simulateTemporaryFailure: TypedContractMethod<[
+        _duration: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    timestamp: TypedContractMethod<[], [bigint], "view">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getNAV"): TypedContractMethod<[], [[bigint, bigint, bigint]], "view">;
+    getFunction(nameOrSignature: "getOracleStatus"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            boolean,
+            string
+        ] & {
+            currentNAV: bigint;
+            willRevert: boolean;
+            message: string;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "recover"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "revertMessage"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "setNAV"): TypedContractMethod<[_newNAV: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setRevertBehavior"): TypedContractMethod<[
+        _shouldRevert: boolean,
+        _revertMessage: string
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "shouldRevert"): TypedContractMethod<[], [boolean], "view">;
+    getFunction(nameOrSignature: "simulateTemporaryFailure"): TypedContractMethod<[_duration: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "timestamp"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getEvent(key: "NAVUpdated"): TypedContractEvent<NAVUpdatedEvent.InputTuple, NAVUpdatedEvent.OutputTuple, NAVUpdatedEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    getEvent(key: "RevertBehaviorChanged"): TypedContractEvent<RevertBehaviorChangedEvent.InputTuple, RevertBehaviorChangedEvent.OutputTuple, RevertBehaviorChangedEvent.OutputObject>;
+    filters: {
+        "NAVUpdated(uint256,uint256,address)": TypedContractEvent<NAVUpdatedEvent.InputTuple, NAVUpdatedEvent.OutputTuple, NAVUpdatedEvent.OutputObject>;
+        NAVUpdated: TypedContractEvent<NAVUpdatedEvent.InputTuple, NAVUpdatedEvent.OutputTuple, NAVUpdatedEvent.OutputObject>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        "RevertBehaviorChanged(bool,string)": TypedContractEvent<RevertBehaviorChangedEvent.InputTuple, RevertBehaviorChangedEvent.OutputTuple, RevertBehaviorChangedEvent.OutputObject>;
+        RevertBehaviorChanged: TypedContractEvent<RevertBehaviorChangedEvent.InputTuple, RevertBehaviorChangedEvent.OutputTuple, RevertBehaviorChangedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/mocks/core/oracles/MockZKMEVerifyUpgradeable.d.ts

@@ -0,0 +1,171 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../../common";
+export interface MockZKMEVerifyUpgradeableInterface extends Interface {
+    getFunction(nameOrSignature: "getApprovalInfo" | "getUserTokenId" | "hasApproved" | "mockApprove" | "mockBatchApprove" | "mockResetCooperator" | "mockRevoke"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approve" | "Revoke"): EventFragment;
+    encodeFunctionData(functionFragment: "getApprovalInfo", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "getUserTokenId", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "hasApproved", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "mockApprove", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "mockBatchApprove", values: [AddressLike, AddressLike[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "mockResetCooperator", values: [AddressLike, AddressLike[]]): string;
+    encodeFunctionData(functionFragment: "mockRevoke", values: [AddressLike, AddressLike]): string;
+    decodeFunctionResult(functionFragment: "getApprovalInfo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getUserTokenId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "hasApproved", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mockApprove", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mockBatchApprove", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mockResetCooperator", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mockRevoke", data: BytesLike): Result;
+}
+export declare namespace ApproveEvent {
+    type InputTuple = [
+        cooperator: AddressLike,
+        user: AddressLike,
+        tokenId: BigNumberish
+    ];
+    type OutputTuple = [cooperator: string, user: string, tokenId: bigint];
+    interface OutputObject {
+        cooperator: string;
+        user: string;
+        tokenId: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RevokeEvent {
+    type InputTuple = [
+        cooperator: AddressLike,
+        user: AddressLike,
+        tokenId: BigNumberish
+    ];
+    type OutputTuple = [cooperator: string, user: string, tokenId: bigint];
+    interface OutputObject {
+        cooperator: string;
+        user: string;
+        tokenId: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface MockZKMEVerifyUpgradeable extends BaseContract {
+    connect(runner?: ContractRunner | null): MockZKMEVerifyUpgradeable;
+    waitForDeployment(): Promise<this>;
+    interface: MockZKMEVerifyUpgradeableInterface;
+    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>;
+    getApprovalInfo: TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        [boolean, bigint] & {
+            approved: boolean;
+            tokenId: bigint;
+        }
+    ], "view">;
+    getUserTokenId: TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    hasApproved: TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    mockApprove: TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike,
+        tokenId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    mockBatchApprove: TypedContractMethod<[
+        cooperator: AddressLike,
+        users: AddressLike[],
+        tokenIds: BigNumberish[]
+    ], [
+        void
+    ], "nonpayable">;
+    mockResetCooperator: TypedContractMethod<[
+        cooperator: AddressLike,
+        users: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    mockRevoke: TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getApprovalInfo"): TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        [boolean, bigint] & {
+            approved: boolean;
+            tokenId: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getUserTokenId"): TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "hasApproved"): TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "mockApprove"): TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike,
+        tokenId: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "mockBatchApprove"): TypedContractMethod<[
+        cooperator: AddressLike,
+        users: AddressLike[],
+        tokenIds: BigNumberish[]
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "mockResetCooperator"): TypedContractMethod<[
+        cooperator: AddressLike,
+        users: AddressLike[]
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "mockRevoke"): TypedContractMethod<[
+        cooperator: AddressLike,
+        user: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Approve"): TypedContractEvent<ApproveEvent.InputTuple, ApproveEvent.OutputTuple, ApproveEvent.OutputObject>;
+    getEvent(key: "Revoke"): TypedContractEvent<RevokeEvent.InputTuple, RevokeEvent.OutputTuple, RevokeEvent.OutputObject>;
+    filters: {
+        "Approve(address,address,uint256)": TypedContractEvent<ApproveEvent.InputTuple, ApproveEvent.OutputTuple, ApproveEvent.OutputObject>;
+        Approve: TypedContractEvent<ApproveEvent.InputTuple, ApproveEvent.OutputTuple, ApproveEvent.OutputObject>;
+        "Revoke(address,address,uint256)": TypedContractEvent<RevokeEvent.InputTuple, RevokeEvent.OutputTuple, RevokeEvent.OutputObject>;
+        Revoke: TypedContractEvent<RevokeEvent.InputTuple, RevokeEvent.OutputTuple, RevokeEvent.OutputObject>;
+    };
+}