@opensea/seaport-js 2.0.8 → 3.0.1

package/src/typechain-types/seaport_v1_5/contracts/Seaport.ts

@@ -3,116 +3,112 @@
 /* eslint-disable */
 import type {
   BaseContract,
-  BigNumber,
   BigNumberish,
   BytesLike,
-  CallOverrides,
-  ContractTransaction,
-  Overrides,
-  PayableOverrides,
-  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 type SpentItemStruct = {
   itemType: BigNumberish;
-  token: string;
+  token: AddressLike;
   identifier: BigNumberish;
   amount: BigNumberish;
 };
 
-export type SpentItemStructOutput = [number, string, BigNumber, BigNumber] & {
-  itemType: number;
-  token: string;
-  identifier: BigNumber;
-  amount: BigNumber;
-};
+export type SpentItemStructOutput = [
+  itemType: bigint,
+  token: string,
+  identifier: bigint,
+  amount: bigint
+] & { itemType: bigint; token: string; identifier: bigint; amount: bigint };
 
 export type ReceivedItemStruct = {
   itemType: BigNumberish;
-  token: string;
+  token: AddressLike;
   identifier: BigNumberish;
   amount: BigNumberish;
-  recipient: string;
+  recipient: AddressLike;
 };
 
 export type ReceivedItemStructOutput = [
-  number,
-  string,
-  BigNumber,
-  BigNumber,
-  string
+  itemType: bigint,
+  token: string,
+  identifier: bigint,
+  amount: bigint,
+  recipient: string
 ] & {
-  itemType: number;
+  itemType: bigint;
   token: string;
-  identifier: BigNumber;
-  amount: BigNumber;
+  identifier: bigint;
+  amount: bigint;
   recipient: string;
 };
 
 export type OfferItemStruct = {
   itemType: BigNumberish;
-  token: string;
+  token: AddressLike;
   identifierOrCriteria: BigNumberish;
   startAmount: BigNumberish;
   endAmount: BigNumberish;
 };
 
 export type OfferItemStructOutput = [
-  number,
-  string,
-  BigNumber,
-  BigNumber,
-  BigNumber
+  itemType: bigint,
+  token: string,
+  identifierOrCriteria: bigint,
+  startAmount: bigint,
+  endAmount: bigint
 ] & {
-  itemType: number;
+  itemType: bigint;
   token: string;
-  identifierOrCriteria: BigNumber;
-  startAmount: BigNumber;
-  endAmount: BigNumber;
+  identifierOrCriteria: bigint;
+  startAmount: bigint;
+  endAmount: bigint;
 };
 
 export type ConsiderationItemStruct = {
   itemType: BigNumberish;
-  token: string;
+  token: AddressLike;
   identifierOrCriteria: BigNumberish;
   startAmount: BigNumberish;
   endAmount: BigNumberish;
-  recipient: string;
+  recipient: AddressLike;
 };
 
 export type ConsiderationItemStructOutput = [
-  number,
-  string,
-  BigNumber,
-  BigNumber,
-  BigNumber,
-  string
+  itemType: bigint,
+  token: string,
+  identifierOrCriteria: bigint,
+  startAmount: bigint,
+  endAmount: bigint,
+  recipient: string
 ] & {
-  itemType: number;
+  itemType: bigint;
   token: string;
-  identifierOrCriteria: BigNumber;
-  startAmount: BigNumber;
-  endAmount: BigNumber;
+  identifierOrCriteria: bigint;
+  startAmount: bigint;
+  endAmount: bigint;
   recipient: string;
 };
 
 export type OrderParametersStruct = {
-  offerer: string;
-  zone: string;
+  offerer: AddressLike;
+  zone: AddressLike;
   offer: OfferItemStruct[];
   consideration: ConsiderationItemStruct[];
   orderType: BigNumberish;
@@ -125,34 +121,34 @@ export type OrderParametersStruct = {
 };
 
 export type OrderParametersStructOutput = [
-  string,
-  string,
-  OfferItemStructOutput[],
-  ConsiderationItemStructOutput[],
-  number,
-  BigNumber,
-  BigNumber,
-  string,
-  BigNumber,
-  string,
-  BigNumber
+  offerer: string,
+  zone: string,
+  offer: OfferItemStructOutput[],
+  consideration: ConsiderationItemStructOutput[],
+  orderType: bigint,
+  startTime: bigint,
+  endTime: bigint,
+  zoneHash: string,
+  salt: bigint,
+  conduitKey: string,
+  totalOriginalConsiderationItems: bigint
 ] & {
   offerer: string;
   zone: string;
   offer: OfferItemStructOutput[];
   consideration: ConsiderationItemStructOutput[];
-  orderType: number;
-  startTime: BigNumber;
-  endTime: BigNumber;
+  orderType: bigint;
+  startTime: bigint;
+  endTime: bigint;
   zoneHash: string;
-  salt: BigNumber;
+  salt: bigint;
   conduitKey: string;
-  totalOriginalConsiderationItems: BigNumber;
+  totalOriginalConsiderationItems: bigint;
 };
 
 export type OrderComponentsStruct = {
-  offerer: string;
-  zone: string;
+  offerer: AddressLike;
+  zone: AddressLike;
   offer: OfferItemStruct[];
   consideration: ConsiderationItemStruct[];
   orderType: BigNumberish;
@@ -165,29 +161,29 @@ export type OrderComponentsStruct = {
 };
 
 export type OrderComponentsStructOutput = [
-  string,
-  string,
-  OfferItemStructOutput[],
-  ConsiderationItemStructOutput[],
-  number,
-  BigNumber,
-  BigNumber,
-  string,
-  BigNumber,
-  string,
-  BigNumber
+  offerer: string,
+  zone: string,
+  offer: OfferItemStructOutput[],
+  consideration: ConsiderationItemStructOutput[],
+  orderType: bigint,
+  startTime: bigint,
+  endTime: bigint,
+  zoneHash: string,
+  salt: bigint,
+  conduitKey: string,
+  counter: bigint
 ] & {
   offerer: string;
   zone: string;
   offer: OfferItemStructOutput[];
   consideration: ConsiderationItemStructOutput[];
-  orderType: number;
-  startTime: BigNumber;
-  endTime: BigNumber;
+  orderType: bigint;
+  startTime: bigint;
+  endTime: bigint;
   zoneHash: string;
-  salt: BigNumber;
+  salt: bigint;
   conduitKey: string;
-  counter: BigNumber;
+  counter: bigint;
 };
 
 export type AdvancedOrderStruct = {
@@ -199,15 +195,15 @@ export type AdvancedOrderStruct = {
 };
 
 export type AdvancedOrderStructOutput = [
-  OrderParametersStructOutput,
-  BigNumber,
-  BigNumber,
-  string,
-  string
+  parameters: OrderParametersStructOutput,
+  numerator: bigint,
+  denominator: bigint,
+  signature: string,
+  extraData: string
 ] & {
   parameters: OrderParametersStructOutput;
-  numerator: BigNumber;
-  denominator: BigNumber;
+  numerator: bigint;
+  denominator: bigint;
   signature: string;
   extraData: string;
 };
@@ -221,16 +217,16 @@ export type CriteriaResolverStruct = {
 };
 
 export type CriteriaResolverStructOutput = [
-  BigNumber,
-  number,
-  BigNumber,
-  BigNumber,
-  string[]
+  orderIndex: bigint,
+  side: bigint,
+  index: bigint,
+  identifier: bigint,
+  criteriaProof: string[]
 ] & {
-  orderIndex: BigNumber;
-  side: number;
-  index: BigNumber;
-  identifier: BigNumber;
+  orderIndex: bigint;
+  side: bigint;
+  index: bigint;
+  identifier: bigint;
   criteriaProof: string[];
 };
 
@@ -239,21 +235,21 @@ export type FulfillmentComponentStruct = {
   itemIndex: BigNumberish;
 };
 
-export type FulfillmentComponentStructOutput = [BigNumber, BigNumber] & {
-  orderIndex: BigNumber;
-  itemIndex: BigNumber;
-};
+export type FulfillmentComponentStructOutput = [
+  orderIndex: bigint,
+  itemIndex: bigint
+] & { orderIndex: bigint; itemIndex: bigint };
 
 export type ExecutionStruct = {
   item: ReceivedItemStruct;
-  offerer: string;
+  offerer: AddressLike;
   conduitKey: BytesLike;
 };
 
 export type ExecutionStructOutput = [
-  ReceivedItemStructOutput,
-  string,
-  string
+  item: ReceivedItemStructOutput,
+  offerer: string,
+  conduitKey: string
 ] & { item: ReceivedItemStructOutput; offerer: string; conduitKey: string };
 
 export type OrderStruct = {
@@ -261,28 +257,28 @@ export type OrderStruct = {
   signature: BytesLike;
 };
 
-export type OrderStructOutput = [OrderParametersStructOutput, string] & {
-  parameters: OrderParametersStructOutput;
-  signature: string;
-};
+export type OrderStructOutput = [
+  parameters: OrderParametersStructOutput,
+  signature: string
+] & { parameters: OrderParametersStructOutput; signature: string };
 
 export type AdditionalRecipientStruct = {
   amount: BigNumberish;
-  recipient: string;
+  recipient: AddressLike;
 };
 
-export type AdditionalRecipientStructOutput = [BigNumber, string] & {
-  amount: BigNumber;
-  recipient: string;
-};
+export type AdditionalRecipientStructOutput = [
+  amount: bigint,
+  recipient: string
+] & { amount: bigint; recipient: string };
 
 export type BasicOrderParametersStruct = {
-  considerationToken: string;
+  considerationToken: AddressLike;
   considerationIdentifier: BigNumberish;
   considerationAmount: BigNumberish;
-  offerer: string;
-  zone: string;
-  offerToken: string;
+  offerer: AddressLike;
+  zone: AddressLike;
+  offerToken: AddressLike;
   offerIdentifier: BigNumberish;
   offerAmount: BigNumberish;
   basicOrderType: BigNumberish;
@@ -298,41 +294,41 @@ export type BasicOrderParametersStruct = {
 };
 
 export type BasicOrderParametersStructOutput = [
-  string,
-  BigNumber,
-  BigNumber,
-  string,
-  string,
-  string,
-  BigNumber,
-  BigNumber,
-  number,
-  BigNumber,
-  BigNumber,
-  string,
-  BigNumber,
-  string,
-  string,
-  BigNumber,
-  AdditionalRecipientStructOutput[],
-  string
+  considerationToken: string,
+  considerationIdentifier: bigint,
+  considerationAmount: bigint,
+  offerer: string,
+  zone: string,
+  offerToken: string,
+  offerIdentifier: bigint,
+  offerAmount: bigint,
+  basicOrderType: bigint,
+  startTime: bigint,
+  endTime: bigint,
+  zoneHash: string,
+  salt: bigint,
+  offererConduitKey: string,
+  fulfillerConduitKey: string,
+  totalOriginalAdditionalRecipients: bigint,
+  additionalRecipients: AdditionalRecipientStructOutput[],
+  signature: string
 ] & {
   considerationToken: string;
-  considerationIdentifier: BigNumber;
-  considerationAmount: BigNumber;
+  considerationIdentifier: bigint;
+  considerationAmount: bigint;
   offerer: string;
   zone: string;
   offerToken: string;
-  offerIdentifier: BigNumber;
-  offerAmount: BigNumber;
-  basicOrderType: number;
-  startTime: BigNumber;
-  endTime: BigNumber;
+  offerIdentifier: bigint;
+  offerAmount: bigint;
+  basicOrderType: bigint;
+  startTime: bigint;
+  endTime: bigint;
   zoneHash: string;
-  salt: BigNumber;
+  salt: bigint;
   offererConduitKey: string;
   fulfillerConduitKey: string;
-  totalOriginalAdditionalRecipients: BigNumber;
+  totalOriginalAdditionalRecipients: bigint;
   additionalRecipients: AdditionalRecipientStructOutput[];
   signature: string;
 };
@@ -343,36 +339,16 @@ export type FulfillmentStruct = {
 };
 
 export type FulfillmentStructOutput = [
-  FulfillmentComponentStructOutput[],
-  FulfillmentComponentStructOutput[]
+  offerComponents: FulfillmentComponentStructOutput[],
+  considerationComponents: FulfillmentComponentStructOutput[]
 ] & {
   offerComponents: FulfillmentComponentStructOutput[];
   considerationComponents: FulfillmentComponentStructOutput[];
 };
 
-export interface SeaportInterface extends utils.Interface {
-  functions: {
-    "cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])": FunctionFragment;
-    "fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32,address)": FunctionFragment;
-    "fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)": FunctionFragment;
-    "fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,uint256)": FunctionFragment;
-    "fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": FunctionFragment;
-    "fulfillBasicOrder_efficient_6GL6yc((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": FunctionFragment;
-    "fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)": FunctionFragment;
-    "getContractOffererNonce(address)": FunctionFragment;
-    "getCounter(address)": FunctionFragment;
-    "getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": FunctionFragment;
-    "getOrderStatus(bytes32)": FunctionFragment;
-    "incrementCounter()": FunctionFragment;
-    "information()": FunctionFragment;
-    "matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[],address)": FunctionFragment;
-    "matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])": FunctionFragment;
-    "name()": FunctionFragment;
-    "validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])": FunctionFragment;
-  };
-
+export interface SeaportInterface extends Interface {
   getFunction(
-    nameOrSignatureOrTopic:
+    nameOrSignature:
       | "cancel"
       | "fulfillAdvancedOrder"
       | "fulfillAvailableAdvancedOrders"
@@ -392,13 +368,27 @@ export interface SeaportInterface extends utils.Interface {
       | "validate"
   ): FunctionFragment;
 
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "CounterIncremented"
+      | "OrderCancelled"
+      | "OrderFulfilled"
+      | "OrderValidated"
+      | "OrdersMatched"
+  ): EventFragment;
+
   encodeFunctionData(
     functionFragment: "cancel",
     values: [OrderComponentsStruct[]]
   ): string;
   encodeFunctionData(
     functionFragment: "fulfillAdvancedOrder",
-    values: [AdvancedOrderStruct, CriteriaResolverStruct[], BytesLike, string]
+    values: [
+      AdvancedOrderStruct,
+      CriteriaResolverStruct[],
+      BytesLike,
+      AddressLike
+    ]
   ): string;
   encodeFunctionData(
     functionFragment: "fulfillAvailableAdvancedOrders",
@@ -408,7 +398,7 @@ export interface SeaportInterface extends utils.Interface {
       FulfillmentComponentStruct[][],
       FulfillmentComponentStruct[][],
       BytesLike,
-      string,
+      AddressLike,
       BigNumberish
     ]
   ): string;
@@ -436,9 +426,12 @@ export interface SeaportInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "getContractOffererNonce",
-    values: [string]
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getCounter",
+    values: [AddressLike]
   ): string;
-  encodeFunctionData(functionFragment: "getCounter", values: [string]): string;
   encodeFunctionData(
     functionFragment: "getOrderHash",
     values: [OrderComponentsStruct]
@@ -461,7 +454,7 @@ export interface SeaportInterface extends utils.Interface {
       AdvancedOrderStruct[],
       CriteriaResolverStruct[],
       FulfillmentStruct[],
-      string
+      AddressLike
     ]
   ): string;
   encodeFunctionData(
@@ -530,682 +523,494 @@ export interface SeaportInterface extends utils.Interface {
   ): Result;
   decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "validate", data: BytesLike): Result;
-
-  events: {
-    "CounterIncremented(uint256,address)": EventFragment;
-    "OrderCancelled(bytes32,address,address)": EventFragment;
-    "OrderFulfilled(bytes32,address,address,address,(uint8,address,uint256,uint256)[],(uint8,address,uint256,uint256,address)[])": EventFragment;
-    "OrderValidated(bytes32,(address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": EventFragment;
-    "OrdersMatched(bytes32[])": EventFragment;
-  };
-
-  getEvent(nameOrSignatureOrTopic: "CounterIncremented"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OrderCancelled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OrderFulfilled"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OrderValidated"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "OrdersMatched"): EventFragment;
 }
 
-export interface CounterIncrementedEventObject {
-  newCounter: BigNumber;
-  offerer: string;
+export namespace CounterIncrementedEvent {
+  export type InputTuple = [newCounter: BigNumberish, offerer: AddressLike];
+  export type OutputTuple = [newCounter: bigint, offerer: string];
+  export interface OutputObject {
+    newCounter: bigint;
+    offerer: 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 CounterIncrementedEvent = TypedEvent<
-  [BigNumber, string],
-  CounterIncrementedEventObject
->;
 
-export type CounterIncrementedEventFilter =
-  TypedEventFilter<CounterIncrementedEvent>;
-
-export interface OrderCancelledEventObject {
-  orderHash: string;
-  offerer: string;
-  zone: string;
+export namespace OrderCancelledEvent {
+  export type InputTuple = [
+    orderHash: BytesLike,
+    offerer: AddressLike,
+    zone: AddressLike
+  ];
+  export type OutputTuple = [orderHash: string, offerer: string, zone: string];
+  export interface OutputObject {
+    orderHash: string;
+    offerer: string;
+    zone: 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 OrderCancelledEvent = TypedEvent<
-  [string, string, string],
-  OrderCancelledEventObject
->;
-
-export type OrderCancelledEventFilter = TypedEventFilter<OrderCancelledEvent>;
 
-export interface OrderFulfilledEventObject {
-  orderHash: string;
-  offerer: string;
-  zone: string;
-  recipient: string;
-  offer: SpentItemStructOutput[];
-  consideration: ReceivedItemStructOutput[];
-}
-export type OrderFulfilledEvent = TypedEvent<
-  [
-    string,
-    string,
-    string,
-    string,
-    SpentItemStructOutput[],
-    ReceivedItemStructOutput[]
-  ],
-  OrderFulfilledEventObject
->;
-
-export type OrderFulfilledEventFilter = TypedEventFilter<OrderFulfilledEvent>;
-
-export interface OrderValidatedEventObject {
-  orderHash: string;
-  orderParameters: OrderParametersStructOutput;
+export namespace OrderFulfilledEvent {
+  export type InputTuple = [
+    orderHash: BytesLike,
+    offerer: AddressLike,
+    zone: AddressLike,
+    recipient: AddressLike,
+    offer: SpentItemStruct[],
+    consideration: ReceivedItemStruct[]
+  ];
+  export type OutputTuple = [
+    orderHash: string,
+    offerer: string,
+    zone: string,
+    recipient: string,
+    offer: SpentItemStructOutput[],
+    consideration: ReceivedItemStructOutput[]
+  ];
+  export interface OutputObject {
+    orderHash: string;
+    offerer: string;
+    zone: string;
+    recipient: string;
+    offer: SpentItemStructOutput[];
+    consideration: ReceivedItemStructOutput[];
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type OrderValidatedEvent = TypedEvent<
-  [string, OrderParametersStructOutput],
-  OrderValidatedEventObject
->;
 
-export type OrderValidatedEventFilter = TypedEventFilter<OrderValidatedEvent>;
-
-export interface OrdersMatchedEventObject {
-  orderHashes: string[];
+export namespace OrderValidatedEvent {
+  export type InputTuple = [
+    orderHash: BytesLike,
+    orderParameters: OrderParametersStruct
+  ];
+  export type OutputTuple = [
+    orderHash: string,
+    orderParameters: OrderParametersStructOutput
+  ];
+  export interface OutputObject {
+    orderHash: string;
+    orderParameters: OrderParametersStructOutput;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
 }
-export type OrdersMatchedEvent = TypedEvent<
-  [string[]],
-  OrdersMatchedEventObject
->;
 
-export type OrdersMatchedEventFilter = TypedEventFilter<OrdersMatchedEvent>;
+export namespace OrdersMatchedEvent {
+  export type InputTuple = [orderHashes: BytesLike[]];
+  export type OutputTuple = [orderHashes: string[]];
+  export interface OutputObject {
+    orderHashes: 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 Seaport extends BaseContract {
-  connect(signerOrProvider: Signer | Provider | string): this;
-  attach(addressOrName: string): this;
-  deployed(): Promise<this>;
+  connect(runner?: ContractRunner | null): Seaport;
+  waitForDeployment(): Promise<this>;
 
   interface: SeaportInterface;
 
-  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: {
-    cancel(
-      orders: OrderComponentsStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    fulfillAdvancedOrder(
+  ): 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>;
+
+  cancel: TypedContractMethod<
+    [orders: OrderComponentsStruct[]],
+    [boolean],
+    "nonpayable"
+  >;
+
+  fulfillAdvancedOrder: TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct,
       arg1: CriteriaResolverStruct[],
       fulfillerConduitKey: BytesLike,
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
+      recipient: AddressLike
+    ],
+    [boolean],
+    "payable"
+  >;
 
-    fulfillAvailableAdvancedOrders(
+  fulfillAvailableAdvancedOrders: TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct[],
       arg1: CriteriaResolverStruct[],
       arg2: FulfillmentComponentStruct[][],
       arg3: FulfillmentComponentStruct[][],
       fulfillerConduitKey: BytesLike,
-      recipient: string,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
+      recipient: AddressLike,
+      maximumFulfilled: BigNumberish
+    ],
+    [[boolean[], ExecutionStructOutput[]]],
+    "payable"
+  >;
 
-    fulfillAvailableOrders(
+  fulfillAvailableOrders: TypedContractMethod<
+    [
       arg0: OrderStruct[],
       arg1: FulfillmentComponentStruct[][],
       arg2: FulfillmentComponentStruct[][],
       fulfillerConduitKey: BytesLike,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    fulfillBasicOrder(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    fulfillBasicOrder_efficient_6GL6yc(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    fulfillOrder(
-      arg0: OrderStruct,
-      fulfillerConduitKey: BytesLike,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    getContractOffererNonce(
-      contractOfferer: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber] & { nonce: BigNumber }>;
-
-    getCounter(
-      offerer: string,
-      overrides?: CallOverrides
-    ): Promise<[BigNumber] & { counter: BigNumber }>;
-
-    getOrderHash(
-      arg0: OrderComponentsStruct,
-      overrides?: CallOverrides
-    ): Promise<[string] & { orderHash: string }>;
-
-    getOrderStatus(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
-      [boolean, boolean, BigNumber, BigNumber] & {
+      maximumFulfilled: BigNumberish
+    ],
+    [[boolean[], ExecutionStructOutput[]]],
+    "payable"
+  >;
+
+  fulfillBasicOrder: TypedContractMethod<
+    [parameters: BasicOrderParametersStruct],
+    [boolean],
+    "payable"
+  >;
+
+  fulfillBasicOrder_efficient_6GL6yc: TypedContractMethod<
+    [parameters: BasicOrderParametersStruct],
+    [boolean],
+    "payable"
+  >;
+
+  fulfillOrder: TypedContractMethod<
+    [arg0: OrderStruct, fulfillerConduitKey: BytesLike],
+    [boolean],
+    "payable"
+  >;
+
+  getContractOffererNonce: TypedContractMethod<
+    [contractOfferer: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  getCounter: TypedContractMethod<[offerer: AddressLike], [bigint], "view">;
+
+  getOrderHash: TypedContractMethod<
+    [arg0: OrderComponentsStruct],
+    [string],
+    "view"
+  >;
+
+  getOrderStatus: TypedContractMethod<
+    [orderHash: BytesLike],
+    [
+      [boolean, boolean, bigint, bigint] & {
         isValidated: boolean;
         isCancelled: boolean;
-        totalFilled: BigNumber;
-        totalSize: BigNumber;
+        totalFilled: bigint;
+        totalSize: bigint;
       }
-    >;
+    ],
+    "view"
+  >;
 
-    incrementCounter(
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
+  incrementCounter: TypedContractMethod<[], [bigint], "nonpayable">;
 
-    information(
-      overrides?: CallOverrides
-    ): Promise<
+  information: TypedContractMethod<
+    [],
+    [
       [string, string, string] & {
         version: string;
         domainSeparator: string;
         conduitController: string;
       }
-    >;
+    ],
+    "view"
+  >;
 
-    matchAdvancedOrders(
+  matchAdvancedOrders: TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct[],
       arg1: CriteriaResolverStruct[],
       arg2: FulfillmentStruct[],
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    matchOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentStruct[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<ContractTransaction>;
-
-    name(overrides?: CallOverrides): Promise<[string]>;
-
-    validate(
-      arg0: OrderStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<ContractTransaction>;
-  };
-
-  cancel(
-    orders: OrderComponentsStruct[],
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillAdvancedOrder(
-    arg0: AdvancedOrderStruct,
-    arg1: CriteriaResolverStruct[],
-    fulfillerConduitKey: BytesLike,
-    recipient: string,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillAvailableAdvancedOrders(
-    arg0: AdvancedOrderStruct[],
-    arg1: CriteriaResolverStruct[],
-    arg2: FulfillmentComponentStruct[][],
-    arg3: FulfillmentComponentStruct[][],
-    fulfillerConduitKey: BytesLike,
-    recipient: string,
-    maximumFulfilled: BigNumberish,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillAvailableOrders(
-    arg0: OrderStruct[],
-    arg1: FulfillmentComponentStruct[][],
-    arg2: FulfillmentComponentStruct[][],
-    fulfillerConduitKey: BytesLike,
-    maximumFulfilled: BigNumberish,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillBasicOrder(
-    parameters: BasicOrderParametersStruct,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillBasicOrder_efficient_6GL6yc(
-    parameters: BasicOrderParametersStruct,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  fulfillOrder(
-    arg0: OrderStruct,
-    fulfillerConduitKey: BytesLike,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  getContractOffererNonce(
-    contractOfferer: string,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
-  getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-
-  getOrderHash(
-    arg0: OrderComponentsStruct,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
-  getOrderStatus(
-    orderHash: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<
-    [boolean, boolean, BigNumber, BigNumber] & {
-      isValidated: boolean;
-      isCancelled: boolean;
-      totalFilled: BigNumber;
-      totalSize: BigNumber;
-    }
+      recipient: AddressLike
+    ],
+    [ExecutionStructOutput[]],
+    "payable"
   >;
 
-  incrementCounter(
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  information(
-    overrides?: CallOverrides
-  ): Promise<
-    [string, string, string] & {
-      version: string;
-      domainSeparator: string;
-      conduitController: string;
-    }
+  matchOrders: TypedContractMethod<
+    [arg0: OrderStruct[], arg1: FulfillmentStruct[]],
+    [ExecutionStructOutput[]],
+    "payable"
   >;
 
-  matchAdvancedOrders(
-    arg0: AdvancedOrderStruct[],
-    arg1: CriteriaResolverStruct[],
-    arg2: FulfillmentStruct[],
-    recipient: string,
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
-
-  matchOrders(
-    arg0: OrderStruct[],
-    arg1: FulfillmentStruct[],
-    overrides?: PayableOverrides & { from?: string }
-  ): Promise<ContractTransaction>;
+  name: TypedContractMethod<[], [string], "view">;
 
-  name(overrides?: CallOverrides): Promise<string>;
+  validate: TypedContractMethod<[arg0: OrderStruct[]], [boolean], "nonpayable">;
 
-  validate(
-    arg0: OrderStruct[],
-    overrides?: Overrides & { from?: string }
-  ): Promise<ContractTransaction>;
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
 
-  callStatic: {
-    cancel(
-      orders: OrderComponentsStruct[],
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    fulfillAdvancedOrder(
+  getFunction(
+    nameOrSignature: "cancel"
+  ): TypedContractMethod<
+    [orders: OrderComponentsStruct[]],
+    [boolean],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillAdvancedOrder"
+  ): TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct,
       arg1: CriteriaResolverStruct[],
       fulfillerConduitKey: BytesLike,
-      recipient: string,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    fulfillAvailableAdvancedOrders(
+      recipient: AddressLike
+    ],
+    [boolean],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillAvailableAdvancedOrders"
+  ): TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct[],
       arg1: CriteriaResolverStruct[],
       arg2: FulfillmentComponentStruct[][],
       arg3: FulfillmentComponentStruct[][],
       fulfillerConduitKey: BytesLike,
-      recipient: string,
-      maximumFulfilled: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[boolean[], ExecutionStructOutput[]]>;
-
-    fulfillAvailableOrders(
+      recipient: AddressLike,
+      maximumFulfilled: BigNumberish
+    ],
+    [[boolean[], ExecutionStructOutput[]]],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillAvailableOrders"
+  ): TypedContractMethod<
+    [
       arg0: OrderStruct[],
       arg1: FulfillmentComponentStruct[][],
       arg2: FulfillmentComponentStruct[][],
       fulfillerConduitKey: BytesLike,
-      maximumFulfilled: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<[boolean[], ExecutionStructOutput[]]>;
-
-    fulfillBasicOrder(
-      parameters: BasicOrderParametersStruct,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    fulfillBasicOrder_efficient_6GL6yc(
-      parameters: BasicOrderParametersStruct,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    fulfillOrder(
-      arg0: OrderStruct,
-      fulfillerConduitKey: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
-    getContractOffererNonce(
-      contractOfferer: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-
-    getOrderHash(
-      arg0: OrderComponentsStruct,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
-    getOrderStatus(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<
-      [boolean, boolean, BigNumber, BigNumber] & {
+      maximumFulfilled: BigNumberish
+    ],
+    [[boolean[], ExecutionStructOutput[]]],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillBasicOrder"
+  ): TypedContractMethod<
+    [parameters: BasicOrderParametersStruct],
+    [boolean],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillBasicOrder_efficient_6GL6yc"
+  ): TypedContractMethod<
+    [parameters: BasicOrderParametersStruct],
+    [boolean],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "fulfillOrder"
+  ): TypedContractMethod<
+    [arg0: OrderStruct, fulfillerConduitKey: BytesLike],
+    [boolean],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "getContractOffererNonce"
+  ): TypedContractMethod<[contractOfferer: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getCounter"
+  ): TypedContractMethod<[offerer: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getOrderHash"
+  ): TypedContractMethod<[arg0: OrderComponentsStruct], [string], "view">;
+  getFunction(
+    nameOrSignature: "getOrderStatus"
+  ): TypedContractMethod<
+    [orderHash: BytesLike],
+    [
+      [boolean, boolean, bigint, bigint] & {
         isValidated: boolean;
         isCancelled: boolean;
-        totalFilled: BigNumber;
-        totalSize: BigNumber;
+        totalFilled: bigint;
+        totalSize: bigint;
       }
-    >;
-
-    incrementCounter(overrides?: CallOverrides): Promise<BigNumber>;
-
-    information(
-      overrides?: CallOverrides
-    ): Promise<
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "incrementCounter"
+  ): TypedContractMethod<[], [bigint], "nonpayable">;
+  getFunction(
+    nameOrSignature: "information"
+  ): TypedContractMethod<
+    [],
+    [
       [string, string, string] & {
         version: string;
         domainSeparator: string;
         conduitController: string;
       }
-    >;
-
-    matchAdvancedOrders(
+    ],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "matchAdvancedOrders"
+  ): TypedContractMethod<
+    [
       arg0: AdvancedOrderStruct[],
       arg1: CriteriaResolverStruct[],
       arg2: FulfillmentStruct[],
-      recipient: string,
-      overrides?: CallOverrides
-    ): Promise<ExecutionStructOutput[]>;
-
-    matchOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentStruct[],
-      overrides?: CallOverrides
-    ): Promise<ExecutionStructOutput[]>;
-
-    name(overrides?: CallOverrides): Promise<string>;
-
-    validate(arg0: OrderStruct[], overrides?: CallOverrides): Promise<boolean>;
-  };
+      recipient: AddressLike
+    ],
+    [ExecutionStructOutput[]],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "matchOrders"
+  ): TypedContractMethod<
+    [arg0: OrderStruct[], arg1: FulfillmentStruct[]],
+    [ExecutionStructOutput[]],
+    "payable"
+  >;
+  getFunction(
+    nameOrSignature: "name"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "validate"
+  ): TypedContractMethod<[arg0: OrderStruct[]], [boolean], "nonpayable">;
+
+  getEvent(
+    key: "CounterIncremented"
+  ): TypedContractEvent<
+    CounterIncrementedEvent.InputTuple,
+    CounterIncrementedEvent.OutputTuple,
+    CounterIncrementedEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrderCancelled"
+  ): TypedContractEvent<
+    OrderCancelledEvent.InputTuple,
+    OrderCancelledEvent.OutputTuple,
+    OrderCancelledEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrderFulfilled"
+  ): TypedContractEvent<
+    OrderFulfilledEvent.InputTuple,
+    OrderFulfilledEvent.OutputTuple,
+    OrderFulfilledEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrderValidated"
+  ): TypedContractEvent<
+    OrderValidatedEvent.InputTuple,
+    OrderValidatedEvent.OutputTuple,
+    OrderValidatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrdersMatched"
+  ): TypedContractEvent<
+    OrdersMatchedEvent.InputTuple,
+    OrdersMatchedEvent.OutputTuple,
+    OrdersMatchedEvent.OutputObject
+  >;
 
   filters: {
-    "CounterIncremented(uint256,address)"(
-      newCounter?: null,
-      offerer?: string | null
-    ): CounterIncrementedEventFilter;
-    CounterIncremented(
-      newCounter?: null,
-      offerer?: string | null
-    ): CounterIncrementedEventFilter;
-
-    "OrderCancelled(bytes32,address,address)"(
-      orderHash?: null,
-      offerer?: string | null,
-      zone?: string | null
-    ): OrderCancelledEventFilter;
-    OrderCancelled(
-      orderHash?: null,
-      offerer?: string | null,
-      zone?: string | null
-    ): OrderCancelledEventFilter;
-
-    "OrderFulfilled(bytes32,address,address,address,(uint8,address,uint256,uint256)[],(uint8,address,uint256,uint256,address)[])"(
-      orderHash?: null,
-      offerer?: string | null,
-      zone?: string | null,
-      recipient?: null,
-      offer?: null,
-      consideration?: null
-    ): OrderFulfilledEventFilter;
-    OrderFulfilled(
-      orderHash?: null,
-      offerer?: string | null,
-      zone?: string | null,
-      recipient?: null,
-      offer?: null,
-      consideration?: null
-    ): OrderFulfilledEventFilter;
-
-    "OrderValidated(bytes32,(address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))"(
-      orderHash?: null,
-      orderParameters?: null
-    ): OrderValidatedEventFilter;
-    OrderValidated(
-      orderHash?: null,
-      orderParameters?: null
-    ): OrderValidatedEventFilter;
-
-    "OrdersMatched(bytes32[])"(orderHashes?: null): OrdersMatchedEventFilter;
-    OrdersMatched(orderHashes?: null): OrdersMatchedEventFilter;
-  };
-
-  estimateGas: {
-    cancel(
-      orders: OrderComponentsStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillAdvancedOrder(
-      arg0: AdvancedOrderStruct,
-      arg1: CriteriaResolverStruct[],
-      fulfillerConduitKey: BytesLike,
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillAvailableAdvancedOrders(
-      arg0: AdvancedOrderStruct[],
-      arg1: CriteriaResolverStruct[],
-      arg2: FulfillmentComponentStruct[][],
-      arg3: FulfillmentComponentStruct[][],
-      fulfillerConduitKey: BytesLike,
-      recipient: string,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillAvailableOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentComponentStruct[][],
-      arg2: FulfillmentComponentStruct[][],
-      fulfillerConduitKey: BytesLike,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillBasicOrder(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillBasicOrder_efficient_6GL6yc(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    fulfillOrder(
-      arg0: OrderStruct,
-      fulfillerConduitKey: BytesLike,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    getContractOffererNonce(
-      contractOfferer: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-
-    getOrderHash(
-      arg0: OrderComponentsStruct,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    getOrderStatus(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    incrementCounter(
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    information(overrides?: CallOverrides): Promise<BigNumber>;
-
-    matchAdvancedOrders(
-      arg0: AdvancedOrderStruct[],
-      arg1: CriteriaResolverStruct[],
-      arg2: FulfillmentStruct[],
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    matchOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentStruct[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<BigNumber>;
-
-    name(overrides?: CallOverrides): Promise<BigNumber>;
-
-    validate(
-      arg0: OrderStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<BigNumber>;
-  };
-
-  populateTransaction: {
-    cancel(
-      orders: OrderComponentsStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillAdvancedOrder(
-      arg0: AdvancedOrderStruct,
-      arg1: CriteriaResolverStruct[],
-      fulfillerConduitKey: BytesLike,
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillAvailableAdvancedOrders(
-      arg0: AdvancedOrderStruct[],
-      arg1: CriteriaResolverStruct[],
-      arg2: FulfillmentComponentStruct[][],
-      arg3: FulfillmentComponentStruct[][],
-      fulfillerConduitKey: BytesLike,
-      recipient: string,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillAvailableOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentComponentStruct[][],
-      arg2: FulfillmentComponentStruct[][],
-      fulfillerConduitKey: BytesLike,
-      maximumFulfilled: BigNumberish,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillBasicOrder(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillBasicOrder_efficient_6GL6yc(
-      parameters: BasicOrderParametersStruct,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    fulfillOrder(
-      arg0: OrderStruct,
-      fulfillerConduitKey: BytesLike,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    getContractOffererNonce(
-      contractOfferer: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getCounter(
-      offerer: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getOrderHash(
-      arg0: OrderComponentsStruct,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    getOrderStatus(
-      orderHash: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
-    incrementCounter(
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
-
-    information(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    "CounterIncremented(uint256,address)": TypedContractEvent<
+      CounterIncrementedEvent.InputTuple,
+      CounterIncrementedEvent.OutputTuple,
+      CounterIncrementedEvent.OutputObject
+    >;
+    CounterIncremented: TypedContractEvent<
+      CounterIncrementedEvent.InputTuple,
+      CounterIncrementedEvent.OutputTuple,
+      CounterIncrementedEvent.OutputObject
+    >;
 
-    matchAdvancedOrders(
-      arg0: AdvancedOrderStruct[],
-      arg1: CriteriaResolverStruct[],
-      arg2: FulfillmentStruct[],
-      recipient: string,
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
+    "OrderCancelled(bytes32,address,address)": TypedContractEvent<
+      OrderCancelledEvent.InputTuple,
+      OrderCancelledEvent.OutputTuple,
+      OrderCancelledEvent.OutputObject
+    >;
+    OrderCancelled: TypedContractEvent<
+      OrderCancelledEvent.InputTuple,
+      OrderCancelledEvent.OutputTuple,
+      OrderCancelledEvent.OutputObject
+    >;
 
-    matchOrders(
-      arg0: OrderStruct[],
-      arg1: FulfillmentStruct[],
-      overrides?: PayableOverrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
+    "OrderFulfilled(bytes32,address,address,address,tuple[],tuple[])": TypedContractEvent<
+      OrderFulfilledEvent.InputTuple,
+      OrderFulfilledEvent.OutputTuple,
+      OrderFulfilledEvent.OutputObject
+    >;
+    OrderFulfilled: TypedContractEvent<
+      OrderFulfilledEvent.InputTuple,
+      OrderFulfilledEvent.OutputTuple,
+      OrderFulfilledEvent.OutputObject
+    >;
 
-    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    "OrderValidated(bytes32,tuple)": TypedContractEvent<
+      OrderValidatedEvent.InputTuple,
+      OrderValidatedEvent.OutputTuple,
+      OrderValidatedEvent.OutputObject
+    >;
+    OrderValidated: TypedContractEvent<
+      OrderValidatedEvent.InputTuple,
+      OrderValidatedEvent.OutputTuple,
+      OrderValidatedEvent.OutputObject
+    >;
 
-    validate(
-      arg0: OrderStruct[],
-      overrides?: Overrides & { from?: string }
-    ): Promise<PopulatedTransaction>;
+    "OrdersMatched(bytes32[])": TypedContractEvent<
+      OrdersMatchedEvent.InputTuple,
+      OrdersMatchedEvent.OutputTuple,
+      OrdersMatchedEvent.OutputObject
+    >;
+    OrdersMatched: TypedContractEvent<
+      OrdersMatchedEvent.InputTuple,
+      OrdersMatchedEvent.OutputTuple,
+      OrdersMatchedEvent.OutputObject
+    >;
   };
 }