@raac/rpc 1.1.0-beta.92 → 1.2.0-beta.2

package/dist/types/typechain-types/contracts/mocks/libraries/governance/PowerCheckpointMock.d.ts

@@ -1,69 +1,38 @@
-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";
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
 export interface PowerCheckpointMockInterface extends Interface {
-    getFunction(nameOrSignature: "getCheckpointBlock" | "getCheckpointCount" | "getCheckpointValue" | "getCurrentBlockNumber" | "getPastTotalSupply" | "getVotingPowerAtTimestamp" | "setProposalSnapshot" | "writeCheckpoint"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "CheckpointCreated" | "CheckpointWritten" | "ProposalSnapshotSet"): EventFragment;
+    getFunction(nameOrSignature: "createLock" | "emergencyWithdrawAll" | "extendLock" | "findIndex" | "getCheckpointBlock" | "getCheckpointCount" | "getCheckpointValue" | "getCurrentBlockNumber" | "getPastTotalSupply" | "increaseLock" | "setLockParams" | "setProposalSnapshot" | "setTimePerBlock" | "withdrawExpired" | "writeCheckpoint"): FunctionFragment;
+    encodeFunctionData(functionFragment: "createLock", values: [AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "emergencyWithdrawAll", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "extendLock", values: [AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "findIndex", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "getCheckpointBlock", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "getCheckpointCount", values: [AddressLike]): string;
     encodeFunctionData(functionFragment: "getCheckpointValue", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "getCurrentBlockNumber", values?: undefined): string;
     encodeFunctionData(functionFragment: "getPastTotalSupply", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "getVotingPowerAtTimestamp", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "increaseLock", values: [AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setLockParams", values: [BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: "setProposalSnapshot", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setTimePerBlock", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawExpired", values: [AddressLike]): string;
     encodeFunctionData(functionFragment: "writeCheckpoint", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "emergencyWithdrawAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "extendLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "findIndex", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getCheckpointBlock", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getCheckpointCount", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getCheckpointValue", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getCurrentBlockNumber", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getPastTotalSupply", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "getVotingPowerAtTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLockParams", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "setProposalSnapshot", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTimePerBlock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawExpired", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "writeCheckpoint", data: BytesLike): Result;
 }
-export declare namespace CheckpointCreatedEvent {
-    type InputTuple = [
-        user: AddressLike,
-        blockNumber: BigNumberish,
-        power: BigNumberish
-    ];
-    type OutputTuple = [user: string, blockNumber: bigint, power: bigint];
-    interface OutputObject {
-        user: string;
-        blockNumber: bigint;
-        power: bigint;
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
-}
-export declare namespace CheckpointWrittenEvent {
-    type InputTuple = [blockNumber: BigNumberish, value: BigNumberish];
-    type OutputTuple = [blockNumber: bigint, value: bigint];
-    interface OutputObject {
-        blockNumber: bigint;
-        value: bigint;
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
-}
-export declare namespace ProposalSnapshotSetEvent {
-    type InputTuple = [
-        proposalId: BigNumberish,
-        blockNumber: BigNumberish
-    ];
-    type OutputTuple = [proposalId: bigint, blockNumber: bigint];
-    interface OutputObject {
-        proposalId: bigint;
-        blockNumber: bigint;
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
-}
 export interface PowerCheckpointMock extends BaseContract {
     connect(runner?: ContractRunner | null): PowerCheckpointMock;
     waitForDeployment(): Promise<this>;
@@ -77,6 +46,59 @@ export interface PowerCheckpointMock 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>;
+    createLock: TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        epochs: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            uBias: bigint;
+            gBias: bigint;
+            epochEnd: bigint;
+        }
+    ], "nonpayable">;
+    emergencyWithdrawAll: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            processedAmount: bigint;
+            processed: bigint;
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    extendLock: TypedContractMethod<[
+        user: AddressLike,
+        fromEpochEnd: BigNumberish,
+        addEpochs: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            newEpochEnd: bigint;
+            amount: bigint;
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    findIndex: TypedContractMethod<[
+        user: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
     getCheckpointBlock: TypedContractMethod<[
         index: BigNumberish
     ], [
@@ -99,18 +121,41 @@ export interface PowerCheckpointMock extends BaseContract {
     ], [
         bigint
     ], "view">;
-    getVotingPowerAtTimestamp: TypedContractMethod<[
+    increaseLock: TypedContractMethod<[
         user: AddressLike,
-        timestamp: BigNumberish
+        amountToAdd: BigNumberish,
+        epochEnd: BigNumberish
     ], [
-        bigint
-    ], "view">;
+        [bigint, bigint] & {
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    setLockParams: TypedContractMethod<[
+        epochDuration: BigNumberish,
+        maxLockEpochs: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
     setProposalSnapshot: TypedContractMethod<[
         proposalId: BigNumberish,
         blockNumber: BigNumberish
     ], [
         void
     ], "nonpayable">;
+    setTimePerBlock: TypedContractMethod<[
+        timePerBlock: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdrawExpired: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [bigint, bigint] & {
+            withdrawn: bigint;
+            processed: bigint;
+        }
+    ], "nonpayable">;
     writeCheckpoint: TypedContractMethod<[
         user: AddressLike,
         power: BigNumberish
@@ -118,6 +163,59 @@ export interface PowerCheckpointMock extends BaseContract {
         void
     ], "nonpayable">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "createLock"): TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        epochs: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            uBias: bigint;
+            gBias: bigint;
+            epochEnd: bigint;
+        }
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "emergencyWithdrawAll"): TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            processedAmount: bigint;
+            processed: bigint;
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "extendLock"): TypedContractMethod<[
+        user: AddressLike,
+        fromEpochEnd: BigNumberish,
+        addEpochs: BigNumberish
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            newEpochEnd: bigint;
+            amount: bigint;
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "findIndex"): TypedContractMethod<[
+        user: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
     getFunction(nameOrSignature: "getCheckpointBlock"): TypedContractMethod<[index: BigNumberish], [bigint], "view">;
     getFunction(nameOrSignature: "getCheckpointCount"): TypedContractMethod<[user: AddressLike], [bigint], "view">;
     getFunction(nameOrSignature: "getCheckpointValue"): TypedContractMethod<[
@@ -128,33 +226,42 @@ export interface PowerCheckpointMock extends BaseContract {
     ], "view">;
     getFunction(nameOrSignature: "getCurrentBlockNumber"): TypedContractMethod<[], [bigint], "view">;
     getFunction(nameOrSignature: "getPastTotalSupply"): TypedContractMethod<[blockNumber: BigNumberish], [bigint], "view">;
-    getFunction(nameOrSignature: "getVotingPowerAtTimestamp"): TypedContractMethod<[
+    getFunction(nameOrSignature: "increaseLock"): TypedContractMethod<[
         user: AddressLike,
-        timestamp: BigNumberish
+        amountToAdd: BigNumberish,
+        epochEnd: BigNumberish
     ], [
-        bigint
-    ], "view">;
+        [bigint, bigint] & {
+            uBias: bigint;
+            gBias: bigint;
+        }
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setLockParams"): TypedContractMethod<[
+        epochDuration: BigNumberish,
+        maxLockEpochs: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
     getFunction(nameOrSignature: "setProposalSnapshot"): TypedContractMethod<[
         proposalId: BigNumberish,
         blockNumber: BigNumberish
     ], [
         void
     ], "nonpayable">;
+    getFunction(nameOrSignature: "setTimePerBlock"): TypedContractMethod<[timePerBlock: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "withdrawExpired"): TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [bigint, bigint] & {
+            withdrawn: bigint;
+            processed: bigint;
+        }
+    ], "nonpayable">;
     getFunction(nameOrSignature: "writeCheckpoint"): TypedContractMethod<[
         user: AddressLike,
         power: BigNumberish
     ], [
         void
     ], "nonpayable">;
-    getEvent(key: "CheckpointCreated"): TypedContractEvent<CheckpointCreatedEvent.InputTuple, CheckpointCreatedEvent.OutputTuple, CheckpointCreatedEvent.OutputObject>;
-    getEvent(key: "CheckpointWritten"): TypedContractEvent<CheckpointWrittenEvent.InputTuple, CheckpointWrittenEvent.OutputTuple, CheckpointWrittenEvent.OutputObject>;
-    getEvent(key: "ProposalSnapshotSet"): TypedContractEvent<ProposalSnapshotSetEvent.InputTuple, ProposalSnapshotSetEvent.OutputTuple, ProposalSnapshotSetEvent.OutputObject>;
-    filters: {
-        "CheckpointCreated(address,uint256,uint256)": TypedContractEvent<CheckpointCreatedEvent.InputTuple, CheckpointCreatedEvent.OutputTuple, CheckpointCreatedEvent.OutputObject>;
-        CheckpointCreated: TypedContractEvent<CheckpointCreatedEvent.InputTuple, CheckpointCreatedEvent.OutputTuple, CheckpointCreatedEvent.OutputObject>;
-        "CheckpointWritten(uint32,uint224)": TypedContractEvent<CheckpointWrittenEvent.InputTuple, CheckpointWrittenEvent.OutputTuple, CheckpointWrittenEvent.OutputObject>;
-        CheckpointWritten: TypedContractEvent<CheckpointWrittenEvent.InputTuple, CheckpointWrittenEvent.OutputTuple, CheckpointWrittenEvent.OutputObject>;
-        "ProposalSnapshotSet(uint256,uint256)": TypedContractEvent<ProposalSnapshotSetEvent.InputTuple, ProposalSnapshotSetEvent.OutputTuple, ProposalSnapshotSetEvent.OutputObject>;
-        ProposalSnapshotSet: TypedContractEvent<ProposalSnapshotSetEvent.InputTuple, ProposalSnapshotSetEvent.OutputTuple, ProposalSnapshotSetEvent.OutputObject>;
-    };
+    filters: {};
 }

package/dist/types/typechain-types/contracts/mocks/libraries/governance/RagequitHarness.d.ts

@@ -0,0 +1,90 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../common";
+export interface RagequitHarnessInterface extends Interface {
+    getFunction(nameOrSignature: "cappedRemaining" | "computeFeesForLock" | "splitVariable"): FunctionFragment;
+    encodeFunctionData(functionFragment: "cappedRemaining", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "computeFeesForLock", values: [
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    encodeFunctionData(functionFragment: "splitVariable", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "cappedRemaining", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "computeFeesForLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "splitVariable", data: BytesLike): Result;
+}
+export interface RagequitHarness extends BaseContract {
+    connect(runner?: ContractRunner | null): RagequitHarness;
+    waitForDeployment(): Promise<this>;
+    interface: RagequitHarnessInterface;
+    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>;
+    cappedRemaining: TypedContractMethod<[
+        unlockTime: BigNumberish,
+        nowTs: BigNumberish,
+        maxDuration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    computeFeesForLock: TypedContractMethod<[
+        amount: BigNumberish,
+        remainingTime: BigNumberish,
+        maxDuration: BigNumberish,
+        fixedExitFee: BigNumberish,
+        maxVariableExitFee: BigNumberish,
+        bpsDenominator: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            fixedFee: bigint;
+            variableFee: bigint;
+        }
+    ], "view">;
+    splitVariable: TypedContractMethod<[
+        variableFee: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            toTreasury: bigint;
+            toStream: bigint;
+        }
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "cappedRemaining"): TypedContractMethod<[
+        unlockTime: BigNumberish,
+        nowTs: BigNumberish,
+        maxDuration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "computeFeesForLock"): TypedContractMethod<[
+        amount: BigNumberish,
+        remainingTime: BigNumberish,
+        maxDuration: BigNumberish,
+        fixedExitFee: BigNumberish,
+        maxVariableExitFee: BigNumberish,
+        bpsDenominator: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            fixedFee: bigint;
+            variableFee: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "splitVariable"): TypedContractMethod<[
+        variableFee: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            toTreasury: bigint;
+            toStream: bigint;
+        }
+    ], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/libraries/governance/RewardIntegralCalculatorMock.sol/MockRewardIntegralCalculator.d.ts

@@ -0,0 +1,188 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../../common";
+export interface MockRewardIntegralCalculatorInterface extends Interface {
+    getFunction(nameOrSignature: "calculateGaugeIntegral" | "calculatePeriodBoundariesFromIndex" | "calculatePeriodBoundariesFromTime" | "calculatePeriodIndexFromTime" | "calculateRate" | "calculateUserIntegral" | "calculateWorkingBalance" | "recalculateRate"): FunctionFragment;
+    encodeFunctionData(functionFragment: "calculateGaugeIntegral", values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculatePeriodBoundariesFromIndex", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculatePeriodBoundariesFromTime", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculatePeriodIndexFromTime", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateRate", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateUserIntegral", values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateWorkingBalance", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "recalculateRate", values: [
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish,
+        BigNumberish
+    ]): string;
+    decodeFunctionResult(functionFragment: "calculateGaugeIntegral", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePeriodBoundariesFromIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePeriodBoundariesFromTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePeriodIndexFromTime", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateRate", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateUserIntegral", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateWorkingBalance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recalculateRate", data: BytesLike): Result;
+}
+export interface MockRewardIntegralCalculator extends BaseContract {
+    connect(runner?: ContractRunner | null): MockRewardIntegralCalculator;
+    waitForDeployment(): Promise<this>;
+    interface: MockRewardIntegralCalculatorInterface;
+    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>;
+    calculateGaugeIntegral: TypedContractMethod<[
+        currentIntegral: BigNumberish,
+        rate: BigNumberish,
+        timeDelta: BigNumberish,
+        workingSupply: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculatePeriodBoundariesFromIndex: TypedContractMethod<[
+        periodIndex: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            periodStartTime: bigint;
+            periodEndTime: bigint;
+        }
+    ], "view">;
+    calculatePeriodBoundariesFromTime: TypedContractMethod<[
+        time: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            periodStartTime: bigint;
+            periodEndTime: bigint;
+        }
+    ], "view">;
+    calculatePeriodIndexFromTime: TypedContractMethod<[
+        time: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculateRate: TypedContractMethod<[
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculateUserIntegral: TypedContractMethod<[
+        userWorkingBalance: BigNumberish,
+        gaugeIntegral: BigNumberish,
+        userLastGaugeIntegral: BigNumberish,
+        userIntegral: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            newUserIntegral: bigint;
+            claimableRewards: bigint;
+        }
+    ], "view">;
+    calculateWorkingBalance: TypedContractMethod<[
+        balance: BigNumberish,
+        userWeight: BigNumberish,
+        maxBoost: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    recalculateRate: TypedContractMethod<[
+        currentRate: BigNumberish,
+        oldWorkingSupply: BigNumberish,
+        newWorkingSupply: BigNumberish,
+        remainingTime: BigNumberish,
+        lastUpdateTime: BigNumberish,
+        currentTime: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            newRate: bigint;
+            accruedRewards: bigint;
+        }
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "calculateGaugeIntegral"): TypedContractMethod<[
+        currentIntegral: BigNumberish,
+        rate: BigNumberish,
+        timeDelta: BigNumberish,
+        workingSupply: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculatePeriodBoundariesFromIndex"): TypedContractMethod<[
+        periodIndex: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            periodStartTime: bigint;
+            periodEndTime: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "calculatePeriodBoundariesFromTime"): TypedContractMethod<[
+        time: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            periodStartTime: bigint;
+            periodEndTime: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "calculatePeriodIndexFromTime"): TypedContractMethod<[
+        time: BigNumberish,
+        gaugeInitialStartTime: BigNumberish,
+        periodDuration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculateRate"): TypedContractMethod<[
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculateUserIntegral"): TypedContractMethod<[
+        userWorkingBalance: BigNumberish,
+        gaugeIntegral: BigNumberish,
+        userLastGaugeIntegral: BigNumberish,
+        userIntegral: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            newUserIntegral: bigint;
+            claimableRewards: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "calculateWorkingBalance"): TypedContractMethod<[
+        balance: BigNumberish,
+        userWeight: BigNumberish,
+        maxBoost: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "recalculateRate"): TypedContractMethod<[
+        currentRate: BigNumberish,
+        oldWorkingSupply: BigNumberish,
+        newWorkingSupply: BigNumberish,
+        remainingTime: BigNumberish,
+        lastUpdateTime: BigNumberish,
+        currentTime: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            newRate: bigint;
+            accruedRewards: bigint;
+        }
+    ], "view">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/libraries/governance/RewardIntegralCalculatorMock.sol/index.d.ts

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

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

@@ -1,3 +1,5 @@
+import type * as rewardIntegralCalculatorMockSol from "./RewardIntegralCalculatorMock.sol";
+export type { rewardIntegralCalculatorMockSol };
 export type { BoostCalculatorMock } from "./BoostCalculatorMock";
-export type { LockManagerMock } from "./LockManagerMock";
 export type { PowerCheckpointMock } from "./PowerCheckpointMock";
+export type { RagequitHarness } from "./RagequitHarness";

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

@@ -5,3 +5,4 @@ export type { math };
 import type * as pools from "./pools";
 export type { pools };
 export type { MockStringUtils } from "./MockStringUtils";
+export type { MockTimeUtils } from "./MockTimeUtils";