@raac/rpc 1.1.0-beta.4 → 1.1.0-beta.40

package/dist/types/typechain-types/contracts/interfaces/index.d.ts

@@ -4,10 +4,8 @@ import type * as curve from "./curve";
 export type { curve };
 import type * as zeno from "./zeno";
 export type { zeno };
+export type { IComplianceRegistry } from "./IComplianceRegistry";
 export type { IERC20 } from "./IERC20";
-export type { IHousePrices } from "./IHousePrices";
 export type { INFTLiquidator } from "./INFTLiquidator";
-export type { IPoolManager } from "./IPoolManager";
-export type { IReserveAllocationLibraryMock } from "./IReserveAllocationLibraryMock";
+export type { INFTWhitelist } from "./INFTWhitelist";
 export type { IUSDC } from "./IUSDC";
-export type { IveRAACDistributor } from "./IveRAACDistributor";

package/dist/types/typechain-types/contracts/interfaces/zeno/IAuction.d.ts

@@ -48,7 +48,7 @@ export declare namespace IAuction {
 }
 export interface IAuctionInterface extends Interface {
     getFunction(nameOrSignature: "buy" | "checkAuctionEnded" | "getDetails" | "getPrice"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "AuctionEnded" | "ZENOPurchased"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "AuctionEnded" | "EmergencyERC20Refund" | "ZENOPurchased"): EventFragment;
     encodeFunctionData(functionFragment: "buy", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "checkAuctionEnded", values?: undefined): string;
     encodeFunctionData(functionFragment: "getDetails", values?: undefined): string;
@@ -69,6 +69,18 @@ export declare namespace AuctionEndedEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+export declare namespace EmergencyERC20RefundEvent {
+    type InputTuple = [token: AddressLike, amount: BigNumberish];
+    type OutputTuple = [token: string, amount: bigint];
+    interface OutputObject {
+        token: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
 export declare namespace ZENOPurchasedEvent {
     type InputTuple = [
         buyer: AddressLike,
@@ -100,7 +112,7 @@ export interface IAuction extends BaseContract {
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
     buy: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
-    checkAuctionEnded: TypedContractMethod<[], [void], "nonpayable">;
+    checkAuctionEnded: TypedContractMethod<[], [boolean], "nonpayable">;
     getDetails: TypedContractMethod<[
     ], [
         IAuction.AuctionDetailsStructOutput
@@ -108,14 +120,17 @@ export interface IAuction extends BaseContract {
     getPrice: TypedContractMethod<[], [bigint], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
     getFunction(nameOrSignature: "buy"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
-    getFunction(nameOrSignature: "checkAuctionEnded"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "checkAuctionEnded"): TypedContractMethod<[], [boolean], "nonpayable">;
     getFunction(nameOrSignature: "getDetails"): TypedContractMethod<[], [IAuction.AuctionDetailsStructOutput], "view">;
     getFunction(nameOrSignature: "getPrice"): TypedContractMethod<[], [bigint], "view">;
     getEvent(key: "AuctionEnded"): TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
+    getEvent(key: "EmergencyERC20Refund"): TypedContractEvent<EmergencyERC20RefundEvent.InputTuple, EmergencyERC20RefundEvent.OutputTuple, EmergencyERC20RefundEvent.OutputObject>;
     getEvent(key: "ZENOPurchased"): TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
     filters: {
         "AuctionEnded(uint256)": TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
         AuctionEnded: TypedContractEvent<AuctionEndedEvent.InputTuple, AuctionEndedEvent.OutputTuple, AuctionEndedEvent.OutputObject>;
+        "EmergencyERC20Refund(address,uint256)": TypedContractEvent<EmergencyERC20RefundEvent.InputTuple, EmergencyERC20RefundEvent.OutputTuple, EmergencyERC20RefundEvent.OutputObject>;
+        EmergencyERC20Refund: TypedContractEvent<EmergencyERC20RefundEvent.InputTuple, EmergencyERC20RefundEvent.OutputTuple, EmergencyERC20RefundEvent.OutputObject>;
         "ZENOPurchased(address,uint256,uint256)": TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
         ZENOPurchased: TypedContractEvent<ZENOPurchasedEvent.InputTuple, ZENOPurchasedEvent.OutputTuple, ZENOPurchasedEvent.OutputObject>;
     };

package/dist/types/typechain-types/contracts/interfaces/zeno/IZENO.d.ts

@@ -21,7 +21,7 @@ export declare namespace IZENO {
 }
 export interface IZENOInterface extends Interface {
     getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "getDetails" | "isRedeemable" | "mint" | "redeem" | "redeemAll" | "totalSupply" | "totalZENOMinted" | "totalZENORedeemed" | "transfer" | "transferFrom"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "EmergencyUnderlyingWithdraw" | "Redeemed" | "Transfer"): EventFragment;
     encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
@@ -66,6 +66,30 @@ export declare namespace ApprovalEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
+export declare namespace EmergencyUnderlyingWithdrawEvent {
+    type InputTuple = [to: AddressLike, amount: BigNumberish];
+    type OutputTuple = [to: string, amount: bigint];
+    interface OutputObject {
+        to: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace RedeemedEvent {
+    type InputTuple = [redeemer: AddressLike, amount: BigNumberish];
+    type OutputTuple = [redeemer: string, amount: bigint];
+    interface OutputObject {
+        redeemer: string;
+        amount: 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,
@@ -176,10 +200,16 @@ export interface IZENO extends BaseContract {
         boolean
     ], "nonpayable">;
     getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "EmergencyUnderlyingWithdraw"): TypedContractEvent<EmergencyUnderlyingWithdrawEvent.InputTuple, EmergencyUnderlyingWithdrawEvent.OutputTuple, EmergencyUnderlyingWithdrawEvent.OutputObject>;
+    getEvent(key: "Redeemed"): TypedContractEvent<RedeemedEvent.InputTuple, RedeemedEvent.OutputTuple, RedeemedEvent.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>;
+        "EmergencyUnderlyingWithdraw(address,uint256)": TypedContractEvent<EmergencyUnderlyingWithdrawEvent.InputTuple, EmergencyUnderlyingWithdrawEvent.OutputTuple, EmergencyUnderlyingWithdrawEvent.OutputObject>;
+        EmergencyUnderlyingWithdraw: TypedContractEvent<EmergencyUnderlyingWithdrawEvent.InputTuple, EmergencyUnderlyingWithdrawEvent.OutputTuple, EmergencyUnderlyingWithdrawEvent.OutputObject>;
+        "Redeemed(address,uint256)": TypedContractEvent<RedeemedEvent.InputTuple, RedeemedEvent.OutputTuple, RedeemedEvent.OutputObject>;
+        Redeemed: TypedContractEvent<RedeemedEvent.InputTuple, RedeemedEvent.OutputTuple, RedeemedEvent.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/libraries/governance/LockManager.d.ts

@@ -7,12 +7,19 @@ export declare namespace LockCreatedEvent {
     type InputTuple = [
         user: AddressLike,
         amount: BigNumberish,
+        start: BigNumberish,
         end: BigNumberish
     ];
-    type OutputTuple = [user: string, amount: bigint, end: bigint];
+    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>;
@@ -75,7 +82,7 @@ export interface LockManager extends BaseContract {
     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)": TypedContractEvent<LockCreatedEvent.InputTuple, LockCreatedEvent.OutputTuple, LockCreatedEvent.OutputObject>;
+        "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>;

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

@@ -1,7 +1,22 @@
 import type { BaseContract, BigNumberish, FunctionFragment, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
 import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
 export interface PowerCheckpointInterface extends Interface {
-    getEvent(nameOrSignatureOrTopic: "CheckpointCreated" | "ProposalSnapshotSet"): EventFragment;
+    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 = [
@@ -20,6 +35,18 @@ export declare namespace CheckpointCreatedEvent {
     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,
@@ -49,11 +76,17 @@ 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>;
     };

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

@@ -1,6 +1,3 @@
 export type { BoostCalculator } from "./BoostCalculator";
-export type { Checkpoints } from "./Checkpoints";
 export type { LockManager } from "./LockManager";
 export type { PowerCheckpoint } from "./PowerCheckpoint";
-export type { RAACVoting } from "./RAACVoting";
-export type { VotingPowerLib } from "./VotingPowerLib";

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

@@ -21,7 +21,7 @@ export declare namespace TimeWeightedAverage {
 }
 export interface TimeWeightedAverageInterface extends Interface {
     getFunction(nameOrSignature: "calculateTimeWeightedAverage"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "PeriodCreated" | "ValueUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PeriodCreated"): EventFragment;
     encodeFunctionData(functionFragment: "calculateTimeWeightedAverage", values: [TimeWeightedAverage.PeriodParamsStruct[], BigNumberish]): string;
     decodeFunctionResult(functionFragment: "calculateTimeWeightedAverage", data: BytesLike): Result;
 }
@@ -46,27 +46,6 @@ export declare namespace PeriodCreatedEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
-export declare namespace ValueUpdatedEvent {
-    type InputTuple = [
-        timestamp: BigNumberish,
-        oldValue: BigNumberish,
-        newValue: BigNumberish
-    ];
-    type OutputTuple = [
-        timestamp: bigint,
-        oldValue: bigint,
-        newValue: bigint
-    ];
-    interface OutputObject {
-        timestamp: bigint;
-        oldValue: bigint;
-        newValue: bigint;
-    }
-    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
-    type Filter = TypedDeferredTopicFilter<Event>;
-    type Log = TypedEventLog<Event>;
-    type LogDescription = TypedLogDescription<Event>;
-}
 export interface TimeWeightedAverage extends BaseContract {
     connect(runner?: ContractRunner | null): TimeWeightedAverage;
     waitForDeployment(): Promise<this>;
@@ -94,11 +73,8 @@ export interface TimeWeightedAverage extends BaseContract {
         bigint
     ], "view">;
     getEvent(key: "PeriodCreated"): TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
-    getEvent(key: "ValueUpdated"): TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
     filters: {
         "PeriodCreated(uint256,uint256,uint256)": TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
         PeriodCreated: TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
-        "ValueUpdated(uint256,uint256,uint256)": TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
-        ValueUpdated: TypedContractEvent<ValueUpdatedEvent.InputTuple, ValueUpdatedEvent.OutputTuple, ValueUpdatedEvent.OutputObject>;
     };
 }

package/dist/types/typechain-types/contracts/mocks/core/collectors/MockWETH.d.ts

@@ -0,0 +1,225 @@
+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 MockWETHInterface extends Interface {
+    getFunction(nameOrSignature: "CALLBACK_SUCCESS" | "DOMAIN_SEPARATOR" | "PERMIT_TYPEHASH" | "allowance" | "approve" | "balanceOf" | "decimals" | "deploymentChainId" | "deposit" | "depositTo" | "flashFee" | "flashMinted" | "maxFlashLoan" | "name" | "nonces" | "symbol" | "totalSupply" | "transfer" | "transferFrom" | "withdraw" | "withdrawFrom" | "withdrawTo"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "CALLBACK_SUCCESS", values?: undefined): string;
+    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string;
+    encodeFunctionData(functionFragment: "PERMIT_TYPEHASH", values?: undefined): string;
+    encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deploymentChainId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "deposit", values?: undefined): string;
+    encodeFunctionData(functionFragment: "depositTo", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "flashFee", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "flashMinted", values?: undefined): string;
+    encodeFunctionData(functionFragment: "maxFlashLoan", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "nonces", values: [AddressLike]): 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;
+    encodeFunctionData(functionFragment: "withdraw", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "withdrawTo", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "CALLBACK_SUCCESS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "PERMIT_TYPEHASH", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deploymentChainId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "flashFee", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "flashMinted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "maxFlashLoan", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nonces", 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;
+    decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "withdrawTo", 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 MockWETH extends BaseContract {
+    connect(runner?: ContractRunner | null): MockWETH;
+    waitForDeployment(): Promise<this>;
+    interface: MockWETHInterface;
+    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>;
+    CALLBACK_SUCCESS: TypedContractMethod<[], [string], "view">;
+    DOMAIN_SEPARATOR: TypedContractMethod<[], [string], "view">;
+    PERMIT_TYPEHASH: TypedContractMethod<[], [string], "view">;
+    allowance: TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    deploymentChainId: TypedContractMethod<[], [bigint], "view">;
+    deposit: TypedContractMethod<[], [void], "payable">;
+    depositTo: TypedContractMethod<[to: AddressLike], [void], "payable">;
+    flashFee: TypedContractMethod<[
+        token: AddressLike,
+        arg1: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    flashMinted: TypedContractMethod<[], [bigint], "view">;
+    maxFlashLoan: TypedContractMethod<[token: AddressLike], [bigint], "view">;
+    name: TypedContractMethod<[], [string], "view">;
+    nonces: TypedContractMethod<[arg0: AddressLike], [bigint], "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">;
+    withdraw: TypedContractMethod<[value: BigNumberish], [void], "nonpayable">;
+    withdrawFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    withdrawTo: TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "CALLBACK_SUCCESS"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "DOMAIN_SEPARATOR"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "PERMIT_TYPEHASH"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "allowance"): TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        value: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deploymentChainId"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "deposit"): TypedContractMethod<[], [void], "payable">;
+    getFunction(nameOrSignature: "depositTo"): TypedContractMethod<[to: AddressLike], [void], "payable">;
+    getFunction(nameOrSignature: "flashFee"): TypedContractMethod<[
+        token: AddressLike,
+        arg1: BigNumberish
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "flashMinted"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "maxFlashLoan"): TypedContractMethod<[token: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "nonces"): TypedContractMethod<[arg0: AddressLike], [bigint], "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">;
+    getFunction(nameOrSignature: "withdraw"): TypedContractMethod<[value: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "withdrawFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "withdrawTo"): TypedContractMethod<[
+        to: AddressLike,
+        value: BigNumberish
+    ], [
+        void
+    ], "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/collectors/index.d.ts

@@ -1 +1,2 @@
 export type { MockTreasury } from "./MockTreasury";
+export type { MockWETH } from "./MockWETH";

package/dist/types/typechain-types/contracts/mocks/core/curve/CurveLiquidityGaugeV5Mock.sol/CurveLiquidityGaugeV5Mock.d.ts

@@ -0,0 +1,56 @@
+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 CurveLiquidityGaugeV5MockInterface extends Interface {
+    getFunction(nameOrSignature: "deposit_reward_token" | "depositedRewards"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "RewardDeposited"): EventFragment;
+    encodeFunctionData(functionFragment: "deposit_reward_token", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "depositedRewards", values: [AddressLike]): string;
+    decodeFunctionResult(functionFragment: "deposit_reward_token", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "depositedRewards", data: BytesLike): Result;
+}
+export declare namespace RewardDepositedEvent {
+    type InputTuple = [token: AddressLike, amount: BigNumberish];
+    type OutputTuple = [token: string, amount: bigint];
+    interface OutputObject {
+        token: string;
+        amount: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface CurveLiquidityGaugeV5Mock extends BaseContract {
+    connect(runner?: ContractRunner | null): CurveLiquidityGaugeV5Mock;
+    waitForDeployment(): Promise<this>;
+    interface: CurveLiquidityGaugeV5MockInterface;
+    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>;
+    deposit_reward_token: TypedContractMethod<[
+        _reward_token: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    depositedRewards: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "deposit_reward_token"): TypedContractMethod<[
+        _reward_token: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "depositedRewards"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
+    getEvent(key: "RewardDeposited"): TypedContractEvent<RewardDepositedEvent.InputTuple, RewardDepositedEvent.OutputTuple, RewardDepositedEvent.OutputObject>;
+    filters: {
+        "RewardDeposited(address,uint256)": TypedContractEvent<RewardDepositedEvent.InputTuple, RewardDepositedEvent.OutputTuple, RewardDepositedEvent.OutputObject>;
+        RewardDeposited: TypedContractEvent<RewardDepositedEvent.InputTuple, RewardDepositedEvent.OutputTuple, RewardDepositedEvent.OutputObject>;
+    };
+}

package/dist/types/typechain-types/contracts/mocks/core/curve/CurveLiquidityGaugeV5Mock.sol/ILiquidityGauge.d.ts

@@ -0,0 +1,35 @@
+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 ILiquidityGaugeInterface extends Interface {
+    getFunction(nameOrSignature: "deposit_reward_token"): FunctionFragment;
+    encodeFunctionData(functionFragment: "deposit_reward_token", values: [AddressLike, BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "deposit_reward_token", data: BytesLike): Result;
+}
+export interface ILiquidityGauge extends BaseContract {
+    connect(runner?: ContractRunner | null): ILiquidityGauge;
+    waitForDeployment(): Promise<this>;
+    interface: ILiquidityGaugeInterface;
+    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>;
+    deposit_reward_token: TypedContractMethod<[
+        _reward_token: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "deposit_reward_token"): TypedContractMethod<[
+        _reward_token: AddressLike,
+        _amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    filters: {};
+}

package/dist/types/typechain-types/contracts/mocks/core/curve/CurveLiquidityGaugeV5Mock.sol/index.d.ts

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

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

@@ -0,0 +1,2 @@
+import type * as curveLiquidityGaugeV5MockSol from "./CurveLiquidityGaugeV5Mock.sol";
+export type { curveLiquidityGaugeV5MockSol };

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

@@ -1,11 +1,9 @@
-import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
 import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "../../../../../common";
 export interface MockGaugeControllerInterface extends Interface {
-    getFunction(nameOrSignature: "getGaugeWeight" | "getTypeWeight"): FunctionFragment;
+    getFunction(nameOrSignature: "getGaugeWeight"): FunctionFragment;
     encodeFunctionData(functionFragment: "getGaugeWeight", values: [AddressLike]): string;
-    encodeFunctionData(functionFragment: "getTypeWeight", values: [BigNumberish]): string;
     decodeFunctionResult(functionFragment: "getGaugeWeight", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "getTypeWeight", data: BytesLike): Result;
 }
 export interface MockGaugeController extends BaseContract {
     connect(runner?: ContractRunner | null): MockGaugeController;
@@ -21,9 +19,7 @@ export interface MockGaugeController extends BaseContract {
     listeners(eventName?: string): Promise<Array<Listener>>;
     removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
     getGaugeWeight: TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
-    getTypeWeight: TypedContractMethod<[arg0: BigNumberish], [bigint], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
     getFunction(nameOrSignature: "getGaugeWeight"): TypedContractMethod<[arg0: AddressLike], [bigint], "view">;
-    getFunction(nameOrSignature: "getTypeWeight"): TypedContractMethod<[arg0: BigNumberish], [bigint], "view">;
     filters: {};
 }

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

@@ -1,2 +1 @@
-export type { MockBaseGauge } from "./MockBaseGauge";
 export type { MockGaugeController } from "./MockGaugeController";