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

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

@@ -1,67 +1,11 @@
-import type { BaseContract, BigNumberish, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../common";
 export interface LockManagerInterface extends Interface {
-    getEvent(nameOrSignatureOrTopic: "LockCreated" | "LockExtended" | "LockIncreased" | "LockWithdrawn"): EventFragment;
-}
-export declare namespace LockCreatedEvent {
-    type InputTuple = [
-        user: AddressLike,
-        amount: BigNumberish,
-        start: BigNumberish,
-        end: BigNumberish
-    ];
-    type OutputTuple = [
-        user: string,
-        amount: bigint,
-        start: bigint,
-        end: bigint
-    ];
-    interface OutputObject {
-        user: string;
-        amount: bigint;
-        start: 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 declare namespace LockWithdrawnEvent {
-    type InputTuple = [user: AddressLike, amount: BigNumberish];
-    type OutputTuple = [user: string, amount: bigint];
-    interface OutputObject {
-        user: string;
-        amount: bigint;
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
+    getFunction(nameOrSignature: "MAX_CASTABLE_INT128" | "roundUpToWeek"): FunctionFragment;
+    encodeFunctionData(functionFragment: "MAX_CASTABLE_INT128", values?: undefined): string;
+    encodeFunctionData(functionFragment: "roundUpToWeek", values: [BigNumberish, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "MAX_CASTABLE_INT128", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "roundUpToWeek", data: BytesLike): Result;
 }
 export interface LockManager extends BaseContract {
     connect(runner?: ContractRunner | null): LockManager;
@@ -76,19 +20,20 @@ export interface LockManager 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>;
+    MAX_CASTABLE_INT128: TypedContractMethod<[], [bigint], "view">;
+    roundUpToWeek: TypedContractMethod<[
+        timestamp: BigNumberish,
+        WEEK: BigNumberish
+    ], [
+        bigint
+    ], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    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>;
-    getEvent(key: "LockWithdrawn"): TypedContractEvent<LockWithdrawnEvent.InputTuple, LockWithdrawnEvent.OutputTuple, LockWithdrawnEvent.OutputObject>;
-    filters: {
-        "LockCreated(address,uint256,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>;
-        "LockWithdrawn(address,uint256)": TypedContractEvent<LockWithdrawnEvent.InputTuple, LockWithdrawnEvent.OutputTuple, LockWithdrawnEvent.OutputObject>;
-        LockWithdrawn: TypedContractEvent<LockWithdrawnEvent.InputTuple, LockWithdrawnEvent.OutputTuple, LockWithdrawnEvent.OutputObject>;
-    };
+    getFunction(nameOrSignature: "MAX_CASTABLE_INT128"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "roundUpToWeek"): TypedContractMethod<[
+        timestamp: BigNumberish,
+        WEEK: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    filters: {};
 }

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

@@ -1,66 +1,6 @@
-import type { BaseContract, BigNumberish, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
 export interface PowerCheckpointInterface extends Interface {
-    getEvent(nameOrSignatureOrTopic: "BatchCheckpointsWritten" | "CheckpointCreated" | "CheckpointWritten" | "ProposalSnapshotSet"): EventFragment;
-}
-export declare namespace BatchCheckpointsWrittenEvent {
-    type InputTuple = [
-        blockNumbers: BigNumberish[],
-        values: BigNumberish[]
-    ];
-    type OutputTuple = [blockNumbers: bigint[], values: bigint[]];
-    interface OutputObject {
-        blockNumbers: bigint[];
-        values: bigint[];
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
-}
-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 PowerCheckpoint extends BaseContract {
     connect(runner?: ContractRunner | null): PowerCheckpoint;
@@ -76,18 +16,5 @@ export interface PowerCheckpoint extends BaseContract {
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getEvent(key: "BatchCheckpointsWritten"): TypedContractEvent<BatchCheckpointsWrittenEvent.InputTuple, BatchCheckpointsWrittenEvent.OutputTuple, BatchCheckpointsWrittenEvent.OutputObject>;
-    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: {
-        "BatchCheckpointsWritten(uint32[],uint224[])": TypedContractEvent<BatchCheckpointsWrittenEvent.InputTuple, BatchCheckpointsWrittenEvent.OutputTuple, BatchCheckpointsWrittenEvent.OutputObject>;
-        BatchCheckpointsWritten: TypedContractEvent<BatchCheckpointsWrittenEvent.InputTuple, BatchCheckpointsWrittenEvent.OutputTuple, BatchCheckpointsWrittenEvent.OutputObject>;
-        "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/{@openzeppelin/contracts/proxy/Proxy.d.ts → contracts/libraries/governance/RagequitLib.d.ts}

@@ -1,11 +1,11 @@
 import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
 import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../../../common";
-export interface ProxyInterface extends Interface {
+export interface RagequitLibInterface extends Interface {
 }
-export interface Proxy extends BaseContract {
-    connect(runner?: ContractRunner | null): Proxy;
+export interface RagequitLib extends BaseContract {
+    connect(runner?: ContractRunner | null): RagequitLib;
     waitForDeployment(): Promise<this>;
-    interface: ProxyInterface;
+    interface: RagequitLibInterface;
     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>;

package/dist/types/typechain-types/{@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.d.ts → contracts/libraries/governance/RewardLib.d.ts}

@@ -1,23 +1,36 @@
-import type { BaseContract, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../../common";
-export interface ERC1967ProxyInterface extends Interface {
-    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
+import type { BaseContract, BigNumberish, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
+export interface RewardLibInterface extends Interface {
+    getEvent(nameOrSignatureOrTopic: "RewardPaid"): EventFragment;
 }
-export declare namespace UpgradedEvent {
-    type InputTuple = [implementation: AddressLike];
-    type OutputTuple = [implementation: string];
+export declare namespace RewardPaidEvent {
+    type InputTuple = [
+        token: AddressLike,
+        user: AddressLike,
+        reward: BigNumberish,
+        index: BigNumberish
+    ];
+    type OutputTuple = [
+        token: string,
+        user: string,
+        reward: bigint,
+        index: bigint
+    ];
     interface OutputObject {
-        implementation: string;
+        token: string;
+        user: string;
+        reward: bigint;
+        index: bigint;
     }
     type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
     type Filter = TypedDeferredTopicFilter<Event>;
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
-export interface ERC1967Proxy extends BaseContract {
-    connect(runner?: ContractRunner | null): ERC1967Proxy;
+export interface RewardLib extends BaseContract {
+    connect(runner?: ContractRunner | null): RewardLib;
     waitForDeployment(): Promise<this>;
-    interface: ERC1967ProxyInterface;
+    interface: RewardLibInterface;
     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>;
@@ -28,9 +41,9 @@ export interface ERC1967Proxy extends BaseContract {
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getEvent(key: "Upgraded"): TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+    getEvent(key: "RewardPaid"): TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
     filters: {
-        "Upgraded(address)": TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
-        Upgraded: TypedContractEvent<UpgradedEvent.InputTuple, UpgradedEvent.OutputTuple, UpgradedEvent.OutputObject>;
+        "RewardPaid(address,address,uint256,uint256)": TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
+        RewardPaid: TypedContractEvent<RewardPaidEvent.InputTuple, RewardPaidEvent.OutputTuple, RewardPaidEvent.OutputObject>;
     };
 }

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

@@ -1,3 +1,5 @@
 export type { BoostCalculator } from "./BoostCalculator";
 export type { LockManager } from "./LockManager";
 export type { PowerCheckpoint } from "./PowerCheckpoint";
+export type { RagequitLib } from "./RagequitLib";
+export type { RewardLib } from "./RewardLib";

package/dist/types/typechain-types/contracts/mocks/ERC20BurnableMock.d.ts

@@ -0,0 +1,173 @@
+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 ERC20BurnableMockInterface extends Interface {
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "burn" | "burnFrom" | "decimals" | "mint" | "name" | "symbol" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "burn", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "burnFrom", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "mint", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
+}
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, value: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, value: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        value: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface ERC20BurnableMock extends BaseContract {
+    connect(runner?: ContractRunner | null): ERC20BurnableMock;
+    waitForDeployment(): Promise<this>;
+    interface: ERC20BurnableMockInterface;
+    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>;
+    allowance: TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    burn: TypedContractMethod<[value: BigNumberish], [void], "nonpayable">;
+    burnFrom: TypedContractMethod<[
+        account: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    mint: TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    totalSupply: TypedContractMethod<[], [bigint], "view">;
+    transfer: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        owner: AddressLike,
+        spender: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "burn"): TypedContractMethod<[value: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "burnFrom"): TypedContractMethod<[
+        account: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "mint"): TypedContractMethod<[
+        to: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    filters: {
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+    };
+}

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

@@ -1,4 +1,6 @@
 import type * as gauges from "./gauges";
 export type { gauges };
+import type * as libraries from "./libraries";
+export type { libraries };
 import type * as proposals from "./proposals";
 export type { proposals };