@d8x/perpetuals-sdk 1.3.6 → 2.0.0-alpha

package/src/contracts/PerpetualManagerProxy.ts

@@ -3,27 +3,24 @@
 /* eslint-disable */
 import type {
   BaseContract,
-  BigNumber,
   BigNumberish,
   BytesLike,
-  CallOverrides,
-  ContractTransaction,
-  Overrides,
-  PopulatedTransaction,
-  Signer,
-  utils,
-} from "ethers";
-import type {
   FunctionFragment,
   Result,
+  Interface,
   EventFragment,
-} from "@ethersproject/abi";
-import type { Listener, Provider } from "@ethersproject/providers";
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
 import type {
-  TypedEventFilter,
-  TypedEvent,
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
   TypedListener,
-  OnEvent,
+  TypedContractMethod,
 } from "./common";
 
 export declare namespace IPerpetualOrder {
@@ -31,13 +28,13 @@ export declare namespace IPerpetualOrder {
     leverageTDR: BigNumberish;
     brokerFeeTbps: BigNumberish;
     iPerpetualId: BigNumberish;
-    traderAddr: string;
+    traderAddr: AddressLike;
     executionTimestamp: BigNumberish;
-    brokerAddr: string;
+    brokerAddr: AddressLike;
     submittedTimestamp: BigNumberish;
     flags: BigNumberish;
     iDeadline: BigNumberish;
-    executorAddr: string;
+    executorAddr: AddressLike;
     fAmount: BigNumberish;
     fLimitPrice: BigNumberish;
     fTriggerPrice: BigNumberish;
@@ -45,57 +42,41 @@ export declare namespace IPerpetualOrder {
   };
 
   export type OrderStructOutput = [
-    number,
-    number,
-    number,
-    string,
-    number,
-    string,
-    number,
-    number,
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    string
+    leverageTDR: bigint,
+    brokerFeeTbps: bigint,
+    iPerpetualId: bigint,
+    traderAddr: string,
+    executionTimestamp: bigint,
+    brokerAddr: string,
+    submittedTimestamp: bigint,
+    flags: bigint,
+    iDeadline: bigint,
+    executorAddr: string,
+    fAmount: bigint,
+    fLimitPrice: bigint,
+    fTriggerPrice: bigint,
+    brokerSignature: string
   ] & {
-    leverageTDR: number;
-    brokerFeeTbps: number;
-    iPerpetualId: number;
+    leverageTDR: bigint;
+    brokerFeeTbps: bigint;
+    iPerpetualId: bigint;
     traderAddr: string;
-    executionTimestamp: number;
+    executionTimestamp: bigint;
     brokerAddr: string;
-    submittedTimestamp: number;
-    flags: number;
-    iDeadline: number;
+    submittedTimestamp: bigint;
+    flags: bigint;
+    iDeadline: bigint;
     executorAddr: string;
-    fAmount: BigNumber;
-    fLimitPrice: BigNumber;
-    fTriggerPrice: BigNumber;
+    fAmount: bigint;
+    fLimitPrice: bigint;
+    fTriggerPrice: bigint;
     brokerSignature: string;
   };
 }
 
-export interface PerpetualManagerProxyInterface extends utils.Interface {
-  functions: {
-    "getImplementation(bytes4)": FunctionFragment;
-    "getModuleImplementationAddress(string)": FunctionFragment;
-    "getProxyOwner()": FunctionFragment;
-    "governance()": FunctionFragment;
-    "maintainer()": FunctionFragment;
-    "pause()": FunctionFragment;
-    "paused()": FunctionFragment;
-    "setImplementation(address)": FunctionFragment;
-    "setImplementationCrossModules(address)": FunctionFragment;
-    "setProxyOwner(address)": FunctionFragment;
-    "transferGovernance(address)": FunctionFragment;
-    "transferMaintainer(address)": FunctionFragment;
-    "unpause()": FunctionFragment;
-  };
-
+export interface PerpetualManagerProxyInterface extends Interface {
   getFunction(
-    nameOrSignatureOrTopic:
+    nameOrSignature:
       | "getImplementation"
       | "getModuleImplementationAddress"
       | "getProxyOwner"
@@ -111,6 +92,57 @@ export interface PerpetualManagerProxyInterface extends utils.Interface {
       | "unpause"
   ): FunctionFragment;
 
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "BrokerLotsTransferred"
+      | "BrokerVolumeTransferred"
+      | "Clear"
+      | "DistributeFees"
+      | "GovernanceTransferred"
+      | "ImplementationChanged"
+      | "Liquidate"
+      | "LiquidityAdded"
+      | "LiquidityPoolCreated"
+      | "LiquidityProvisionPaused"
+      | "LiquidityRemoved"
+      | "LiquidityWithdrawalInitiated"
+      | "MaintainerTransferred"
+      | "Paused"
+      | "PerpetualCreated"
+      | "PerpetualLimitOrderCancelled"
+      | "ProxyOwnershipTransferred"
+      | "RunLiquidityPool"
+      | "SetBlockDelay"
+      | "SetBrokerDesignations"
+      | "SetBrokerTiers"
+      | "SetBrokerVolumeTiers"
+      | "SetClearedState"
+      | "SetDelegate"
+      | "SetEmergencyState"
+      | "SetNormalState"
+      | "SetOracles"
+      | "SetParameter"
+      | "SetParameterPair"
+      | "SetPerpetualBaseParameters"
+      | "SetPerpetualRiskParameters"
+      | "SetPoolParameter"
+      | "SetTraderTiers"
+      | "SetTraderVolumeTiers"
+      | "SetUtilityToken"
+      | "Settle"
+      | "SettleState"
+      | "SettlementComplete"
+      | "TokensDeposited"
+      | "TokensWithdrawn"
+      | "Trade"
+      | "TransferAddressTo"
+      | "Unpaused"
+      | "UpdateBrokerAddedCash"
+      | "UpdateFundingRate"
+      | "UpdateMarginAccount"
+      | "UpdateMarkPrice"
+  ): EventFragment;
+
   encodeFunctionData(
     functionFragment: "getImplementation",
     values: [BytesLike]
@@ -135,23 +167,23 @@ export interface PerpetualManagerProxyInterface extends utils.Interface {
   encodeFunctionData(functionFragment: "paused", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "setImplementation",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(
     functionFragment: "setImplementationCrossModules",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(
     functionFragment: "setProxyOwner",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(
     functionFragment: "transferGovernance",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(
     functionFragment: "transferMaintainer",
-    values: [string]
+    values: [AddressLike]
   ): string;
   encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
 
@@ -192,1456 +224,1896 @@ export interface PerpetualManagerProxyInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
-
-  events: {
-    "BrokerLotsTransferred(uint8,address,address,uint32)": EventFragment;
-    "BrokerVolumeTransferred(uint8,address,address,int128)": EventFragment;
-    "Clear(uint24,address)": EventFragment;
-    "DistributeFees(uint8,uint24,address,int128,int128)": EventFragment;
-    "GovernanceTransferred(address,address)": EventFragment;
-    "ImplementationChanged(bytes4,address,address)": EventFragment;
-    "Liquidate(uint24,address,address,int128,int128,int128,int128,int128)": EventFragment;
-    "LiquidityAdded(uint8,address,uint256,uint256)": EventFragment;
-    "LiquidityPoolCreated(uint8,address,address,uint16,int128)": EventFragment;
-    "LiquidityProvisionPaused(bool,uint8)": EventFragment;
-    "LiquidityRemoved(uint8,address,uint256,uint256)": EventFragment;
-    "LiquidityWithdrawalInitiated(uint8,address,uint256)": EventFragment;
-    "MaintainerTransferred(address,address)": EventFragment;
-    "Paused(address)": EventFragment;
-    "PerpetualCreated(uint8,uint24,int128[7],int128[5],int128[12],uint256)": EventFragment;
-    "PerpetualLimitOrderCancelled(uint24,bytes32)": EventFragment;
-    "ProxyOwnershipTransferred(address,address)": EventFragment;
-    "RunLiquidityPool(uint8)": EventFragment;
-    "SetBlockDelay(uint8)": EventFragment;
-    "SetBrokerDesignations(uint32[],uint16[])": EventFragment;
-    "SetBrokerTiers(uint256[],uint16[])": EventFragment;
-    "SetBrokerVolumeTiers(uint256[],uint16[])": EventFragment;
-    "SetClearedState(uint24)": EventFragment;
-    "SetDelegate(address,address)": EventFragment;
-    "SetEmergencyState(uint24,int128,int128,int128)": EventFragment;
-    "SetNormalState(uint24)": EventFragment;
-    "SetOracles(uint24,bytes4[2],bytes4[2])": EventFragment;
-    "SetParameter(uint24,string,int128)": EventFragment;
-    "SetParameterPair(uint24,string,int128,int128)": EventFragment;
-    "SetPerpetualBaseParameters(uint24,int128[7])": EventFragment;
-    "SetPerpetualRiskParameters(uint24,int128[5],int128[12])": EventFragment;
-    "SetPoolParameter(uint8,string,int128)": EventFragment;
-    "SetTraderTiers(uint256[],uint16[])": EventFragment;
-    "SetTraderVolumeTiers(uint256[],uint16[])": EventFragment;
-    "SetUtilityToken(address)": EventFragment;
-    "Settle(uint24,address,int256)": EventFragment;
-    "SettleState(uint24)": EventFragment;
-    "SettlementComplete(uint24)": EventFragment;
-    "TokensDeposited(uint24,address,int128)": EventFragment;
-    "TokensWithdrawn(uint24,address,int128)": EventFragment;
-    "Trade(uint24,address,(uint16,uint16,uint24,address,uint32,address,uint32,uint32,uint32,address,int128,int128,int128,bytes),bytes32,int128,int128,int128,int128,int128)": EventFragment;
-    "TransferAddressTo(string,address,address)": EventFragment;
-    "Unpaused(address)": EventFragment;
-    "UpdateBrokerAddedCash(uint8,uint32,uint32)": EventFragment;
-    "UpdateFundingRate(uint24,int128)": EventFragment;
-    "UpdateMarginAccount(uint24,address,int128)": EventFragment;
-    "UpdateMarkPrice(uint24,int128,int128,int128)": EventFragment;
-  };
-
-  getEvent(nameOrSignatureOrTopic: "BrokerLotsTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "BrokerVolumeTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Clear"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "DistributeFees"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "GovernanceTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ImplementationChanged"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Liquidate"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "LiquidityAdded"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "LiquidityPoolCreated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "LiquidityProvisionPaused"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "LiquidityRemoved"): EventFragment;
-  getEvent(
-    nameOrSignatureOrTopic: "LiquidityWithdrawalInitiated"
-  ): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "MaintainerTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "PerpetualCreated"): EventFragment;
-  getEvent(
-    nameOrSignatureOrTopic: "PerpetualLimitOrderCancelled"
-  ): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "ProxyOwnershipTransferred"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RunLiquidityPool"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetBlockDelay"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetBrokerDesignations"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetBrokerTiers"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetBrokerVolumeTiers"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetClearedState"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetDelegate"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetEmergencyState"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetNormalState"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetOracles"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetParameter"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetParameterPair"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetPerpetualBaseParameters"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetPerpetualRiskParameters"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetPoolParameter"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetTraderTiers"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetTraderVolumeTiers"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SetUtilityToken"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Settle"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SettleState"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SettlementComplete"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "TokensDeposited"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "TokensWithdrawn"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Trade"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "TransferAddressTo"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "UpdateBrokerAddedCash"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "UpdateFundingRate"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "UpdateMarginAccount"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "UpdateMarkPrice"): EventFragment;
 }
 
-export interface BrokerLotsTransferredEventObject {
-  poolId: number;
-  oldOwner: string;
-  newOwner: string;
-  numLots: number;
-}
-export type BrokerLotsTransferredEvent = TypedEvent<
-  [number, string, string, number],
-  BrokerLotsTransferredEventObject
->;
-
-export type BrokerLotsTransferredEventFilter =
-  TypedEventFilter<BrokerLotsTransferredEvent>;
-
-export interface BrokerVolumeTransferredEventObject {
-  poolId: number;
-  oldOwner: string;
-  newOwner: string;
-  fVolume: BigNumber;
+export namespace BrokerLotsTransferredEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    oldOwner: AddressLike,
+    newOwner: AddressLike,
+    numLots: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    oldOwner: string,
+    newOwner: string,
+    numLots: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    oldOwner: string;
+    newOwner: string;
+    numLots: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type BrokerVolumeTransferredEvent = TypedEvent<
-  [number, string, string, BigNumber],
-  BrokerVolumeTransferredEventObject
->;
-
-export type BrokerVolumeTransferredEventFilter =
-  TypedEventFilter<BrokerVolumeTransferredEvent>;
 
-export interface ClearEventObject {
-  perpetualId: number;
-  trader: string;
+export namespace BrokerVolumeTransferredEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    oldOwner: AddressLike,
+    newOwner: AddressLike,
+    fVolume: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    oldOwner: string,
+    newOwner: string,
+    fVolume: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    oldOwner: string;
+    newOwner: string;
+    fVolume: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type ClearEvent = TypedEvent<[number, string], ClearEventObject>;
 
-export type ClearEventFilter = TypedEventFilter<ClearEvent>;
-
-export interface DistributeFeesEventObject {
-  poolId: number;
-  perpetualId: number;
-  trader: string;
-  protocolFeeCC: BigNumber;
-  participationFundFeeCC: BigNumber;
+export namespace ClearEvent {
+  export type InputTuple = [perpetualId: BigNumberish, trader: AddressLike];
+  export type OutputTuple = [perpetualId: bigint, trader: string];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type DistributeFeesEvent = TypedEvent<
-  [number, number, string, BigNumber, BigNumber],
-  DistributeFeesEventObject
->;
-
-export type DistributeFeesEventFilter = TypedEventFilter<DistributeFeesEvent>;
 
-export interface GovernanceTransferredEventObject {
-  previousGovernance: string;
-  newGovernance: string;
-}
-export type GovernanceTransferredEvent = TypedEvent<
-  [string, string],
-  GovernanceTransferredEventObject
->;
-
-export type GovernanceTransferredEventFilter =
-  TypedEventFilter<GovernanceTransferredEvent>;
-
-export interface ImplementationChangedEventObject {
-  _sig: string;
-  _oldImplementation: string;
-  _newImplementation: string;
+export namespace DistributeFeesEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    protocolFeeCC: BigNumberish,
+    participationFundFeeCC: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    perpetualId: bigint,
+    trader: string,
+    protocolFeeCC: bigint,
+    participationFundFeeCC: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    perpetualId: bigint;
+    trader: string;
+    protocolFeeCC: bigint;
+    participationFundFeeCC: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type ImplementationChangedEvent = TypedEvent<
-  [string, string, string],
-  ImplementationChangedEventObject
->;
-
-export type ImplementationChangedEventFilter =
-  TypedEventFilter<ImplementationChangedEvent>;
-
-export interface LiquidateEventObject {
-  perpetualId: number;
-  liquidator: string;
-  trader: string;
-  amountLiquidatedBC: BigNumber;
-  liquidationPrice: BigNumber;
-  newPositionSizeBC: BigNumber;
-  fFeeCC: BigNumber;
-  fPnlCC: BigNumber;
-}
-export type LiquidateEvent = TypedEvent<
-  [
-    number,
-    string,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
-  LiquidateEventObject
->;
-
-export type LiquidateEventFilter = TypedEventFilter<LiquidateEvent>;
-
-export interface LiquidityAddedEventObject {
-  poolId: number;
-  user: string;
-  tokenAmount: BigNumber;
-  shareAmount: BigNumber;
-}
-export type LiquidityAddedEvent = TypedEvent<
-  [number, string, BigNumber, BigNumber],
-  LiquidityAddedEventObject
->;
-
-export type LiquidityAddedEventFilter = TypedEventFilter<LiquidityAddedEvent>;
-
-export interface LiquidityPoolCreatedEventObject {
-  id: number;
-  marginTokenAddress: string;
-  shareTokenAddress: string;
-  iTargetPoolSizeUpdateTime: number;
-  fBrokerCollateralLotSize: BigNumber;
-}
-export type LiquidityPoolCreatedEvent = TypedEvent<
-  [number, string, string, number, BigNumber],
-  LiquidityPoolCreatedEventObject
->;
 
-export type LiquidityPoolCreatedEventFilter =
-  TypedEventFilter<LiquidityPoolCreatedEvent>;
-
-export interface LiquidityProvisionPausedEventObject {
-  pauseOn: boolean;
-  poolId: number;
-}
-export type LiquidityProvisionPausedEvent = TypedEvent<
-  [boolean, number],
-  LiquidityProvisionPausedEventObject
->;
-
-export type LiquidityProvisionPausedEventFilter =
-  TypedEventFilter<LiquidityProvisionPausedEvent>;
-
-export interface LiquidityRemovedEventObject {
-  poolId: number;
-  user: string;
-  tokenAmount: BigNumber;
-  shareAmount: BigNumber;
-}
-export type LiquidityRemovedEvent = TypedEvent<
-  [number, string, BigNumber, BigNumber],
-  LiquidityRemovedEventObject
->;
-
-export type LiquidityRemovedEventFilter =
-  TypedEventFilter<LiquidityRemovedEvent>;
-
-export interface LiquidityWithdrawalInitiatedEventObject {
-  poolId: number;
-  user: string;
-  shareAmount: BigNumber;
+export namespace GovernanceTransferredEvent {
+  export type InputTuple = [
+    previousGovernance: AddressLike,
+    newGovernance: AddressLike
+  ];
+  export type OutputTuple = [previousGovernance: string, newGovernance: string];
+  export interface OutputObject {
+    previousGovernance: string;
+    newGovernance: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type LiquidityWithdrawalInitiatedEvent = TypedEvent<
-  [number, string, BigNumber],
-  LiquidityWithdrawalInitiatedEventObject
->;
 
-export type LiquidityWithdrawalInitiatedEventFilter =
-  TypedEventFilter<LiquidityWithdrawalInitiatedEvent>;
-
-export interface MaintainerTransferredEventObject {
-  previousMaintainer: string;
-  newMaintainer: string;
+export namespace ImplementationChangedEvent {
+  export type InputTuple = [
+    _sig: BytesLike,
+    _oldImplementation: AddressLike,
+    _newImplementation: AddressLike
+  ];
+  export type OutputTuple = [
+    _sig: string,
+    _oldImplementation: string,
+    _newImplementation: string
+  ];
+  export interface OutputObject {
+    _sig: string;
+    _oldImplementation: string;
+    _newImplementation: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type MaintainerTransferredEvent = TypedEvent<
-  [string, string],
-  MaintainerTransferredEventObject
->;
-
-export type MaintainerTransferredEventFilter =
-  TypedEventFilter<MaintainerTransferredEvent>;
 
-export interface PausedEventObject {
-  account: string;
+export namespace LiquidateEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    liquidator: AddressLike,
+    trader: AddressLike,
+    amountLiquidatedBC: BigNumberish,
+    liquidationPrice: BigNumberish,
+    newPositionSizeBC: BigNumberish,
+    fFeeCC: BigNumberish,
+    fPnlCC: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    liquidator: string,
+    trader: string,
+    amountLiquidatedBC: bigint,
+    liquidationPrice: bigint,
+    newPositionSizeBC: bigint,
+    fFeeCC: bigint,
+    fPnlCC: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    liquidator: string;
+    trader: string;
+    amountLiquidatedBC: bigint;
+    liquidationPrice: bigint;
+    newPositionSizeBC: bigint;
+    fFeeCC: bigint;
+    fPnlCC: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type PausedEvent = TypedEvent<[string], PausedEventObject>;
 
-export type PausedEventFilter = TypedEventFilter<PausedEvent>;
-
-export interface PerpetualCreatedEventObject {
-  poolId: number;
-  id: number;
-  baseParams: BigNumber[];
-  underlyingRiskParams: [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
-  defaultFundRiskParams: BigNumber[];
-  eCollateralCurrency: BigNumber;
-}
-export type PerpetualCreatedEvent = TypedEvent<
-  [
-    number,
-    number,
-    BigNumber[],
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
-    BigNumber[],
-    BigNumber
-  ],
-  PerpetualCreatedEventObject
->;
-
-export type PerpetualCreatedEventFilter =
-  TypedEventFilter<PerpetualCreatedEvent>;
-
-export interface PerpetualLimitOrderCancelledEventObject {
-  perpetualId: number;
-  orderHash: string;
+export namespace LiquidityAddedEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    user: AddressLike,
+    tokenAmount: BigNumberish,
+    shareAmount: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    user: string,
+    tokenAmount: bigint,
+    shareAmount: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    user: string;
+    tokenAmount: bigint;
+    shareAmount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type PerpetualLimitOrderCancelledEvent = TypedEvent<
-  [number, string],
-  PerpetualLimitOrderCancelledEventObject
->;
-
-export type PerpetualLimitOrderCancelledEventFilter =
-  TypedEventFilter<PerpetualLimitOrderCancelledEvent>;
 
-export interface ProxyOwnershipTransferredEventObject {
-  _oldOwner: string;
-  _newOwner: string;
+export namespace LiquidityPoolCreatedEvent {
+  export type InputTuple = [
+    id: BigNumberish,
+    marginTokenAddress: AddressLike,
+    shareTokenAddress: AddressLike,
+    iTargetPoolSizeUpdateTime: BigNumberish,
+    fBrokerCollateralLotSize: BigNumberish
+  ];
+  export type OutputTuple = [
+    id: bigint,
+    marginTokenAddress: string,
+    shareTokenAddress: string,
+    iTargetPoolSizeUpdateTime: bigint,
+    fBrokerCollateralLotSize: bigint
+  ];
+  export interface OutputObject {
+    id: bigint;
+    marginTokenAddress: string;
+    shareTokenAddress: string;
+    iTargetPoolSizeUpdateTime: bigint;
+    fBrokerCollateralLotSize: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type ProxyOwnershipTransferredEvent = TypedEvent<
-  [string, string],
-  ProxyOwnershipTransferredEventObject
->;
 
-export type ProxyOwnershipTransferredEventFilter =
-  TypedEventFilter<ProxyOwnershipTransferredEvent>;
-
-export interface RunLiquidityPoolEventObject {
-  _liqPoolID: number;
+export namespace LiquidityProvisionPausedEvent {
+  export type InputTuple = [pauseOn: boolean, poolId: BigNumberish];
+  export type OutputTuple = [pauseOn: boolean, poolId: bigint];
+  export interface OutputObject {
+    pauseOn: boolean;
+    poolId: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type RunLiquidityPoolEvent = TypedEvent<
-  [number],
-  RunLiquidityPoolEventObject
->;
-
-export type RunLiquidityPoolEventFilter =
-  TypedEventFilter<RunLiquidityPoolEvent>;
 
-export interface SetBlockDelayEventObject {
-  delay: number;
+export namespace LiquidityRemovedEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    user: AddressLike,
+    tokenAmount: BigNumberish,
+    shareAmount: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    user: string,
+    tokenAmount: bigint,
+    shareAmount: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    user: string;
+    tokenAmount: bigint;
+    shareAmount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetBlockDelayEvent = TypedEvent<[number], SetBlockDelayEventObject>;
-
-export type SetBlockDelayEventFilter = TypedEventFilter<SetBlockDelayEvent>;
 
-export interface SetBrokerDesignationsEventObject {
-  designations: number[];
-  fees: number[];
+export namespace LiquidityWithdrawalInitiatedEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    user: AddressLike,
+    shareAmount: BigNumberish
+  ];
+  export type OutputTuple = [poolId: bigint, user: string, shareAmount: bigint];
+  export interface OutputObject {
+    poolId: bigint;
+    user: string;
+    shareAmount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetBrokerDesignationsEvent = TypedEvent<
-  [number[], number[]],
-  SetBrokerDesignationsEventObject
->;
 
-export type SetBrokerDesignationsEventFilter =
-  TypedEventFilter<SetBrokerDesignationsEvent>;
-
-export interface SetBrokerTiersEventObject {
-  tiers: BigNumber[];
-  feesTbps: number[];
+export namespace MaintainerTransferredEvent {
+  export type InputTuple = [
+    previousMaintainer: AddressLike,
+    newMaintainer: AddressLike
+  ];
+  export type OutputTuple = [previousMaintainer: string, newMaintainer: string];
+  export interface OutputObject {
+    previousMaintainer: string;
+    newMaintainer: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetBrokerTiersEvent = TypedEvent<
-  [BigNumber[], number[]],
-  SetBrokerTiersEventObject
->;
-
-export type SetBrokerTiersEventFilter = TypedEventFilter<SetBrokerTiersEvent>;
 
-export interface SetBrokerVolumeTiersEventObject {
-  tiers: BigNumber[];
-  feesTbps: number[];
+export namespace PausedEvent {
+  export type InputTuple = [account: AddressLike];
+  export type OutputTuple = [account: string];
+  export interface OutputObject {
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetBrokerVolumeTiersEvent = TypedEvent<
-  [BigNumber[], number[]],
-  SetBrokerVolumeTiersEventObject
->;
-
-export type SetBrokerVolumeTiersEventFilter =
-  TypedEventFilter<SetBrokerVolumeTiersEvent>;
 
-export interface SetClearedStateEventObject {
-  perpetualId: number;
+export namespace PerpetualCreatedEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    id: BigNumberish,
+    baseParams: BigNumberish[],
+    underlyingRiskParams: [
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish
+    ],
+    defaultFundRiskParams: BigNumberish[],
+    eCollateralCurrency: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    id: bigint,
+    baseParams: bigint[],
+    underlyingRiskParams: [bigint, bigint, bigint, bigint, bigint],
+    defaultFundRiskParams: bigint[],
+    eCollateralCurrency: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    id: bigint;
+    baseParams: bigint[];
+    underlyingRiskParams: [bigint, bigint, bigint, bigint, bigint];
+    defaultFundRiskParams: bigint[];
+    eCollateralCurrency: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetClearedStateEvent = TypedEvent<
-  [number],
-  SetClearedStateEventObject
->;
 
-export type SetClearedStateEventFilter = TypedEventFilter<SetClearedStateEvent>;
-
-export interface SetDelegateEventObject {
-  trader: string;
-  delegate: string;
-}
-export type SetDelegateEvent = TypedEvent<
-  [string, string],
-  SetDelegateEventObject
->;
-
-export type SetDelegateEventFilter = TypedEventFilter<SetDelegateEvent>;
-
-export interface SetEmergencyStateEventObject {
-  perpetualId: number;
-  fSettlementMarkPremiumRate: BigNumber;
-  fSettlementS2Price: BigNumber;
-  fSettlementS3Price: BigNumber;
+export namespace PerpetualLimitOrderCancelledEvent {
+  export type InputTuple = [perpetualId: BigNumberish, orderHash: BytesLike];
+  export type OutputTuple = [perpetualId: bigint, orderHash: string];
+  export interface OutputObject {
+    perpetualId: bigint;
+    orderHash: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetEmergencyStateEvent = TypedEvent<
-  [number, BigNumber, BigNumber, BigNumber],
-  SetEmergencyStateEventObject
->;
-
-export type SetEmergencyStateEventFilter =
-  TypedEventFilter<SetEmergencyStateEvent>;
 
-export interface SetNormalStateEventObject {
-  perpetualId: number;
+export namespace ProxyOwnershipTransferredEvent {
+  export type InputTuple = [_oldOwner: AddressLike, _newOwner: AddressLike];
+  export type OutputTuple = [_oldOwner: string, _newOwner: string];
+  export interface OutputObject {
+    _oldOwner: string;
+    _newOwner: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetNormalStateEvent = TypedEvent<
-  [number],
-  SetNormalStateEventObject
->;
 
-export type SetNormalStateEventFilter = TypedEventFilter<SetNormalStateEvent>;
-
-export interface SetOraclesEventObject {
-  perpetualId: number;
-  baseQuoteS2: [string, string];
-  baseQuoteS3: [string, string];
+export namespace RunLiquidityPoolEvent {
+  export type InputTuple = [_liqPoolID: BigNumberish];
+  export type OutputTuple = [_liqPoolID: bigint];
+  export interface OutputObject {
+    _liqPoolID: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetOraclesEvent = TypedEvent<
-  [number, [string, string], [string, string]],
-  SetOraclesEventObject
->;
-
-export type SetOraclesEventFilter = TypedEventFilter<SetOraclesEvent>;
 
-export interface SetParameterEventObject {
-  perpetualId: number;
-  name: string;
-  value: BigNumber;
-}
-export type SetParameterEvent = TypedEvent<
-  [number, string, BigNumber],
-  SetParameterEventObject
->;
-
-export type SetParameterEventFilter = TypedEventFilter<SetParameterEvent>;
-
-export interface SetParameterPairEventObject {
-  perpetualId: number;
-  name: string;
-  value1: BigNumber;
-  value2: BigNumber;
+export namespace SetBlockDelayEvent {
+  export type InputTuple = [delay: BigNumberish];
+  export type OutputTuple = [delay: bigint];
+  export interface OutputObject {
+    delay: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetParameterPairEvent = TypedEvent<
-  [number, string, BigNumber, BigNumber],
-  SetParameterPairEventObject
->;
 
-export type SetParameterPairEventFilter =
-  TypedEventFilter<SetParameterPairEvent>;
-
-export interface SetPerpetualBaseParametersEventObject {
-  perpetualId: number;
-  baseParams: BigNumber[];
-}
-export type SetPerpetualBaseParametersEvent = TypedEvent<
-  [number, BigNumber[]],
-  SetPerpetualBaseParametersEventObject
->;
-
-export type SetPerpetualBaseParametersEventFilter =
-  TypedEventFilter<SetPerpetualBaseParametersEvent>;
-
-export interface SetPerpetualRiskParametersEventObject {
-  perpetualId: number;
-  underlyingRiskParams: [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber];
-  defaultFundRiskParams: BigNumber[];
+export namespace SetBrokerDesignationsEvent {
+  export type InputTuple = [designations: BigNumberish[], fees: BigNumberish[]];
+  export type OutputTuple = [designations: bigint[], fees: bigint[]];
+  export interface OutputObject {
+    designations: bigint[];
+    fees: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetPerpetualRiskParametersEvent = TypedEvent<
-  [
-    number,
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
-    BigNumber[]
-  ],
-  SetPerpetualRiskParametersEventObject
->;
-
-export type SetPerpetualRiskParametersEventFilter =
-  TypedEventFilter<SetPerpetualRiskParametersEvent>;
-
-export interface SetPoolParameterEventObject {
-  poolId: number;
-  name: string;
-  value: BigNumber;
+
+export namespace SetBrokerTiersEvent {
+  export type InputTuple = [tiers: BigNumberish[], feesTbps: BigNumberish[]];
+  export type OutputTuple = [tiers: bigint[], feesTbps: bigint[]];
+  export interface OutputObject {
+    tiers: bigint[];
+    feesTbps: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetPoolParameterEvent = TypedEvent<
-  [number, string, BigNumber],
-  SetPoolParameterEventObject
->;
 
-export type SetPoolParameterEventFilter =
-  TypedEventFilter<SetPoolParameterEvent>;
+export namespace SetBrokerVolumeTiersEvent {
+  export type InputTuple = [tiers: BigNumberish[], feesTbps: BigNumberish[]];
+  export type OutputTuple = [tiers: bigint[], feesTbps: bigint[]];
+  export interface OutputObject {
+    tiers: bigint[];
+    feesTbps: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SetTraderTiersEventObject {
-  tiers: BigNumber[];
-  feesTbps: number[];
+export namespace SetClearedStateEvent {
+  export type InputTuple = [perpetualId: BigNumberish];
+  export type OutputTuple = [perpetualId: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetTraderTiersEvent = TypedEvent<
-  [BigNumber[], number[]],
-  SetTraderTiersEventObject
->;
 
-export type SetTraderTiersEventFilter = TypedEventFilter<SetTraderTiersEvent>;
+export namespace SetDelegateEvent {
+  export type InputTuple = [trader: AddressLike, delegate: AddressLike];
+  export type OutputTuple = [trader: string, delegate: string];
+  export interface OutputObject {
+    trader: string;
+    delegate: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SetTraderVolumeTiersEventObject {
-  tiers: BigNumber[];
-  feesTbps: number[];
+export namespace SetEmergencyStateEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    fSettlementMarkPremiumRate: BigNumberish,
+    fSettlementS2Price: BigNumberish,
+    fSettlementS3Price: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    fSettlementMarkPremiumRate: bigint,
+    fSettlementS2Price: bigint,
+    fSettlementS3Price: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    fSettlementMarkPremiumRate: bigint;
+    fSettlementS2Price: bigint;
+    fSettlementS3Price: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetTraderVolumeTiersEvent = TypedEvent<
-  [BigNumber[], number[]],
-  SetTraderVolumeTiersEventObject
->;
 
-export type SetTraderVolumeTiersEventFilter =
-  TypedEventFilter<SetTraderVolumeTiersEvent>;
+export namespace SetNormalStateEvent {
+  export type InputTuple = [perpetualId: BigNumberish];
+  export type OutputTuple = [perpetualId: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SetUtilityTokenEventObject {
-  tokenAddr: string;
+export namespace SetOraclesEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    baseQuoteS2: [BytesLike, BytesLike],
+    baseQuoteS3: [BytesLike, BytesLike]
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    baseQuoteS2: [string, string],
+    baseQuoteS3: [string, string]
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    baseQuoteS2: [string, string];
+    baseQuoteS3: [string, string];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SetUtilityTokenEvent = TypedEvent<
-  [string],
-  SetUtilityTokenEventObject
->;
 
-export type SetUtilityTokenEventFilter = TypedEventFilter<SetUtilityTokenEvent>;
+export namespace SetParameterEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    name: string,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [perpetualId: bigint, name: string, value: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+    name: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SettleEventObject {
-  perpetualId: number;
-  trader: string;
-  amount: BigNumber;
+export namespace SetParameterPairEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    name: string,
+    value1: BigNumberish,
+    value2: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    name: string,
+    value1: bigint,
+    value2: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    name: string;
+    value1: bigint;
+    value2: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SettleEvent = TypedEvent<
-  [number, string, BigNumber],
-  SettleEventObject
->;
 
-export type SettleEventFilter = TypedEventFilter<SettleEvent>;
+export namespace SetPerpetualBaseParametersEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    baseParams: BigNumberish[]
+  ];
+  export type OutputTuple = [perpetualId: bigint, baseParams: bigint[]];
+  export interface OutputObject {
+    perpetualId: bigint;
+    baseParams: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SettleStateEventObject {
-  perpetualId: number;
+export namespace SetPerpetualRiskParametersEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    underlyingRiskParams: [
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish,
+      BigNumberish
+    ],
+    defaultFundRiskParams: BigNumberish[]
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    underlyingRiskParams: [bigint, bigint, bigint, bigint, bigint],
+    defaultFundRiskParams: bigint[]
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    underlyingRiskParams: [bigint, bigint, bigint, bigint, bigint];
+    defaultFundRiskParams: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SettleStateEvent = TypedEvent<[number], SettleStateEventObject>;
 
-export type SettleStateEventFilter = TypedEventFilter<SettleStateEvent>;
+export namespace SetPoolParameterEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    name: string,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [poolId: bigint, name: string, value: bigint];
+  export interface OutputObject {
+    poolId: bigint;
+    name: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface SettlementCompleteEventObject {
-  perpetualId: number;
+export namespace SetTraderTiersEvent {
+  export type InputTuple = [tiers: BigNumberish[], feesTbps: BigNumberish[]];
+  export type OutputTuple = [tiers: bigint[], feesTbps: bigint[]];
+  export interface OutputObject {
+    tiers: bigint[];
+    feesTbps: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type SettlementCompleteEvent = TypedEvent<
-  [number],
-  SettlementCompleteEventObject
->;
-
-export type SettlementCompleteEventFilter =
-  TypedEventFilter<SettlementCompleteEvent>;
-
-export interface TokensDepositedEventObject {
-  perpetualId: number;
-  trader: string;
-  amount: BigNumber;
+
+export namespace SetTraderVolumeTiersEvent {
+  export type InputTuple = [tiers: BigNumberish[], feesTbps: BigNumberish[]];
+  export type OutputTuple = [tiers: bigint[], feesTbps: bigint[]];
+  export interface OutputObject {
+    tiers: bigint[];
+    feesTbps: bigint[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type TokensDepositedEvent = TypedEvent<
-  [number, string, BigNumber],
-  TokensDepositedEventObject
->;
 
-export type TokensDepositedEventFilter = TypedEventFilter<TokensDepositedEvent>;
+export namespace SetUtilityTokenEvent {
+  export type InputTuple = [tokenAddr: AddressLike];
+  export type OutputTuple = [tokenAddr: string];
+  export interface OutputObject {
+    tokenAddr: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface TokensWithdrawnEventObject {
-  perpetualId: number;
-  trader: string;
-  amount: BigNumber;
+export namespace SettleEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    amount: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    amount: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    amount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type TokensWithdrawnEvent = TypedEvent<
-  [number, string, BigNumber],
-  TokensWithdrawnEventObject
->;
-
-export type TokensWithdrawnEventFilter = TypedEventFilter<TokensWithdrawnEvent>;
-
-export interface TradeEventObject {
-  perpetualId: number;
-  trader: string;
-  order: IPerpetualOrder.OrderStructOutput;
-  orderDigest: string;
-  newPositionSizeBC: BigNumber;
-  price: BigNumber;
-  fFeeCC: BigNumber;
-  fPnlCC: BigNumber;
-  fB2C: BigNumber;
+
+export namespace SettleStateEvent {
+  export type InputTuple = [perpetualId: BigNumberish];
+  export type OutputTuple = [perpetualId: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type TradeEvent = TypedEvent<
-  [
-    number,
-    string,
-    IPerpetualOrder.OrderStructOutput,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-  ],
-  TradeEventObject
->;
-
-export type TradeEventFilter = TypedEventFilter<TradeEvent>;
-
-export interface TransferAddressToEventObject {
-  name: string;
-  oldOBFactory: string;
-  newOBFactory: string;
+
+export namespace SettlementCompleteEvent {
+  export type InputTuple = [perpetualId: BigNumberish];
+  export type OutputTuple = [perpetualId: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type TransferAddressToEvent = TypedEvent<
-  [string, string, string],
-  TransferAddressToEventObject
->;
 
-export type TransferAddressToEventFilter =
-  TypedEventFilter<TransferAddressToEvent>;
+export namespace TokensDepositedEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    amount: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    amount: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    amount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface UnpausedEventObject {
-  account: string;
+export namespace TokensWithdrawnEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    amount: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    amount: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    amount: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
 
-export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
+export namespace TradeEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    order: IPerpetualOrder.OrderStruct,
+    orderDigest: BytesLike,
+    newPositionSizeBC: BigNumberish,
+    price: BigNumberish,
+    fFeeCC: BigNumberish,
+    fPnlCC: BigNumberish,
+    fB2C: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    order: IPerpetualOrder.OrderStructOutput,
+    orderDigest: string,
+    newPositionSizeBC: bigint,
+    price: bigint,
+    fFeeCC: bigint,
+    fPnlCC: bigint,
+    fB2C: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    order: IPerpetualOrder.OrderStructOutput;
+    orderDigest: string;
+    newPositionSizeBC: bigint;
+    price: bigint;
+    fFeeCC: bigint;
+    fPnlCC: bigint;
+    fB2C: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface UpdateBrokerAddedCashEventObject {
-  poolId: number;
-  iLots: number;
-  iNewBrokerLots: number;
+export namespace TransferAddressToEvent {
+  export type InputTuple = [
+    name: string,
+    oldOBFactory: AddressLike,
+    newOBFactory: AddressLike
+  ];
+  export type OutputTuple = [
+    name: string,
+    oldOBFactory: string,
+    newOBFactory: string
+  ];
+  export interface OutputObject {
+    name: string;
+    oldOBFactory: string;
+    newOBFactory: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type UpdateBrokerAddedCashEvent = TypedEvent<
-  [number, number, number],
-  UpdateBrokerAddedCashEventObject
->;
 
-export type UpdateBrokerAddedCashEventFilter =
-  TypedEventFilter<UpdateBrokerAddedCashEvent>;
+export namespace UnpausedEvent {
+  export type InputTuple = [account: AddressLike];
+  export type OutputTuple = [account: string];
+  export interface OutputObject {
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
-export interface UpdateFundingRateEventObject {
-  perpetualId: number;
-  fFundingRate: BigNumber;
+export namespace UpdateBrokerAddedCashEvent {
+  export type InputTuple = [
+    poolId: BigNumberish,
+    iLots: BigNumberish,
+    iNewBrokerLots: BigNumberish
+  ];
+  export type OutputTuple = [
+    poolId: bigint,
+    iLots: bigint,
+    iNewBrokerLots: bigint
+  ];
+  export interface OutputObject {
+    poolId: bigint;
+    iLots: bigint;
+    iNewBrokerLots: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type UpdateFundingRateEvent = TypedEvent<
-  [number, BigNumber],
-  UpdateFundingRateEventObject
->;
-
-export type UpdateFundingRateEventFilter =
-  TypedEventFilter<UpdateFundingRateEvent>;
-
-export interface UpdateMarginAccountEventObject {
-  perpetualId: number;
-  trader: string;
-  fFundingPaymentCC: BigNumber;
+
+export namespace UpdateFundingRateEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    fFundingRate: BigNumberish
+  ];
+  export type OutputTuple = [perpetualId: bigint, fFundingRate: bigint];
+  export interface OutputObject {
+    perpetualId: bigint;
+    fFundingRate: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type UpdateMarginAccountEvent = TypedEvent<
-  [number, string, BigNumber],
-  UpdateMarginAccountEventObject
->;
-
-export type UpdateMarginAccountEventFilter =
-  TypedEventFilter<UpdateMarginAccountEvent>;
-
-export interface UpdateMarkPriceEventObject {
-  perpetualId: number;
-  fMidPricePremium: BigNumber;
-  fMarkPricePremium: BigNumber;
-  fSpotIndexPrice: BigNumber;
+
+export namespace UpdateMarginAccountEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    trader: AddressLike,
+    fFundingPaymentCC: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    trader: string,
+    fFundingPaymentCC: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    trader: string;
+    fFundingPaymentCC: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type UpdateMarkPriceEvent = TypedEvent<
-  [number, BigNumber, BigNumber, BigNumber],
-  UpdateMarkPriceEventObject
->;
 
-export type UpdateMarkPriceEventFilter = TypedEventFilter<UpdateMarkPriceEvent>;
+export namespace UpdateMarkPriceEvent {
+  export type InputTuple = [
+    perpetualId: BigNumberish,
+    fMidPricePremium: BigNumberish,
+    fMarkPricePremium: BigNumberish,
+    fSpotIndexPrice: BigNumberish
+  ];
+  export type OutputTuple = [
+    perpetualId: bigint,
+    fMidPricePremium: bigint,
+    fMarkPricePremium: bigint,
+    fSpotIndexPrice: bigint
+  ];
+  export interface OutputObject {
+    perpetualId: bigint;
+    fMidPricePremium: bigint;
+    fMarkPricePremium: bigint;
+    fSpotIndexPrice: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
 
 export interface PerpetualManagerProxy extends BaseContract {
-  connect(signerOrProvider: Signer | Provider | string): this;
-  attach(addressOrName: string): this;
-  deployed(): Promise<this>;
+  connect(runner?: ContractRunner | null): PerpetualManagerProxy;
+  waitForDeployment(): Promise<this>;
 
   interface: PerpetualManagerProxyInterface;
 
-  queryFilter<TEvent extends TypedEvent>(
-    event: TypedEventFilter<TEvent>,
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
     fromBlockOrBlockhash?: string | number | undefined,
     toBlock?: string | number | undefined
-  ): Promise<Array<TEvent>>;
-
-  listeners<TEvent extends TypedEvent>(
-    eventFilter?: TypedEventFilter<TEvent>
-  ): Array<TypedListener<TEvent>>;
-  listeners(eventName?: string): Array<Listener>;
-  removeAllListeners<TEvent extends TypedEvent>(
-    eventFilter: TypedEventFilter<TEvent>
-  ): this;
-  removeAllListeners(eventName?: string): this;
-  off: OnEvent<this>;
-  on: OnEvent<this>;
-  once: OnEvent<this>;
-  removeListener: OnEvent<this>;
-
-  functions: {
-    getImplementation(
-      _sig: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<[string]>;
-
-    getModuleImplementationAddress(
-      _moduleName: string,
-      overrides?: CallOverrides
-    ): Promise<[string]>;
-
-    getProxyOwner(
-      overrides?: CallOverrides
-    ): Promise<[string] & { _owner: string }>;
-
-    governance(overrides?: CallOverrides): Promise<[string]>;
-
-    maintainer(overrides?: CallOverrides): Promise<[string]>;
-
-    pause(
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    paused(overrides?: CallOverrides): Promise<[boolean]>;
-
-    setImplementation(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    setImplementationCrossModules(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    setProxyOwner(
-      _owner: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    transferGovernance(
-      newGovernance: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    transferMaintainer(
-      newMaintainer: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    unpause(
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-  };
-
-  getImplementation(
-    _sig: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  getModuleImplementationAddress(
-    _moduleName: string,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  getProxyOwner(overrides?: CallOverrides): Promise<string>;
-
-  governance(overrides?: CallOverrides): Promise<string>;
-
-  maintainer(overrides?: CallOverrides): Promise<string>;
-
-  pause(
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  paused(overrides?: CallOverrides): Promise<boolean>;
-
-  setImplementation(
-    _impl: string,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  setImplementationCrossModules(
-    _impl: string,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  setProxyOwner(
-    _owner: string,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  transferGovernance(
-    newGovernance: string,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  transferMaintainer(
-    newMaintainer: string,
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  unpause(
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  callStatic: {
-    getImplementation(
-      _sig: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
-    getModuleImplementationAddress(
-      _moduleName: string,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
-    getProxyOwner(overrides?: CallOverrides): Promise<string>;
-
-    governance(overrides?: CallOverrides): Promise<string>;
-
-    maintainer(overrides?: CallOverrides): Promise<string>;
-
-    pause(overrides?: CallOverrides): Promise<void>;
-
-    paused(overrides?: CallOverrides): Promise<boolean>;
-
-    setImplementation(_impl: string, overrides?: CallOverrides): Promise<void>;
-
-    setImplementationCrossModules(
-      _impl: string,
-      overrides?: CallOverrides
-    ): Promise<void>;
-
-    setProxyOwner(_owner: string, overrides?: CallOverrides): Promise<void>;
-
-    transferGovernance(
-      newGovernance: string,
-      overrides?: CallOverrides
-    ): Promise<void>;
+  ): 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>;
+
+  getImplementation: TypedContractMethod<[_sig: BytesLike], [string], "view">;
+
+  getModuleImplementationAddress: TypedContractMethod<
+    [_moduleName: string],
+    [string],
+    "view"
+  >;
+
+  getProxyOwner: TypedContractMethod<[], [string], "view">;
+
+  governance: TypedContractMethod<[], [string], "view">;
+
+  maintainer: TypedContractMethod<[], [string], "view">;
+
+  pause: TypedContractMethod<[], [void], "nonpayable">;
+
+  paused: TypedContractMethod<[], [boolean], "view">;
+
+  setImplementation: TypedContractMethod<
+    [_impl: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setImplementationCrossModules: TypedContractMethod<
+    [_impl: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setProxyOwner: TypedContractMethod<
+    [_owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  transferGovernance: TypedContractMethod<
+    [newGovernance: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  transferMaintainer: TypedContractMethod<
+    [newMaintainer: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unpause: TypedContractMethod<[], [void], "nonpayable">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
 
-    transferMaintainer(
-      newMaintainer: string,
-      overrides?: CallOverrides
-    ): Promise<void>;
+  getFunction(
+    nameOrSignature: "getImplementation"
+  ): TypedContractMethod<[_sig: BytesLike], [string], "view">;
+  getFunction(
+    nameOrSignature: "getModuleImplementationAddress"
+  ): TypedContractMethod<[_moduleName: string], [string], "view">;
+  getFunction(
+    nameOrSignature: "getProxyOwner"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "governance"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "maintainer"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "pause"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "paused"
+  ): TypedContractMethod<[], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "setImplementation"
+  ): TypedContractMethod<[_impl: AddressLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setImplementationCrossModules"
+  ): TypedContractMethod<[_impl: AddressLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setProxyOwner"
+  ): TypedContractMethod<[_owner: AddressLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "transferGovernance"
+  ): TypedContractMethod<[newGovernance: AddressLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "transferMaintainer"
+  ): TypedContractMethod<[newMaintainer: AddressLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "unpause"
+  ): TypedContractMethod<[], [void], "nonpayable">;
 
-    unpause(overrides?: CallOverrides): Promise<void>;
-  };
+  getEvent(
+    key: "BrokerLotsTransferred"
+  ): TypedContractEvent<
+    BrokerLotsTransferredEvent.InputTuple,
+    BrokerLotsTransferredEvent.OutputTuple,
+    BrokerLotsTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "BrokerVolumeTransferred"
+  ): TypedContractEvent<
+    BrokerVolumeTransferredEvent.InputTuple,
+    BrokerVolumeTransferredEvent.OutputTuple,
+    BrokerVolumeTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "Clear"
+  ): TypedContractEvent<
+    ClearEvent.InputTuple,
+    ClearEvent.OutputTuple,
+    ClearEvent.OutputObject
+  >;
+  getEvent(
+    key: "DistributeFees"
+  ): TypedContractEvent<
+    DistributeFeesEvent.InputTuple,
+    DistributeFeesEvent.OutputTuple,
+    DistributeFeesEvent.OutputObject
+  >;
+  getEvent(
+    key: "GovernanceTransferred"
+  ): TypedContractEvent<
+    GovernanceTransferredEvent.InputTuple,
+    GovernanceTransferredEvent.OutputTuple,
+    GovernanceTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "ImplementationChanged"
+  ): TypedContractEvent<
+    ImplementationChangedEvent.InputTuple,
+    ImplementationChangedEvent.OutputTuple,
+    ImplementationChangedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Liquidate"
+  ): TypedContractEvent<
+    LiquidateEvent.InputTuple,
+    LiquidateEvent.OutputTuple,
+    LiquidateEvent.OutputObject
+  >;
+  getEvent(
+    key: "LiquidityAdded"
+  ): TypedContractEvent<
+    LiquidityAddedEvent.InputTuple,
+    LiquidityAddedEvent.OutputTuple,
+    LiquidityAddedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LiquidityPoolCreated"
+  ): TypedContractEvent<
+    LiquidityPoolCreatedEvent.InputTuple,
+    LiquidityPoolCreatedEvent.OutputTuple,
+    LiquidityPoolCreatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LiquidityProvisionPaused"
+  ): TypedContractEvent<
+    LiquidityProvisionPausedEvent.InputTuple,
+    LiquidityProvisionPausedEvent.OutputTuple,
+    LiquidityProvisionPausedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LiquidityRemoved"
+  ): TypedContractEvent<
+    LiquidityRemovedEvent.InputTuple,
+    LiquidityRemovedEvent.OutputTuple,
+    LiquidityRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LiquidityWithdrawalInitiated"
+  ): TypedContractEvent<
+    LiquidityWithdrawalInitiatedEvent.InputTuple,
+    LiquidityWithdrawalInitiatedEvent.OutputTuple,
+    LiquidityWithdrawalInitiatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "MaintainerTransferred"
+  ): TypedContractEvent<
+    MaintainerTransferredEvent.InputTuple,
+    MaintainerTransferredEvent.OutputTuple,
+    MaintainerTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "Paused"
+  ): TypedContractEvent<
+    PausedEvent.InputTuple,
+    PausedEvent.OutputTuple,
+    PausedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PerpetualCreated"
+  ): TypedContractEvent<
+    PerpetualCreatedEvent.InputTuple,
+    PerpetualCreatedEvent.OutputTuple,
+    PerpetualCreatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PerpetualLimitOrderCancelled"
+  ): TypedContractEvent<
+    PerpetualLimitOrderCancelledEvent.InputTuple,
+    PerpetualLimitOrderCancelledEvent.OutputTuple,
+    PerpetualLimitOrderCancelledEvent.OutputObject
+  >;
+  getEvent(
+    key: "ProxyOwnershipTransferred"
+  ): TypedContractEvent<
+    ProxyOwnershipTransferredEvent.InputTuple,
+    ProxyOwnershipTransferredEvent.OutputTuple,
+    ProxyOwnershipTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "RunLiquidityPool"
+  ): TypedContractEvent<
+    RunLiquidityPoolEvent.InputTuple,
+    RunLiquidityPoolEvent.OutputTuple,
+    RunLiquidityPoolEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetBlockDelay"
+  ): TypedContractEvent<
+    SetBlockDelayEvent.InputTuple,
+    SetBlockDelayEvent.OutputTuple,
+    SetBlockDelayEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetBrokerDesignations"
+  ): TypedContractEvent<
+    SetBrokerDesignationsEvent.InputTuple,
+    SetBrokerDesignationsEvent.OutputTuple,
+    SetBrokerDesignationsEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetBrokerTiers"
+  ): TypedContractEvent<
+    SetBrokerTiersEvent.InputTuple,
+    SetBrokerTiersEvent.OutputTuple,
+    SetBrokerTiersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetBrokerVolumeTiers"
+  ): TypedContractEvent<
+    SetBrokerVolumeTiersEvent.InputTuple,
+    SetBrokerVolumeTiersEvent.OutputTuple,
+    SetBrokerVolumeTiersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetClearedState"
+  ): TypedContractEvent<
+    SetClearedStateEvent.InputTuple,
+    SetClearedStateEvent.OutputTuple,
+    SetClearedStateEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetDelegate"
+  ): TypedContractEvent<
+    SetDelegateEvent.InputTuple,
+    SetDelegateEvent.OutputTuple,
+    SetDelegateEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetEmergencyState"
+  ): TypedContractEvent<
+    SetEmergencyStateEvent.InputTuple,
+    SetEmergencyStateEvent.OutputTuple,
+    SetEmergencyStateEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetNormalState"
+  ): TypedContractEvent<
+    SetNormalStateEvent.InputTuple,
+    SetNormalStateEvent.OutputTuple,
+    SetNormalStateEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetOracles"
+  ): TypedContractEvent<
+    SetOraclesEvent.InputTuple,
+    SetOraclesEvent.OutputTuple,
+    SetOraclesEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetParameter"
+  ): TypedContractEvent<
+    SetParameterEvent.InputTuple,
+    SetParameterEvent.OutputTuple,
+    SetParameterEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetParameterPair"
+  ): TypedContractEvent<
+    SetParameterPairEvent.InputTuple,
+    SetParameterPairEvent.OutputTuple,
+    SetParameterPairEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetPerpetualBaseParameters"
+  ): TypedContractEvent<
+    SetPerpetualBaseParametersEvent.InputTuple,
+    SetPerpetualBaseParametersEvent.OutputTuple,
+    SetPerpetualBaseParametersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetPerpetualRiskParameters"
+  ): TypedContractEvent<
+    SetPerpetualRiskParametersEvent.InputTuple,
+    SetPerpetualRiskParametersEvent.OutputTuple,
+    SetPerpetualRiskParametersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetPoolParameter"
+  ): TypedContractEvent<
+    SetPoolParameterEvent.InputTuple,
+    SetPoolParameterEvent.OutputTuple,
+    SetPoolParameterEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetTraderTiers"
+  ): TypedContractEvent<
+    SetTraderTiersEvent.InputTuple,
+    SetTraderTiersEvent.OutputTuple,
+    SetTraderTiersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetTraderVolumeTiers"
+  ): TypedContractEvent<
+    SetTraderVolumeTiersEvent.InputTuple,
+    SetTraderVolumeTiersEvent.OutputTuple,
+    SetTraderVolumeTiersEvent.OutputObject
+  >;
+  getEvent(
+    key: "SetUtilityToken"
+  ): TypedContractEvent<
+    SetUtilityTokenEvent.InputTuple,
+    SetUtilityTokenEvent.OutputTuple,
+    SetUtilityTokenEvent.OutputObject
+  >;
+  getEvent(
+    key: "Settle"
+  ): TypedContractEvent<
+    SettleEvent.InputTuple,
+    SettleEvent.OutputTuple,
+    SettleEvent.OutputObject
+  >;
+  getEvent(
+    key: "SettleState"
+  ): TypedContractEvent<
+    SettleStateEvent.InputTuple,
+    SettleStateEvent.OutputTuple,
+    SettleStateEvent.OutputObject
+  >;
+  getEvent(
+    key: "SettlementComplete"
+  ): TypedContractEvent<
+    SettlementCompleteEvent.InputTuple,
+    SettlementCompleteEvent.OutputTuple,
+    SettlementCompleteEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokensDeposited"
+  ): TypedContractEvent<
+    TokensDepositedEvent.InputTuple,
+    TokensDepositedEvent.OutputTuple,
+    TokensDepositedEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokensWithdrawn"
+  ): TypedContractEvent<
+    TokensWithdrawnEvent.InputTuple,
+    TokensWithdrawnEvent.OutputTuple,
+    TokensWithdrawnEvent.OutputObject
+  >;
+  getEvent(
+    key: "Trade"
+  ): TypedContractEvent<
+    TradeEvent.InputTuple,
+    TradeEvent.OutputTuple,
+    TradeEvent.OutputObject
+  >;
+  getEvent(
+    key: "TransferAddressTo"
+  ): TypedContractEvent<
+    TransferAddressToEvent.InputTuple,
+    TransferAddressToEvent.OutputTuple,
+    TransferAddressToEvent.OutputObject
+  >;
+  getEvent(
+    key: "Unpaused"
+  ): TypedContractEvent<
+    UnpausedEvent.InputTuple,
+    UnpausedEvent.OutputTuple,
+    UnpausedEvent.OutputObject
+  >;
+  getEvent(
+    key: "UpdateBrokerAddedCash"
+  ): TypedContractEvent<
+    UpdateBrokerAddedCashEvent.InputTuple,
+    UpdateBrokerAddedCashEvent.OutputTuple,
+    UpdateBrokerAddedCashEvent.OutputObject
+  >;
+  getEvent(
+    key: "UpdateFundingRate"
+  ): TypedContractEvent<
+    UpdateFundingRateEvent.InputTuple,
+    UpdateFundingRateEvent.OutputTuple,
+    UpdateFundingRateEvent.OutputObject
+  >;
+  getEvent(
+    key: "UpdateMarginAccount"
+  ): TypedContractEvent<
+    UpdateMarginAccountEvent.InputTuple,
+    UpdateMarginAccountEvent.OutputTuple,
+    UpdateMarginAccountEvent.OutputObject
+  >;
+  getEvent(
+    key: "UpdateMarkPrice"
+  ): TypedContractEvent<
+    UpdateMarkPriceEvent.InputTuple,
+    UpdateMarkPriceEvent.OutputTuple,
+    UpdateMarkPriceEvent.OutputObject
+  >;
 
   filters: {
-    "BrokerLotsTransferred(uint8,address,address,uint32)"(
-      poolId?: BigNumberish | null,
-      oldOwner?: null,
-      newOwner?: null,
-      numLots?: null
-    ): BrokerLotsTransferredEventFilter;
-    BrokerLotsTransferred(
-      poolId?: BigNumberish | null,
-      oldOwner?: null,
-      newOwner?: null,
-      numLots?: null
-    ): BrokerLotsTransferredEventFilter;
-
-    "BrokerVolumeTransferred(uint8,address,address,int128)"(
-      poolId?: BigNumberish | null,
-      oldOwner?: null,
-      newOwner?: null,
-      fVolume?: null
-    ): BrokerVolumeTransferredEventFilter;
-    BrokerVolumeTransferred(
-      poolId?: BigNumberish | null,
-      oldOwner?: null,
-      newOwner?: null,
-      fVolume?: null
-    ): BrokerVolumeTransferredEventFilter;
-
-    "Clear(uint24,address)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null
-    ): ClearEventFilter;
-    Clear(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null
-    ): ClearEventFilter;
-
-    "DistributeFees(uint8,uint24,address,int128,int128)"(
-      poolId?: BigNumberish | null,
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      protocolFeeCC?: null,
-      participationFundFeeCC?: null
-    ): DistributeFeesEventFilter;
-    DistributeFees(
-      poolId?: BigNumberish | null,
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      protocolFeeCC?: null,
-      participationFundFeeCC?: null
-    ): DistributeFeesEventFilter;
-
-    "GovernanceTransferred(address,address)"(
-      previousGovernance?: string | null,
-      newGovernance?: string | null
-    ): GovernanceTransferredEventFilter;
-    GovernanceTransferred(
-      previousGovernance?: string | null,
-      newGovernance?: string | null
-    ): GovernanceTransferredEventFilter;
-
-    "ImplementationChanged(bytes4,address,address)"(
-      _sig?: null,
-      _oldImplementation?: string | null,
-      _newImplementation?: string | null
-    ): ImplementationChangedEventFilter;
-    ImplementationChanged(
-      _sig?: null,
-      _oldImplementation?: string | null,
-      _newImplementation?: string | null
-    ): ImplementationChangedEventFilter;
-
-    "Liquidate(uint24,address,address,int128,int128,int128,int128,int128)"(
-      perpetualId?: null,
-      liquidator?: string | null,
-      trader?: string | null,
-      amountLiquidatedBC?: null,
-      liquidationPrice?: null,
-      newPositionSizeBC?: null,
-      fFeeCC?: null,
-      fPnlCC?: null
-    ): LiquidateEventFilter;
-    Liquidate(
-      perpetualId?: null,
-      liquidator?: string | null,
-      trader?: string | null,
-      amountLiquidatedBC?: null,
-      liquidationPrice?: null,
-      newPositionSizeBC?: null,
-      fFeeCC?: null,
-      fPnlCC?: null
-    ): LiquidateEventFilter;
-
-    "LiquidityAdded(uint8,address,uint256,uint256)"(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      tokenAmount?: null,
-      shareAmount?: null
-    ): LiquidityAddedEventFilter;
-    LiquidityAdded(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      tokenAmount?: null,
-      shareAmount?: null
-    ): LiquidityAddedEventFilter;
-
-    "LiquidityPoolCreated(uint8,address,address,uint16,int128)"(
-      id?: null,
-      marginTokenAddress?: null,
-      shareTokenAddress?: null,
-      iTargetPoolSizeUpdateTime?: null,
-      fBrokerCollateralLotSize?: null
-    ): LiquidityPoolCreatedEventFilter;
-    LiquidityPoolCreated(
-      id?: null,
-      marginTokenAddress?: null,
-      shareTokenAddress?: null,
-      iTargetPoolSizeUpdateTime?: null,
-      fBrokerCollateralLotSize?: null
-    ): LiquidityPoolCreatedEventFilter;
-
-    "LiquidityProvisionPaused(bool,uint8)"(
-      pauseOn?: null,
-      poolId?: null
-    ): LiquidityProvisionPausedEventFilter;
-    LiquidityProvisionPaused(
-      pauseOn?: null,
-      poolId?: null
-    ): LiquidityProvisionPausedEventFilter;
-
-    "LiquidityRemoved(uint8,address,uint256,uint256)"(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      tokenAmount?: null,
-      shareAmount?: null
-    ): LiquidityRemovedEventFilter;
-    LiquidityRemoved(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      tokenAmount?: null,
-      shareAmount?: null
-    ): LiquidityRemovedEventFilter;
-
-    "LiquidityWithdrawalInitiated(uint8,address,uint256)"(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      shareAmount?: null
-    ): LiquidityWithdrawalInitiatedEventFilter;
-    LiquidityWithdrawalInitiated(
-      poolId?: BigNumberish | null,
-      user?: string | null,
-      shareAmount?: null
-    ): LiquidityWithdrawalInitiatedEventFilter;
-
-    "MaintainerTransferred(address,address)"(
-      previousMaintainer?: string | null,
-      newMaintainer?: string | null
-    ): MaintainerTransferredEventFilter;
-    MaintainerTransferred(
-      previousMaintainer?: string | null,
-      newMaintainer?: string | null
-    ): MaintainerTransferredEventFilter;
-
-    "Paused(address)"(account?: null): PausedEventFilter;
-    Paused(account?: null): PausedEventFilter;
-
-    "PerpetualCreated(uint8,uint24,int128[7],int128[5],int128[12],uint256)"(
-      poolId?: null,
-      id?: null,
-      baseParams?: null,
-      underlyingRiskParams?: null,
-      defaultFundRiskParams?: null,
-      eCollateralCurrency?: null
-    ): PerpetualCreatedEventFilter;
-    PerpetualCreated(
-      poolId?: null,
-      id?: null,
-      baseParams?: null,
-      underlyingRiskParams?: null,
-      defaultFundRiskParams?: null,
-      eCollateralCurrency?: null
-    ): PerpetualCreatedEventFilter;
-
-    "PerpetualLimitOrderCancelled(uint24,bytes32)"(
-      perpetualId?: BigNumberish | null,
-      orderHash?: BytesLike | null
-    ): PerpetualLimitOrderCancelledEventFilter;
-    PerpetualLimitOrderCancelled(
-      perpetualId?: BigNumberish | null,
-      orderHash?: BytesLike | null
-    ): PerpetualLimitOrderCancelledEventFilter;
-
-    "ProxyOwnershipTransferred(address,address)"(
-      _oldOwner?: string | null,
-      _newOwner?: string | null
-    ): ProxyOwnershipTransferredEventFilter;
-    ProxyOwnershipTransferred(
-      _oldOwner?: string | null,
-      _newOwner?: string | null
-    ): ProxyOwnershipTransferredEventFilter;
-
-    "RunLiquidityPool(uint8)"(_liqPoolID?: null): RunLiquidityPoolEventFilter;
-    RunLiquidityPool(_liqPoolID?: null): RunLiquidityPoolEventFilter;
-
-    "SetBlockDelay(uint8)"(delay?: null): SetBlockDelayEventFilter;
-    SetBlockDelay(delay?: null): SetBlockDelayEventFilter;
-
-    "SetBrokerDesignations(uint32[],uint16[])"(
-      designations?: null,
-      fees?: null
-    ): SetBrokerDesignationsEventFilter;
-    SetBrokerDesignations(
-      designations?: null,
-      fees?: null
-    ): SetBrokerDesignationsEventFilter;
-
-    "SetBrokerTiers(uint256[],uint16[])"(
-      tiers?: null,
-      feesTbps?: null
-    ): SetBrokerTiersEventFilter;
-    SetBrokerTiers(tiers?: null, feesTbps?: null): SetBrokerTiersEventFilter;
-
-    "SetBrokerVolumeTiers(uint256[],uint16[])"(
-      tiers?: null,
-      feesTbps?: null
-    ): SetBrokerVolumeTiersEventFilter;
-    SetBrokerVolumeTiers(
-      tiers?: null,
-      feesTbps?: null
-    ): SetBrokerVolumeTiersEventFilter;
-
-    "SetClearedState(uint24)"(
-      perpetualId?: BigNumberish | null
-    ): SetClearedStateEventFilter;
-    SetClearedState(
-      perpetualId?: BigNumberish | null
-    ): SetClearedStateEventFilter;
-
-    "SetDelegate(address,address)"(
-      trader?: null,
-      delegate?: null
-    ): SetDelegateEventFilter;
-    SetDelegate(trader?: null, delegate?: null): SetDelegateEventFilter;
-
-    "SetEmergencyState(uint24,int128,int128,int128)"(
-      perpetualId?: BigNumberish | null,
-      fSettlementMarkPremiumRate?: null,
-      fSettlementS2Price?: null,
-      fSettlementS3Price?: null
-    ): SetEmergencyStateEventFilter;
-    SetEmergencyState(
-      perpetualId?: BigNumberish | null,
-      fSettlementMarkPremiumRate?: null,
-      fSettlementS2Price?: null,
-      fSettlementS3Price?: null
-    ): SetEmergencyStateEventFilter;
-
-    "SetNormalState(uint24)"(
-      perpetualId?: BigNumberish | null
-    ): SetNormalStateEventFilter;
-    SetNormalState(
-      perpetualId?: BigNumberish | null
-    ): SetNormalStateEventFilter;
-
-    "SetOracles(uint24,bytes4[2],bytes4[2])"(
-      perpetualId?: BigNumberish | null,
-      baseQuoteS2?: null,
-      baseQuoteS3?: null
-    ): SetOraclesEventFilter;
-    SetOracles(
-      perpetualId?: BigNumberish | null,
-      baseQuoteS2?: null,
-      baseQuoteS3?: null
-    ): SetOraclesEventFilter;
-
-    "SetParameter(uint24,string,int128)"(
-      perpetualId?: BigNumberish | null,
-      name?: null,
-      value?: null
-    ): SetParameterEventFilter;
-    SetParameter(
-      perpetualId?: BigNumberish | null,
-      name?: null,
-      value?: null
-    ): SetParameterEventFilter;
-
-    "SetParameterPair(uint24,string,int128,int128)"(
-      perpetualId?: BigNumberish | null,
-      name?: null,
-      value1?: null,
-      value2?: null
-    ): SetParameterPairEventFilter;
-    SetParameterPair(
-      perpetualId?: BigNumberish | null,
-      name?: null,
-      value1?: null,
-      value2?: null
-    ): SetParameterPairEventFilter;
-
-    "SetPerpetualBaseParameters(uint24,int128[7])"(
-      perpetualId?: BigNumberish | null,
-      baseParams?: null
-    ): SetPerpetualBaseParametersEventFilter;
-    SetPerpetualBaseParameters(
-      perpetualId?: BigNumberish | null,
-      baseParams?: null
-    ): SetPerpetualBaseParametersEventFilter;
-
-    "SetPerpetualRiskParameters(uint24,int128[5],int128[12])"(
-      perpetualId?: BigNumberish | null,
-      underlyingRiskParams?: null,
-      defaultFundRiskParams?: null
-    ): SetPerpetualRiskParametersEventFilter;
-    SetPerpetualRiskParameters(
-      perpetualId?: BigNumberish | null,
-      underlyingRiskParams?: null,
-      defaultFundRiskParams?: null
-    ): SetPerpetualRiskParametersEventFilter;
-
-    "SetPoolParameter(uint8,string,int128)"(
-      poolId?: BigNumberish | null,
-      name?: null,
-      value?: null
-    ): SetPoolParameterEventFilter;
-    SetPoolParameter(
-      poolId?: BigNumberish | null,
-      name?: null,
-      value?: null
-    ): SetPoolParameterEventFilter;
-
-    "SetTraderTiers(uint256[],uint16[])"(
-      tiers?: null,
-      feesTbps?: null
-    ): SetTraderTiersEventFilter;
-    SetTraderTiers(tiers?: null, feesTbps?: null): SetTraderTiersEventFilter;
-
-    "SetTraderVolumeTiers(uint256[],uint16[])"(
-      tiers?: null,
-      feesTbps?: null
-    ): SetTraderVolumeTiersEventFilter;
-    SetTraderVolumeTiers(
-      tiers?: null,
-      feesTbps?: null
-    ): SetTraderVolumeTiersEventFilter;
-
-    "SetUtilityToken(address)"(tokenAddr?: null): SetUtilityTokenEventFilter;
-    SetUtilityToken(tokenAddr?: null): SetUtilityTokenEventFilter;
-
-    "Settle(uint24,address,int256)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): SettleEventFilter;
-    Settle(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): SettleEventFilter;
-
-    "SettleState(uint24)"(
-      perpetualId?: BigNumberish | null
-    ): SettleStateEventFilter;
-    SettleState(perpetualId?: BigNumberish | null): SettleStateEventFilter;
-
-    "SettlementComplete(uint24)"(
-      perpetualId?: BigNumberish | null
-    ): SettlementCompleteEventFilter;
-    SettlementComplete(
-      perpetualId?: BigNumberish | null
-    ): SettlementCompleteEventFilter;
-
-    "TokensDeposited(uint24,address,int128)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): TokensDepositedEventFilter;
-    TokensDeposited(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): TokensDepositedEventFilter;
-
-    "TokensWithdrawn(uint24,address,int128)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): TokensWithdrawnEventFilter;
-    TokensWithdrawn(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      amount?: null
-    ): TokensWithdrawnEventFilter;
-
-    "Trade(uint24,address,(uint16,uint16,uint24,address,uint32,address,uint32,uint32,uint32,address,int128,int128,int128,bytes),bytes32,int128,int128,int128,int128,int128)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      order?: null,
-      orderDigest?: null,
-      newPositionSizeBC?: null,
-      price?: null,
-      fFeeCC?: null,
-      fPnlCC?: null,
-      fB2C?: null
-    ): TradeEventFilter;
-    Trade(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      order?: null,
-      orderDigest?: null,
-      newPositionSizeBC?: null,
-      price?: null,
-      fFeeCC?: null,
-      fPnlCC?: null,
-      fB2C?: null
-    ): TradeEventFilter;
-
-    "TransferAddressTo(string,address,address)"(
-      name?: null,
-      oldOBFactory?: null,
-      newOBFactory?: null
-    ): TransferAddressToEventFilter;
-    TransferAddressTo(
-      name?: null,
-      oldOBFactory?: null,
-      newOBFactory?: null
-    ): TransferAddressToEventFilter;
-
-    "Unpaused(address)"(account?: null): UnpausedEventFilter;
-    Unpaused(account?: null): UnpausedEventFilter;
-
-    "UpdateBrokerAddedCash(uint8,uint32,uint32)"(
-      poolId?: BigNumberish | null,
-      iLots?: null,
-      iNewBrokerLots?: null
-    ): UpdateBrokerAddedCashEventFilter;
-    UpdateBrokerAddedCash(
-      poolId?: BigNumberish | null,
-      iLots?: null,
-      iNewBrokerLots?: null
-    ): UpdateBrokerAddedCashEventFilter;
-
-    "UpdateFundingRate(uint24,int128)"(
-      perpetualId?: BigNumberish | null,
-      fFundingRate?: null
-    ): UpdateFundingRateEventFilter;
-    UpdateFundingRate(
-      perpetualId?: BigNumberish | null,
-      fFundingRate?: null
-    ): UpdateFundingRateEventFilter;
-
-    "UpdateMarginAccount(uint24,address,int128)"(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      fFundingPaymentCC?: null
-    ): UpdateMarginAccountEventFilter;
-    UpdateMarginAccount(
-      perpetualId?: BigNumberish | null,
-      trader?: string | null,
-      fFundingPaymentCC?: null
-    ): UpdateMarginAccountEventFilter;
-
-    "UpdateMarkPrice(uint24,int128,int128,int128)"(
-      perpetualId?: BigNumberish | null,
-      fMidPricePremium?: null,
-      fMarkPricePremium?: null,
-      fSpotIndexPrice?: null
-    ): UpdateMarkPriceEventFilter;
-    UpdateMarkPrice(
-      perpetualId?: BigNumberish | null,
-      fMidPricePremium?: null,
-      fMarkPricePremium?: null,
-      fSpotIndexPrice?: null
-    ): UpdateMarkPriceEventFilter;
-  };
-
-  estimateGas: {
-    getImplementation(
-      _sig: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getModuleImplementationAddress(
-      _moduleName: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getProxyOwner(overrides?: CallOverrides): Promise<BigNumber>;
-
-    governance(overrides?: CallOverrides): Promise<BigNumber>;
-
-    maintainer(overrides?: CallOverrides): Promise<BigNumber>;
-
-    pause(overrides?: Overrides & { from?: string }): Promise<BigNumber>;
-
-    paused(overrides?: CallOverrides): Promise<BigNumber>;
-
-    setImplementation(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    setImplementationCrossModules(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    setProxyOwner(
-      _owner: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    transferGovernance(
-      newGovernance: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    transferMaintainer(
-      newMaintainer: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    unpause(overrides?: Overrides & { from?: string }): Promise<BigNumber>;
-  };
-
-  populateTransaction: {
-    getImplementation(
-      _sig: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getModuleImplementationAddress(
-      _moduleName: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getProxyOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    governance(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    maintainer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    pause(
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    setImplementation(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    setImplementationCrossModules(
-      _impl: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    setProxyOwner(
-      _owner: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    transferGovernance(
-      newGovernance: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    transferMaintainer(
-      newMaintainer: string,
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    unpause(
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
+    "BrokerLotsTransferred(uint8,address,address,uint32)": TypedContractEvent<
+      BrokerLotsTransferredEvent.InputTuple,
+      BrokerLotsTransferredEvent.OutputTuple,
+      BrokerLotsTransferredEvent.OutputObject
+    >;
+    BrokerLotsTransferred: TypedContractEvent<
+      BrokerLotsTransferredEvent.InputTuple,
+      BrokerLotsTransferredEvent.OutputTuple,
+      BrokerLotsTransferredEvent.OutputObject
+    >;
+
+    "BrokerVolumeTransferred(uint8,address,address,int128)": TypedContractEvent<
+      BrokerVolumeTransferredEvent.InputTuple,
+      BrokerVolumeTransferredEvent.OutputTuple,
+      BrokerVolumeTransferredEvent.OutputObject
+    >;
+    BrokerVolumeTransferred: TypedContractEvent<
+      BrokerVolumeTransferredEvent.InputTuple,
+      BrokerVolumeTransferredEvent.OutputTuple,
+      BrokerVolumeTransferredEvent.OutputObject
+    >;
+
+    "Clear(uint24,address)": TypedContractEvent<
+      ClearEvent.InputTuple,
+      ClearEvent.OutputTuple,
+      ClearEvent.OutputObject
+    >;
+    Clear: TypedContractEvent<
+      ClearEvent.InputTuple,
+      ClearEvent.OutputTuple,
+      ClearEvent.OutputObject
+    >;
+
+    "DistributeFees(uint8,uint24,address,int128,int128)": TypedContractEvent<
+      DistributeFeesEvent.InputTuple,
+      DistributeFeesEvent.OutputTuple,
+      DistributeFeesEvent.OutputObject
+    >;
+    DistributeFees: TypedContractEvent<
+      DistributeFeesEvent.InputTuple,
+      DistributeFeesEvent.OutputTuple,
+      DistributeFeesEvent.OutputObject
+    >;
+
+    "GovernanceTransferred(address,address)": TypedContractEvent<
+      GovernanceTransferredEvent.InputTuple,
+      GovernanceTransferredEvent.OutputTuple,
+      GovernanceTransferredEvent.OutputObject
+    >;
+    GovernanceTransferred: TypedContractEvent<
+      GovernanceTransferredEvent.InputTuple,
+      GovernanceTransferredEvent.OutputTuple,
+      GovernanceTransferredEvent.OutputObject
+    >;
+
+    "ImplementationChanged(bytes4,address,address)": TypedContractEvent<
+      ImplementationChangedEvent.InputTuple,
+      ImplementationChangedEvent.OutputTuple,
+      ImplementationChangedEvent.OutputObject
+    >;
+    ImplementationChanged: TypedContractEvent<
+      ImplementationChangedEvent.InputTuple,
+      ImplementationChangedEvent.OutputTuple,
+      ImplementationChangedEvent.OutputObject
+    >;
+
+    "Liquidate(uint24,address,address,int128,int128,int128,int128,int128)": TypedContractEvent<
+      LiquidateEvent.InputTuple,
+      LiquidateEvent.OutputTuple,
+      LiquidateEvent.OutputObject
+    >;
+    Liquidate: TypedContractEvent<
+      LiquidateEvent.InputTuple,
+      LiquidateEvent.OutputTuple,
+      LiquidateEvent.OutputObject
+    >;
+
+    "LiquidityAdded(uint8,address,uint256,uint256)": TypedContractEvent<
+      LiquidityAddedEvent.InputTuple,
+      LiquidityAddedEvent.OutputTuple,
+      LiquidityAddedEvent.OutputObject
+    >;
+    LiquidityAdded: TypedContractEvent<
+      LiquidityAddedEvent.InputTuple,
+      LiquidityAddedEvent.OutputTuple,
+      LiquidityAddedEvent.OutputObject
+    >;
+
+    "LiquidityPoolCreated(uint8,address,address,uint16,int128)": TypedContractEvent<
+      LiquidityPoolCreatedEvent.InputTuple,
+      LiquidityPoolCreatedEvent.OutputTuple,
+      LiquidityPoolCreatedEvent.OutputObject
+    >;
+    LiquidityPoolCreated: TypedContractEvent<
+      LiquidityPoolCreatedEvent.InputTuple,
+      LiquidityPoolCreatedEvent.OutputTuple,
+      LiquidityPoolCreatedEvent.OutputObject
+    >;
+
+    "LiquidityProvisionPaused(bool,uint8)": TypedContractEvent<
+      LiquidityProvisionPausedEvent.InputTuple,
+      LiquidityProvisionPausedEvent.OutputTuple,
+      LiquidityProvisionPausedEvent.OutputObject
+    >;
+    LiquidityProvisionPaused: TypedContractEvent<
+      LiquidityProvisionPausedEvent.InputTuple,
+      LiquidityProvisionPausedEvent.OutputTuple,
+      LiquidityProvisionPausedEvent.OutputObject
+    >;
+
+    "LiquidityRemoved(uint8,address,uint256,uint256)": TypedContractEvent<
+      LiquidityRemovedEvent.InputTuple,
+      LiquidityRemovedEvent.OutputTuple,
+      LiquidityRemovedEvent.OutputObject
+    >;
+    LiquidityRemoved: TypedContractEvent<
+      LiquidityRemovedEvent.InputTuple,
+      LiquidityRemovedEvent.OutputTuple,
+      LiquidityRemovedEvent.OutputObject
+    >;
+
+    "LiquidityWithdrawalInitiated(uint8,address,uint256)": TypedContractEvent<
+      LiquidityWithdrawalInitiatedEvent.InputTuple,
+      LiquidityWithdrawalInitiatedEvent.OutputTuple,
+      LiquidityWithdrawalInitiatedEvent.OutputObject
+    >;
+    LiquidityWithdrawalInitiated: TypedContractEvent<
+      LiquidityWithdrawalInitiatedEvent.InputTuple,
+      LiquidityWithdrawalInitiatedEvent.OutputTuple,
+      LiquidityWithdrawalInitiatedEvent.OutputObject
+    >;
+
+    "MaintainerTransferred(address,address)": TypedContractEvent<
+      MaintainerTransferredEvent.InputTuple,
+      MaintainerTransferredEvent.OutputTuple,
+      MaintainerTransferredEvent.OutputObject
+    >;
+    MaintainerTransferred: TypedContractEvent<
+      MaintainerTransferredEvent.InputTuple,
+      MaintainerTransferredEvent.OutputTuple,
+      MaintainerTransferredEvent.OutputObject
+    >;
+
+    "Paused(address)": TypedContractEvent<
+      PausedEvent.InputTuple,
+      PausedEvent.OutputTuple,
+      PausedEvent.OutputObject
+    >;
+    Paused: TypedContractEvent<
+      PausedEvent.InputTuple,
+      PausedEvent.OutputTuple,
+      PausedEvent.OutputObject
+    >;
+
+    "PerpetualCreated(uint8,uint24,int128[7],int128[5],int128[12],uint256)": TypedContractEvent<
+      PerpetualCreatedEvent.InputTuple,
+      PerpetualCreatedEvent.OutputTuple,
+      PerpetualCreatedEvent.OutputObject
+    >;
+    PerpetualCreated: TypedContractEvent<
+      PerpetualCreatedEvent.InputTuple,
+      PerpetualCreatedEvent.OutputTuple,
+      PerpetualCreatedEvent.OutputObject
+    >;
+
+    "PerpetualLimitOrderCancelled(uint24,bytes32)": TypedContractEvent<
+      PerpetualLimitOrderCancelledEvent.InputTuple,
+      PerpetualLimitOrderCancelledEvent.OutputTuple,
+      PerpetualLimitOrderCancelledEvent.OutputObject
+    >;
+    PerpetualLimitOrderCancelled: TypedContractEvent<
+      PerpetualLimitOrderCancelledEvent.InputTuple,
+      PerpetualLimitOrderCancelledEvent.OutputTuple,
+      PerpetualLimitOrderCancelledEvent.OutputObject
+    >;
+
+    "ProxyOwnershipTransferred(address,address)": TypedContractEvent<
+      ProxyOwnershipTransferredEvent.InputTuple,
+      ProxyOwnershipTransferredEvent.OutputTuple,
+      ProxyOwnershipTransferredEvent.OutputObject
+    >;
+    ProxyOwnershipTransferred: TypedContractEvent<
+      ProxyOwnershipTransferredEvent.InputTuple,
+      ProxyOwnershipTransferredEvent.OutputTuple,
+      ProxyOwnershipTransferredEvent.OutputObject
+    >;
+
+    "RunLiquidityPool(uint8)": TypedContractEvent<
+      RunLiquidityPoolEvent.InputTuple,
+      RunLiquidityPoolEvent.OutputTuple,
+      RunLiquidityPoolEvent.OutputObject
+    >;
+    RunLiquidityPool: TypedContractEvent<
+      RunLiquidityPoolEvent.InputTuple,
+      RunLiquidityPoolEvent.OutputTuple,
+      RunLiquidityPoolEvent.OutputObject
+    >;
+
+    "SetBlockDelay(uint8)": TypedContractEvent<
+      SetBlockDelayEvent.InputTuple,
+      SetBlockDelayEvent.OutputTuple,
+      SetBlockDelayEvent.OutputObject
+    >;
+    SetBlockDelay: TypedContractEvent<
+      SetBlockDelayEvent.InputTuple,
+      SetBlockDelayEvent.OutputTuple,
+      SetBlockDelayEvent.OutputObject
+    >;
+
+    "SetBrokerDesignations(uint32[],uint16[])": TypedContractEvent<
+      SetBrokerDesignationsEvent.InputTuple,
+      SetBrokerDesignationsEvent.OutputTuple,
+      SetBrokerDesignationsEvent.OutputObject
+    >;
+    SetBrokerDesignations: TypedContractEvent<
+      SetBrokerDesignationsEvent.InputTuple,
+      SetBrokerDesignationsEvent.OutputTuple,
+      SetBrokerDesignationsEvent.OutputObject
+    >;
+
+    "SetBrokerTiers(uint256[],uint16[])": TypedContractEvent<
+      SetBrokerTiersEvent.InputTuple,
+      SetBrokerTiersEvent.OutputTuple,
+      SetBrokerTiersEvent.OutputObject
+    >;
+    SetBrokerTiers: TypedContractEvent<
+      SetBrokerTiersEvent.InputTuple,
+      SetBrokerTiersEvent.OutputTuple,
+      SetBrokerTiersEvent.OutputObject
+    >;
+
+    "SetBrokerVolumeTiers(uint256[],uint16[])": TypedContractEvent<
+      SetBrokerVolumeTiersEvent.InputTuple,
+      SetBrokerVolumeTiersEvent.OutputTuple,
+      SetBrokerVolumeTiersEvent.OutputObject
+    >;
+    SetBrokerVolumeTiers: TypedContractEvent<
+      SetBrokerVolumeTiersEvent.InputTuple,
+      SetBrokerVolumeTiersEvent.OutputTuple,
+      SetBrokerVolumeTiersEvent.OutputObject
+    >;
+
+    "SetClearedState(uint24)": TypedContractEvent<
+      SetClearedStateEvent.InputTuple,
+      SetClearedStateEvent.OutputTuple,
+      SetClearedStateEvent.OutputObject
+    >;
+    SetClearedState: TypedContractEvent<
+      SetClearedStateEvent.InputTuple,
+      SetClearedStateEvent.OutputTuple,
+      SetClearedStateEvent.OutputObject
+    >;
+
+    "SetDelegate(address,address)": TypedContractEvent<
+      SetDelegateEvent.InputTuple,
+      SetDelegateEvent.OutputTuple,
+      SetDelegateEvent.OutputObject
+    >;
+    SetDelegate: TypedContractEvent<
+      SetDelegateEvent.InputTuple,
+      SetDelegateEvent.OutputTuple,
+      SetDelegateEvent.OutputObject
+    >;
+
+    "SetEmergencyState(uint24,int128,int128,int128)": TypedContractEvent<
+      SetEmergencyStateEvent.InputTuple,
+      SetEmergencyStateEvent.OutputTuple,
+      SetEmergencyStateEvent.OutputObject
+    >;
+    SetEmergencyState: TypedContractEvent<
+      SetEmergencyStateEvent.InputTuple,
+      SetEmergencyStateEvent.OutputTuple,
+      SetEmergencyStateEvent.OutputObject
+    >;
+
+    "SetNormalState(uint24)": TypedContractEvent<
+      SetNormalStateEvent.InputTuple,
+      SetNormalStateEvent.OutputTuple,
+      SetNormalStateEvent.OutputObject
+    >;
+    SetNormalState: TypedContractEvent<
+      SetNormalStateEvent.InputTuple,
+      SetNormalStateEvent.OutputTuple,
+      SetNormalStateEvent.OutputObject
+    >;
+
+    "SetOracles(uint24,bytes4[2],bytes4[2])": TypedContractEvent<
+      SetOraclesEvent.InputTuple,
+      SetOraclesEvent.OutputTuple,
+      SetOraclesEvent.OutputObject
+    >;
+    SetOracles: TypedContractEvent<
+      SetOraclesEvent.InputTuple,
+      SetOraclesEvent.OutputTuple,
+      SetOraclesEvent.OutputObject
+    >;
+
+    "SetParameter(uint24,string,int128)": TypedContractEvent<
+      SetParameterEvent.InputTuple,
+      SetParameterEvent.OutputTuple,
+      SetParameterEvent.OutputObject
+    >;
+    SetParameter: TypedContractEvent<
+      SetParameterEvent.InputTuple,
+      SetParameterEvent.OutputTuple,
+      SetParameterEvent.OutputObject
+    >;
+
+    "SetParameterPair(uint24,string,int128,int128)": TypedContractEvent<
+      SetParameterPairEvent.InputTuple,
+      SetParameterPairEvent.OutputTuple,
+      SetParameterPairEvent.OutputObject
+    >;
+    SetParameterPair: TypedContractEvent<
+      SetParameterPairEvent.InputTuple,
+      SetParameterPairEvent.OutputTuple,
+      SetParameterPairEvent.OutputObject
+    >;
+
+    "SetPerpetualBaseParameters(uint24,int128[7])": TypedContractEvent<
+      SetPerpetualBaseParametersEvent.InputTuple,
+      SetPerpetualBaseParametersEvent.OutputTuple,
+      SetPerpetualBaseParametersEvent.OutputObject
+    >;
+    SetPerpetualBaseParameters: TypedContractEvent<
+      SetPerpetualBaseParametersEvent.InputTuple,
+      SetPerpetualBaseParametersEvent.OutputTuple,
+      SetPerpetualBaseParametersEvent.OutputObject
+    >;
+
+    "SetPerpetualRiskParameters(uint24,int128[5],int128[12])": TypedContractEvent<
+      SetPerpetualRiskParametersEvent.InputTuple,
+      SetPerpetualRiskParametersEvent.OutputTuple,
+      SetPerpetualRiskParametersEvent.OutputObject
+    >;
+    SetPerpetualRiskParameters: TypedContractEvent<
+      SetPerpetualRiskParametersEvent.InputTuple,
+      SetPerpetualRiskParametersEvent.OutputTuple,
+      SetPerpetualRiskParametersEvent.OutputObject
+    >;
+
+    "SetPoolParameter(uint8,string,int128)": TypedContractEvent<
+      SetPoolParameterEvent.InputTuple,
+      SetPoolParameterEvent.OutputTuple,
+      SetPoolParameterEvent.OutputObject
+    >;
+    SetPoolParameter: TypedContractEvent<
+      SetPoolParameterEvent.InputTuple,
+      SetPoolParameterEvent.OutputTuple,
+      SetPoolParameterEvent.OutputObject
+    >;
+
+    "SetTraderTiers(uint256[],uint16[])": TypedContractEvent<
+      SetTraderTiersEvent.InputTuple,
+      SetTraderTiersEvent.OutputTuple,
+      SetTraderTiersEvent.OutputObject
+    >;
+    SetTraderTiers: TypedContractEvent<
+      SetTraderTiersEvent.InputTuple,
+      SetTraderTiersEvent.OutputTuple,
+      SetTraderTiersEvent.OutputObject
+    >;
+
+    "SetTraderVolumeTiers(uint256[],uint16[])": TypedContractEvent<
+      SetTraderVolumeTiersEvent.InputTuple,
+      SetTraderVolumeTiersEvent.OutputTuple,
+      SetTraderVolumeTiersEvent.OutputObject
+    >;
+    SetTraderVolumeTiers: TypedContractEvent<
+      SetTraderVolumeTiersEvent.InputTuple,
+      SetTraderVolumeTiersEvent.OutputTuple,
+      SetTraderVolumeTiersEvent.OutputObject
+    >;
+
+    "SetUtilityToken(address)": TypedContractEvent<
+      SetUtilityTokenEvent.InputTuple,
+      SetUtilityTokenEvent.OutputTuple,
+      SetUtilityTokenEvent.OutputObject
+    >;
+    SetUtilityToken: TypedContractEvent<
+      SetUtilityTokenEvent.InputTuple,
+      SetUtilityTokenEvent.OutputTuple,
+      SetUtilityTokenEvent.OutputObject
+    >;
+
+    "Settle(uint24,address,int256)": TypedContractEvent<
+      SettleEvent.InputTuple,
+      SettleEvent.OutputTuple,
+      SettleEvent.OutputObject
+    >;
+    Settle: TypedContractEvent<
+      SettleEvent.InputTuple,
+      SettleEvent.OutputTuple,
+      SettleEvent.OutputObject
+    >;
+
+    "SettleState(uint24)": TypedContractEvent<
+      SettleStateEvent.InputTuple,
+      SettleStateEvent.OutputTuple,
+      SettleStateEvent.OutputObject
+    >;
+    SettleState: TypedContractEvent<
+      SettleStateEvent.InputTuple,
+      SettleStateEvent.OutputTuple,
+      SettleStateEvent.OutputObject
+    >;
+
+    "SettlementComplete(uint24)": TypedContractEvent<
+      SettlementCompleteEvent.InputTuple,
+      SettlementCompleteEvent.OutputTuple,
+      SettlementCompleteEvent.OutputObject
+    >;
+    SettlementComplete: TypedContractEvent<
+      SettlementCompleteEvent.InputTuple,
+      SettlementCompleteEvent.OutputTuple,
+      SettlementCompleteEvent.OutputObject
+    >;
+
+    "TokensDeposited(uint24,address,int128)": TypedContractEvent<
+      TokensDepositedEvent.InputTuple,
+      TokensDepositedEvent.OutputTuple,
+      TokensDepositedEvent.OutputObject
+    >;
+    TokensDeposited: TypedContractEvent<
+      TokensDepositedEvent.InputTuple,
+      TokensDepositedEvent.OutputTuple,
+      TokensDepositedEvent.OutputObject
+    >;
+
+    "TokensWithdrawn(uint24,address,int128)": TypedContractEvent<
+      TokensWithdrawnEvent.InputTuple,
+      TokensWithdrawnEvent.OutputTuple,
+      TokensWithdrawnEvent.OutputObject
+    >;
+    TokensWithdrawn: TypedContractEvent<
+      TokensWithdrawnEvent.InputTuple,
+      TokensWithdrawnEvent.OutputTuple,
+      TokensWithdrawnEvent.OutputObject
+    >;
+
+    "Trade(uint24,address,tuple,bytes32,int128,int128,int128,int128,int128)": TypedContractEvent<
+      TradeEvent.InputTuple,
+      TradeEvent.OutputTuple,
+      TradeEvent.OutputObject
+    >;
+    Trade: TypedContractEvent<
+      TradeEvent.InputTuple,
+      TradeEvent.OutputTuple,
+      TradeEvent.OutputObject
+    >;
+
+    "TransferAddressTo(string,address,address)": TypedContractEvent<
+      TransferAddressToEvent.InputTuple,
+      TransferAddressToEvent.OutputTuple,
+      TransferAddressToEvent.OutputObject
+    >;
+    TransferAddressTo: TypedContractEvent<
+      TransferAddressToEvent.InputTuple,
+      TransferAddressToEvent.OutputTuple,
+      TransferAddressToEvent.OutputObject
+    >;
+
+    "Unpaused(address)": TypedContractEvent<
+      UnpausedEvent.InputTuple,
+      UnpausedEvent.OutputTuple,
+      UnpausedEvent.OutputObject
+    >;
+    Unpaused: TypedContractEvent<
+      UnpausedEvent.InputTuple,
+      UnpausedEvent.OutputTuple,
+      UnpausedEvent.OutputObject
+    >;
+
+    "UpdateBrokerAddedCash(uint8,uint32,uint32)": TypedContractEvent<
+      UpdateBrokerAddedCashEvent.InputTuple,
+      UpdateBrokerAddedCashEvent.OutputTuple,
+      UpdateBrokerAddedCashEvent.OutputObject
+    >;
+    UpdateBrokerAddedCash: TypedContractEvent<
+      UpdateBrokerAddedCashEvent.InputTuple,
+      UpdateBrokerAddedCashEvent.OutputTuple,
+      UpdateBrokerAddedCashEvent.OutputObject
+    >;
+
+    "UpdateFundingRate(uint24,int128)": TypedContractEvent<
+      UpdateFundingRateEvent.InputTuple,
+      UpdateFundingRateEvent.OutputTuple,
+      UpdateFundingRateEvent.OutputObject
+    >;
+    UpdateFundingRate: TypedContractEvent<
+      UpdateFundingRateEvent.InputTuple,
+      UpdateFundingRateEvent.OutputTuple,
+      UpdateFundingRateEvent.OutputObject
+    >;
+
+    "UpdateMarginAccount(uint24,address,int128)": TypedContractEvent<
+      UpdateMarginAccountEvent.InputTuple,
+      UpdateMarginAccountEvent.OutputTuple,
+      UpdateMarginAccountEvent.OutputObject
+    >;
+    UpdateMarginAccount: TypedContractEvent<
+      UpdateMarginAccountEvent.InputTuple,
+      UpdateMarginAccountEvent.OutputTuple,
+      UpdateMarginAccountEvent.OutputObject
+    >;
+
+    "UpdateMarkPrice(uint24,int128,int128,int128)": TypedContractEvent<
+      UpdateMarkPriceEvent.InputTuple,
+      UpdateMarkPriceEvent.OutputTuple,
+      UpdateMarkPriceEvent.OutputObject
+    >;
+    UpdateMarkPrice: TypedContractEvent<
+      UpdateMarkPriceEvent.InputTuple,
+      UpdateMarkPriceEvent.OutputTuple,
+      UpdateMarkPriceEvent.OutputObject
+    >;
   };
 }