@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.4

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

@@ -4,59 +4,57 @@ export declare namespace IAuction {
     type AuctionDetailsStruct = {
         auctionAddress: AddressLike;
         zenoAddress: AddressLike;
-        businessAddress: AddressLike;
+        issuer: AddressLike;
         auctionEndTime: BigNumberish;
         startingPrice: BigNumberish;
         reservePrice: BigNumberish;
         auctionStartTime: BigNumberish;
         totalZENOAllocated: BigNumberish;
         totalZENORemaining: BigNumberish;
-        lastBidTime: BigNumberish;
-        lastBidder: AddressLike;
-        lastBidAmount: BigNumberish;
         price: BigNumberish;
+        fundingMode: BigNumberish;
     };
     type AuctionDetailsStructOutput = [
         auctionAddress: string,
         zenoAddress: string,
-        businessAddress: string,
+        issuer: string,
         auctionEndTime: bigint,
         startingPrice: bigint,
         reservePrice: bigint,
         auctionStartTime: bigint,
         totalZENOAllocated: bigint,
         totalZENORemaining: bigint,
-        lastBidTime: bigint,
-        lastBidder: string,
-        lastBidAmount: bigint,
-        price: bigint
+        price: bigint,
+        fundingMode: bigint
     ] & {
         auctionAddress: string;
         zenoAddress: string;
-        businessAddress: string;
+        issuer: string;
         auctionEndTime: bigint;
         startingPrice: bigint;
         reservePrice: bigint;
         auctionStartTime: bigint;
         totalZENOAllocated: bigint;
         totalZENORemaining: bigint;
-        lastBidTime: bigint;
-        lastBidder: string;
-        lastBidAmount: bigint;
         price: bigint;
+        fundingMode: bigint;
     };
 }
 export interface IAuctionInterface extends Interface {
-    getFunction(nameOrSignature: "buy" | "checkAuctionEnded" | "getDetails" | "getPrice"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "AuctionEnded" | "EmergencyERC20Refund" | "ZENOPurchased"): EventFragment;
-    encodeFunctionData(functionFragment: "buy", values: [BigNumberish]): string;
+    getFunction(nameOrSignature: "buy" | "checkAuctionEnded" | "getDetails" | "getPrice" | "totalRemaining" | "zeno"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AuctionEnded" | "ZENOPurchased"): EventFragment;
+    encodeFunctionData(functionFragment: "buy", values: [BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: "checkAuctionEnded", values?: undefined): string;
     encodeFunctionData(functionFragment: "getDetails", values?: undefined): string;
     encodeFunctionData(functionFragment: "getPrice", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalRemaining", values?: undefined): string;
+    encodeFunctionData(functionFragment: "zeno", values?: undefined): string;
     decodeFunctionResult(functionFragment: "buy", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "checkAuctionEnded", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getDetails", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getPrice", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalRemaining", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "zeno", data: BytesLike): Result;
 }
 export declare namespace AuctionEndedEvent {
     type InputTuple = [price: BigNumberish];
@@ -69,28 +67,23 @@ 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,
-        amount: BigNumberish,
+        zenoAmount: BigNumberish,
+        paymentAmount: BigNumberish,
         price: BigNumberish
     ];
-    type OutputTuple = [buyer: string, amount: bigint, price: bigint];
+    type OutputTuple = [
+        buyer: string,
+        zenoAmount: bigint,
+        paymentAmount: bigint,
+        price: bigint
+    ];
     interface OutputObject {
         buyer: string;
-        amount: bigint;
+        zenoAmount: bigint;
+        paymentAmount: bigint;
         price: bigint;
     }
     type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
@@ -111,27 +104,38 @@ export interface IAuction 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>;
-    buy: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
-    checkAuctionEnded: TypedContractMethod<[], [boolean], "nonpayable">;
+    buy: TypedContractMethod<[
+        paymentAmount: BigNumberish,
+        minZenoOut: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    checkAuctionEnded: TypedContractMethod<[], [boolean], "view">;
     getDetails: TypedContractMethod<[
     ], [
         IAuction.AuctionDetailsStructOutput
     ], "view">;
     getPrice: TypedContractMethod<[], [bigint], "view">;
+    totalRemaining: TypedContractMethod<[], [bigint], "view">;
+    zeno: TypedContractMethod<[], [string], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: "buy"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
-    getFunction(nameOrSignature: "checkAuctionEnded"): TypedContractMethod<[], [boolean], "nonpayable">;
+    getFunction(nameOrSignature: "buy"): TypedContractMethod<[
+        paymentAmount: BigNumberish,
+        minZenoOut: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "checkAuctionEnded"): TypedContractMethod<[], [boolean], "view">;
     getFunction(nameOrSignature: "getDetails"): TypedContractMethod<[], [IAuction.AuctionDetailsStructOutput], "view">;
     getFunction(nameOrSignature: "getPrice"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "totalRemaining"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "zeno"): TypedContractMethod<[], [string], "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(address,uint256,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

@@ -6,22 +6,28 @@ export declare namespace IZENO {
         maturityDate: BigNumberish;
         name: string;
         symbol: string;
+        totalMinted: BigNumberish;
+        totalRedeemed: BigNumberish;
     };
     type ZENODetailsStructOutput = [
         zenoAddress: string,
         maturityDate: bigint,
         name: string,
-        symbol: string
+        symbol: string,
+        totalMinted: bigint,
+        totalRedeemed: bigint
     ] & {
         zenoAddress: string;
         maturityDate: bigint;
         name: string;
         symbol: string;
+        totalMinted: bigint;
+        totalRedeemed: bigint;
     };
 }
 export interface IZENOInterface extends Interface {
-    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "getDetails" | "isRedeemable" | "mint" | "redeem" | "redeemAll" | "totalSupply" | "totalZENOMinted" | "totalZENORedeemed" | "transfer" | "transferFrom"): FunctionFragment;
-    getEvent(nameOrSignatureOrTopic: "Approval" | "EmergencyUnderlyingWithdraw" | "Redeemed" | "Transfer"): EventFragment;
+    getFunction(nameOrSignature: "allowance" | "approve" | "balanceOf" | "getDetails" | "isRedeemable" | "mint" | "redeem" | "redeemAll" | "sweepableSurplus" | "totalMinted" | "totalSupply" | "transfer" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "Redeemed" | "SurplusSwept" | "Transfer"): EventFragment;
     encodeFunctionData(functionFragment: "allowance", values: [AddressLike, AddressLike]): string;
     encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
@@ -30,9 +36,9 @@ export interface IZENOInterface extends Interface {
     encodeFunctionData(functionFragment: "mint", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "redeem", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "redeemAll", values?: undefined): string;
+    encodeFunctionData(functionFragment: "sweepableSurplus", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalMinted", values?: undefined): string;
     encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
-    encodeFunctionData(functionFragment: "totalZENOMinted", values?: undefined): string;
-    encodeFunctionData(functionFragment: "totalZENORedeemed", values?: undefined): string;
     encodeFunctionData(functionFragment: "transfer", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
     decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
@@ -43,9 +49,9 @@ export interface IZENOInterface extends Interface {
     decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "redeemAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweepableSurplus", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalMinted", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "totalZENOMinted", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "totalZENORedeemed", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
 }
@@ -66,11 +72,11 @@ 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];
+export declare namespace RedeemedEvent {
+    type InputTuple = [redeemer: AddressLike, amount: BigNumberish];
+    type OutputTuple = [redeemer: string, amount: bigint];
     interface OutputObject {
-        to: string;
+        redeemer: string;
         amount: bigint;
     }
     type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
@@ -78,11 +84,11 @@ export declare namespace EmergencyUnderlyingWithdrawEvent {
     type Log = TypedEventLog<Event>;
     type LogDescription = TypedLogDescription<Event>;
 }
-export declare namespace RedeemedEvent {
-    type InputTuple = [redeemer: AddressLike, amount: BigNumberish];
-    type OutputTuple = [redeemer: string, amount: bigint];
+export declare namespace SurplusSweptEvent {
+    type InputTuple = [to: AddressLike, amount: BigNumberish];
+    type OutputTuple = [to: string, amount: bigint];
     interface OutputObject {
-        redeemer: string;
+        to: string;
         amount: bigint;
     }
     type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
@@ -143,9 +149,9 @@ export interface IZENO extends BaseContract {
     ], "nonpayable">;
     redeem: TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
     redeemAll: TypedContractMethod<[], [void], "nonpayable">;
+    sweepableSurplus: TypedContractMethod<[], [bigint], "view">;
+    totalMinted: TypedContractMethod<[], [bigint], "view">;
     totalSupply: TypedContractMethod<[], [bigint], "view">;
-    totalZENOMinted: TypedContractMethod<[], [bigint], "view">;
-    totalZENORedeemed: TypedContractMethod<[], [bigint], "view">;
     transfer: TypedContractMethod<[
         to: AddressLike,
         value: BigNumberish
@@ -183,9 +189,9 @@ export interface IZENO extends BaseContract {
     ], "nonpayable">;
     getFunction(nameOrSignature: "redeem"): TypedContractMethod<[amount: BigNumberish], [void], "nonpayable">;
     getFunction(nameOrSignature: "redeemAll"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "sweepableSurplus"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "totalMinted"): TypedContractMethod<[], [bigint], "view">;
     getFunction(nameOrSignature: "totalSupply"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "totalZENOMinted"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "totalZENORedeemed"): TypedContractMethod<[], [bigint], "view">;
     getFunction(nameOrSignature: "transfer"): TypedContractMethod<[
         to: AddressLike,
         value: BigNumberish
@@ -200,16 +206,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: "SurplusSwept"): TypedContractEvent<SurplusSweptEvent.InputTuple, SurplusSweptEvent.OutputTuple, SurplusSweptEvent.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>;
+        "SurplusSwept(address,uint256)": TypedContractEvent<SurplusSweptEvent.InputTuple, SurplusSweptEvent.OutputTuple, SurplusSweptEvent.OutputObject>;
+        SurplusSwept: TypedContractEvent<SurplusSweptEvent.InputTuple, SurplusSweptEvent.OutputTuple, SurplusSweptEvent.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/math/TimeWeightedAverage.d.ts

@@ -1,29 +1,7 @@
-import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
-export declare namespace TimeWeightedAverage {
-    type PeriodParamsStruct = {
-        startTime: BigNumberish;
-        endTime: BigNumberish;
-        value: BigNumberish;
-        weight: BigNumberish;
-    };
-    type PeriodParamsStructOutput = [
-        startTime: bigint,
-        endTime: bigint,
-        value: bigint,
-        weight: bigint
-    ] & {
-        startTime: bigint;
-        endTime: bigint;
-        value: bigint;
-        weight: bigint;
-    };
-}
+import type { BaseContract, BigNumberish, FunctionFragment, Interface, EventFragment, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener } from "../../../common";
 export interface TimeWeightedAverageInterface extends Interface {
-    getFunction(nameOrSignature: "calculateTimeWeightedAverage"): FunctionFragment;
     getEvent(nameOrSignatureOrTopic: "PeriodCreated"): EventFragment;
-    encodeFunctionData(functionFragment: "calculateTimeWeightedAverage", values: [TimeWeightedAverage.PeriodParamsStruct[], BigNumberish]): string;
-    decodeFunctionResult(functionFragment: "calculateTimeWeightedAverage", data: BytesLike): Result;
 }
 export declare namespace PeriodCreatedEvent {
     type InputTuple = [
@@ -59,19 +37,7 @@ export interface TimeWeightedAverage 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>;
-    calculateTimeWeightedAverage: TypedContractMethod<[
-        periods: TimeWeightedAverage.PeriodParamsStruct[],
-        timestamp: BigNumberish
-    ], [
-        bigint
-    ], "view">;
     getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: "calculateTimeWeightedAverage"): TypedContractMethod<[
-        periods: TimeWeightedAverage.PeriodParamsStruct[],
-        timestamp: BigNumberish
-    ], [
-        bigint
-    ], "view">;
     getEvent(key: "PeriodCreated"): TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;
     filters: {
         "PeriodCreated(uint256,uint256,uint256)": TypedContractEvent<PeriodCreatedEvent.InputTuple, PeriodCreatedEvent.OutputTuple, PeriodCreatedEvent.OutputObject>;

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

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

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

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

package/dist/types/typechain-types/contracts/mocks/core/lockers/LockerSimMocks.sol/SimToken.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 SimTokenInterface 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 SimToken extends BaseContract {
+    connect(runner?: ContractRunner | null): SimToken;
+    waitForDeployment(): Promise<this>;
+    interface: SimTokenInterface;
+    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<[amt: BigNumberish], [void], "nonpayable">;
+    burnFrom: TypedContractMethod<[
+        a: AddressLike,
+        amt: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    decimals: TypedContractMethod<[], [bigint], "view">;
+    mint: TypedContractMethod<[
+        to: AddressLike,
+        amt: 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<[amt: BigNumberish], [void], "nonpayable">;
+    getFunction(nameOrSignature: "burnFrom"): TypedContractMethod<[
+        a: AddressLike,
+        amt: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "mint"): TypedContractMethod<[
+        to: AddressLike,
+        amt: 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/lockers/LockerSimMocks.sol/SimVault.d.ts

@@ -0,0 +1,53 @@
+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 SimVaultInterface extends Interface {
+    getFunction(nameOrSignature: "depositFor" | "distribute" | "raac"): FunctionFragment;
+    encodeFunctionData(functionFragment: "depositFor", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "distribute", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "raac", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "depositFor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "distribute", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "raac", data: BytesLike): Result;
+}
+export interface SimVault extends BaseContract {
+    connect(runner?: ContractRunner | null): SimVault;
+    waitForDeployment(): Promise<this>;
+    interface: SimVaultInterface;
+    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>;
+    depositFor: TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    distribute: TypedContractMethod<[
+        from: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    raac: TypedContractMethod<[], [string], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "depositFor"): TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "distribute"): TypedContractMethod<[
+        from: AddressLike,
+        amount: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "raac"): TypedContractMethod<[], [string], "view">;
+    filters: {};
+}