@opensea/seaport-js 2.0.8 → 3.0.0

package/lib/typechain-types/src/contracts/test/TestERC721.d.ts

@@ -1,39 +1,22 @@
-import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
-import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
-import type { Listener, Provider } from "@ethersproject/providers";
-import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../common";
-export interface TestERC721Interface extends utils.Interface {
-    functions: {
-        "approve(address,uint256)": FunctionFragment;
-        "balanceOf(address)": FunctionFragment;
-        "getApproved(uint256)": FunctionFragment;
-        "isApprovedForAll(address,address)": FunctionFragment;
-        "mint(address,uint256)": FunctionFragment;
-        "name()": FunctionFragment;
-        "ownerOf(uint256)": FunctionFragment;
-        "safeTransferFrom(address,address,uint256)": FunctionFragment;
-        "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
-        "setApprovalForAll(address,bool)": FunctionFragment;
-        "supportsInterface(bytes4)": FunctionFragment;
-        "symbol()": FunctionFragment;
-        "tokenURI(uint256)": FunctionFragment;
-        "transferFrom(address,address,uint256)": FunctionFragment;
-    };
-    getFunction(nameOrSignatureOrTopic: "approve" | "balanceOf" | "getApproved" | "isApprovedForAll" | "mint" | "name" | "ownerOf" | "safeTransferFrom(address,address,uint256)" | "safeTransferFrom(address,address,uint256,bytes)" | "setApprovalForAll" | "supportsInterface" | "symbol" | "tokenURI" | "transferFrom"): FunctionFragment;
-    encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../../common";
+export interface TestERC721Interface extends Interface {
+    getFunction(nameOrSignature: "approve" | "balanceOf" | "getApproved" | "isApprovedForAll" | "mint" | "name" | "ownerOf" | "safeTransferFrom(address,address,uint256)" | "safeTransferFrom(address,address,uint256,bytes)" | "setApprovalForAll" | "supportsInterface" | "symbol" | "tokenURI" | "transferFrom"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "Approval" | "ApprovalForAll" | "Transfer"): EventFragment;
+    encodeFunctionData(functionFragment: "approve", values: [AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [AddressLike]): string;
     encodeFunctionData(functionFragment: "getApproved", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "isApprovedForAll", values: [string, string]): string;
-    encodeFunctionData(functionFragment: "mint", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "isApprovedForAll", values: [AddressLike, AddressLike]): string;
+    encodeFunctionData(functionFragment: "mint", values: [AddressLike, BigNumberish]): string;
     encodeFunctionData(functionFragment: "name", values?: undefined): string;
     encodeFunctionData(functionFragment: "ownerOf", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256)", values: [string, string, BigNumberish]): string;
-    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", values: [string, string, BigNumberish, BytesLike]): string;
-    encodeFunctionData(functionFragment: "setApprovalForAll", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256)", values: [AddressLike, AddressLike, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", values: [AddressLike, AddressLike, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "setApprovalForAll", values: [AddressLike, boolean]): string;
     encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
     encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
     encodeFunctionData(functionFragment: "tokenURI", values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "transferFrom", values: [AddressLike, AddressLike, BigNumberish]): string;
     decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getApproved", data: BytesLike): Result;
@@ -48,196 +31,195 @@ export interface TestERC721Interface extends utils.Interface {
     decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
-    events: {
-        "Approval(address,address,uint256)": EventFragment;
-        "ApprovalForAll(address,address,bool)": EventFragment;
-        "Transfer(address,address,uint256)": EventFragment;
-    };
-    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
 }
-export interface ApprovalEventObject {
-    owner: string;
-    spender: string;
-    id: BigNumber;
+export declare namespace ApprovalEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        spender: AddressLike,
+        id: BigNumberish
+    ];
+    type OutputTuple = [owner: string, spender: string, id: bigint];
+    interface OutputObject {
+        owner: string;
+        spender: string;
+        id: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type ApprovalEvent = TypedEvent<[
-    string,
-    string,
-    BigNumber
-], ApprovalEventObject>;
-export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
-export interface ApprovalForAllEventObject {
-    owner: string;
-    operator: string;
-    approved: boolean;
+export declare namespace ApprovalForAllEvent {
+    type InputTuple = [
+        owner: AddressLike,
+        operator: AddressLike,
+        approved: boolean
+    ];
+    type OutputTuple = [
+        owner: string,
+        operator: string,
+        approved: boolean
+    ];
+    interface OutputObject {
+        owner: string;
+        operator: string;
+        approved: boolean;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type ApprovalForAllEvent = TypedEvent<[
-    string,
-    string,
-    boolean
-], ApprovalForAllEventObject>;
-export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
-export interface TransferEventObject {
-    from: string;
-    to: string;
-    id: BigNumber;
+export declare namespace TransferEvent {
+    type InputTuple = [
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish
+    ];
+    type OutputTuple = [from: string, to: string, id: bigint];
+    interface OutputObject {
+        from: string;
+        to: string;
+        id: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type TransferEvent = TypedEvent<[
-    string,
-    string,
-    BigNumber
-], TransferEventObject>;
-export type TransferEventFilter = TypedEventFilter<TransferEvent>;
 export interface TestERC721 extends BaseContract {
-    connect(signerOrProvider: Signer | Provider | string): this;
-    attach(addressOrName: string): this;
-    deployed(): Promise<this>;
+    connect(runner?: ContractRunner | null): TestERC721;
+    waitForDeployment(): Promise<this>;
     interface: TestERC721Interface;
-    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, 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: {
-        approve(spender: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        balanceOf(owner: string, overrides?: CallOverrides): Promise<[BigNumber]>;
-        getApproved(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
-        isApprovedForAll(arg0: string, arg1: string, overrides?: CallOverrides): Promise<[boolean]>;
-        mint(to: string, tokenId: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        name(overrides?: CallOverrides): Promise<[string]>;
-        ownerOf(id: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
-            owner: string;
-        }>;
-        "safeTransferFrom(address,address,uint256)"(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, id: BigNumberish, data: BytesLike, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
-        symbol(overrides?: CallOverrides): Promise<[string]>;
-        tokenURI(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
-        transferFrom(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-    };
-    approve(spender: string, id: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    balanceOf(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
-    getApproved(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
-    isApprovedForAll(arg0: string, arg1: string, overrides?: CallOverrides): Promise<boolean>;
-    mint(to: string, tokenId: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    name(overrides?: CallOverrides): Promise<string>;
-    ownerOf(id: BigNumberish, overrides?: CallOverrides): Promise<string>;
-    "safeTransferFrom(address,address,uint256)"(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, id: BigNumberish, data: BytesLike, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
-    symbol(overrides?: CallOverrides): Promise<string>;
-    tokenURI(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
-    transferFrom(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    callStatic: {
-        approve(spender: string, id: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        balanceOf(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getApproved(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
-        isApprovedForAll(arg0: string, arg1: string, overrides?: CallOverrides): Promise<boolean>;
-        mint(to: string, tokenId: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
-        name(overrides?: CallOverrides): Promise<string>;
-        ownerOf(id: BigNumberish, overrides?: CallOverrides): Promise<string>;
-        "safeTransferFrom(address,address,uint256)"(from: string, to: string, id: BigNumberish, overrides?: CallOverrides): Promise<void>;
-        "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, id: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<void>;
-        setApprovalForAll(operator: string, approved: boolean, overrides?: CallOverrides): Promise<void>;
-        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
-        symbol(overrides?: CallOverrides): Promise<string>;
-        tokenURI(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
-        transferFrom(from: string, to: string, id: BigNumberish, overrides?: CallOverrides): Promise<void>;
-    };
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    approve: TypedContractMethod<[
+        spender: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    balanceOf: TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getApproved: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    isApprovedForAll: TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    mint: TypedContractMethod<[
+        to: AddressLike,
+        tokenId: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    name: TypedContractMethod<[], [string], "view">;
+    ownerOf: TypedContractMethod<[id: BigNumberish], [string], "view">;
+    "safeTransferFrom(address,address,uint256)": TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    "safeTransferFrom(address,address,uint256,bytes)": TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish,
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    setApprovalForAll: TypedContractMethod<[
+        operator: AddressLike,
+        approved: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    supportsInterface: TypedContractMethod<[
+        interfaceId: BytesLike
+    ], [
+        boolean
+    ], "view">;
+    symbol: TypedContractMethod<[], [string], "view">;
+    tokenURI: TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    transferFrom: TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "approve"): TypedContractMethod<[
+        spender: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "balanceOf"): TypedContractMethod<[owner: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getApproved"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "isApprovedForAll"): TypedContractMethod<[
+        arg0: AddressLike,
+        arg1: AddressLike
+    ], [
+        boolean
+    ], "view">;
+    getFunction(nameOrSignature: "mint"): TypedContractMethod<[
+        to: AddressLike,
+        tokenId: BigNumberish
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "ownerOf"): TypedContractMethod<[id: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "safeTransferFrom(address,address,uint256)"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "safeTransferFrom(address,address,uint256,bytes)"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish,
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "setApprovalForAll"): TypedContractMethod<[
+        operator: AddressLike,
+        approved: boolean
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "supportsInterface"): TypedContractMethod<[interfaceId: BytesLike], [boolean], "view">;
+    getFunction(nameOrSignature: "symbol"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "tokenURI"): TypedContractMethod<[arg0: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "transferFrom"): TypedContractMethod<[
+        from: AddressLike,
+        to: AddressLike,
+        id: BigNumberish
+    ], [
+        void
+    ], "nonpayable">;
+    getEvent(key: "Approval"): TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+    getEvent(key: "ApprovalForAll"): TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+    getEvent(key: "Transfer"): TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
     filters: {
-        "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, id?: BigNumberish | null): ApprovalEventFilter;
-        Approval(owner?: string | null, spender?: string | null, id?: BigNumberish | null): ApprovalEventFilter;
-        "ApprovalForAll(address,address,bool)"(owner?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
-        ApprovalForAll(owner?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
-        "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, id?: BigNumberish | null): TransferEventFilter;
-        Transfer(from?: string | null, to?: string | null, id?: BigNumberish | null): TransferEventFilter;
-    };
-    estimateGas: {
-        approve(spender: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        balanceOf(owner: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getApproved(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        isApprovedForAll(arg0: string, arg1: string, overrides?: CallOverrides): Promise<BigNumber>;
-        mint(to: string, tokenId: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        name(overrides?: CallOverrides): Promise<BigNumber>;
-        ownerOf(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        "safeTransferFrom(address,address,uint256)"(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, id: BigNumberish, data: BytesLike, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
-        symbol(overrides?: CallOverrides): Promise<BigNumber>;
-        tokenURI(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
-        transferFrom(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-    };
-    populateTransaction: {
-        approve(spender: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        balanceOf(owner: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getApproved(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        isApprovedForAll(arg0: string, arg1: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        mint(to: string, tokenId: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        ownerOf(id: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        "safeTransferFrom(address,address,uint256)"(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, id: BigNumberish, data: BytesLike, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        tokenURI(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        transferFrom(from: string, to: string, id: BigNumberish, overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
+        "Approval(address,address,uint256)": TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        Approval: TypedContractEvent<ApprovalEvent.InputTuple, ApprovalEvent.OutputTuple, ApprovalEvent.OutputObject>;
+        "ApprovalForAll(address,address,bool)": TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+        ApprovalForAll: TypedContractEvent<ApprovalForAllEvent.InputTuple, ApprovalForAllEvent.OutputTuple, ApprovalForAllEvent.OutputObject>;
+        "Transfer(address,address,uint256)": TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
+        Transfer: TypedContractEvent<TransferEvent.InputTuple, TransferEvent.OutputTuple, TransferEvent.OutputObject>;
     };
 }

package/lib/types.d.ts

@@ -1,13 +1,14 @@
-import type { DomainRegistry as TypeChainDomainRegistryContract } from "./typechain-types";
-import type { OrderStruct, Seaport as TypeChainSeaportContract } from "./typechain-types/seaport_v1_4/contracts/Seaport";
-import { BigNumber, BigNumberish, BytesLike, Contract, ContractTransaction, ethers, Overrides, PayableOverrides, PopulatedTransaction } from "ethers";
+import { BigNumberish, BytesLike, ContractTransaction, ethers } from "ethers";
 import { ItemType, OrderType } from "./constants";
 import type { TestERC20, TestERC721 } from "./typechain-types";
+import { TransactionMethods } from "./utils/usecase";
+import { Seaport as SeaportContract } from "./typechain-types/seaport_v1_5/contracts/Seaport";
+export type { SeaportContract };
 export type SeaportConfig = {
     ascendingAmountFulfillmentBuffer?: number;
     balanceAndApprovalChecksOnOrderCreation?: boolean;
     conduitKeyToConduit?: Record<string, string>;
-    seaportVersion?: "1.4" | "1.5";
+    seaportVersion?: "1.5";
     overrides?: {
         contractAddress?: string;
         domainRegistryAddress?: string;
@@ -65,8 +66,8 @@ export type Order = {
     signature: string;
 };
 export type AdvancedOrder = Order & {
-    numerator: BigNumber;
-    denominator: BigNumber;
+    numerator: bigint;
+    denominator: bigint;
     extraData: string;
 };
 export type BasicErc721Item = {
@@ -141,27 +142,20 @@ export type InputCriteria = {
 export type OrderStatus = {
     isValidated: boolean;
     isCancelled: boolean;
-    totalFilled: BigNumber;
-    totalSize: BigNumber;
+    totalFilled: bigint;
+    totalSize: bigint;
 };
 export type OrderWithCounter = {
     parameters: OrderComponents;
     signature: string;
 };
-export type ContractMethodReturnType<T extends Contract, U extends keyof T["callStatic"]> = Awaited<ReturnType<T["callStatic"][U]>>;
-export type TransactionMethods<T = unknown> = {
-    buildTransaction: (overrides?: Overrides) => Promise<PopulatedTransaction>;
-    callStatic: (overrides?: Overrides) => Promise<T>;
-    estimateGas: (overrides?: Overrides) => Promise<BigNumber>;
-    transact: (overrides?: Overrides) => Promise<ContractTransaction>;
-};
 export type ApprovalAction = {
     type: "approval";
     token: string;
     identifierOrCriteria: string;
     itemType: ItemType;
     operator: string;
-    transactionMethods: TransactionMethods<ContractMethodReturnType<TestERC721, "setApprovalForAll">> | TransactionMethods<ContractMethodReturnType<TestERC20, "approve">>;
+    transactionMethods: TransactionMethods<TestERC721["setApprovalForAll"] | TestERC20["approve"]>;
 };
 export type ExchangeAction<T = unknown> = {
     type: "exchange";
@@ -210,31 +204,3 @@ export type MatchOrdersFulfillment = {
     offerComponents: MatchOrdersFulfillmentComponent[];
     considerationComponents: MatchOrdersFulfillmentComponent[];
 };
-export type SeaportContract = TypeChainSeaportContract & {
-    encodeFunctionData(functionFragment: "matchOrders", values: [OrderStruct[], MatchOrdersFulfillment[]]): string;
-    matchOrders(orders: OrderStruct[], fulfillments: MatchOrdersFulfillment[], overrides?: PayableOverrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    functions: TypeChainSeaportContract["functions"] & {
-        matchOrders(orders: OrderStruct[], fulfillments: MatchOrdersFulfillment[], overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-    };
-    callStatic: TypeChainSeaportContract["callStatic"] & {
-        matchOrders(orders: OrderStruct[], fulfillments: MatchOrdersFulfillment[], overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-    };
-    estimateGas: TypeChainSeaportContract["estimateGas"] & {
-        matchOrders(orders: OrderStruct[], fulfillments: MatchOrdersFulfillment[], overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-    };
-    populateTransaction: TypeChainSeaportContract["populateTransaction"] & {
-        matchOrders(orders: OrderStruct[], fulfillments: MatchOrdersFulfillment[], overrides?: PayableOverrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-    };
-};
-export type DomainRegistryContract = TypeChainDomainRegistryContract;
-export {};

package/lib/utils/approval.d.ts

@@ -1,9 +1,8 @@
-import { providers as multicallProviders } from "@0xsequence/multicall";
-import { BigNumber, Signer } from "ethers";
+import { Signer, ethers } from "ethers";
 import type { ApprovalAction, Item } from "../types";
 import type { InsufficientApprovals } from "./balanceAndApprovalCheck";
-export declare const approvedItemAmount: (owner: string, item: Item, operator: string, multicallProvider: multicallProviders.MulticallProvider) => Promise<BigNumber>;
+export declare const approvedItemAmount: (owner: string, item: Item, operator: string, provider: ethers.Provider) => Promise<bigint>;
 /**
- * Get approval actions given a list of insufficent approvals.
+ * Get approval actions given a list of insufficient approvals.
  */
 export declare function getApprovalActions(insufficientApprovals: InsufficientApprovals, exactApproval: boolean, signer: Signer): ApprovalAction[];

package/lib/utils/approval.js

@@ -1,39 +1,28 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getApprovalActions = exports.approvedItemAmount = void 0;
-const ethers_1 = require("ethers");
-const ERC20_1 = require("../abi/ERC20");
-const ERC721_1 = require("../abi/ERC721");
 const constants_1 = require("../constants");
+const typechain_types_1 = require("../typechain-types");
 const item_1 = require("./item");
 const usecase_1 = require("./usecase");
-const approvedItemAmount = (owner, item, operator, multicallProvider) => __awaiter(void 0, void 0, void 0, function* () {
+const approvedItemAmount = async (owner, item, operator, provider) => {
     if ((0, item_1.isErc721Item)(item.itemType) || (0, item_1.isErc1155Item)(item.itemType)) {
         // isApprovedForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-        const contract = new ethers_1.Contract(item.token, ERC721_1.ERC721ABI, multicallProvider);
-        return contract.isApprovedForAll(owner, operator).then((isApprovedForAll) => 
+        const contract = typechain_types_1.TestERC721__factory.connect(item.token, provider);
+        const isApprovedForAll = await contract.isApprovedForAll(owner, operator);
         // Setting to the max int to consolidate types and simplify
-        isApprovedForAll ? constants_1.MAX_INT : ethers_1.BigNumber.from(0));
+        return isApprovedForAll ? constants_1.MAX_INT : 0n;
     }
     else if (item.itemType === constants_1.ItemType.ERC20) {
-        const contract = new ethers_1.Contract(item.token, ERC20_1.ERC20ABI, multicallProvider);
+        const contract = typechain_types_1.TestERC20__factory.connect(item.token, provider);
         return contract.allowance(owner, operator);
     }
     // We don't need to check approvals for native tokens
     return constants_1.MAX_INT;
-});
+};
 exports.approvedItemAmount = approvedItemAmount;
 /**
- * Get approval actions given a list of insufficent approvals.
+ * Get approval actions given a list of insufficient approvals.
  */
 function getApprovalActions(insufficientApprovals, exactApproval, signer) {
     return insufficientApprovals
@@ -43,27 +32,33 @@ function getApprovalActions(insufficientApprovals, exactApproval, signer) {
         const isErc1155 = (0, item_1.isErc1155Item)(itemType);
         if ((0, item_1.isErc721Item)(itemType) || isErc1155) {
             // setApprovalForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-            const contract = new ethers_1.Contract(token, ERC721_1.ERC721ABI, signer);
+            const contract = typechain_types_1.TestERC721__factory.connect(token, signer);
+            const transactionMethods = exactApproval && !isErc1155
+                ? (0, usecase_1.getTransactionMethods)(signer, contract, "approve", [
+                    operator,
+                    identifierOrCriteria,
+                ])
+                : (0, usecase_1.getTransactionMethods)(signer, contract, "setApprovalForAll", [
+                    operator,
+                    true,
+                ]);
             return {
                 type: "approval",
                 token,
                 identifierOrCriteria,
                 itemType,
                 operator,
-                transactionMethods: (0, usecase_1.getTransactionMethods)(contract.connect(signer), exactApproval && !isErc1155 ? "approve" : "setApprovalForAll", [
-                    operator,
-                    exactApproval && !isErc1155 ? identifierOrCriteria : true,
-                ]),
+                transactionMethods,
             };
         }
         else {
-            const contract = new ethers_1.Contract(token, ERC20_1.ERC20ABI, signer);
+            const contract = typechain_types_1.TestERC20__factory.connect(token, signer);
             return {
                 type: "approval",
                 token,
                 identifierOrCriteria,
                 itemType,
-                transactionMethods: (0, usecase_1.getTransactionMethods)(contract.connect(signer), "approve", [operator, exactApproval ? requiredApprovedAmount : constants_1.MAX_INT]),
+                transactionMethods: (0, usecase_1.getTransactionMethods)(signer, contract, "approve", [operator, exactApproval ? requiredApprovedAmount : constants_1.MAX_INT]),
                 operator,
             };
         }