@opensea/seaport-js 2.0.8 → 3.0.0

package/src/utils/fulfill.ts

@@ -1,20 +1,18 @@
 import {
-  BigNumber,
   BigNumberish,
   ContractTransaction,
   ethers,
-  PayableOverrides,
+  Overrides,
   Signer,
 } from "ethers";
 import type {
-  Seaport as SeaportContract,
   BasicOrderParametersStruct,
-  Seaport,
   FulfillmentComponentStruct,
   OrderStruct,
-} from "../typechain-types/seaport_v1_4/contracts/Seaport";
+} from "../typechain-types/seaport_v1_5/contracts/Seaport";
 import { BasicOrderRouteType, ItemType, NO_CONDUIT } from "../constants";
 import type {
+  SeaportContract,
   AdvancedOrder,
   ConsiderationItem,
   ExchangeAction,
@@ -23,7 +21,6 @@ import type {
   OrderParameters,
   OrderStatus,
   OrderUseCase,
-  ContractMethodReturnType,
 } from "../types";
 import { getApprovalActions } from "./approval";
 import {
@@ -49,7 +46,11 @@ import {
   mapOrderAmountsFromUnitsToFill,
   totalItemsAmount,
 } from "./order";
-import { executeAllActions, getTransactionMethods } from "./usecase";
+import {
+  ContractMethodReturnType,
+  executeAllActions,
+  getTransactionMethods,
+} from "./usecase";
 
 /**
  * We should use basic fulfill order if the order adheres to the following criteria:
@@ -72,7 +73,7 @@ export const shouldUseBasicFulfill = (
   totalFilled: OrderStatus["totalFilled"],
 ) => {
   // 1. The order must not be partially filled
-  if (!totalFilled.eq(0)) {
+  if (totalFilled !== 0n) {
     return false;
   }
 
@@ -134,7 +135,7 @@ export const shouldUseBasicFulfill = (
   if (
     consideration.length > 1 &&
     restConsideration.every((item) => item.itemType === offer[0].itemType) &&
-    totalItemsAmount(restConsideration).endAmount.gt(offer[0].endAmount)
+    totalItemsAmount(restConsideration).endAmount > BigInt(offer[0].endAmount)
   ) {
     return false;
   }
@@ -145,10 +146,10 @@ export const shouldUseBasicFulfill = (
   //  currencies needs to be zero, and the amounts on the 721 item need to be 1
   const nativeCurrencyIsZeroAddress = currencies
     .filter(({ itemType }) => itemType === ItemType.NATIVE)
-    .every(({ token }) => token === ethers.constants.AddressZero);
+    .every(({ token }) => token === ethers.ZeroAddress);
 
   const currencyIdentifiersAreZero = currencies.every(
-    ({ identifierOrCriteria }) => BigNumber.from(identifierOrCriteria).eq(0),
+    ({ identifierOrCriteria }) => BigInt(identifierOrCriteria) === 0n,
   );
 
   const erc721sAreSingleAmount = nfts
@@ -195,7 +196,7 @@ export function fulfillBasicOrder(
     overrides,
   }: {
     order: Order;
-    seaportContract: Seaport;
+    seaportContract: SeaportContract;
     offererBalancesAndApprovals: BalancesAndApprovals;
     fulfillerBalancesAndApprovals: BalancesAndApprovals;
     timeBasedItemParams: TimeBasedItemParams;
@@ -205,7 +206,7 @@ export function fulfillBasicOrder(
     tips?: ConsiderationItem[];
     conduitKey: string;
     domain?: string;
-    overrides?: PayableOverrides;
+    overrides?: Overrides;
   },
   exactApproval: boolean,
 ): OrderUseCase<
@@ -246,7 +247,7 @@ export function fulfillBasicOrder(
       ...timeBasedItemParams,
       isConsiderationItem: true,
     },
-  })[ethers.constants.AddressZero]?.["0"];
+  })[ethers.ZeroAddress]?.["0"];
 
   const insufficientApprovals = validateBasicFulfillBalancesAndApprovals({
     offer,
@@ -284,7 +285,7 @@ export function fulfillBasicOrder(
     zoneHash: order.parameters.zoneHash,
   };
 
-  const payableOverrides = { ...overrides, value: totalNativeAmount };
+  overrides = { ...overrides, value: totalNativeAmount };
 
   const approvalActions = getApprovalActions(
     insufficientApprovals,
@@ -295,9 +296,10 @@ export function fulfillBasicOrder(
   const exchangeAction = {
     type: "exchange",
     transactionMethods: getTransactionMethods(
-      seaportContract.connect(signer),
+      signer,
+      seaportContract,
       "fulfillBasicOrder",
-      [basicOrderParameters, payableOverrides],
+      [basicOrderParameters, overrides],
       domain,
     ),
   } as const;
@@ -335,13 +337,13 @@ export function fulfillStandardOrder(
   }: {
     order: Order;
     unitsToFill?: BigNumberish;
-    totalFilled: BigNumber;
-    totalSize: BigNumber;
+    totalFilled: bigint;
+    totalSize: bigint;
     offerCriteria: InputCriteria[];
     considerationCriteria: InputCriteria[];
     tips?: ConsiderationItem[];
     extraData?: string;
-    seaportContract: Seaport;
+    seaportContract: SeaportContract;
     offererBalancesAndApprovals: BalancesAndApprovals;
     fulfillerBalancesAndApprovals: BalancesAndApprovals;
     offererOperator: string;
@@ -351,7 +353,7 @@ export function fulfillStandardOrder(
     timeBasedItemParams: TimeBasedItemParams;
     signer: Signer;
     domain?: string;
-    overrides?: PayableOverrides;
+    overrides?: Overrides;
   },
   exactApproval: boolean,
 ): OrderUseCase<
@@ -408,7 +410,7 @@ export function fulfillStandardOrder(
       ...timeBasedItemParams,
       isConsiderationItem: true,
     },
-  })[ethers.constants.AddressZero]?.["0"];
+  })[ethers.ZeroAddress]?.["0"];
 
   const insufficientApprovals = validateStandardFulfillBalancesAndApprovals({
     offer,
@@ -422,7 +424,7 @@ export function fulfillStandardOrder(
     fulfillerOperator,
   });
 
-  const payableOverrides = { ...overrides, value: totalNativeAmount };
+  overrides = { ...overrides, value: totalNativeAmount };
 
   const approvalActions = getApprovalActions(
     insufficientApprovals,
@@ -430,7 +432,7 @@ export function fulfillStandardOrder(
     signer,
   );
 
-  const isGift = recipientAddress !== ethers.constants.AddressZero;
+  const isGift = recipientAddress !== ethers.ZeroAddress;
 
   const useAdvanced = Boolean(unitsToFill) || hasCriteriaItems || isGift;
 
@@ -452,7 +454,8 @@ export function fulfillStandardOrder(
     type: "exchange",
     transactionMethods: useAdvanced
       ? getTransactionMethods(
-          seaportContract.connect(signer),
+          signer,
+          seaportContract,
           "fulfillAdvancedOrder",
           [
             {
@@ -470,14 +473,15 @@ export function fulfillStandardOrder(
               : [],
             conduitKey,
             recipientAddress,
-            payableOverrides,
+            overrides,
           ],
           domain,
         )
       : getTransactionMethods(
-          seaportContract.connect(signer),
+          signer,
+          seaportContract,
           "fulfillOrder",
-          [orderAccountingForTips, conduitKey, payableOverrides],
+          [orderAccountingForTips, conduitKey, overrides],
           domain,
         ),
   } as const;
@@ -497,7 +501,7 @@ export function validateAndSanitizeFromOrderStatus(
 ): Order {
   const { isValidated, isCancelled, totalFilled, totalSize } = orderStatus;
 
-  if (totalSize.gt(0) && totalFilled.div(totalSize).eq(1)) {
+  if (totalSize > 0n && totalFilled / totalSize === 1n) {
     throw new Error("The order you are trying to fulfill is already filled");
   }
 
@@ -539,7 +543,7 @@ export function fulfillAvailableOrders({
   domain,
 }: {
   ordersMetadata: FulfillOrdersMetadata;
-  seaportContract: Seaport;
+  seaportContract: SeaportContract;
   fulfillerBalancesAndApprovals: BalancesAndApprovals;
   fulfillerOperator: string;
   currentBlockTimestamp: number;
@@ -580,7 +584,7 @@ export function fulfillAvailableOrders({
     }),
   );
 
-  let totalNativeAmount = BigNumber.from(0);
+  let totalNativeAmount = 0n;
   const totalInsufficientApprovals: InsufficientApprovals = [];
   const criteriaOffersAndConsiderations = sanitizedOrdersMetadata
     .flatMap((orderMetadata) => [
@@ -628,13 +632,13 @@ export function fulfillAvailableOrders({
         isConsiderationItem: true,
       };
 
-      totalNativeAmount = totalNativeAmount.add(
-        getSummedTokenAndIdentifierAmounts({
+      totalNativeAmount =
+        totalNativeAmount +
+        (getSummedTokenAndIdentifierAmounts({
           items: considerationIncludingTips,
           criterias: considerationCriteria,
           timeBasedItemParams,
-        })[ethers.constants.AddressZero]?.["0"] ?? BigNumber.from(0),
-      );
+        })[ethers.ZeroAddress]?.["0"] ?? 0n);
 
       const insufficientApprovals = validateStandardFulfillBalancesAndApprovals(
         {
@@ -671,7 +675,7 @@ export function fulfillAvailableOrders({
     },
   );
 
-  const payableOverrides = { value: totalNativeAmount };
+  const overrides = { value: totalNativeAmount };
 
   const approvalActions = getApprovalActions(
     totalInsufficientApprovals,
@@ -711,7 +715,8 @@ export function fulfillAvailableOrders({
   const exchangeAction = {
     type: "exchange",
     transactionMethods: getTransactionMethods(
-      seaportContract.connect(signer),
+      signer,
+      seaportContract,
       "fulfillAvailableAdvancedOrders",
       [
         advancedOrdersWithTips,
@@ -731,7 +736,7 @@ export function fulfillAvailableOrders({
         conduitKey,
         recipientAddress,
         advancedOrdersWithTips.length,
-        payableOverrides,
+        overrides,
       ],
       domain,
     ),
@@ -839,15 +844,15 @@ export const getAdvancedOrderNumeratorDenominator = (
 ) => {
   // Used for advanced order cases
   const maxUnits = getMaximumSizeForOrder(order);
-  const unitsToFillBn = BigNumber.from(unitsToFill);
 
   // Reduce the numerator/denominator as optimization
-  const unitsGcd = gcd(unitsToFillBn, maxUnits);
-
-  const numerator = unitsToFill
-    ? unitsToFillBn.div(unitsGcd)
-    : BigNumber.from(1);
-  const denominator = unitsToFill ? maxUnits.div(unitsGcd) : BigNumber.from(1);
+  let numerator = 1n;
+  let denominator = 1n;
+  if (unitsToFill) {
+    const unitsGcd = gcd(BigInt(unitsToFill), maxUnits);
+    numerator = BigInt(unitsToFill) / unitsGcd;
+    denominator = maxUnits / unitsGcd;
+  }
 
   return { numerator, denominator };
 };

package/src/utils/gcd.ts

@@ -1,23 +1,23 @@
-import { BigNumber, BigNumberish } from "ethers";
+import { BigNumberish } from "ethers";
 
-export const gcd = (a: BigNumberish, b: BigNumberish): BigNumber => {
-  const bnA = BigNumber.from(a);
-  const bnB = BigNumber.from(b);
+export const gcd = (a: BigNumberish, b: BigNumberish): bigint => {
+  const bnA = BigInt(a);
+  const bnB = BigInt(b);
 
-  if (bnA.eq(0)) {
+  if (bnA === 0n) {
     return bnB;
   }
 
-  return gcd(bnB.mod(a), bnA);
+  return gcd(bnB % bnA, bnA);
 };
 
 export const findGcd = (elements: BigNumberish[]) => {
-  let result = BigNumber.from(elements[0]);
+  let result = BigInt(elements[0]);
 
   for (let i = 1; i < elements.length; i++) {
     result = gcd(elements[i], result);
 
-    if (result.eq(1)) {
+    if (result === 1n) {
       return result;
     }
   }

package/src/utils/item.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "ethers";
 import { ItemType } from "../constants";
 import type { InputCriteria, Item, Order, OrderParameters } from "../types";
 import { getItemToCriteriaMap } from "./criteria";
@@ -36,12 +35,12 @@ export const getPresentItemAmount = ({
   timeBasedItemParams,
 }: Pick<Item, "startAmount" | "endAmount"> & {
   timeBasedItemParams?: TimeBasedItemParams;
-}): BigNumber => {
-  const startAmountBn = BigNumber.from(startAmount);
-  const endAmountBn = BigNumber.from(endAmount);
+}): bigint => {
+  const startAmountBn = BigInt(startAmount);
+  const endAmountBn = BigInt(endAmount);
 
   if (!timeBasedItemParams) {
-    return startAmountBn.gt(endAmountBn) ? startAmountBn : endAmountBn;
+    return startAmountBn > endAmountBn ? startAmountBn : endAmountBn;
   }
 
   const {
@@ -52,34 +51,36 @@ export const getPresentItemAmount = ({
     endTime,
   } = timeBasedItemParams;
 
-  const duration = BigNumber.from(endTime).sub(startTime);
-  const isAscending = endAmountBn.gt(startAmount);
-  const adjustedBlockTimestamp = BigNumber.from(
+  const startTimeBn = BigInt(startTime);
+  const endTimeBn = BigInt(endTime);
+
+  const duration = endTimeBn - startTimeBn;
+  const isAscending = endAmountBn > startAmountBn;
+  const adjustedBlockTimestamp = BigInt(
     isAscending
       ? currentBlockTimestamp + ascendingAmountTimestampBuffer
       : currentBlockTimestamp,
   );
 
-  if (adjustedBlockTimestamp.lt(startTime)) {
+  if (adjustedBlockTimestamp < startTimeBn) {
     return startAmountBn;
   }
 
-  const elapsed = (
-    adjustedBlockTimestamp.gt(endTime)
-      ? BigNumber.from(endTime)
-      : adjustedBlockTimestamp
-  ).sub(startTime);
+  const elapsed =
+    (adjustedBlockTimestamp > endTimeBn ? endTimeBn : adjustedBlockTimestamp) -
+    startTimeBn;
 
-  const remaining = duration.sub(elapsed);
+  const remaining = duration - elapsed;
 
   // Adjust amounts based on current time
   // For offer items, we round down
   // For consideration items, we round up
-  return startAmountBn
-    .mul(remaining)
-    .add(endAmountBn.mul(elapsed))
-    .add(isConsiderationItem ? duration.sub(1) : 0)
-    .div(duration);
+  return (
+    (startAmountBn * remaining +
+      endAmountBn * elapsed +
+      (isConsiderationItem ? duration - 1n : 0n)) /
+    duration
+  );
 };
 
 export const getSummedTokenAndIdentifierAmounts = ({
@@ -94,7 +95,7 @@ export const getSummedTokenAndIdentifierAmounts = ({
   const itemToCriteria = getItemToCriteriaMap(items, criterias);
 
   const tokenAndIdentifierToSummedAmount = items.reduce<
-    Record<string, Record<string, BigNumber>>
+    Record<string, Record<string, bigint>>
   >((map, item) => {
     const identifierOrCriteria =
       itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria;
@@ -104,16 +105,14 @@ export const getSummedTokenAndIdentifierAmounts = ({
       [item.token]: {
         ...map[item.token],
         // Being explicit about the undefined type as it's possible for it to be undefined at first iteration
-        [identifierOrCriteria]: (
-          (map[item.token]?.[identifierOrCriteria] as BigNumber | undefined) ??
-          BigNumber.from(0)
-        ).add(
+        [identifierOrCriteria]:
+          ((map[item.token]?.[identifierOrCriteria] as bigint | undefined) ??
+            0n) +
           getPresentItemAmount({
             startAmount: item.startAmount,
             endAmount: item.endAmount,
             timeBasedItemParams,
           }),
-        ),
       },
     };
   }, {});

package/src/utils/merkletree.ts

@@ -1,14 +1,8 @@
-import { BigNumber } from "ethers";
-import { keccak256 } from "ethers/lib/utils";
+import { keccak256, toBeHex } from "ethers";
 import MerkleTreeJS from "merkletreejs";
 
 const hashIdentifier = (identifier: string) =>
-  keccak256(
-    Buffer.from(
-      BigNumber.from(identifier).toHexString().slice(2).padStart(64, "0"),
-      "hex",
-    ),
-  );
+  keccak256(Buffer.from(toBeHex(identifier).slice(2).padStart(64, "0"), "hex"));
 
 /**
  * Simple wrapper over the MerkleTree in merkletreejs.

package/src/utils/order.ts

@@ -1,5 +1,12 @@
-import { BigNumber, BigNumberish, ethers } from "ethers";
-import { concat, keccak256, randomBytes, toUtf8Bytes } from "ethers/lib/utils";
+import {
+  BigNumberish,
+  ethers,
+  concat,
+  keccak256,
+  randomBytes,
+  toUtf8Bytes,
+  toBeHex,
+} from "ethers";
 import { ItemType, ONE_HUNDRED_PERCENT_BP } from "../constants";
 import type {
   ConsiderationItem,
@@ -14,9 +21,7 @@ import { getMaximumSizeForOrder, isCurrencyItem } from "./item";
 import { MerkleTree } from "./merkletree";
 
 const multiplyBasisPoints = (amount: BigNumberish, basisPoints: BigNumberish) =>
-  BigNumber.from(amount)
-    .mul(BigNumber.from(basisPoints))
-    .div(ONE_HUNDRED_PERCENT_BP);
+  (BigInt(amount) * BigInt(basisPoints)) / ONE_HUNDRED_PERCENT_BP;
 
 export const feeToConsiderationItem = ({
   fee,
@@ -30,8 +35,7 @@ export const feeToConsiderationItem = ({
   baseEndAmount?: BigNumberish;
 }): ConsiderationItem => {
   return {
-    itemType:
-      token === ethers.constants.AddressZero ? ItemType.NATIVE : ItemType.ERC20,
+    itemType: token === ethers.ZeroAddress ? ItemType.NATIVE : ItemType.ERC20,
     token,
     identifierOrCriteria: "0",
     startAmount: multiplyBasisPoints(baseAmount, fee.basisPoints).toString(),
@@ -56,14 +60,16 @@ export const deductFees = <T extends Item>(
   return items.map((item) => ({
     ...item,
     startAmount: isCurrencyItem(item)
-      ? BigNumber.from(item.startAmount)
-          .sub(multiplyBasisPoints(item.startAmount, totalBasisPoints))
-          .toString()
+      ? (
+          BigInt(item.startAmount) -
+          multiplyBasisPoints(item.startAmount, totalBasisPoints)
+        ).toString()
       : item.startAmount,
     endAmount: isCurrencyItem(item)
-      ? BigNumber.from(item.endAmount)
-          .sub(multiplyBasisPoints(item.endAmount, totalBasisPoints))
-          .toString()
+      ? (
+          BigInt(item.endAmount) -
+          multiplyBasisPoints(item.endAmount, totalBasisPoints)
+        ).toString()
       : item.endAmount,
   }));
 };
@@ -114,10 +120,10 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
   // Item is a currency
   return {
     itemType:
-      item.token && item.token !== ethers.constants.AddressZero
+      item.token && item.token !== ethers.ZeroAddress
         ? ItemType.ERC20
         : ItemType.NATIVE,
-    token: item.token ?? ethers.constants.AddressZero,
+    token: item.token ?? ethers.ZeroAddress,
     identifierOrCriteria: "0",
     startAmount: item.amount,
     endAmount: item.endAmount ?? item.amount,
@@ -140,8 +146,8 @@ export const areAllCurrenciesSame = ({
 
 export const totalItemsAmount = <T extends OfferItem>(items: T[]) => {
   const initialValues = {
-    startAmount: BigNumber.from(0),
-    endAmount: BigNumber.from(0),
+    startAmount: 0n,
+    endAmount: 0n,
   };
 
   return items
@@ -154,12 +160,12 @@ export const totalItemsAmount = <T extends OfferItem>(items: T[]) => {
         { startAmount: totalStartAmount, endAmount: totalEndAmount },
         { startAmount, endAmount },
       ) => ({
-        startAmount: totalStartAmount.add(startAmount),
-        endAmount: totalEndAmount.add(endAmount),
+        startAmount: totalStartAmount + BigInt(startAmount),
+        endAmount: totalEndAmount + BigInt(endAmount),
       }),
       {
-        startAmount: BigNumber.from(0),
-        endAmount: BigNumber.from(0),
+        startAmount: 0n,
+        endAmount: 0n,
       },
     );
 };
@@ -171,17 +177,15 @@ export const totalItemsAmount = <T extends OfferItem>(items: T[]) => {
  */
 export const mapOrderAmountsFromFilledStatus = (
   order: Order,
-  { totalFilled, totalSize }: { totalFilled: BigNumber; totalSize: BigNumber },
+  { totalFilled, totalSize }: { totalFilled: bigint; totalSize: bigint },
 ): Order => {
-  if (totalFilled.eq(0) || totalSize.eq(0)) {
+  if (totalFilled === 0n || totalSize === 0n) {
     return order;
   }
 
   // i.e if totalFilled is 3 and totalSize is 4, there are 1 / 4 order amounts left to fill.
-  const basisPoints = totalSize
-    .sub(totalFilled)
-    .mul(ONE_HUNDRED_PERCENT_BP)
-    .div(totalSize);
+  const basisPoints =
+    totalSize - (totalFilled * ONE_HUNDRED_PERCENT_BP) / totalSize;
 
   return {
     parameters: {
@@ -211,7 +215,7 @@ const multiplyDivision = (
   amount: BigNumberish,
   numerator: BigNumberish,
   denominator: BigNumberish,
-) => BigNumber.from(amount).mul(BigNumber.from(numerator)).div(denominator);
+) => (BigInt(amount) * BigInt(numerator)) / BigInt(denominator);
 
 /**
  * Maps order offer and consideration item amounts based on the units needed to fulfill
@@ -221,20 +225,17 @@ const multiplyDivision = (
  */
 export const mapOrderAmountsFromUnitsToFill = (
   order: Order,
-  {
-    unitsToFill,
-    totalSize,
-  }: { unitsToFill: BigNumberish; totalSize: BigNumber },
+  { unitsToFill, totalSize }: { unitsToFill: BigNumberish; totalSize: bigint },
 ): Order => {
-  const unitsToFillBn = BigNumber.from(unitsToFill);
+  const unitsToFillBn = BigInt(unitsToFill);
 
-  if (unitsToFillBn.lte(0)) {
+  if (unitsToFillBn <= 0n) {
     throw new Error("Units to fill must be greater than 1");
   }
 
   const maxUnits = getMaximumSizeForOrder(order);
 
-  if (totalSize.eq(0)) {
+  if (totalSize === 0n) {
     totalSize = maxUnits;
   }
 
@@ -274,13 +275,13 @@ export const mapOrderAmountsFromUnitsToFill = (
 
 export const generateRandomSalt = (domain?: string) => {
   if (domain) {
-    return `0x${Buffer.from(
+    return toBeHex(
       concat([
         keccak256(toUtf8Bytes(domain)).slice(0, 10),
         Uint8Array.from(Array(20).fill(0)),
         randomBytes(8),
       ]),
-    ).toString("hex")}`;
+    );
   }
   return `0x${Buffer.from(randomBytes(8)).toString("hex").padStart(64, "0")}`;
 };