@opensea/seaport-js 1.3.0 → 2.0.1

package/src/utils/balanceAndApprovalCheck.ts

@@ -0,0 +1,436 @@
+import { providers as multicallProviders } from "@0xsequence/multicall";
+import { BigNumber } from "ethers";
+import { ItemType, MAX_INT } from "../constants";
+import type { InputCriteria, Item, OrderParameters } from "../types";
+import { approvedItemAmount } from "./approval";
+import { balanceOf } from "./balance";
+import { getItemToCriteriaMap } from "./criteria";
+import {
+  getSummedTokenAndIdentifierAmounts,
+  isErc1155Item,
+  isErc20Item,
+  isErc721Item,
+  TimeBasedItemParams,
+} from "./item";
+
+export type BalancesAndApprovals = {
+  token: string;
+  identifierOrCriteria: string;
+  balance: BigNumber;
+  approvedAmount: BigNumber;
+  itemType: ItemType;
+}[];
+
+export type InsufficientBalances = {
+  token: string;
+  identifierOrCriteria: string;
+  requiredAmount: BigNumber;
+  amountHave: BigNumber;
+  itemType: ItemType;
+}[];
+
+export type InsufficientApprovals = {
+  token: string;
+  identifierOrCriteria: string;
+  approvedAmount: BigNumber;
+  requiredApprovedAmount: BigNumber;
+  operator: string;
+  itemType: ItemType;
+}[];
+
+const findBalanceAndApproval = (
+  balancesAndApprovals: BalancesAndApprovals,
+  token: string,
+  identifierOrCriteria: string
+) => {
+  const balanceAndApproval = balancesAndApprovals.find(
+    ({
+      token: checkedToken,
+      identifierOrCriteria: checkedIdentifierOrCriteria,
+    }) =>
+      token.toLowerCase() === checkedToken.toLowerCase() &&
+      checkedIdentifierOrCriteria.toLowerCase() ===
+        identifierOrCriteria.toLowerCase()
+  );
+
+  if (!balanceAndApproval) {
+    throw new Error(
+      "Balances and approvals didn't contain all tokens and identifiers"
+    );
+  }
+
+  return balanceAndApproval;
+};
+
+export const getBalancesAndApprovals = async ({
+  owner,
+  items,
+  criterias,
+  operator,
+  multicallProvider,
+}: {
+  owner: string;
+  items: Item[];
+  criterias: InputCriteria[];
+  operator: string;
+  multicallProvider: multicallProviders.MulticallProvider;
+}): Promise<BalancesAndApprovals> => {
+  const itemToCriteria = getItemToCriteriaMap(items, criterias);
+
+  return Promise.all(
+    items.map(async (item) => {
+      let approvedAmountPromise = Promise.resolve(BigNumber.from(0));
+
+      if (isErc721Item(item.itemType) || isErc1155Item(item.itemType)) {
+        approvedAmountPromise = approvedItemAmount(
+          owner,
+          item,
+          operator,
+          multicallProvider
+        );
+      } else if (isErc20Item(item.itemType)) {
+        approvedAmountPromise = approvedItemAmount(
+          owner,
+          item,
+          operator,
+          multicallProvider
+        );
+      }
+      // If native token, we don't need to check for approvals
+      else {
+        approvedAmountPromise = Promise.resolve(MAX_INT);
+      }
+
+      return {
+        token: item.token,
+        identifierOrCriteria:
+          itemToCriteria.get(item)?.identifier ?? item.identifierOrCriteria,
+        balance: await balanceOf(
+          owner,
+          item,
+          multicallProvider,
+          itemToCriteria.get(item)
+        ),
+        approvedAmount: await approvedAmountPromise,
+        itemType: item.itemType,
+      };
+    })
+  );
+};
+
+export const getInsufficientBalanceAndApprovalAmounts = ({
+  balancesAndApprovals,
+  tokenAndIdentifierAmounts,
+  operator,
+}: {
+  balancesAndApprovals: BalancesAndApprovals;
+  tokenAndIdentifierAmounts: ReturnType<
+    typeof getSummedTokenAndIdentifierAmounts
+  >;
+  operator: string;
+}): {
+  insufficientBalances: InsufficientBalances;
+  insufficientApprovals: InsufficientApprovals;
+} => {
+  const tokenAndIdentifierAndAmountNeeded = [
+    ...Object.entries(tokenAndIdentifierAmounts).map(
+      ([token, identifierToAmount]) =>
+        Object.entries(identifierToAmount).map(
+          ([identifierOrCriteria, amountNeeded]) =>
+            [token, identifierOrCriteria, amountNeeded] as const
+        )
+    ),
+  ].flat();
+
+  const filterBalancesOrApprovals = (
+    filterKey: "balance" | "approvedAmount"
+  ): InsufficientBalances =>
+    tokenAndIdentifierAndAmountNeeded
+      .filter(([token, identifierOrCriteria, amountNeeded]) =>
+        findBalanceAndApproval(
+          balancesAndApprovals,
+          token,
+          identifierOrCriteria
+        )[filterKey].lt(amountNeeded)
+      )
+      .map(([token, identifierOrCriteria, amount]) => {
+        const balanceAndApproval = findBalanceAndApproval(
+          balancesAndApprovals,
+          token,
+          identifierOrCriteria
+        );
+
+        return {
+          token,
+          identifierOrCriteria,
+          requiredAmount: amount,
+          amountHave: balanceAndApproval[filterKey],
+          itemType: balanceAndApproval.itemType,
+        };
+      });
+
+  const mapToApproval = (
+    insufficientBalance: InsufficientBalances[number]
+  ): InsufficientApprovals[number] => ({
+    token: insufficientBalance.token,
+    identifierOrCriteria: insufficientBalance.identifierOrCriteria,
+    approvedAmount: insufficientBalance.amountHave,
+    requiredApprovedAmount: insufficientBalance.requiredAmount,
+    itemType: insufficientBalance.itemType,
+    operator,
+  });
+
+  const [insufficientBalances, insufficientApprovals] = [
+    filterBalancesOrApprovals("balance"),
+    filterBalancesOrApprovals("approvedAmount").map(mapToApproval),
+  ];
+
+  return {
+    insufficientBalances,
+    insufficientApprovals,
+  };
+};
+
+/**
+ * 1. The offerer should have sufficient balance of all offered items.
+ * 2. If the order does not indicate proxy utilization, the offerer should have sufficient approvals set
+ *    for the Seaport contract for all offered ERC20, ERC721, and ERC1155 items.
+ * 3. If the order does indicate proxy utilization, the offerer should have sufficient approvals set
+ *    for their respective proxy contract for all offered ERC20, ERC721, and ERC1155 items.
+ */
+export const validateOfferBalancesAndApprovals = ({
+  offer,
+  criterias,
+  balancesAndApprovals,
+  timeBasedItemParams,
+  throwOnInsufficientBalances = true,
+  throwOnInsufficientApprovals,
+  operator,
+}: {
+  balancesAndApprovals: BalancesAndApprovals;
+  timeBasedItemParams?: TimeBasedItemParams;
+  throwOnInsufficientBalances?: boolean;
+  throwOnInsufficientApprovals?: boolean;
+  operator: string;
+} & Pick<OrderParameters, "offer"> & {
+    criterias: InputCriteria[];
+  }): InsufficientApprovals => {
+  const { insufficientBalances, insufficientApprovals } =
+    getInsufficientBalanceAndApprovalAmounts({
+      balancesAndApprovals,
+      tokenAndIdentifierAmounts: getSummedTokenAndIdentifierAmounts({
+        items: offer,
+        criterias,
+        timeBasedItemParams: timeBasedItemParams
+          ? { ...timeBasedItemParams, isConsiderationItem: false }
+          : undefined,
+      }),
+      operator,
+    });
+
+  if (throwOnInsufficientBalances && insufficientBalances.length > 0) {
+    throw new Error(
+      "The offerer does not have the amount needed to create or fulfill."
+    );
+  }
+
+  if (throwOnInsufficientApprovals && insufficientApprovals.length > 0) {
+    throw new Error("The offerer does not have the sufficient approvals.");
+  }
+
+  return insufficientApprovals;
+};
+
+/**
+ * When fulfilling a basic order, the following requirements need to be checked to ensure that the order will be fulfillable:
+ * 1. Offer checks need to be performed to ensure that the offerer still has sufficient balance and approvals
+ * 2. The fulfiller should have sufficient balance of all consideration items except for those with an
+ *    item type that matches the order's offered item type — by way of example, if the fulfilled order offers
+ *    an ERC20 item and requires an ERC721 item to the offerer and the same ERC20 item to another recipient,
+ *    the fulfiller needs to own the ERC721 item but does not need to own the ERC20 item as it will be sourced from the offerer.
+ * 3. If the fulfiller does not elect to utilize a proxy, they need to have sufficient approvals set for the
+ *    Seaport contract for all ERC20, ERC721, and ERC1155 consideration items on the fulfilled order except
+ *    for ERC20 items with an item type that matches the order's offered item type.
+ * 4. If the fulfiller does elect to utilize a proxy, they need to have sufficient approvals set for their
+ *    respective proxy contract for all ERC20, ERC721, and ERC1155 consideration items on the fulfilled order
+ *    except for ERC20 items with an item type that matches the order's offered item type.
+ * 5. If the fulfilled order specifies Ether (or other native tokens) as consideration items, the fulfiller must
+ *    be able to supply the sum total of those items as msg.value.
+ *
+ * @returns the list of insufficient owner and proxy approvals
+ */
+export const validateBasicFulfillBalancesAndApprovals = ({
+  offer,
+  consideration,
+  offererBalancesAndApprovals,
+  fulfillerBalancesAndApprovals,
+  timeBasedItemParams,
+  offererOperator,
+  fulfillerOperator,
+}: {
+  offererBalancesAndApprovals: BalancesAndApprovals;
+  fulfillerBalancesAndApprovals: BalancesAndApprovals;
+  timeBasedItemParams: TimeBasedItemParams;
+  offererOperator: string;
+  fulfillerOperator: string;
+} & Pick<OrderParameters, "offer" | "consideration">) => {
+  validateOfferBalancesAndApprovals({
+    offer,
+    criterias: [],
+    balancesAndApprovals: offererBalancesAndApprovals,
+    timeBasedItemParams,
+    throwOnInsufficientApprovals: true,
+    operator: offererOperator,
+  });
+
+  const considerationWithoutOfferItemType = consideration.filter(
+    (item) => item.itemType !== offer[0].itemType
+  );
+
+  const { insufficientBalances, insufficientApprovals } =
+    getInsufficientBalanceAndApprovalAmounts({
+      balancesAndApprovals: fulfillerBalancesAndApprovals,
+      tokenAndIdentifierAmounts: getSummedTokenAndIdentifierAmounts({
+        items: considerationWithoutOfferItemType,
+        criterias: [],
+        timeBasedItemParams: {
+          ...timeBasedItemParams,
+          isConsiderationItem: true,
+        },
+      }),
+      operator: fulfillerOperator,
+    });
+
+  if (insufficientBalances.length > 0) {
+    throw new Error(
+      "The fulfiller does not have the balances needed to fulfill."
+    );
+  }
+
+  return insufficientApprovals;
+};
+
+/**
+ * When fulfilling a standard order, the following requirements need to be checked to ensure that the order will be fulfillable:
+ * 1. Offer checks need to be performed to ensure that the offerer still has sufficient balance and approvals
+ * 2. The fulfiller should have sufficient balance of all consideration items after receiving all offered items
+ *    — by way of example, if the fulfilled order offers an ERC20 item and requires an ERC721 item to the offerer
+ *    and the same ERC20 item to another recipient with an amount less than or equal to the offered amount,
+ *    the fulfiller does not need to own the ERC20 item as it will first be received from the offerer.
+ * 3. If the fulfiller does not elect to utilize a proxy, they need to have sufficient approvals set for the
+ *    Seaport contract for all ERC20, ERC721, and ERC1155 consideration items on the fulfilled order.
+ * 4. If the fulfiller does elect to utilize a proxy, they need to have sufficient approvals set for their
+ *    respective proxy contract for all ERC20, ERC721, and ERC1155 consideration items on the fulfilled order.
+ * 5. If the fulfilled order specifies Ether (or other native tokens) as consideration items, the fulfiller must
+ *    be able to supply the sum total of those items as msg.value.
+ *
+ * @returns the list of insufficient owner and proxy approvals
+ */
+export const validateStandardFulfillBalancesAndApprovals = ({
+  offer,
+  consideration,
+  offerCriteria,
+  considerationCriteria,
+  offererBalancesAndApprovals,
+  fulfillerBalancesAndApprovals,
+  timeBasedItemParams,
+  offererOperator,
+  fulfillerOperator,
+}: Pick<OrderParameters, "offer" | "consideration"> & {
+  offerCriteria: InputCriteria[];
+  considerationCriteria: InputCriteria[];
+  offererBalancesAndApprovals: BalancesAndApprovals;
+  fulfillerBalancesAndApprovals: BalancesAndApprovals;
+  timeBasedItemParams: TimeBasedItemParams;
+  offererOperator: string;
+  fulfillerOperator: string;
+}) => {
+  validateOfferBalancesAndApprovals({
+    offer,
+    criterias: offerCriteria,
+    balancesAndApprovals: offererBalancesAndApprovals,
+    timeBasedItemParams,
+    throwOnInsufficientApprovals: true,
+    operator: offererOperator,
+  });
+
+  const fulfillerBalancesAndApprovalsAfterReceivingOfferedItems =
+    addToExistingBalances({
+      items: offer,
+      criterias: offerCriteria,
+      balancesAndApprovals: fulfillerBalancesAndApprovals,
+      timeBasedItemParams,
+    });
+
+  const { insufficientBalances, insufficientApprovals } =
+    getInsufficientBalanceAndApprovalAmounts({
+      balancesAndApprovals:
+        fulfillerBalancesAndApprovalsAfterReceivingOfferedItems,
+      tokenAndIdentifierAmounts: getSummedTokenAndIdentifierAmounts({
+        items: consideration,
+        criterias: considerationCriteria,
+        timeBasedItemParams: {
+          ...timeBasedItemParams,
+          isConsiderationItem: true,
+        },
+      }),
+      operator: fulfillerOperator,
+    });
+
+  if (insufficientBalances.length > 0) {
+    throw new Error(
+      "The fulfiller does not have the balances needed to fulfill."
+    );
+  }
+
+  return insufficientApprovals;
+};
+
+const addToExistingBalances = ({
+  items,
+  criterias,
+  timeBasedItemParams,
+  balancesAndApprovals,
+}: {
+  items: Item[];
+  criterias: InputCriteria[];
+  timeBasedItemParams: TimeBasedItemParams;
+  balancesAndApprovals: BalancesAndApprovals;
+}) => {
+  const summedItemAmounts = getSummedTokenAndIdentifierAmounts({
+    items,
+    criterias,
+    timeBasedItemParams: { ...timeBasedItemParams, isConsiderationItem: false },
+  });
+
+  // Deep clone existing balances
+  const balancesAndApprovalsAfterReceivingItems = balancesAndApprovals.map(
+    (item) => ({ ...item })
+  );
+
+  // Add each summed item amount to the existing balances as we may want tocheck balances after receiving all items
+  Object.entries(summedItemAmounts).forEach(
+    ([token, identifierOrCriteriaToAmount]) =>
+      Object.entries(identifierOrCriteriaToAmount).forEach(
+        ([identifierOrCriteria, amount]) => {
+          const balanceAndApproval = findBalanceAndApproval(
+            balancesAndApprovalsAfterReceivingItems,
+            token,
+            identifierOrCriteria
+          );
+
+          const balanceAndApprovalIndex =
+            balancesAndApprovalsAfterReceivingItems.indexOf(balanceAndApproval);
+
+          balancesAndApprovalsAfterReceivingItems[
+            balanceAndApprovalIndex
+          ].balance =
+            balancesAndApprovalsAfterReceivingItems[
+              balanceAndApprovalIndex
+            ].balance.add(amount);
+        }
+      )
+  );
+
+  return balancesAndApprovalsAfterReceivingItems;
+};

package/src/utils/criteria.ts

@@ -0,0 +1,83 @@
+import { Side } from "../constants";
+import { InputCriteria, Item, Order } from "../types";
+import { isCriteriaItem } from "./item";
+
+export const generateCriteriaResolvers = ({
+  orders,
+  offerCriterias = [[]],
+  considerationCriterias = [[]],
+}: {
+  orders: Order[];
+  offerCriterias?: InputCriteria[][];
+  considerationCriterias?: InputCriteria[][];
+}) => {
+  const offerCriteriaItems = orders.flatMap((order, orderIndex) =>
+    order.parameters.offer
+      .map(
+        (item, index) =>
+          ({
+            orderIndex,
+            item,
+            index,
+            side: Side.OFFER,
+          } as const)
+      )
+      .filter(({ item }) => isCriteriaItem(item.itemType))
+  );
+
+  const considerationCriteriaItems = orders.flatMap((order, orderIndex) =>
+    order.parameters.consideration
+      .map(
+        (item, index) =>
+          ({
+            orderIndex,
+            item,
+            index,
+            side: Side.CONSIDERATION,
+          } as const)
+      )
+      .filter(({ item }) => isCriteriaItem(item.itemType))
+  );
+
+  const mapCriteriaItemsToResolver = (
+    criteriaItems:
+      | typeof offerCriteriaItems
+      | typeof considerationCriteriaItems,
+    criterias: InputCriteria[][]
+  ) =>
+    criteriaItems.map(({ orderIndex, item, index, side }) => {
+      const merkleRoot = item.identifierOrCriteria || "0";
+      const inputCriteria: InputCriteria = criterias[orderIndex][index];
+      return {
+        orderIndex,
+        index,
+        side,
+        identifier: inputCriteria.identifier,
+        criteriaProof: merkleRoot === "0" ? [] : inputCriteria.proof,
+      };
+    });
+
+  const criteriaResolvers = [
+    ...mapCriteriaItemsToResolver(offerCriteriaItems, offerCriterias),
+    ...mapCriteriaItemsToResolver(
+      considerationCriteriaItems,
+      considerationCriterias
+    ),
+  ];
+
+  return criteriaResolvers;
+};
+
+export const getItemToCriteriaMap = (
+  items: Item[],
+  criterias: InputCriteria[]
+) => {
+  const criteriasCopy = [...criterias];
+
+  return items.reduce((map, item) => {
+    if (isCriteriaItem(item.itemType)) {
+      map.set(item, criteriasCopy.shift() as InputCriteria);
+    }
+    return map;
+  }, new Map<Item, InputCriteria>());
+};

package/src/utils/eip712/Eip712MerkleTree.ts

@@ -0,0 +1,128 @@
+import { _TypedDataEncoder as TypedDataEncoder } from "@ethersproject/hash";
+import {
+  defaultAbiCoder,
+  hexConcat,
+  keccak256,
+  toUtf8Bytes,
+} from "ethers/lib/utils";
+import { MerkleTree } from "merkletreejs";
+
+import { DefaultGetter } from "./defaults";
+import {
+  bufferKeccak,
+  bufferToHex,
+  chunk,
+  fillArray,
+  getRoot,
+  hexToBuffer,
+} from "./utils";
+
+import type { EIP712TypeDefinitions } from "./defaults";
+
+type BulkOrderElements<T> =
+  | [T, T]
+  | [BulkOrderElements<T>, BulkOrderElements<T>];
+
+const getTree = (leaves: string[], defaultLeafHash: string) =>
+  new MerkleTree(leaves.map(hexToBuffer), bufferKeccak, {
+    complete: true,
+    sort: false,
+    hashLeaves: false,
+    fillDefaultHash: hexToBuffer(defaultLeafHash),
+  });
+
+const encodeProof = (
+  key: number,
+  proof: string[],
+  signature = `0x${"ff".repeat(64)}`
+) => {
+  return hexConcat([
+    signature,
+    `0x${key.toString(16).padStart(6, "0")}`,
+    defaultAbiCoder.encode([`uint256[${proof.length}]`], [proof]),
+  ]);
+};
+
+export class Eip712MerkleTree<BaseType extends Record<string, any> = any> {
+  tree: MerkleTree;
+  private leafHasher: (value: any) => string;
+  defaultNode: BaseType;
+  defaultLeaf: string;
+  encoder: TypedDataEncoder;
+
+  get completedSize() {
+    return Math.pow(2, this.depth);
+  }
+
+  /** Returns the array of elements in the tree, padded to the complete size with empty items. */
+  getCompleteElements() {
+    const elements = this.elements;
+    return fillArray([...elements], this.completedSize, this.defaultNode);
+  }
+
+  /** Returns the array of leaf nodes in the tree, padded to the complete size with default hashes. */
+  getCompleteLeaves() {
+    const leaves = this.elements.map(this.leafHasher);
+    return fillArray([...leaves], this.completedSize, this.defaultLeaf);
+  }
+
+  get root() {
+    return this.tree.getHexRoot();
+  }
+
+  getProof(i: number) {
+    const leaves = this.getCompleteLeaves();
+    const leaf = leaves[i];
+    const proof = this.tree.getHexProof(leaf, i);
+    const root = this.tree.getHexRoot();
+    return { leaf, proof, root };
+  }
+
+  getEncodedProofAndSignature(i: number, signature: string) {
+    const { proof } = this.getProof(i);
+    return encodeProof(i, proof, signature);
+  }
+
+  getDataToSign(): BulkOrderElements<BaseType> {
+    let layer = this.getCompleteElements() as any;
+    while (layer.length > 2) {
+      layer = chunk(layer, 2);
+    }
+    return layer;
+  }
+
+  add(element: BaseType) {
+    this.elements.push(element);
+  }
+
+  getBulkOrderHash() {
+    const structHash = this.encoder.hashStruct("BulkOrder", {
+      tree: this.getDataToSign(),
+    });
+    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]));
+
+    if (bulkOrderHash !== structHash) {
+      throw new Error("expected derived bulk order hash to match");
+    }
+
+    return structHash;
+  }
+
+  constructor(
+    public types: EIP712TypeDefinitions,
+    public rootType: string,
+    public leafType: string,
+    public elements: BaseType[],
+    public depth: number
+  ) {
+    const encoder = TypedDataEncoder.from(types);
+    this.encoder = encoder;
+    this.leafHasher = (leaf: BaseType) => encoder.hashStruct(leafType, leaf);
+    this.defaultNode = DefaultGetter.from(types, leafType);
+    this.defaultLeaf = this.leafHasher(this.defaultNode);
+    this.tree = getTree(this.getCompleteLeaves(), this.defaultLeaf);
+  }
+}

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

@@ -0,0 +1,62 @@
+import { _TypedDataEncoder, keccak256, toUtf8Bytes } from "ethers/lib/utils";
+
+import { Eip712MerkleTree } from "./Eip712MerkleTree";
+import { DefaultGetter } from "./defaults";
+import { fillArray } from "./utils";
+
+import type { OrderComponents } from "../../types";
+import type { EIP712TypeDefinitions } from "./defaults";
+
+import { EIP_712_BULK_ORDER_TYPE } from "../../constants";
+
+function getBulkOrderTypes(height: number): EIP712TypeDefinitions {
+  const types = { ...EIP_712_BULK_ORDER_TYPE };
+  types.BulkOrder = [
+    { name: "tree", type: `OrderComponents${`[2]`.repeat(height)}` },
+  ];
+  return types;
+}
+
+export function getBulkOrderTreeHeight(length: number): number {
+  return Math.max(Math.ceil(Math.log2(length)), 1);
+}
+
+export function getBulkOrderTree(
+  orderComponents: OrderComponents[],
+  startIndex = 0,
+  height = getBulkOrderTreeHeight(orderComponents.length + startIndex)
+) {
+  const types = getBulkOrderTypes(height);
+  const defaultNode = DefaultGetter.from(types, "OrderComponents");
+  let elements = [...orderComponents];
+
+  if (startIndex > 0) {
+    elements = [
+      ...fillArray([] as OrderComponents[], startIndex, defaultNode),
+      ...orderComponents,
+    ];
+  }
+  const tree = new Eip712MerkleTree(
+    types,
+    "BulkOrder",
+    "OrderComponents",
+    elements,
+    height
+  );
+  return tree;
+}
+
+export function getBulkOrderTypeHash(height: number): string {
+  const types = getBulkOrderTypes(height);
+  const encoder = _TypedDataEncoder.from(types);
+  const typeString = toUtf8Bytes(encoder._types.BulkOrder);
+  return keccak256(typeString);
+}
+
+export function getBulkOrderTypeHashes(maxHeight: number): string[] {
+  const typeHashes: string[] = [];
+  for (let i = 0; i < maxHeight; i++) {
+    typeHashes.push(getBulkOrderTypeHash(i + 1));
+  }
+  return typeHashes;
+}