@raac/rpc 1.0.0 → 1.0.1

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

@@ -0,0 +1,163 @@
+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 declare namespace LockManager {
+    type LockStruct = {
+        amount: BigNumberish;
+        end: BigNumberish;
+        exists: boolean;
+    };
+    type LockStructOutput = [
+        amount: bigint,
+        end: bigint,
+        exists: boolean
+    ] & {
+        amount: bigint;
+        end: bigint;
+        exists: boolean;
+    };
+}
+export interface LockManagerMockInterface extends Interface {
+    getFunction(nameOrSignature: "createLock" | "extendLock" | "getLock" | "getTotalLocked" | "increaseLock" | "setLockDurations"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "LockCreated" | "LockExtended" | "LockIncreased"): EventFragment;
+    encodeFunctionData(functionFragment: "createLock", values: [AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "extendLock", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getLock", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getTotalLocked", values?: undefined): string;
+    encodeFunctionData(functionFragment: "increaseLock", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setLockDurations", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "extendLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTotalLocked", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseLock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLockDurations", data: BytesLike): Result;
+}
+export declare namespace LockCreatedEvent {
+    type InputTuple = [
+        user: AddressLike,
+        amount: BigNumberish,
+        end: BigNumberish
+    ];
+    type OutputTuple = [user: string, amount: bigint, end: bigint];
+    interface OutputObject {
+        user: string;
+        amount: bigint;
+        end: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace LockExtendedEvent {
+    type InputTuple = [user: AddressLike, newEnd: BigNumberish];
+    type OutputTuple = [user: string, newEnd: bigint];
+    interface OutputObject {
+        user: string;
+        newEnd: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace LockIncreasedEvent {
+    type InputTuple = [user: AddressLike, additionalAmount: BigNumberish];
+    type OutputTuple = [user: string, additionalAmount: bigint];
+    interface OutputObject {
+        user: string;
+        additionalAmount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface LockManagerMock extends BaseContract {
+    connect(runner?: ContractRunner | null): LockManagerMock;
+    waitForDeployment(): Promise<this>;
+    interface: LockManagerMockInterface;
+    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>;
+    createLock: TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    extendLock: TypedContractMethod<[
+        user: AddressLike,
+        newDuration: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getLock: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        LockManager.LockStructOutput
+    ], "view">;
+    getTotalLocked: TypedContractMethod<[], [bigint], "view">;
+    increaseLock: TypedContractMethod<[
+        user: AddressLike,
+        additionalAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    setLockDurations: TypedContractMethod<[
+        min: BigNumberish,
+        max: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "createLock"): TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "extendLock"): TypedContractMethod<[
+        user: AddressLike,
+        newDuration: BigNumberish
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "getLock"): TypedContractMethod<[
+        user: AddressLike
+    ], [
+        LockManager.LockStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getTotalLocked"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "increaseLock"): TypedContractMethod<[
+        user: AddressLike,
+        additionalAmount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setLockDurations"): TypedContractMethod<[
+        min: BigNumberish,
+        max: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "LockCreated"): TypedContractEvent<LockCreatedEvent.InputTuple, LockCreatedEvent.OutputTuple, LockCreatedEvent.OutputObject>;
+    getEvent(key: "LockExtended"): TypedContractEvent<LockExtendedEvent.InputTuple, LockExtendedEvent.OutputTuple, LockExtendedEvent.OutputObject>;
+    getEvent(key: "LockIncreased"): TypedContractEvent<LockIncreasedEvent.InputTuple, LockIncreasedEvent.OutputTuple, LockIncreasedEvent.OutputObject>;
+    filters: {
+        "LockCreated(address,uint256,uint256)": TypedContractEvent<LockCreatedEvent.InputTuple, LockCreatedEvent.OutputTuple, LockCreatedEvent.OutputObject>;
+        LockCreated: TypedContractEvent<LockCreatedEvent.InputTuple, LockCreatedEvent.OutputTuple, LockCreatedEvent.OutputObject>;
+        "LockExtended(address,uint256)": TypedContractEvent<LockExtendedEvent.InputTuple, LockExtendedEvent.OutputTuple, LockExtendedEvent.OutputObject>;
+        LockExtended: TypedContractEvent<LockExtendedEvent.InputTuple, LockExtendedEvent.OutputTuple, LockExtendedEvent.OutputObject>;
+        "LockIncreased(address,uint256)": TypedContractEvent<LockIncreasedEvent.InputTuple, LockIncreasedEvent.OutputTuple, LockIncreasedEvent.OutputObject>;
+        LockIncreased: TypedContractEvent<LockIncreasedEvent.InputTuple, LockIncreasedEvent.OutputTuple, LockIncreasedEvent.OutputObject>;
+    };
+}

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

@@ -0,0 +1,141 @@
+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 PowerCheckpointMockInterface extends Interface {
+    getFunction(nameOrSignature: "getCheckpointBlock" | "getCheckpointCount" | "getPastTotalSupply" | "getPastVotes" | "getPastVotingPower" | "setProposalSnapshot" | "writeCheckpoint"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "CheckpointCreated" | "ProposalSnapshotSet"): EventFragment;
+    encodeFunctionData(functionFragment: "getCheckpointBlock", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getCheckpointCount", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getPastTotalSupply", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getPastVotes", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getPastVotingPower", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setProposalSnapshot", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "writeCheckpoint", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "getCheckpointBlock", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCheckpointCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPastTotalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPastVotes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPastVotingPower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setProposalSnapshot", 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 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>;
+    interface: PowerCheckpointMockInterface;
+    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>;
+    getCheckpointBlock: TypedContractMethod<[
+        index: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getCheckpointCount: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getPastTotalSupply: TypedContractMethod<[
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getPastVotes: TypedContractMethod<[
+        account: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getPastVotingPower: TypedContractMethod<[
+        user: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    setProposalSnapshot: TypedContractMethod<[
+        proposalId: BigNumberish,
+        blockNumber: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    writeCheckpoint: TypedContractMethod<[
+        user: AddressLike,
+        power: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getCheckpointBlock"): TypedContractMethod<[index: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "getCheckpointCount"): TypedContractMethod<[user: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getPastTotalSupply"): TypedContractMethod<[blockNumber: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "getPastVotes"): TypedContractMethod<[
+        account: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "getPastVotingPower"): TypedContractMethod<[
+        user: AddressLike,
+        blockNumber: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "setProposalSnapshot"): TypedContractMethod<[
+        proposalId: BigNumberish,
+        blockNumber: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "writeCheckpoint"): TypedContractMethod<[
+        user: AddressLike,
+        power: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "CheckpointCreated"): TypedContractEvent<CheckpointCreatedEvent.InputTuple, CheckpointCreatedEvent.OutputTuple, CheckpointCreatedEvent.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>;
+        "ProposalSnapshotSet(uint256,uint256)": TypedContractEvent<ProposalSnapshotSetEvent.InputTuple, ProposalSnapshotSetEvent.OutputTuple, ProposalSnapshotSetEvent.OutputObject>;
+        ProposalSnapshotSet: TypedContractEvent<ProposalSnapshotSetEvent.InputTuple, ProposalSnapshotSetEvent.OutputTuple, ProposalSnapshotSetEvent.OutputObject>;
+    };
+}

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

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

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

@@ -0,0 +1,281 @@
+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 declare namespace Checkpoints {
+    type CheckpointStruct = {
+        fromBlock: BigNumberish;
+        value: BigNumberish;
+    };
+    type CheckpointStructOutput = [fromBlock: bigint, value: bigint] & {
+        fromBlock: bigint;
+        value: bigint;
+    };
+}
+export interface VotingPowerMockInterface extends Interface {
+    getFunction(nameOrSignature: "MAX_BOOST" | "batchUpdatePower" | "batchWriteCheckpoints" | "calculateAndUpdatePower" | "calculateBoost" | "calculateInitialPower" | "calculatePowerAtTimestamp" | "getCheckpointAt" | "getCheckpointCount" | "getCurrentPower" | "getLastAccountCheckpoint" | "getPoint" | "getSlopeChange" | "writeCheckpoint"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "PowerUpdated" | "VotingPowerUpdated"): EventFragment;
+    encodeFunctionData(functionFragment: "MAX_BOOST", values?: undefined): string;
+    encodeFunctionData(functionFragment: "batchUpdatePower", values: [AddressLike[], BigNumberish[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "batchWriteCheckpoints", values: [AddressLike, BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "calculateAndUpdatePower", values: [AddressLike, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateBoost", values: [BigNumberish, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculateInitialPower", values: [BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "calculatePowerAtTimestamp", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getCheckpointAt", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getCheckpointCount", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getCurrentPower", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getLastAccountCheckpoint", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getPoint", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getSlopeChange", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "writeCheckpoint", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "MAX_BOOST", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "batchUpdatePower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "batchWriteCheckpoints", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateAndUpdatePower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateBoost", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculateInitialPower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "calculatePowerAtTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCheckpointAt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCheckpointCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCurrentPower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLastAccountCheckpoint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPoint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getSlopeChange", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "writeCheckpoint", data: BytesLike): Result;
+}
+export declare namespace PowerUpdatedEvent {
+    type InputTuple = [
+        user: AddressLike,
+        amount: BigNumberish,
+        unlockTime: BigNumberish,
+        bias: BigNumberish,
+        slope: BigNumberish
+    ];
+    type OutputTuple = [
+        user: string,
+        amount: bigint,
+        unlockTime: bigint,
+        bias: bigint,
+        slope: bigint
+    ];
+    interface OutputObject {
+        user: string;
+        amount: bigint;
+        unlockTime: bigint;
+        bias: bigint;
+        slope: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace VotingPowerUpdatedEvent {
+    type InputTuple = [
+        user: AddressLike,
+        oldPower: BigNumberish,
+        newPower: BigNumberish
+    ];
+    type OutputTuple = [user: string, oldPower: bigint, newPower: bigint];
+    interface OutputObject {
+        user: string;
+        oldPower: bigint;
+        newPower: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface VotingPowerMock extends BaseContract {
+    connect(runner?: ContractRunner | null): VotingPowerMock;
+    waitForDeployment(): Promise<this>;
+    interface: VotingPowerMockInterface;
+    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>;
+    MAX_BOOST: TypedContractMethod<[], [bigint], "view">;
+    batchUpdatePower: TypedContractMethod<[
+        users: AddressLike[],
+        amounts: BigNumberish[],
+        unlockTimes: BigNumberish[]
+    ], [
+        bigint
+    ], "nonpayable">;
+    batchWriteCheckpoints: TypedContractMethod<[
+        user: AddressLike,
+        powers: BigNumberish[]
+    ], [
+        bigint
+    ], "nonpayable">;
+    calculateAndUpdatePower: TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        unlockTime: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            bias: bigint;
+            slope: bigint;
+        }
+    ], "nonpayable">;
+    calculateBoost: TypedContractMethod<[
+        userBalance: BigNumberish,
+        totalSupply: BigNumberish,
+        amount: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculateInitialPower: TypedContractMethod<[
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    calculatePowerAtTimestamp: TypedContractMethod<[
+        account: AddressLike,
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getCheckpointAt: TypedContractMethod<[
+        account: AddressLike,
+        index: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            fromBlock: bigint;
+            value: bigint;
+        }
+    ], "view">;
+    getCheckpointCount: TypedContractMethod<[
+        account: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getCurrentPower: TypedContractMethod<[
+        account: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getLastAccountCheckpoint: TypedContractMethod<[
+        account: AddressLike
+    ], [
+        Checkpoints.CheckpointStructOutput
+    ], "view">;
+    getPoint: TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            bias: bigint;
+            slope: bigint;
+            timestamp: bigint;
+        }
+    ], "view">;
+    getSlopeChange: TypedContractMethod<[
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    writeCheckpoint: TypedContractMethod<[
+        account: AddressLike,
+        newPower: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "MAX_BOOST"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "batchUpdatePower"): TypedContractMethod<[
+        users: AddressLike[],
+        amounts: BigNumberish[],
+        unlockTimes: BigNumberish[]
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "batchWriteCheckpoints"): TypedContractMethod<[
+        user: AddressLike,
+        powers: BigNumberish[]
+    ], [
+        bigint
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "calculateAndUpdatePower"): TypedContractMethod<[
+        user: AddressLike,
+        amount: BigNumberish,
+        unlockTime: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            bias: bigint;
+            slope: bigint;
+        }
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "calculateBoost"): TypedContractMethod<[
+        userBalance: BigNumberish,
+        totalSupply: BigNumberish,
+        amount: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculateInitialPower"): TypedContractMethod<[
+        amount: BigNumberish,
+        duration: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "calculatePowerAtTimestamp"): TypedContractMethod<[
+        account: AddressLike,
+        timestamp: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "getCheckpointAt"): TypedContractMethod<[
+        account: AddressLike,
+        index: BigNumberish
+    ], [
+        [bigint, bigint] & {
+            fromBlock: bigint;
+            value: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getCheckpointCount"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getCurrentPower"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getLastAccountCheckpoint"): TypedContractMethod<[
+        account: AddressLike
+    ], [
+        Checkpoints.CheckpointStructOutput
+    ], "view">;
+    getFunction(nameOrSignature: "getPoint"): TypedContractMethod<[
+        user: AddressLike
+    ], [
+        [
+            bigint,
+            bigint,
+            bigint
+        ] & {
+            bias: bigint;
+            slope: bigint;
+            timestamp: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "getSlopeChange"): TypedContractMethod<[timestamp: BigNumberish], [bigint], "view">;
+    getFunction(nameOrSignature: "writeCheckpoint"): TypedContractMethod<[
+        account: AddressLike,
+        newPower: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "PowerUpdated"): TypedContractEvent<PowerUpdatedEvent.InputTuple, PowerUpdatedEvent.OutputTuple, PowerUpdatedEvent.OutputObject>;
+    getEvent(key: "VotingPowerUpdated"): TypedContractEvent<VotingPowerUpdatedEvent.InputTuple, VotingPowerUpdatedEvent.OutputTuple, VotingPowerUpdatedEvent.OutputObject>;
+    filters: {
+        "PowerUpdated(address,uint256,uint256,int128,int128)": TypedContractEvent<PowerUpdatedEvent.InputTuple, PowerUpdatedEvent.OutputTuple, PowerUpdatedEvent.OutputObject>;
+        PowerUpdated: TypedContractEvent<PowerUpdatedEvent.InputTuple, PowerUpdatedEvent.OutputTuple, PowerUpdatedEvent.OutputObject>;
+        "VotingPowerUpdated(address,uint256,uint256)": TypedContractEvent<VotingPowerUpdatedEvent.InputTuple, VotingPowerUpdatedEvent.OutputTuple, VotingPowerUpdatedEvent.OutputObject>;
+        VotingPowerUpdated: TypedContractEvent<VotingPowerUpdatedEvent.InputTuple, VotingPowerUpdatedEvent.OutputTuple, VotingPowerUpdatedEvent.OutputObject>;
+    };
+}

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

@@ -0,0 +1,6 @@
+export type { BoostCalculatorMock } from "./BoostCalculatorMock";
+export type { CheckpointsMock } from "./CheckpointsMock";
+export type { LockManagerMock } from "./LockManagerMock";
+export type { PowerCheckpointMock } from "./PowerCheckpointMock";
+export type { RAACVotingMock } from "./RAACVotingMock";
+export type { VotingPowerMock } from "./VotingPowerMock";

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

@@ -0,0 +1,6 @@
+import type * as governance from "./governance";
+export type { governance };
+import type * as math from "./math";
+export type { math };
+import type * as pools from "./pools";
+export type { pools };