@opensea/seaport-js 2.0.8 → 3.0.1

package/src/types.ts

@@ -1,21 +1,10 @@
-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 = {
   // Used because fulfillments may be invalid if confirmations take too long. Default buffer is 5 minutes
@@ -28,7 +17,7 @@ export type SeaportConfig = {
   conduitKeyToConduit?: Record<string, string>;
 
   // The Seaport version to use
-  seaportVersion?: "1.4" | "1.5";
+  seaportVersion?: "1.5";
 
   overrides?: {
     contractAddress?: string;
@@ -101,8 +90,8 @@ export type Order = {
 };
 
 export type AdvancedOrder = Order & {
-  numerator: BigNumber;
-  denominator: BigNumber;
+  numerator: bigint;
+  denominator: bigint;
   extraData: string;
 };
 
@@ -180,8 +169,8 @@ export type InputCriteria = {
 export type OrderStatus = {
   isValidated: boolean;
   isCancelled: boolean;
-  totalFilled: BigNumber;
-  totalSize: BigNumber;
+  totalFilled: bigint;
+  totalSize: bigint;
 };
 
 export type OrderWithCounter = {
@@ -189,30 +178,15 @@ export type OrderWithCounter = {
   signature: string;
 };
 
-export type ContractMethodReturnType<
-  T extends Contract,
-  U extends keyof T["callStatic"],
-  // eslint-disable-next-line no-undef
-> = 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> = {
@@ -255,14 +229,14 @@ export type OrderUseCase<
   actions: T extends CreateOrderAction
     ? CreateOrderActions
     : T extends CreateBulkOrdersAction
-    ? CreateBulkOrdersActions
-    : OrderExchangeActions<T extends ExchangeAction<infer U> ? U : never>;
+      ? CreateBulkOrdersActions
+      : OrderExchangeActions<T extends ExchangeAction<infer U> ? U : never>;
   executeAllActions: () => Promise<
     T extends CreateOrderAction
       ? OrderWithCounter
       : T extends CreateBulkOrdersAction
-      ? OrderWithCounter[]
-      : ContractTransaction
+        ? OrderWithCounter[]
+        : ContractTransaction
   >;
 };
 
@@ -285,52 +259,3 @@ export type MatchOrdersFulfillment = {
   offerComponents: MatchOrdersFulfillmentComponent[];
   considerationComponents: MatchOrdersFulfillmentComponent[];
 };
-
-// Overrides matchOrders types to fix fulfillments type which is generated
-// by TypeChain incorrectly
-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;

package/src/utils/approval.ts

@@ -1,9 +1,6 @@
-import { providers as multicallProviders } from "@0xsequence/multicall";
-import { BigNumber, Contract, Signer } from "ethers";
-import { ERC20ABI } from "../abi/ERC20";
-import { ERC721ABI } from "../abi/ERC721";
+import { Signer, ethers } from "ethers";
 import { ItemType, MAX_INT } from "../constants";
-import type { TestERC20, TestERC721 } from "../typechain-types";
+import { TestERC721__factory, TestERC20__factory } from "../typechain-types";
 import type { ApprovalAction, Item } from "../types";
 import type { InsufficientApprovals } from "./balanceAndApprovalCheck";
 import { isErc1155Item, isErc721Item } from "./item";
@@ -13,25 +10,17 @@ export const approvedItemAmount = async (
   owner: string,
   item: Item,
   operator: string,
-  multicallProvider: multicallProviders.MulticallProvider,
+  provider: ethers.Provider,
 ) => {
   if (isErc721Item(item.itemType) || isErc1155Item(item.itemType)) {
     // isApprovedForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-    const contract = new Contract(
-      item.token,
-      ERC721ABI,
-      multicallProvider,
-    ) as TestERC721;
-    return contract.isApprovedForAll(owner, operator).then((isApprovedForAll) =>
-      // Setting to the max int to consolidate types and simplify
-      isApprovedForAll ? MAX_INT : BigNumber.from(0),
-    );
+    const contract = TestERC721__factory.connect(item.token, provider);
+
+    const isApprovedForAll = await contract.isApprovedForAll(owner, operator);
+    // Setting to the max int to consolidate types and simplify
+    return isApprovedForAll ? MAX_INT : 0n;
   } else if (item.itemType === ItemType.ERC20) {
-    const contract = new Contract(
-      item.token,
-      ERC20ABI,
-      multicallProvider,
-    ) as TestERC20;
+    const contract = TestERC20__factory.connect(item.token, provider);
 
     return contract.allowance(owner, operator);
   }
@@ -41,7 +30,7 @@ export const approvedItemAmount = async (
 };
 
 /**
- * Get approval actions given a list of insufficent approvals.
+ * Get approval actions given a list of insufficient approvals.
  */
 export function getApprovalActions(
   insufficientApprovals: InsufficientApprovals,
@@ -65,7 +54,17 @@ export function getApprovalActions(
         const isErc1155 = isErc1155Item(itemType);
         if (isErc721Item(itemType) || isErc1155) {
           // setApprovalForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-          const contract = new Contract(token, ERC721ABI, signer) as TestERC721;
+          const contract = TestERC721__factory.connect(token, signer);
+          const transactionMethods =
+            exactApproval && !isErc1155
+              ? getTransactionMethods(signer, contract, "approve", [
+                  operator,
+                  identifierOrCriteria,
+                ])
+              : getTransactionMethods(signer, contract, "setApprovalForAll", [
+                  operator,
+                  true,
+                ]);
 
           return {
             type: "approval",
@@ -73,17 +72,10 @@ export function getApprovalActions(
             identifierOrCriteria,
             itemType,
             operator,
-            transactionMethods: getTransactionMethods(
-              contract.connect(signer),
-              exactApproval && !isErc1155 ? "approve" : "setApprovalForAll",
-              [
-                operator,
-                exactApproval && !isErc1155 ? identifierOrCriteria : true,
-              ],
-            ),
+            transactionMethods,
           };
         } else {
-          const contract = new Contract(token, ERC20ABI, signer) as TestERC20;
+          const contract = TestERC20__factory.connect(token, signer);
 
           return {
             type: "approval",
@@ -91,7 +83,8 @@ export function getApprovalActions(
             identifierOrCriteria,
             itemType,
             transactionMethods: getTransactionMethods(
-              contract.connect(signer),
+              signer,
+              contract,
               "approve",
               [operator, exactApproval ? requiredApprovedAmount : MAX_INT],
             ),

package/src/utils/balance.ts

@@ -1,58 +1,46 @@
-import { providers as multicallProviders } from "@0xsequence/multicall";
-import { BigNumber, Contract } from "ethers";
-import { ERC1155ABI } from "../abi/ERC1155";
-import { ERC20ABI } from "../abi/ERC20";
-import { ERC721ABI } from "../abi/ERC721";
+import { ethers } from "ethers";
 import { ItemType } from "../constants";
-import type { TestERC20, TestERC1155, TestERC721 } from "../typechain-types";
+import {
+  TestERC721__factory,
+  TestERC1155__factory,
+  TestERC20__factory,
+} from "../typechain-types";
 import type { InputCriteria, Item } from "../types";
 import { isErc1155Item, isErc20Item, isErc721Item } from "./item";
 
 export const balanceOf = async (
   owner: string,
   item: Item,
-  multicallProvider: multicallProviders.MulticallProvider,
+  provider: ethers.Provider,
   criteria?: InputCriteria,
-): Promise<BigNumber> => {
+): Promise<bigint> => {
   if (isErc721Item(item.itemType)) {
-    const contract = new Contract(
-      item.token,
-      ERC721ABI,
-      multicallProvider,
-    ) as TestERC721;
+    const contract = TestERC721__factory.connect(item.token, provider);
 
     if (item.itemType === ItemType.ERC721_WITH_CRITERIA) {
       return criteria
         ? contract
             .ownerOf(criteria.identifier)
             .then((ownerOf) =>
-              BigNumber.from(
-                Number(ownerOf.toLowerCase() === owner.toLowerCase()),
-              ),
+              BigInt(ownerOf.toLowerCase() === owner.toLowerCase()),
             )
         : contract.balanceOf(owner);
     }
 
     return contract
       .ownerOf(item.identifierOrCriteria)
-      .then((ownerOf) =>
-        BigNumber.from(Number(ownerOf.toLowerCase() === owner.toLowerCase())),
-      );
+      .then((ownerOf) => BigInt(ownerOf.toLowerCase() === owner.toLowerCase()));
   } else if (isErc1155Item(item.itemType)) {
-    const contract = new Contract(
-      item.token,
-      ERC1155ABI,
-      multicallProvider,
-    ) as TestERC1155;
+    const contract = TestERC1155__factory.connect(item.token, provider);
 
     if (item.itemType === ItemType.ERC1155_WITH_CRITERIA) {
       if (!criteria) {
         // We don't have a good way to determine the balance of an erc1155 criteria item unless explicit
         // identifiers are provided, so just assume the offerer has sufficient balance
-        const startAmount = BigNumber.from(item.startAmount);
-        const endAmount = BigNumber.from(item.endAmount);
+        const startAmount = BigInt(item.startAmount);
+        const endAmount = BigInt(item.endAmount);
 
-        return startAmount.gt(endAmount) ? startAmount : endAmount;
+        return startAmount > endAmount ? startAmount : endAmount;
       }
       return contract.balanceOf(owner, criteria.identifier);
     }
@@ -61,13 +49,9 @@ export const balanceOf = async (
   }
 
   if (isErc20Item(item.itemType)) {
-    const contract = new Contract(
-      item.token,
-      ERC20ABI,
-      multicallProvider,
-    ) as TestERC20;
+    const contract = TestERC20__factory.connect(item.token, provider);
     return contract.balanceOf(owner);
   }
 
-  return multicallProvider.getBalance(owner);
+  return provider.getBalance(owner);
 };

package/src/utils/balanceAndApprovalCheck.ts

@@ -1,5 +1,4 @@
-import { providers as multicallProviders } from "@0xsequence/multicall";
-import { BigNumber } from "ethers";
+import { ethers } from "ethers";
 import { ItemType, MAX_INT } from "../constants";
 import type { InputCriteria, Item, OrderParameters } from "../types";
 import { approvedItemAmount } from "./approval";
@@ -16,24 +15,24 @@ import {
 export type BalancesAndApprovals = {
   token: string;
   identifierOrCriteria: string;
-  balance: BigNumber;
-  approvedAmount: BigNumber;
+  balance: bigint;
+  approvedAmount: bigint;
   itemType: ItemType;
 }[];
 
 export type InsufficientBalances = {
   token: string;
   identifierOrCriteria: string;
-  requiredAmount: BigNumber;
-  amountHave: BigNumber;
+  requiredAmount: bigint;
+  amountHave: bigint;
   itemType: ItemType;
 }[];
 
 export type InsufficientApprovals = {
   token: string;
   identifierOrCriteria: string;
-  approvedAmount: BigNumber;
-  requiredApprovedAmount: BigNumber;
+  approvedAmount: bigint;
+  requiredApprovedAmount: bigint;
   operator: string;
   itemType: ItemType;
 }[];
@@ -67,38 +66,37 @@ export const getBalancesAndApprovals = async ({
   items,
   criterias,
   operator,
-  multicallProvider,
+  provider,
 }: {
   owner: string;
   items: Item[];
   criterias: InputCriteria[];
   operator: string;
-  multicallProvider: multicallProviders.MulticallProvider;
+  provider: ethers.Provider;
 }): Promise<BalancesAndApprovals> => {
   const itemToCriteria = getItemToCriteriaMap(items, criterias);
 
   return Promise.all(
     items.map(async (item) => {
-      let approvedAmountPromise = Promise.resolve(BigNumber.from(0));
+      let approvedAmount = 0n;
 
       if (isErc721Item(item.itemType) || isErc1155Item(item.itemType)) {
-        approvedAmountPromise = approvedItemAmount(
+        approvedAmount = await approvedItemAmount(
           owner,
           item,
           operator,
-          multicallProvider,
+          provider,
         );
       } else if (isErc20Item(item.itemType)) {
-        approvedAmountPromise = approvedItemAmount(
+        approvedAmount = await approvedItemAmount(
           owner,
           item,
           operator,
-          multicallProvider,
+          provider,
         );
-      }
-      // If native token, we don't need to check for approvals
-      else {
-        approvedAmountPromise = Promise.resolve(MAX_INT);
+      } else {
+        // If native token, we don't need to check for approvals
+        approvedAmount = MAX_INT;
       }
 
       return {
@@ -108,10 +106,10 @@ export const getBalancesAndApprovals = async ({
         balance: await balanceOf(
           owner,
           item,
-          multicallProvider,
+          provider,
           itemToCriteria.get(item),
         ),
-        approvedAmount: await approvedAmountPromise,
+        approvedAmount,
         itemType: item.itemType,
       };
     }),
@@ -146,12 +144,13 @@ export const getInsufficientBalanceAndApprovalAmounts = ({
     filterKey: "balance" | "approvedAmount",
   ): InsufficientBalances =>
     tokenAndIdentifierAndAmountNeeded
-      .filter(([token, identifierOrCriteria, amountNeeded]) =>
-        findBalanceAndApproval(
-          balancesAndApprovals,
-          token,
-          identifierOrCriteria,
-        )[filterKey].lt(amountNeeded),
+      .filter(
+        ([token, identifierOrCriteria, amountNeeded]) =>
+          findBalanceAndApproval(
+            balancesAndApprovals,
+            token,
+            identifierOrCriteria,
+          )[filterKey] < amountNeeded,
       )
       .map(([token, identifierOrCriteria, amount]) => {
         const balanceAndApproval = findBalanceAndApproval(
@@ -408,7 +407,7 @@ const addToExistingBalances = ({
     (item) => ({ ...item }),
   );
 
-  // Add each summed item amount to the existing balances as we may want tocheck balances after receiving all items
+  // Add each summed item amount to the existing balances as we may want to check balances after receiving all items
   Object.entries(summedItemAmounts).forEach(
     ([token, identifierOrCriteriaToAmount]) =>
       Object.entries(identifierOrCriteriaToAmount).forEach(
@@ -425,9 +424,8 @@ const addToExistingBalances = ({
           balancesAndApprovalsAfterReceivingItems[
             balanceAndApprovalIndex
           ].balance =
-            balancesAndApprovalsAfterReceivingItems[
-              balanceAndApprovalIndex
-            ].balance.add(amount);
+            balancesAndApprovalsAfterReceivingItems[balanceAndApprovalIndex]
+              .balance + amount;
         },
       ),
   );

package/src/utils/eip712/Eip712MerkleTree.ts

@@ -1,10 +1,10 @@
-import { _TypedDataEncoder as TypedDataEncoder } from "@ethersproject/hash";
 import {
-  defaultAbiCoder,
-  hexConcat,
+  TypedDataEncoder,
+  AbiCoder,
   keccak256,
   toUtf8Bytes,
-} from "ethers/lib/utils";
+  concat,
+} from "ethers";
 import { MerkleTree } from "merkletreejs";
 
 import { DefaultGetter } from "./defaults";
@@ -36,10 +36,10 @@ const encodeProof = (
   proof: string[],
   signature = `0x${"ff".repeat(64)}`,
 ) => {
-  return hexConcat([
+  return concat([
     signature,
     `0x${key.toString(16).padStart(6, "0")}`,
-    defaultAbiCoder.encode([`uint256[${proof.length}]`], [proof]),
+    AbiCoder.defaultAbiCoder().encode([`uint256[${proof.length}]`], [proof]),
   ]);
 };
 
@@ -101,8 +101,10 @@ export class Eip712MerkleTree<BaseType extends Record<string, any> = any> {
     });
     const leaves = this.getCompleteLeaves().map(hexToBuffer);
     const rootHash = bufferToHex(getRoot(leaves, false));
-    const typeHash = keccak256(toUtf8Bytes(this.encoder._types.BulkOrder));
-    const bulkOrderHash = keccak256(hexConcat([typeHash, rootHash]));
+    const typeHash = keccak256(
+      toUtf8Bytes(this.encoder.types.BulkOrder[0].type),
+    );
+    const bulkOrderHash = keccak256(concat([typeHash, rootHash]));
 
     if (bulkOrderHash !== structHash) {
       throw new Error("expected derived bulk order hash to match");

package/src/utils/eip712/bulk-orders.ts

@@ -1,4 +1,4 @@
-import { _TypedDataEncoder, keccak256, toUtf8Bytes } from "ethers/lib/utils";
+import { TypedDataEncoder, keccak256, toUtf8Bytes } from "ethers";
 
 import { Eip712MerkleTree } from "./Eip712MerkleTree";
 import { DefaultGetter } from "./defaults";
@@ -48,8 +48,8 @@ export function getBulkOrderTree(
 
 export function getBulkOrderTypeHash(height: number): string {
   const types = getBulkOrderTypes(height);
-  const encoder = _TypedDataEncoder.from(types);
-  const typeString = toUtf8Bytes(encoder._types.BulkOrder);
+  const encoder = TypedDataEncoder.from(types);
+  const typeString = toUtf8Bytes(encoder.types.BulkOrder[0].type);
   return keccak256(typeString);
 }
 

package/src/utils/eip712/defaults.ts

@@ -1,13 +1,8 @@
-import { Logger } from "@ethersproject/logger";
-import { hexZeroPad } from "ethers/lib/utils";
-
-import type { TypedDataField } from "@ethersproject/abstract-signer";
-
-const logger = new Logger("defaults");
+import { ethers, zeroPadValue, TypedDataField } from "ethers";
 
 const baseDefaults: Record<string, any> = {
   integer: 0,
-  address: hexZeroPad("0x", 20),
+  address: ethers.zeroPadValue("0x", 20),
   bool: false,
   bytes: "0x",
   string: "",
@@ -19,8 +14,7 @@ const isNullish = (value: any): boolean => {
   return (
     value !== undefined &&
     value !== null &&
-    ((["string", "number"].includes(typeof value) &&
-      BigInt(value) === BigInt(0)) ||
+    ((["string", "number"].includes(typeof value) && BigInt(value) === 0n) ||
       (Array.isArray(value) && value.every(isNullish)) ||
       (typeof value === "object" && Object.values(value).every(isNullish)) ||
       (typeof value === "boolean" && value === false))
@@ -30,7 +24,7 @@ const isNullish = (value: any): boolean => {
 function getDefaultForBaseType(type: string): any {
   // bytesXX
   const [, width] = type.match(/^bytes(\d+)$/) ?? [];
-  if (width) return hexZeroPad("0x", parseInt(width));
+  if (width) return zeroPadValue("0x", parseInt(width));
 
   if (type.match(/^(u?)int(\d*)$/)) type = "integer";
 
@@ -51,7 +45,7 @@ export class DefaultGetter<Types extends EIP712TypeDefinitions> {
       const defaultValue = this.getDefaultValue(name);
       this.defaultValues[name] = defaultValue;
       if (!isNullish(defaultValue)) {
-        logger.throwError(
+        throw new Error(
           `Got non-empty value for type ${name} in default generator: ${defaultValue}`,
         );
       }
@@ -108,6 +102,6 @@ export class DefaultGetter<Types extends EIP712TypeDefinitions> {
       );
     }
 
-    return logger.throwArgumentError(`unknown type: ${type}`, "type", type);
+    throw new Error(`unknown type: ${type}`);
   }
 }

package/src/utils/eip712/utils.ts

@@ -1,4 +1,4 @@
-import { hexConcat, hexlify, keccak256 } from "ethers/lib/utils";
+import { concat, toBeHex, keccak256 } from "ethers";
 
 import type { BytesLike } from "ethers";
 
@@ -13,14 +13,14 @@ export const chunk = <T>(array: T[], size: number) => {
   );
 };
 
-export const bufferToHex = (buf: Buffer) => hexlify(buf);
+export const bufferToHex = (buf: Buffer) => toBeHex(buf.toString("hex"));
 
 export const hexToBuffer = (value: string) =>
   Buffer.from(value.slice(2), "hex");
 
 export const bufferKeccak = (value: BytesLike) => hexToBuffer(keccak256(value));
 
-export const hashConcat = (arr: BytesLike[]) => bufferKeccak(hexConcat(arr));
+export const hashConcat = (arr: BytesLike[]) => bufferKeccak(concat(arr));
 
 export const fillArray = <T>(arr: T[], length: number, value: T) => {
   if (length > arr.length) arr.push(...Array(length - arr.length).fill(value));