@opensea/seaport-js 4.0.6 → 4.1.0

package/src/utils/gcd.ts

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

package/src/utils/item.ts

@@ -1,46 +1,46 @@
-import { ItemType } from "../constants";
-import type { InputCriteria, Item, Order, OrderParameters } from "../types";
-import { getItemToCriteriaMap } from "./criteria";
-import { findGcd } from "./gcd";
+import { ItemType } from "../constants"
+import type { InputCriteria, Item, Order, OrderParameters } from "../types"
+import { getItemToCriteriaMap } from "./criteria"
+import { findGcd } from "./gcd"
 
 export const isCurrencyItem = ({ itemType }: Item) =>
-  [ItemType.NATIVE, ItemType.ERC20].includes(itemType);
+  [ItemType.NATIVE, ItemType.ERC20].includes(itemType)
 
 export const isNativeCurrencyItem = ({ itemType }: Item) =>
-  itemType === ItemType.NATIVE;
+  itemType === ItemType.NATIVE
 
 export const isErc20Item = (itemType: Item["itemType"]) =>
-  itemType === ItemType.ERC20;
+  itemType === ItemType.ERC20
 
 export const isErc721Item = (itemType: Item["itemType"]) =>
-  [ItemType.ERC721, ItemType.ERC721_WITH_CRITERIA].includes(itemType);
+  [ItemType.ERC721, ItemType.ERC721_WITH_CRITERIA].includes(itemType)
 
 export const isErc1155Item = (itemType: Item["itemType"]) =>
-  [ItemType.ERC1155, ItemType.ERC1155_WITH_CRITERIA].includes(itemType);
+  [ItemType.ERC1155, ItemType.ERC1155_WITH_CRITERIA].includes(itemType)
 
 export const isCriteriaItem = (itemType: Item["itemType"]) =>
   [ItemType.ERC721_WITH_CRITERIA, ItemType.ERC1155_WITH_CRITERIA].includes(
     itemType,
-  );
+  )
 
 export type TimeBasedItemParams = {
-  isConsiderationItem?: boolean;
-  currentBlockTimestamp: number;
-  ascendingAmountTimestampBuffer: number;
-} & Pick<OrderParameters, "startTime" | "endTime">;
+  isConsiderationItem?: boolean
+  currentBlockTimestamp: number
+  ascendingAmountTimestampBuffer: number
+} & Pick<OrderParameters, "startTime" | "endTime">
 
 export const getPresentItemAmount = ({
   startAmount,
   endAmount,
   timeBasedItemParams,
 }: Pick<Item, "startAmount" | "endAmount"> & {
-  timeBasedItemParams?: TimeBasedItemParams;
+  timeBasedItemParams?: TimeBasedItemParams
 }): bigint => {
-  const startAmountBn = BigInt(startAmount);
-  const endAmountBn = BigInt(endAmount);
+  const startAmountBn = BigInt(startAmount)
+  const endAmountBn = BigInt(endAmount)
 
   if (!timeBasedItemParams) {
-    return startAmountBn > endAmountBn ? startAmountBn : endAmountBn;
+    return startAmountBn > endAmountBn ? startAmountBn : endAmountBn
   }
 
   const {
@@ -49,28 +49,28 @@ export const getPresentItemAmount = ({
     ascendingAmountTimestampBuffer,
     startTime,
     endTime,
-  } = timeBasedItemParams;
+  } = timeBasedItemParams
 
-  const startTimeBn = BigInt(startTime);
-  const endTimeBn = BigInt(endTime);
+  const startTimeBn = BigInt(startTime)
+  const endTimeBn = BigInt(endTime)
 
-  const duration = endTimeBn - startTimeBn;
-  const isAscending = endAmountBn > startAmountBn;
+  const duration = endTimeBn - startTimeBn
+  const isAscending = endAmountBn > startAmountBn
   const adjustedBlockTimestamp = BigInt(
     isAscending
       ? currentBlockTimestamp + ascendingAmountTimestampBuffer
       : currentBlockTimestamp,
-  );
+  )
 
   if (adjustedBlockTimestamp < startTimeBn) {
-    return startAmountBn;
+    return startAmountBn
   }
 
   const elapsed =
     (adjustedBlockTimestamp > endTimeBn ? endTimeBn : adjustedBlockTimestamp) -
-    startTimeBn;
+    startTimeBn
 
-  const remaining = duration - elapsed;
+  const remaining = duration - elapsed
 
   // Adjust amounts based on current time
   // For offer items, we round down
@@ -80,25 +80,25 @@ export const getPresentItemAmount = ({
       endAmountBn * elapsed +
       (isConsiderationItem ? duration - 1n : 0n)) /
     duration
-  );
-};
+  )
+}
 
 export const getSummedTokenAndIdentifierAmounts = ({
   items,
   criterias,
   timeBasedItemParams,
 }: {
-  items: Item[];
-  criterias: InputCriteria[];
-  timeBasedItemParams?: TimeBasedItemParams;
+  items: Item[]
+  criterias: InputCriteria[]
+  timeBasedItemParams?: TimeBasedItemParams
 }) => {
-  const itemToCriteria = getItemToCriteriaMap(items, criterias);
+  const itemToCriteria = getItemToCriteriaMap(items, criterias)
 
   const tokenAndIdentifierToSummedAmount = items.reduce<
     Record<string, Record<string, bigint>>
   >((map, item) => {
     const identifierOrCriteria =
-      itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria;
+      itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria
 
     return {
       ...map,
@@ -114,11 +114,11 @@ export const getSummedTokenAndIdentifierAmounts = ({
             timeBasedItemParams,
           }),
       },
-    };
-  }, {});
+    }
+  }, {})
 
-  return tokenAndIdentifierToSummedAmount;
-};
+  return tokenAndIdentifierToSummedAmount
+}
 
 /**
  * Returns the maximum size of units possible for the order
@@ -130,12 +130,12 @@ export const getSummedTokenAndIdentifierAmounts = ({
 export const getMaximumSizeForOrder = ({
   parameters: { offer, consideration },
 }: Order) => {
-  const allItems = [...offer, ...consideration];
+  const allItems = [...offer, ...consideration]
 
   const amounts = allItems.flatMap(({ startAmount, endAmount }) => [
     startAmount,
     endAmount,
-  ]);
+  ])
 
-  return findGcd(amounts);
-};
+  return findGcd(amounts)
+}

package/src/utils/match.ts

@@ -52,4 +52,4 @@ The algorithm (broad-strokes first pass)
 9. Ensure that all consideration items have been met!
   */
 
-export {};
+export {}

package/src/utils/merkletree.ts

@@ -1,27 +1,27 @@
-import { keccak256, toBeHex } from "ethers";
-import MerkleTreeJS from "merkletreejs";
+import { keccak256, toBeHex } from "ethers"
+import { MerkleTree as MerkleTreeJS } from "merkletreejs"
 
 const hashIdentifier = (identifier: string) =>
-  keccak256(Buffer.from(toBeHex(identifier).slice(2).padStart(64, "0"), "hex"));
+  keccak256(Buffer.from(toBeHex(identifier).slice(2).padStart(64, "0"), "hex"))
 
 /**
  * Simple wrapper over the MerkleTree in merkletreejs.
  * Handles hashing identifiers to be compatible with Seaport.
  */
 export class MerkleTree {
-  tree: MerkleTreeJS;
+  tree: MerkleTreeJS
 
   constructor(identifiers: string[]) {
     this.tree = new MerkleTreeJS(identifiers.map(hashIdentifier), keccak256, {
       sort: true,
-    });
+    })
   }
 
   getProof(identifier: string): string[] {
-    return this.tree.getHexProof(hashIdentifier(identifier));
+    return this.tree.getHexProof(hashIdentifier(identifier))
   }
 
   getRoot() {
-    return this.tree.getRoot().toString("hex") ? this.tree.getHexRoot() : "0";
+    return this.tree.getRoot().toString("hex") ? this.tree.getHexRoot() : "0"
   }
 }

package/src/utils/order.ts

@@ -1,13 +1,13 @@
 import {
-  BigNumberish,
-  ethers,
+  type BigNumberish,
   concat,
+  ethers,
   keccak256,
   randomBytes,
-  toUtf8Bytes,
   toBeHex,
-} from "ethers";
-import { ItemType, ONE_HUNDRED_PERCENT_BP } from "../constants";
+  toUtf8Bytes,
+} from "ethers"
+import { ItemType, ONE_HUNDRED_PERCENT_BP } from "../constants"
 import type {
   ConsiderationItem,
   CreateInputItem,
@@ -16,12 +16,12 @@ import type {
   OfferItem,
   Order,
   OrderParameters,
-} from "../types";
-import { getMaximumSizeForOrder, isCurrencyItem } from "./item";
-import { MerkleTree } from "./merkletree";
+} from "../types"
+import { getMaximumSizeForOrder, isCurrencyItem } from "./item"
+import { MerkleTree } from "./merkletree"
 
 const multiplyBasisPoints = (amount: BigNumberish, basisPoints: BigNumberish) =>
-  (BigInt(amount) * BigInt(basisPoints)) / ONE_HUNDRED_PERCENT_BP;
+  (BigInt(amount) * BigInt(basisPoints)) / ONE_HUNDRED_PERCENT_BP
 
 export const feeToConsiderationItem = ({
   fee,
@@ -29,10 +29,10 @@ export const feeToConsiderationItem = ({
   baseAmount,
   baseEndAmount = baseAmount,
 }: {
-  fee: Fee;
-  token: string;
-  baseAmount: BigNumberish;
-  baseEndAmount?: BigNumberish;
+  fee: Fee
+  token: string
+  baseAmount: BigNumberish
+  baseEndAmount?: BigNumberish
 }): ConsiderationItem => {
   return {
     itemType: token === ethers.ZeroAddress ? ItemType.NATIVE : ItemType.ERC20,
@@ -41,23 +41,23 @@ export const feeToConsiderationItem = ({
     startAmount: multiplyBasisPoints(baseAmount, fee.basisPoints).toString(),
     endAmount: multiplyBasisPoints(baseEndAmount, fee.basisPoints).toString(),
     recipient: fee.recipient,
-  };
-};
+  }
+}
 
 export const deductFees = <T extends Item>(
   items: T[],
   fees?: readonly Fee[],
 ): T[] => {
   if (!fees) {
-    return items;
+    return items
   }
 
   const totalBasisPoints = fees.reduce(
     (accBasisPoints, fee) => accBasisPoints + fee.basisPoints,
     0,
-  );
+  )
 
-  return items.map((item) => ({
+  return items.map(item => ({
     ...item,
     startAmount: isCurrencyItem(item)
       ? (
@@ -71,8 +71,8 @@ export const deductFees = <T extends Item>(
           multiplyBasisPoints(item.endAmount, totalBasisPoints)
         ).toString()
       : item.endAmount,
-  }));
-};
+  }))
+}
 
 export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
   if ("itemType" in item) {
@@ -81,7 +81,7 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
       const root =
         "criteria" in item
           ? item.criteria
-          : new MerkleTree(item.identifiers).getRoot();
+          : new MerkleTree(item.identifiers).getRoot()
 
       return {
         itemType:
@@ -92,7 +92,7 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
         identifierOrCriteria: root,
         startAmount: item.amount ?? "1",
         endAmount: item.endAmount ?? item.amount ?? "1",
-      };
+      }
     }
 
     if ("amount" in item || "endAmount" in item) {
@@ -101,11 +101,11 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
         token: item.token,
         // prevent undefined for fungible items
         identifierOrCriteria: item.identifier ?? "0",
-        // @ts-ignore
+        // @ts-expect-error - amount exists on fungible items
         startAmount: item.amount,
-        // @ts-ignore
+        // @ts-expect-error - amount/endAmount exists on fungible items
         endAmount: item.endAmount ?? item.amount ?? "1",
-      };
+      }
     }
 
     return {
@@ -114,7 +114,7 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
       identifierOrCriteria: item.identifier,
       startAmount: "1",
       endAmount: "1",
-    };
+    }
   }
 
   // Item is a currency
@@ -127,35 +127,30 @@ export const mapInputItemToOfferItem = (item: CreateInputItem): OfferItem => {
     identifierOrCriteria: "0",
     startAmount: item.amount,
     endAmount: item.endAmount ?? item.amount,
-  };
-};
+  }
+}
 
 export const areAllCurrenciesSame = ({
   offer,
   consideration,
 }: Pick<OrderParameters, "offer" | "consideration">) => {
-  const allItems = [...offer, ...consideration];
-  const currencies = allItems.filter(isCurrencyItem);
+  const allItems = [...offer, ...consideration]
+  const currencies = allItems.filter(isCurrencyItem)
 
   return currencies.every(
     ({ itemType, token }) =>
       itemType === currencies[0].itemType &&
       token.toLowerCase() === currencies[0].token.toLowerCase(),
-  );
-};
+  )
+}
 
 export const totalItemsAmount = <T extends OfferItem>(items: T[]) => {
-  const initialValues = {
-    startAmount: 0n,
-    endAmount: 0n,
-  };
-
   return items
     .map(({ startAmount, endAmount }) => ({
       startAmount,
       endAmount,
     }))
-    .reduce<typeof initialValues>(
+    .reduce<{ startAmount: bigint; endAmount: bigint }>(
       (
         { startAmount: totalStartAmount, endAmount: totalEndAmount },
         { startAmount, endAmount },
@@ -167,8 +162,8 @@ export const totalItemsAmount = <T extends OfferItem>(items: T[]) => {
         startAmount: 0n,
         endAmount: 0n,
       },
-    );
-};
+    )
+}
 
 /**
  * Maps order offer and consideration item amounts based on the order's filled status
@@ -180,17 +175,17 @@ export const mapOrderAmountsFromFilledStatus = (
   { totalFilled, totalSize }: { totalFilled: bigint; totalSize: bigint },
 ): Order => {
   if (totalFilled === 0n || totalSize === 0n) {
-    return order;
+    return order
   }
 
   // i.e if totalFilled is 3 and totalSize is 4, there are 1 / 4 order amounts left to fill.
   const basisPoints =
-    ((totalSize - totalFilled) * ONE_HUNDRED_PERCENT_BP) / totalSize;
+    ((totalSize - totalFilled) * ONE_HUNDRED_PERCENT_BP) / totalSize
 
   return {
     parameters: {
       ...order.parameters,
-      offer: order.parameters.offer.map((item) => ({
+      offer: order.parameters.offer.map(item => ({
         ...item,
         startAmount: multiplyBasisPoints(
           item.startAmount,
@@ -198,7 +193,7 @@ export const mapOrderAmountsFromFilledStatus = (
         ).toString(),
         endAmount: multiplyBasisPoints(item.endAmount, basisPoints).toString(),
       })),
-      consideration: order.parameters.consideration.map((item) => ({
+      consideration: order.parameters.consideration.map(item => ({
         ...item,
         startAmount: multiplyBasisPoints(
           item.startAmount,
@@ -208,14 +203,14 @@ export const mapOrderAmountsFromFilledStatus = (
       })),
     },
     signature: order.signature,
-  };
-};
+  }
+}
 
 const multiplyDivision = (
   amount: BigNumberish,
   numerator: BigNumberish,
   denominator: BigNumberish,
-) => (BigInt(amount) * BigInt(numerator)) / BigInt(denominator);
+) => (BigInt(amount) * BigInt(numerator)) / BigInt(denominator)
 
 /**
  * Maps order offer and consideration item amounts based on the units needed to fulfill
@@ -227,22 +222,22 @@ export const mapOrderAmountsFromUnitsToFill = (
   order: Order,
   { unitsToFill, totalSize }: { unitsToFill: BigNumberish; totalSize: bigint },
 ): Order => {
-  const unitsToFillBn = BigInt(unitsToFill);
+  const unitsToFillBn = BigInt(unitsToFill)
 
   if (unitsToFillBn <= 0n) {
-    throw new Error("Units to fill must be greater than 1");
+    throw new Error("Units to fill must be greater than 0")
   }
 
-  const maxUnits = getMaximumSizeForOrder(order);
+  const maxUnits = getMaximumSizeForOrder(order)
 
   if (totalSize === 0n) {
-    totalSize = maxUnits;
+    totalSize = maxUnits
   }
 
   return {
     parameters: {
       ...order.parameters,
-      offer: order.parameters.offer.map((item) => ({
+      offer: order.parameters.offer.map(item => ({
         ...item,
         startAmount: multiplyDivision(
           item.startAmount,
@@ -255,7 +250,7 @@ export const mapOrderAmountsFromUnitsToFill = (
           totalSize,
         ).toString(),
       })),
-      consideration: order.parameters.consideration.map((item) => ({
+      consideration: order.parameters.consideration.map(item => ({
         ...item,
         startAmount: multiplyDivision(
           item.startAmount,
@@ -270,21 +265,21 @@ export const mapOrderAmountsFromUnitsToFill = (
       })),
     },
     signature: order.signature,
-  };
-};
+  }
+}
 
 export function mapTipAmountsFromUnitsToFill(
   tips: ConsiderationItem[],
   unitsToFill: BigNumberish,
   totalSize: bigint,
 ): ConsiderationItem[] {
-  const unitsToFillBn = BigInt(unitsToFill);
+  const unitsToFillBn = BigInt(unitsToFill)
 
   if (unitsToFillBn <= 0n) {
-    throw new Error("Units to fill must be greater than 0");
+    throw new Error("Units to fill must be greater than 0")
   }
 
-  return tips.map((tip) => ({
+  return tips.map(tip => ({
     ...tip,
     startAmount: multiplyDivision(
       tip.startAmount,
@@ -296,7 +291,7 @@ export function mapTipAmountsFromUnitsToFill(
       unitsToFillBn,
       totalSize,
     ).toString(),
-  }));
+  }))
 }
 
 export function mapTipAmountsFromFilledStatus(
@@ -305,18 +300,18 @@ export function mapTipAmountsFromFilledStatus(
   totalSize: bigint,
 ): ConsiderationItem[] {
   if (totalFilled === 0n || totalSize === 0n) {
-    return tips;
+    return tips
   }
 
   // i.e if totalFilled is 3 and totalSize is 4, there are 1 / 4 order amounts left to fill.
   const basisPoints =
-    ((totalSize - totalFilled) * ONE_HUNDRED_PERCENT_BP) / totalSize;
+    ((totalSize - totalFilled) * ONE_HUNDRED_PERCENT_BP) / totalSize
 
-  return tips.map((tip) => ({
+  return tips.map(tip => ({
     ...tip,
     startAmount: multiplyBasisPoints(tip.startAmount, basisPoints).toString(),
     endAmount: multiplyBasisPoints(tip.endAmount, basisPoints).toString(),
-  }));
+  }))
 }
 
 export const generateRandomSalt = (domain?: string) => {
@@ -327,9 +322,9 @@ export const generateRandomSalt = (domain?: string) => {
         Uint8Array.from(Array(20).fill(0)),
         randomBytes(8),
       ]),
-    );
+    )
   }
-  return `0x${Buffer.from(randomBytes(8)).toString("hex").padStart(64, "0")}`;
-};
+  return `0x${Buffer.from(randomBytes(8)).toString("hex").padStart(64, "0")}`
+}
 
-export const shouldUseMatchForFulfill = () => true;
+export const shouldUseMatchForFulfill = () => true