@opensea/seaport-js 4.0.7 → 4.1.0

package/src/utils/fulfill.ts

@@ -1,18 +1,17 @@
 import {
-  BigNumberish,
-  ContractTransaction,
+  type BigNumberish,
+  type ContractTransaction,
   ethers,
-  Overrides,
-  Signer,
-} from "ethers";
+  type Overrides,
+  type Signer,
+} from "ethers"
+import { BasicOrderRouteType, ItemType, NO_CONDUIT } from "../constants"
 import type {
   BasicOrderParametersStruct,
   FulfillmentComponentStruct,
   OrderStruct,
-} from "../typechain-types/seaport/contracts/Seaport";
-import { BasicOrderRouteType, ItemType, NO_CONDUIT } from "../constants";
+} from "../typechain-types/seaport/contracts/Seaport"
 import type {
-  SeaportContract,
   AdvancedOrder,
   ConsiderationItem,
   ExchangeAction,
@@ -22,16 +21,17 @@ import type {
   OrderStatus,
   OrderUseCase,
   OrderWithCounter,
-} from "../types";
-import { getApprovalActions } from "./approval";
+  SeaportContract,
+} from "../types"
+import { getApprovalActions } from "./approval"
 import {
-  BalancesAndApprovals,
-  InsufficientApprovals,
+  type BalancesAndApprovals,
+  type InsufficientApprovals,
   validateBasicFulfillBalancesAndApprovals,
   validateStandardFulfillBalancesAndApprovals,
-} from "./balanceAndApprovalCheck";
-import { generateCriteriaResolvers, getItemToCriteriaMap } from "./criteria";
-import { gcd } from "./gcd";
+} from "./balanceAndApprovalCheck"
+import { generateCriteriaResolvers, getItemToCriteriaMap } from "./criteria"
+import { gcd } from "./gcd"
 import {
   getMaximumSizeForOrder,
   getSummedTokenAndIdentifierAmounts,
@@ -39,8 +39,8 @@ import {
   isCurrencyItem,
   isErc721Item,
   isNativeCurrencyItem,
-  TimeBasedItemParams,
-} from "./item";
+  type TimeBasedItemParams,
+} from "./item"
 import {
   areAllCurrenciesSame,
   mapOrderAmountsFromFilledStatus,
@@ -48,12 +48,12 @@ import {
   mapTipAmountsFromFilledStatus,
   mapTipAmountsFromUnitsToFill,
   totalItemsAmount,
-} from "./order";
+} from "./order"
 import {
-  ContractMethodReturnType,
+  type ContractMethodReturnType,
   executeAllActions,
   getTransactionMethods,
-} from "./usecase";
+} from "./usecase"
 
 /**
  * We should use basic fulfill order if the order adheres to the following criteria:
@@ -77,58 +77,58 @@ export const shouldUseBasicFulfill = (
 ) => {
   // 1. The order must not be partially filled
   if (totalFilled !== 0n) {
-    return false;
+    return false
   }
 
   // 2. Must be single offer and at least one consideration
   if (offer.length > 1 || consideration.length === 0) {
-    return false;
+    return false
   }
 
-  const allItems = [...offer, ...consideration];
+  const allItems = [...offer, ...consideration]
 
   const nfts = allItems.filter(({ itemType }) =>
     [ItemType.ERC721, ItemType.ERC1155].includes(itemType),
-  );
+  )
 
   const nftsWithCriteria = allItems.filter(({ itemType }) =>
     isCriteriaItem(itemType),
-  );
+  )
 
-  const offersNativeCurrency = isNativeCurrencyItem(offer[0]);
+  const offersNativeCurrency = isNativeCurrencyItem(offer[0])
 
   // 3. The order does not offer an item with Ether (or other native tokens) as its item type.
   if (offersNativeCurrency) {
-    return false;
+    return false
   }
 
   // 4. The order only contains a single ERC721 or ERC1155 item and that item is not criteria-based
   if (nfts.length !== 1 || nftsWithCriteria.length !== 0) {
-    return false;
+    return false
   }
 
   // 5. All currencies need to have the same address and item type (Native, ERC20)
   if (!areAllCurrenciesSame({ offer, consideration })) {
-    return false;
+    return false
   }
 
   // 6. All individual items need to have the same startAmount and endAmount
   const differentStartAndEndAmount = allItems.some(
     ({ startAmount, endAmount }) => startAmount !== endAmount,
-  );
+  )
 
   if (differentStartAndEndAmount) {
-    return false;
+    return false
   }
 
-  const [firstConsideration, ...restConsideration] = consideration;
+  const [firstConsideration, ...restConsideration] = consideration
 
   // 7. First consideration item must contain the offerer as the recipient
   const firstConsiderationRecipientIsNotOfferer =
-    firstConsideration.recipient.toLowerCase() !== offerer.toLowerCase();
+    firstConsideration.recipient.toLowerCase() !== offerer.toLowerCase()
 
   if (firstConsiderationRecipientIsNotOfferer) {
-    return false;
+    return false
   }
 
   // 8. If the order has multiple consideration items and all consideration items other than the
@@ -137,37 +137,37 @@ export const shouldUseBasicFulfill = (
   // first consideration item amount
   if (
     consideration.length > 1 &&
-    restConsideration.every((item) => item.itemType === offer[0].itemType) &&
+    restConsideration.every(item => item.itemType === offer[0].itemType) &&
     totalItemsAmount(restConsideration).endAmount > BigInt(offer[0].endAmount)
   ) {
-    return false;
+    return false
   }
 
-  const currencies = allItems.filter(isCurrencyItem);
+  const currencies = allItems.filter(isCurrencyItem)
 
   //  9. The token on native currency items needs to be set to the null address and the identifier on
   //  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.ZeroAddress);
+    .every(({ token }) => token === ethers.ZeroAddress)
 
   const currencyIdentifiersAreZero = currencies.every(
     ({ identifierOrCriteria }) => BigInt(identifierOrCriteria) === 0n,
-  );
+  )
 
   const erc721sAreSingleAmount = nfts
     .filter(({ itemType }) => itemType === ItemType.ERC721)
-    .every(({ endAmount }) => endAmount === "1");
+    .every(({ endAmount }) => endAmount === "1")
 
   return (
     nativeCurrencyIsZeroAddress &&
     currencyIdentifiersAreZero &&
     erc721sAreSingleAmount
-  );
-};
+  )
+}
 
 const offerAndConsiderationFulfillmentMapping: {
-  [_key in ItemType]?: { [_key in ItemType]?: BasicOrderRouteType };
+  [_key in ItemType]?: { [_key in ItemType]?: BasicOrderRouteType }
 } = {
   [ItemType.ERC20]: {
     [ItemType.ERC721]: BasicOrderRouteType.ERC721_TO_ERC20,
@@ -181,7 +181,7 @@ const offerAndConsiderationFulfillmentMapping: {
     [ItemType.NATIVE]: BasicOrderRouteType.ETH_TO_ERC1155,
     [ItemType.ERC20]: BasicOrderRouteType.ERC20_TO_ERC1155,
   },
-} as const;
+} as const
 
 export function fulfillBasicOrder(
   {
@@ -198,38 +198,38 @@ export function fulfillBasicOrder(
     domain,
     overrides,
   }: {
-    order: Order;
-    seaportContract: SeaportContract;
-    offererBalancesAndApprovals: BalancesAndApprovals;
-    fulfillerBalancesAndApprovals: BalancesAndApprovals;
-    timeBasedItemParams: TimeBasedItemParams;
-    offererOperator: string;
-    fulfillerOperator: string;
-    signer: Signer;
-    tips?: ConsiderationItem[];
-    conduitKey: string;
-    domain?: string;
-    overrides?: Overrides;
+    order: Order
+    seaportContract: SeaportContract
+    offererBalancesAndApprovals: BalancesAndApprovals
+    fulfillerBalancesAndApprovals: BalancesAndApprovals
+    timeBasedItemParams: TimeBasedItemParams
+    offererOperator: string
+    fulfillerOperator: string
+    signer: Signer
+    tips?: ConsiderationItem[]
+    conduitKey: string
+    domain?: string
+    overrides?: Overrides
   },
   exactApproval: boolean,
 ): OrderUseCase<
   ExchangeAction<ContractMethodReturnType<SeaportContract, "fulfillBasicOrder">>
 > {
-  const { offer, consideration } = order.parameters;
-  const considerationIncludingTips = [...consideration, ...tips];
+  const { offer, consideration } = order.parameters
+  const considerationIncludingTips = [...consideration, ...tips]
 
-  const offerItem = offer[0];
-  const [forOfferer, ...forAdditionalRecipients] = considerationIncludingTips;
+  const offerItem = offer[0]
+  const [forOfferer, ...forAdditionalRecipients] = considerationIncludingTips
 
   const basicOrderRouteType =
     offerAndConsiderationFulfillmentMapping[offerItem.itemType]?.[
       forOfferer.itemType
-    ];
+    ]
 
   if (basicOrderRouteType === undefined) {
     throw new Error(
       "Order parameters did not result in a valid basic fulfillment",
-    );
+    )
   }
 
   const additionalRecipients = forAdditionalRecipients.map(
@@ -237,11 +237,11 @@ export function fulfillBasicOrder(
       amount: startAmount,
       recipient,
     }),
-  );
+  )
 
   const considerationWithoutOfferItemType = considerationIncludingTips.filter(
-    (item) => item.itemType !== offer[0].itemType,
-  );
+    item => item.itemType !== offer[0].itemType,
+  )
 
   const totalNativeAmount = getSummedTokenAndIdentifierAmounts({
     items: considerationWithoutOfferItemType,
@@ -250,7 +250,7 @@ export function fulfillBasicOrder(
       ...timeBasedItemParams,
       isConsiderationItem: true,
     },
-  })[ethers.ZeroAddress]?.["0"];
+  })[ethers.ZeroAddress]?.["0"]
 
   const insufficientApprovals = validateBasicFulfillBalancesAndApprovals({
     offer,
@@ -260,7 +260,7 @@ export function fulfillBasicOrder(
     timeBasedItemParams,
     offererOperator,
     fulfillerOperator,
-  });
+  })
 
   const basicOrderParameters: BasicOrderParametersStruct = {
     offerer: order.parameters.offerer,
@@ -286,15 +286,15 @@ export function fulfillBasicOrder(
     fulfillerConduitKey: conduitKey,
     additionalRecipients,
     zoneHash: order.parameters.zoneHash,
-  };
+  }
 
-  overrides = { ...overrides, value: totalNativeAmount };
+  overrides = { ...overrides, value: totalNativeAmount }
 
   const approvalActions = getApprovalActions(
     insufficientApprovals,
     exactApproval,
     signer,
-  );
+  )
 
   const exchangeAction = {
     type: "exchange",
@@ -305,15 +305,15 @@ export function fulfillBasicOrder(
       [basicOrderParameters, overrides],
       domain,
     ),
-  } as const;
+  } as const
 
-  const actions = [...approvalActions, exchangeAction] as const;
+  const actions = [...approvalActions, exchangeAction] as const
 
   return {
     actions,
     executeAllActions: () =>
       executeAllActions(actions) as Promise<ContractTransaction>,
-  };
+  }
 }
 
 export function fulfillStandardOrder(
@@ -338,25 +338,25 @@ export function fulfillStandardOrder(
     domain,
     overrides,
   }: {
-    order: Order;
-    unitsToFill?: BigNumberish;
-    totalFilled: bigint;
-    totalSize: bigint;
-    offerCriteria: InputCriteria[];
-    considerationCriteria: InputCriteria[];
-    tips?: ConsiderationItem[];
-    extraData?: string;
-    seaportContract: SeaportContract;
-    offererBalancesAndApprovals: BalancesAndApprovals;
-    fulfillerBalancesAndApprovals: BalancesAndApprovals;
-    offererOperator: string;
-    fulfillerOperator: string;
-    conduitKey: string;
-    recipientAddress: string;
-    timeBasedItemParams: TimeBasedItemParams;
-    signer: Signer;
-    domain?: string;
-    overrides?: Overrides;
+    order: Order
+    unitsToFill?: BigNumberish
+    totalFilled: bigint
+    totalSize: bigint
+    offerCriteria: InputCriteria[]
+    considerationCriteria: InputCriteria[]
+    tips?: ConsiderationItem[]
+    extraData?: string
+    seaportContract: SeaportContract
+    offererBalancesAndApprovals: BalancesAndApprovals
+    fulfillerBalancesAndApprovals: BalancesAndApprovals
+    offererOperator: string
+    fulfillerOperator: string
+    conduitKey: string
+    recipientAddress: string
+    timeBasedItemParams: TimeBasedItemParams
+    signer: Signer
+    domain?: string
+    overrides?: Overrides
   },
   exactApproval: boolean,
 ): OrderUseCase<
@@ -378,32 +378,32 @@ export function fulfillStandardOrder(
       mapOrderAmountsFromFilledStatus(order, {
         totalFilled,
         totalSize,
-      });
+      })
 
-  let adjustedTips: ConsiderationItem[] = [];
+  let adjustedTips: ConsiderationItem[] = []
 
   if (tips.length > 0) {
     adjustedTips = unitsToFill
       ? mapTipAmountsFromUnitsToFill(tips, unitsToFill, totalSize)
-      : mapTipAmountsFromFilledStatus(tips, totalFilled, totalSize);
+      : mapTipAmountsFromFilledStatus(tips, totalFilled, totalSize)
   }
 
   const {
     parameters: { offer, consideration },
-  } = orderWithAdjustedFills;
+  } = orderWithAdjustedFills
 
-  const considerationIncludingTips = [...consideration, ...adjustedTips];
+  const considerationIncludingTips = [...consideration, ...adjustedTips]
 
   const offerCriteriaItems = offer.filter(({ itemType }) =>
     isCriteriaItem(itemType),
-  );
+  )
 
   const considerationCriteriaItems = considerationIncludingTips.filter(
     ({ itemType }) => isCriteriaItem(itemType),
-  );
+  )
 
   const hasCriteriaItems =
-    offerCriteriaItems.length > 0 || considerationCriteriaItems.length > 0;
+    offerCriteriaItems.length > 0 || considerationCriteriaItems.length > 0
 
   if (
     offerCriteriaItems.length !== offerCriteria.length ||
@@ -411,7 +411,7 @@ export function fulfillStandardOrder(
   ) {
     throw new Error(
       "You must supply the appropriate criterias for criteria based items",
-    );
+    )
   }
 
   const totalNativeAmount = getSummedTokenAndIdentifierAmounts({
@@ -421,7 +421,7 @@ export function fulfillStandardOrder(
       ...timeBasedItemParams,
       isConsiderationItem: true,
     },
-  })[ethers.ZeroAddress]?.["0"];
+  })[ethers.ZeroAddress]?.["0"]
 
   const insufficientApprovals = validateStandardFulfillBalancesAndApprovals({
     offer,
@@ -433,19 +433,19 @@ export function fulfillStandardOrder(
     timeBasedItemParams,
     offererOperator,
     fulfillerOperator,
-  });
+  })
 
-  overrides = { ...overrides, value: totalNativeAmount };
+  overrides = { ...overrides, value: totalNativeAmount }
 
   const approvalActions = getApprovalActions(
     insufficientApprovals,
     exactApproval,
     signer,
-  );
+  )
 
-  const isGift = recipientAddress !== ethers.ZeroAddress;
+  const isGift = recipientAddress !== ethers.ZeroAddress
 
-  const useAdvanced = Boolean(unitsToFill) || hasCriteriaItems || isGift;
+  const useAdvanced = Boolean(unitsToFill) || hasCriteriaItems || isGift
 
   const orderAccountingForTips: OrderStruct = {
     ...order,
@@ -454,12 +454,12 @@ export function fulfillStandardOrder(
       consideration: [...order.parameters.consideration, ...tips],
       totalOriginalConsiderationItems: consideration.length,
     },
-  };
+  }
 
   const { numerator, denominator } = getAdvancedOrderNumeratorDenominator(
     order,
     unitsToFill,
-  );
+  )
 
   const exchangeAction = {
     type: "exchange",
@@ -495,50 +495,50 @@ export function fulfillStandardOrder(
           [orderAccountingForTips, conduitKey, overrides],
           domain,
         ),
-  } as const;
+  } as const
 
-  const actions = [...approvalActions, exchangeAction] as const;
+  const actions = [...approvalActions, exchangeAction] as const
 
   return {
     actions,
     executeAllActions: () =>
       executeAllActions(actions) as Promise<ContractTransaction>,
-  };
+  }
 }
 
 export function validateAndSanitizeFromOrderStatus(
   order: Order,
   orderStatus: OrderStatus,
 ): Order {
-  const { isValidated, isCancelled, totalFilled, totalSize } = orderStatus;
+  const { isValidated, isCancelled, totalFilled, totalSize } = orderStatus
 
   if (totalSize > 0n && totalFilled / totalSize === 1n) {
-    throw new Error("The order you are trying to fulfill is already filled");
+    throw new Error("The order you are trying to fulfill is already filled")
   }
 
   if (isCancelled) {
-    throw new Error("The order you are trying to fulfill is cancelled");
+    throw new Error("The order you are trying to fulfill is cancelled")
   }
 
   if (isValidated) {
     // If the order is already validated, manually wipe the signature off of the order to save gas
-    return { parameters: { ...order.parameters }, signature: "0x" };
+    return { parameters: { ...order.parameters }, signature: "0x" }
   }
 
-  return order;
+  return order
 }
 
 export type FulfillOrdersMetadata = {
-  order: Order;
-  unitsToFill?: BigNumberish;
-  orderStatus: OrderStatus;
-  offerCriteria: InputCriteria[];
-  considerationCriteria: InputCriteria[];
-  tips: ConsiderationItem[];
-  extraData: string;
-  offererBalancesAndApprovals: BalancesAndApprovals;
-  offererOperator: string;
-}[];
+  order: Order
+  unitsToFill?: BigNumberish
+  orderStatus: OrderStatus
+  offerCriteria: InputCriteria[]
+  considerationCriteria: InputCriteria[]
+  tips: ConsiderationItem[]
+  extraData: string
+  offererBalancesAndApprovals: BalancesAndApprovals
+  offererOperator: string
+}[]
 
 export function fulfillAvailableOrders({
   ordersMetadata,
@@ -553,43 +553,43 @@ export function fulfillAvailableOrders({
   exactApproval,
   domain,
 }: {
-  ordersMetadata: FulfillOrdersMetadata;
-  seaportContract: SeaportContract;
-  fulfillerBalancesAndApprovals: BalancesAndApprovals;
-  fulfillerOperator: string;
-  currentBlockTimestamp: number;
-  ascendingAmountTimestampBuffer: number;
-  conduitKey: string;
-  signer: Signer;
-  recipientAddress: string;
-  exactApproval: boolean;
-  domain?: string;
+  ordersMetadata: FulfillOrdersMetadata
+  seaportContract: SeaportContract
+  fulfillerBalancesAndApprovals: BalancesAndApprovals
+  fulfillerOperator: string
+  currentBlockTimestamp: number
+  ascendingAmountTimestampBuffer: number
+  conduitKey: string
+  signer: Signer
+  recipientAddress: string
+  exactApproval: boolean
+  domain?: string
 }): OrderUseCase<
   ExchangeAction<
     ContractMethodReturnType<SeaportContract, "fulfillAvailableAdvancedOrders">
   >
 > {
-  const sanitizedOrdersMetadata = ordersMetadata.map((orderMetadata) => ({
+  const sanitizedOrdersMetadata = ordersMetadata.map(orderMetadata => ({
     ...orderMetadata,
     order: validateAndSanitizeFromOrderStatus(
       orderMetadata.order,
       orderMetadata.orderStatus,
     ),
-  }));
+  }))
 
   const adjustTips = (orderMetadata: {
-    order: Order;
-    unitsToFill?: BigNumberish;
-    orderStatus: OrderStatus;
-    offerCriteria: InputCriteria[];
-    considerationCriteria: InputCriteria[];
-    tips: ConsiderationItem[];
-    extraData: string;
-    offererBalancesAndApprovals: BalancesAndApprovals;
-    offererOperator: string;
+    order: Order
+    unitsToFill?: BigNumberish
+    orderStatus: OrderStatus
+    offerCriteria: InputCriteria[]
+    considerationCriteria: InputCriteria[]
+    tips: ConsiderationItem[]
+    extraData: string
+    offererBalancesAndApprovals: BalancesAndApprovals
+    offererOperator: string
   }): ConsiderationItem[] => {
-    if (!orderMetadata.tips || !orderMetadata.tips.length) {
-      return [];
+    if (!orderMetadata.tips?.length) {
+      return []
     }
 
     return orderMetadata.unitsToFill
@@ -602,11 +602,11 @@ export function fulfillAvailableOrders({
           orderMetadata.tips,
           orderMetadata.orderStatus.totalFilled,
           orderMetadata.orderStatus.totalSize,
-        );
-  };
+        )
+  }
 
   const ordersMetadataWithAdjustedFills = sanitizedOrdersMetadata.map(
-    (orderMetadata) => ({
+    orderMetadata => ({
       ...orderMetadata,
       // If we are supplying units to fill, we adjust the order by the minimum of the amount to fill and
       // the remaining order left to be fulfilled
@@ -622,33 +622,33 @@ export function fulfillAvailableOrders({
           }),
       tips: adjustTips(orderMetadata),
     }),
-  );
+  )
 
-  let totalNativeAmount = 0n;
-  const totalInsufficientApprovals: InsufficientApprovals = [];
+  let totalNativeAmount = 0n
+  const totalInsufficientApprovals: InsufficientApprovals = []
   const criteriaOffersAndConsiderations = sanitizedOrdersMetadata
-    .flatMap((orderMetadata) => [
+    .flatMap(orderMetadata => [
       orderMetadata.order.parameters.offer,
       orderMetadata.order.parameters.consideration,
     ])
     .flat()
-    .filter(({ itemType }) => isCriteriaItem(itemType));
+    .filter(({ itemType }) => isCriteriaItem(itemType))
 
-  const hasCriteriaItems = criteriaOffersAndConsiderations.length > 0;
+  const hasCriteriaItems = criteriaOffersAndConsiderations.length > 0
 
   const addApprovalIfNeeded = (
     orderInsufficientApprovals: InsufficientApprovals,
   ) => {
-    orderInsufficientApprovals.forEach((insufficientApproval) => {
+    orderInsufficientApprovals.forEach(insufficientApproval => {
       if (
         !totalInsufficientApprovals.find(
-          (approval) => approval.token === insufficientApproval.token,
+          approval => approval.token === insufficientApproval.token,
         )
       ) {
-        totalInsufficientApprovals.push(insufficientApproval);
+        totalInsufficientApprovals.push(insufficientApproval)
       }
-    });
-  };
+    })
+  }
 
   ordersMetadataWithAdjustedFills.forEach(
     ({
@@ -662,7 +662,7 @@ export function fulfillAvailableOrders({
       const considerationIncludingTips = [
         ...order.parameters.consideration,
         ...tips,
-      ];
+      ]
 
       const timeBasedItemParams = {
         startTime: order.parameters.startTime,
@@ -670,7 +670,7 @@ export function fulfillAvailableOrders({
         currentBlockTimestamp,
         ascendingAmountTimestampBuffer,
         isConsiderationItem: true,
-      };
+      }
 
       totalNativeAmount =
         totalNativeAmount +
@@ -678,7 +678,7 @@ export function fulfillAvailableOrders({
           items: considerationIncludingTips,
           criterias: considerationCriteria,
           timeBasedItemParams,
-        })[ethers.ZeroAddress]?.["0"] ?? 0n);
+        })[ethers.ZeroAddress]?.["0"] ?? 0n)
 
       const insufficientApprovals = validateStandardFulfillBalancesAndApprovals(
         {
@@ -692,15 +692,15 @@ export function fulfillAvailableOrders({
           offererOperator,
           fulfillerOperator,
         },
-      );
+      )
 
       const offerCriteriaItems = order.parameters.offer.filter(({ itemType }) =>
         isCriteriaItem(itemType),
-      );
+      )
 
       const considerationCriteriaItems = considerationIncludingTips.filter(
         ({ itemType }) => isCriteriaItem(itemType),
-      );
+      )
 
       if (
         offerCriteriaItems.length !== offerCriteria.length ||
@@ -708,32 +708,32 @@ export function fulfillAvailableOrders({
       ) {
         throw new Error(
           "You must supply the appropriate criterias for criteria based items",
-        );
+        )
       }
 
-      addApprovalIfNeeded(insufficientApprovals);
+      addApprovalIfNeeded(insufficientApprovals)
     },
-  );
+  )
 
-  const overrides = { value: totalNativeAmount };
+  const overrides = { value: totalNativeAmount }
 
   const approvalActions = getApprovalActions(
     totalInsufficientApprovals,
     exactApproval,
     signer,
-  );
+  )
 
   const advancedOrdersWithTips: AdvancedOrder[] = sanitizedOrdersMetadata.map(
     ({ order, unitsToFill = 0, tips, extraData }) => {
       const { numerator, denominator } = getAdvancedOrderNumeratorDenominator(
         order,
         unitsToFill,
-      );
+      )
 
       const considerationIncludingTips = [
         ...order.parameters.consideration,
         ...tips,
-      ];
+      ]
 
       return {
         ...order,
@@ -746,12 +746,12 @@ export function fulfillAvailableOrders({
         numerator,
         denominator,
         extraData,
-      };
+      }
     },
-  );
+  )
 
   const { offerFulfillments, considerationFulfillments } =
-    generateFulfillOrdersFulfillments(ordersMetadata);
+    generateFulfillOrdersFulfillments(ordersMetadata)
 
   const exchangeAction = {
     type: "exchange",
@@ -781,22 +781,22 @@ export function fulfillAvailableOrders({
       ],
       domain,
     ),
-  } as const;
+  } as const
 
-  const actions = [...approvalActions, exchangeAction] as const;
+  const actions = [...approvalActions, exchangeAction] as const
 
   return {
     actions,
     executeAllActions: () =>
       executeAllActions(actions) as Promise<ContractTransaction>,
-  };
+  }
 }
 
 export function generateFulfillOrdersFulfillments(
   ordersMetadata: FulfillOrdersMetadata,
 ): {
-  offerFulfillments: FulfillmentComponentStruct[];
-  considerationFulfillments: FulfillmentComponentStruct[];
+  offerFulfillments: FulfillmentComponentStruct[]
+  considerationFulfillments: FulfillmentComponentStruct[]
 } {
   const hashAggregateKey = ({
     sourceOrDestination,
@@ -804,28 +804,28 @@ export function generateFulfillOrdersFulfillments(
     token,
     identifier,
   }: {
-    sourceOrDestination: string;
-    operator?: string;
-    token: string;
-    identifier: string;
-  }) => `${sourceOrDestination}-${operator}-${token}-${identifier}`;
+    sourceOrDestination: string
+    operator?: string
+    token: string
+    identifier: string
+  }) => `${sourceOrDestination}-${operator}-${token}-${identifier}`
 
   const offerAggregatedFulfillments: Record<
     string,
     FulfillmentComponentStruct
-  > = {};
+  > = {}
 
   const considerationAggregatedFulfillments: Record<
     string,
     FulfillmentComponentStruct
-  > = {};
+  > = {}
 
   ordersMetadata.forEach(
     ({ order, offererOperator, offerCriteria }, orderIndex) => {
       const itemToCriteria = getItemToCriteriaMap(
         order.parameters.offer,
         offerCriteria,
-      );
+      )
 
       return order.parameters.offer.forEach((item, itemIndex) => {
         const aggregateKey = `${hashAggregateKey({
@@ -835,22 +835,22 @@ export function generateFulfillOrdersFulfillments(
           identifier:
             itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria,
           // We tack on the index to ensure that erc721s can never be aggregated and instead must be in separate arrays
-        })}${isErc721Item(item.itemType) ? itemIndex : ""}`;
+        })}${isErc721Item(item.itemType) ? itemIndex : ""}`
 
         offerAggregatedFulfillments[aggregateKey] = [
           ...((offerAggregatedFulfillments[aggregateKey] ?? []) as any),
           { orderIndex, itemIndex },
-        ] as any;
-      });
+        ] as any
+      })
     },
-  );
+  )
 
   ordersMetadata.forEach(
     ({ order, considerationCriteria, tips }, orderIndex) => {
       const itemToCriteria = getItemToCriteriaMap(
         order.parameters.consideration,
         considerationCriteria,
-      );
+      )
       return [...order.parameters.consideration, ...tips].forEach(
         (item, itemIndex) => {
           const aggregateKey = `${hashAggregateKey({
@@ -859,24 +859,24 @@ export function generateFulfillOrdersFulfillments(
             identifier:
               itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria,
             // We tack on the index to ensure that erc721s can never be aggregated and instead must be in separate arrays
-          })}${isErc721Item(item.itemType) ? itemIndex : ""}`;
+          })}${isErc721Item(item.itemType) ? itemIndex : ""}`
 
           considerationAggregatedFulfillments[aggregateKey] = [
             ...((considerationAggregatedFulfillments[aggregateKey] ??
               []) as any),
             { orderIndex, itemIndex },
-          ] as any;
+          ] as any
         },
-      );
+      )
     },
-  );
+  )
 
   return {
     offerFulfillments: Object.values(offerAggregatedFulfillments),
     considerationFulfillments: Object.values(
       considerationAggregatedFulfillments,
     ),
-  };
+  }
 }
 
 export const getAdvancedOrderNumeratorDenominator = (
@@ -884,34 +884,34 @@ export const getAdvancedOrderNumeratorDenominator = (
   unitsToFill?: BigNumberish,
 ) => {
   // Used for advanced order cases
-  const maxUnits = getMaximumSizeForOrder(order);
+  const maxUnits = getMaximumSizeForOrder(order)
 
   // Reduce the numerator/denominator as optimization
-  let numerator = 1n;
-  let denominator = 1n;
+  let numerator = 1n
+  let denominator = 1n
   if (unitsToFill) {
-    const unitsGcd = gcd(BigInt(unitsToFill), maxUnits);
-    numerator = BigInt(unitsToFill) / unitsGcd;
-    denominator = maxUnits / unitsGcd;
+    const unitsGcd = gcd(BigInt(unitsToFill), maxUnits)
+    numerator = BigInt(unitsToFill) / unitsGcd
+    denominator = maxUnits / unitsGcd
   }
 
-  return { numerator, denominator };
-};
+  return { numerator, denominator }
+}
 
 export const scaleOrderStatusToMaxUnits = (
   order: OrderWithCounter,
   orderStatus: OrderStatus,
 ) => {
-  const maxUnits = getMaximumSizeForOrder(order);
+  const maxUnits = getMaximumSizeForOrder(order)
   if (orderStatus.totalSize === 0n) {
     // Seaport returns 0 for totalSize if the order has not been fulfilled before.
-    orderStatus.totalSize = maxUnits;
+    orderStatus.totalSize = maxUnits
   } else {
     // Scale the total filled and total size to the max units,
     // so we can properly calculate the units to fill.
     orderStatus.totalFilled =
-      (orderStatus.totalFilled * maxUnits) / orderStatus.totalSize;
-    orderStatus.totalSize = maxUnits;
+      (orderStatus.totalFilled * maxUnits) / orderStatus.totalSize
+    orderStatus.totalSize = maxUnits
   }
-  return orderStatus;
-};
+  return orderStatus
+}