@raac/rpc 1.0.0 → 1.0.1

package/dist/types/typechain-types/contracts/mocks/libraries/math/TimeWeightedAverageMock.d.ts

@@ -0,0 +1,203 @@
+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 declare namespace TimeWeightedAverage {
+    type PeriodParamsStruct = {
+        startTime: BigNumberish;
+        endTime: BigNumberish;
+        value: BigNumberish;
+        weight: BigNumberish;
+    };
+    type PeriodParamsStructOutput = [
+        startTime: bigint,
+        endTime: bigint,
+        value: bigint,
+        weight: bigint
+    ] & {
+        startTime: bigint;
+        endTime: bigint;
+        value: bigint;
+        weight: bigint;
+    };
+    type PeriodStruct = {
+        startTime: BigNumberish;
+        endTime: BigNumberish;
+        lastUpdateTime: BigNumberish;
+        value: BigNumberish;
+        weightedSum: BigNumberish;
+        totalDuration: BigNumberish;
+        weight: BigNumberish;
+    };
+    type PeriodStructOutput = [
+        startTime: bigint,
+        endTime: bigint,
+        lastUpdateTime: bigint,
+        value: bigint,
+        weightedSum: bigint,
+        totalDuration: bigint,
+        weight: bigint
+    ] & {
+        startTime: bigint;
+        endTime: bigint;
+        lastUpdateTime: bigint;
+        value: bigint;
+        weightedSum: bigint;
+        totalDuration: bigint;
+        weight: bigint;
+    };
+}
+export interface TimeWeightedAverageMockInterface extends Interface {
+    getFunction(nameOrSignature: "calculateAverage" | "calculateTimeWeightedAverage" | "createPeriod" | "getCurrentValue" | "getPeriodDetails" | "getPeriodValue" | "period" | "updateValue"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "PeriodCreated"): EventFragment;
+    encodeFunctionData(functionFragment: "calculateAverage", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateTimeWeightedAverage", values: [TimeWeightedAverage.PeriodParamsStruct[], BigNumberish]): string;
+    encodeFunctionData(functionFragment: "createPeriod", values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getCurrentValue", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPeriodDetails", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPeriodValue", values?: undefined): string;
+    encodeFunctionData(functionFragment: "period", values?: undefined): string;
+    encodeFunctionData(functionFragment: "updateValue", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "calculateAverage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateTimeWeightedAverage", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createPeriod", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPeriodDetails", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPeriodValue", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "period", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateValue", data: BytesLike): Result;
+}
+export declare namespace PeriodCreatedEvent {
+    type InputTuple = [
+        startTime: BigNumberish,
+        duration: BigNumberish,
+        initialValue: BigNumberish
+    ];
+    type OutputTuple = [
+        startTime: bigint,
+        duration: bigint,
+        initialValue: bigint
+    ];
+    interface OutputObject {
+        startTime: bigint;
+        duration: bigint;
+        initialValue: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface TimeWeightedAverageMock extends BaseContract {
+    connect(runner?: ContractRunner | null): TimeWeightedAverageMock;
+    waitForDeployment(): Promise<this>;
+    interface: TimeWeightedAverageMockInterface;
+    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>;
+    calculateAverage: TypedContractMethod<[
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculateTimeWeightedAverage: TypedContractMethod<[
+        periods: TimeWeightedAverage.PeriodParamsStruct[],
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    createPeriod: TypedContractMethod<[
+        startTime: BigNumberish,
+        duration: BigNumberish,
+        initialValue: BigNumberish,
+        weight: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getCurrentValue: TypedContractMethod<[], [bigint], "view">;
+    getPeriodDetails: TypedContractMethod<[
+    ], [
+        TimeWeightedAverage.PeriodStructOutput
+    ], "view">;
+    getPeriodValue: TypedContractMethod<[], [bigint], "view">;
+    period: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            startTime: bigint;
+            endTime: bigint;
+            lastUpdateTime: bigint;
+            value: bigint;
+            weightedSum: bigint;
+            totalDuration: bigint;
+            weight: bigint;
+        }
+    ], "view">;
+    updateValue: TypedContractMethod<[
+        newValue: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "calculateAverage"): TypedContractMethod<[timestamp: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "calculateTimeWeightedAverage"): TypedContractMethod<[
+        periods: TimeWeightedAverage.PeriodParamsStruct[],
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "createPeriod"): TypedContractMethod<[
+        startTime: BigNumberish,
+        duration: BigNumberish,
+        initialValue: BigNumberish,
+        weight: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getCurrentValue"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getPeriodDetails"): TypedContractMethod<[], [TimeWeightedAverage.PeriodStructOutput], "view">;
+    getFunction(nameOrSignature: "getPeriodValue"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "period"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            startTime: bigint;
+            endTime: bigint;
+            lastUpdateTime: bigint;
+            value: bigint;
+            weightedSum: bigint;
+            totalDuration: bigint;
+            weight: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "updateValue"): TypedContractMethod<[
+        newValue: BigNumberish,
+        timestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "PeriodCreated"): TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
+    filters: {
+        "PeriodCreated(uint256,uint256,uint256)": TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
+        PeriodCreated: TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/mocks/libraries/math/WadRayMathMock.d.ts

@@ -0,0 +1,78 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface WadRayMathMockInterface extends Interface {
+    getFunction(nameOrSignature: "rayDiv" | "rayExp" | "rayMul" | "rayPow" | "rayToWad" | "wadDiv" | "wadMul" | "wadToRay"): FunctionFragment;
+    encodeFunctionData(functionFragment: "rayDiv", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "rayExp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "rayMul", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "rayPow", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "rayToWad", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wadDiv", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wadMul", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wadToRay", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "rayDiv", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rayExp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rayMul", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rayPow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "rayToWad", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wadDiv", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wadMul", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wadToRay", data: BytesLike): Result;
+}
+export interface WadRayMathMock extends BaseContract {
+    connect(runner?: ContractRunner | null): WadRayMathMock;
+    waitForDeployment(): Promise<this>;
+    interface: WadRayMathMockInterface;
+    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>;
+    rayDiv: TypedContractMethod<[
+        a: BigNumberish,
+        b: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    rayExp: TypedContractMethod<[x: BigNumberish], [bigint], "view">;
+    rayMul: TypedContractMethod<[
+        a: BigNumberish,
+        b: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    rayPow: TypedContractMethod<[
+        x: BigNumberish,
+        n: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    rayToWad: TypedContractMethod<[a: BigNumberish], [bigint], "view">;
+    wadDiv: TypedContractMethod<[
+        a: BigNumberish,
+        b: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    wadMul: TypedContractMethod<[
+        a: BigNumberish,
+        b: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    wadToRay: TypedContractMethod<[a: BigNumberish], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "rayDiv"): TypedContractMethod<[a: BigNumberish, b: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "rayExp"): TypedContractMethod<[x: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "rayMul"): TypedContractMethod<[a: BigNumberish, b: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "rayPow"): TypedContractMethod<[x: BigNumberish, n: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "rayToWad"): TypedContractMethod<[a: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "wadDiv"): TypedContractMethod<[a: BigNumberish, b: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "wadMul"): TypedContractMethod<[a: BigNumberish, b: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "wadToRay"): TypedContractMethod<[a: BigNumberish], [bigint], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/libraries/math/index.d.ts

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

package/dist/types/typechain-types/contracts/mocks/libraries/pools/ReserveLibraryMock.d.ts

@@ -0,0 +1,225 @@
+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 ReserveLibraryMockInterface extends Interface {
+    getFunction(nameOrSignature: "calculateCompoundedInterest" | "calculateUtilizationRate" | "deposit" | "getRateData" | "getReserveData" | "setLastUpdateTimestamp" | "setPrimeRate" | "setRateParameters" | "withdraw"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "InterestRatesUpdated" | "PrimeRateUpdated" | "ReserveInterestsUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "calculateCompoundedInterest", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateUtilizationRate", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getRateData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getReserveData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setLastUpdateTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setPrimeRate", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setRateParameters", values: [
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "withdraw", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "calculateCompoundedInterest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateUtilizationRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRateData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getReserveData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLastUpdateTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPrimeRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setRateParameters", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+}
+export declare namespace InterestRatesUpdatedEvent {
+    type InputTuple = [
+        liquidityRate: BigNumberish,
+        usageRate: BigNumberish
+    ];
+    type OutputTuple = [liquidityRate: bigint, usageRate: bigint];
+    interface OutputObject {
+        liquidityRate: bigint;
+        usageRate: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace PrimeRateUpdatedEvent {
+    type InputTuple = [
+        oldPrimeRate: BigNumberish,
+        newPrimeRate: BigNumberish
+    ];
+    type OutputTuple = [oldPrimeRate: bigint, newPrimeRate: bigint];
+    interface OutputObject {
+        oldPrimeRate: bigint;
+        newPrimeRate: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace ReserveInterestsUpdatedEvent {
+    type InputTuple = [
+        liquidityIndex: BigNumberish,
+        usageIndex: BigNumberish
+    ];
+    type OutputTuple = [liquidityIndex: bigint, usageIndex: bigint];
+    interface OutputObject {
+        liquidityIndex: bigint;
+        usageIndex: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ReserveLibraryMock extends BaseContract {
+    connect(runner?: ContractRunner | null): ReserveLibraryMock;
+    waitForDeployment(): Promise<this>;
+    interface: ReserveLibraryMockInterface;
+    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>;
+    calculateCompoundedInterest: TypedContractMethod<[
+        rate: BigNumberish,
+        timeDelta: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculateUtilizationRate: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[amount: BigNumberish], [bigint], "nonpayable">;
+    getRateData: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            currentLiquidityRate: bigint;
+            currentUsageRate: bigint;
+            primeRate: bigint;
+            baseRate: bigint;
+            optimalRate: bigint;
+            maxRate: bigint;
+            optimalUtilizationRate: bigint;
+            protocolFeeRate: bigint;
+        }
+    ], "view">;
+    getReserveData: TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            totalLiquidity: bigint;
+            totalUsage: bigint;
+            liquidityIndex: bigint;
+            usageIndex: bigint;
+            lastUpdateTimestamp: bigint;
+        }
+    ], "view">;
+    setLastUpdateTimestamp: TypedContractMethod<[
+        timestamp: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setPrimeRate: TypedContractMethod<[
+        newPrimeRate: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setRateParameters: TypedContractMethod<[
+        baseRate_: BigNumberish,
+        primeRate_: BigNumberish,
+        optimalRate_: BigNumberish,
+        maxRate_: BigNumberish,
+        optimalUtilizationRate_: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdraw: TypedContractMethod<[amount: BigNumberish], [bigint], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "calculateCompoundedInterest"): TypedContractMethod<[
+        rate: BigNumberish,
+        timeDelta: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculateUtilizationRate"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[amount: BigNumberish], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "getRateData"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            currentLiquidityRate: bigint;
+            currentUsageRate: bigint;
+            primeRate: bigint;
+            baseRate: bigint;
+            optimalRate: bigint;
+            maxRate: bigint;
+            optimalUtilizationRate: bigint;
+            protocolFeeRate: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getReserveData"): TypedContractMethod<[
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            totalLiquidity: bigint;
+            totalUsage: bigint;
+            liquidityIndex: bigint;
+            usageIndex: bigint;
+            lastUpdateTimestamp: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "setLastUpdateTimestamp"): TypedContractMethod<[timestamp: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPrimeRate"): TypedContractMethod<[newPrimeRate: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setRateParameters"): TypedContractMethod<[
+        baseRate_: BigNumberish,
+        primeRate_: BigNumberish,
+        optimalRate_: BigNumberish,
+        maxRate_: BigNumberish,
+        optimalUtilizationRate_: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[amount: BigNumberish], [bigint], "nonpayable">;
+    getEvent(key: "InterestRatesUpdated"): TypedContractEvent<InterestRatesUpdatedEvent.InputTuple, InterestRatesUpdatedEvent.OutputTuple, InterestRatesUpdatedEvent.OutputObject>;
+    getEvent(key: "PrimeRateUpdated"): TypedContractEvent<PrimeRateUpdatedEvent.InputTuple, PrimeRateUpdatedEvent.OutputTuple, PrimeRateUpdatedEvent.OutputObject>;
+    getEvent(key: "ReserveInterestsUpdated"): TypedContractEvent<ReserveInterestsUpdatedEvent.InputTuple, ReserveInterestsUpdatedEvent.OutputTuple, ReserveInterestsUpdatedEvent.OutputObject>;
+    filters: {
+        "InterestRatesUpdated(uint256,uint256)": TypedContractEvent<InterestRatesUpdatedEvent.InputTuple, InterestRatesUpdatedEvent.OutputTuple, InterestRatesUpdatedEvent.OutputObject>;
+        InterestRatesUpdated: TypedContractEvent<InterestRatesUpdatedEvent.InputTuple, InterestRatesUpdatedEvent.OutputTuple, InterestRatesUpdatedEvent.OutputObject>;
+        "PrimeRateUpdated(uint256,uint256)": TypedContractEvent<PrimeRateUpdatedEvent.InputTuple, PrimeRateUpdatedEvent.OutputTuple, PrimeRateUpdatedEvent.OutputObject>;
+        PrimeRateUpdated: TypedContractEvent<PrimeRateUpdatedEvent.InputTuple, PrimeRateUpdatedEvent.OutputTuple, PrimeRateUpdatedEvent.OutputObject>;
+        "ReserveInterestsUpdated(uint256,uint256)": TypedContractEvent<ReserveInterestsUpdatedEvent.InputTuple, ReserveInterestsUpdatedEvent.OutputTuple, ReserveInterestsUpdatedEvent.OutputObject>;
+        ReserveInterestsUpdated: TypedContractEvent<ReserveInterestsUpdatedEvent.InputTuple, ReserveInterestsUpdatedEvent.OutputTuple, ReserveInterestsUpdatedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/mocks/libraries/pools/index.d.ts

@@ -0,0 +1 @@
+export type { ReserveLibraryMock } from "./ReserveLibraryMock";

package/dist/types/typechain-types/contracts/mocks/tests/MaliciousDeposit.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface MaliciousDepositInterface extends Interface {
+    getFunction(nameOrSignature: "attack" | "target"): FunctionFragment;
+    encodeFunctionData(functionFragment: "attack", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "target", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "attack", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "target", data: BytesLike): Result;
+}
+export interface MaliciousDeposit extends BaseContract {
+    connect(runner?: ContractRunner | null): MaliciousDeposit;
+    waitForDeployment(): Promise<this>;
+    interface: MaliciousDepositInterface;
+    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>;
+    attack: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    target: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "attack"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "target"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/tests/MaliciousWithdraw.d.ts

@@ -0,0 +1,29 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface MaliciousWithdrawInterface extends Interface {
+    getFunction(nameOrSignature: "attack" | "target"): FunctionFragment;
+    encodeFunctionData(functionFragment: "attack", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "target", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "attack", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "target", data: BytesLike): Result;
+}
+export interface MaliciousWithdraw extends BaseContract {
+    connect(runner?: ContractRunner | null): MaliciousWithdraw;
+    waitForDeployment(): Promise<this>;
+    interface: MaliciousWithdrawInterface;
+    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>;
+    attack: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    target: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "attack"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "target"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/tests/VeRAACFuzzHelper.d.ts

@@ -0,0 +1,71 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
+export interface VeRAACFuzzHelperInterface extends Interface {
+    getFunction(nameOrSignature: "generateBoostScenario" | "generateLockScenario" | "veToken"): FunctionFragment;
+    encodeFunctionData(functionFragment: "generateBoostScenario", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "generateLockScenario", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "veToken", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "generateBoostScenario", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "generateLockScenario", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "veToken", data: BytesLike): Result;
+}
+export interface VeRAACFuzzHelper extends BaseContract {
+    connect(runner?: ContractRunner | null): VeRAACFuzzHelper;
+    waitForDeployment(): Promise<this>;
+    interface: VeRAACFuzzHelperInterface;
+    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>;
+    generateBoostScenario: TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            amount: bigint;
+            lockAmount: bigint;
+            totalSupply: bigint;
+        }
+    ], "view">;
+    generateLockScenario: TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            amount: bigint;
+            duration: bigint;
+        }
+    ], "view">;
+    veToken: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "generateBoostScenario"): TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            amount: bigint;
+            lockAmount: bigint;
+            totalSupply: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "generateLockScenario"): TypedContractMethod<[
+        seed: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            amount: bigint;
+            duration: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "veToken"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}