@opensea/seaport-js 4.0.7 → 4.1.0

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

@@ -1,24 +1,21 @@
-import { TypedDataEncoder, keccak256, toUtf8Bytes } from "ethers";
-
-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";
+import { keccak256, TypedDataEncoder, toUtf8Bytes } from "ethers"
+import { EIP_712_BULK_ORDER_TYPE } from "../../constants"
+import type { OrderComponents } from "../../types"
+import type { EIP712TypeDefinitions } from "./defaults"
+import { DefaultGetter } from "./defaults"
+import { Eip712MerkleTree } from "./Eip712MerkleTree"
+import { fillArray } from "./utils"
 
 function getBulkOrderTypes(height: number): EIP712TypeDefinitions {
-  const types = { ...EIP_712_BULK_ORDER_TYPE };
+  const types = { ...EIP_712_BULK_ORDER_TYPE }
   types.BulkOrder = [
     { name: "tree", type: `OrderComponents${`[2]`.repeat(height)}` },
-  ];
-  return types;
+  ]
+  return types
 }
 
 export function getBulkOrderTreeHeight(length: number): number {
-  return Math.max(Math.ceil(Math.log2(length)), 1);
+  return Math.max(Math.ceil(Math.log2(length)), 1)
 }
 
 export function getBulkOrderTree(
@@ -26,15 +23,15 @@ export function getBulkOrderTree(
   startIndex = 0,
   height = getBulkOrderTreeHeight(orderComponents.length + startIndex),
 ) {
-  const types = getBulkOrderTypes(height);
-  const defaultNode = DefaultGetter.from(types, "OrderComponents");
-  let elements = [...orderComponents];
+  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,
@@ -42,21 +39,21 @@ export function getBulkOrderTree(
     "OrderComponents",
     elements,
     height,
-  );
-  return tree;
+  )
+  return tree
 }
 
 export function getBulkOrderTypeHash(height: number): string {
-  const types = getBulkOrderTypes(height);
-  const encoder = TypedDataEncoder.from(types);
-  const typeString = toUtf8Bytes(encoder.types.BulkOrder[0].type);
-  return keccak256(typeString);
+  const types = getBulkOrderTypes(height)
+  const encoder = TypedDataEncoder.from(types)
+  const typeString = toUtf8Bytes(encoder.types.BulkOrder[0].type)
+  return keccak256(typeString)
 }
 
 export function getBulkOrderTypeHashes(maxHeight: number): string[] {
-  const typeHashes: string[] = [];
+  const typeHashes: string[] = []
   for (let i = 0; i < maxHeight; i++) {
-    typeHashes.push(getBulkOrderTypeHash(i + 1));
+    typeHashes.push(getBulkOrderTypeHash(i + 1))
   }
-  return typeHashes;
+  return typeHashes
 }

package/src/utils/eip712/defaults.ts

@@ -1,4 +1,4 @@
-import { ethers, zeroPadValue, TypedDataField } from "ethers";
+import { ethers, type TypedDataField, zeroPadValue } from "ethers"
 
 const baseDefaults: Record<string, any> = {
   integer: 0,
@@ -6,10 +6,10 @@ const baseDefaults: Record<string, any> = {
   bool: false,
   bytes: "0x",
   string: "",
-};
+}
 
 const isNullish = (value: any): boolean => {
-  if (value === undefined) return false;
+  if (value === undefined) return false
 
   return (
     value !== undefined &&
@@ -18,77 +18,77 @@ const isNullish = (value: any): boolean => {
       (Array.isArray(value) && value.every(isNullish)) ||
       (typeof value === "object" && Object.values(value).every(isNullish)) ||
       (typeof value === "boolean" && value === false))
-  );
-};
+  )
+}
 
 function getDefaultForBaseType(type: string): any {
   // bytesXX
-  const [, width] = type.match(/^bytes(\d+)$/) ?? [];
-  if (width) return zeroPadValue("0x", parseInt(width));
+  const [, width] = type.match(/^bytes(\d+)$/) ?? []
+  if (width) return zeroPadValue("0x", parseInt(width, 10))
 
-  if (type.match(/^(u?)int(\d*)$/)) type = "integer";
+  if (type.match(/^(u?)int(\d*)$/)) type = "integer"
 
-  return baseDefaults[type];
+  return baseDefaults[type]
 }
 
-export type EIP712TypeDefinitions = Record<string, TypedDataField[]>;
+export type EIP712TypeDefinitions = Record<string, TypedDataField[]>
 
 type DefaultMap<T extends EIP712TypeDefinitions> = {
-  [K in keyof T]: any;
-};
+  [K in keyof T]: any
+}
 
 export class DefaultGetter<Types extends EIP712TypeDefinitions> {
-  defaultValues: DefaultMap<Types> = {} as DefaultMap<Types>;
+  defaultValues: DefaultMap<Types> = {} as DefaultMap<Types>
 
   constructor(protected types: Types) {
     for (const name in types) {
-      const defaultValue = this.getDefaultValue(name);
-      this.defaultValues[name] = defaultValue;
+      const defaultValue = this.getDefaultValue(name)
+      this.defaultValues[name] = defaultValue
       if (!isNullish(defaultValue)) {
         throw new Error(
           `Got non-empty value for type ${name} in default generator: ${defaultValue}`,
-        );
+        )
       }
     }
   }
 
   static from<Types extends EIP712TypeDefinitions>(
     types: Types,
-  ): DefaultMap<Types>;
+  ): DefaultMap<Types>
 
   static from<Types extends EIP712TypeDefinitions>(
     types: Types,
     type: keyof Types,
-  ): any;
+  ): any
 
   static from<Types extends EIP712TypeDefinitions>(
     types: Types,
     type?: keyof Types,
   ): DefaultMap<Types> {
-    const { defaultValues } = new DefaultGetter(types);
-    if (type) return defaultValues[type];
-    return defaultValues;
+    const { defaultValues } = new DefaultGetter(types)
+    if (type) return defaultValues[type]
+    return defaultValues
   }
   getDefaultValue(type: string): any {
-    if (this.defaultValues[type]) return this.defaultValues[type];
+    if (this.defaultValues[type]) return this.defaultValues[type]
     // Basic type (address, bool, uint256, etc)
-    const basic = getDefaultForBaseType(type);
-    if (basic !== undefined) return basic;
+    const basic = getDefaultForBaseType(type)
+    if (basic !== undefined) return basic
 
     // Array
-    const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
+    const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/)
     if (match) {
-      const subtype = match[1];
-      const length = parseInt(match[3]);
+      const subtype = match[1]
+      const length = parseInt(match[3], 10)
       if (length > 0) {
-        const baseValue = this.getDefaultValue(subtype);
-        return Array(length).fill(baseValue);
+        const baseValue = this.getDefaultValue(subtype)
+        return Array(length).fill(baseValue)
       }
-      return [];
+      return []
     }
 
     // Struct
-    const fields = this.types[type];
+    const fields = this.types[type]
     if (fields) {
       return fields.reduce(
         (obj, { name, type }) => ({
@@ -96,9 +96,9 @@ export class DefaultGetter<Types extends EIP712TypeDefinitions> {
           [name]: this.getDefaultValue(type),
         }),
         {},
-      );
+      )
     }
 
-    throw new Error(`unknown type: ${type}`);
+    throw new Error(`unknown type: ${type}`)
   }
 }

package/src/utils/eip712/utils.ts

@@ -1,50 +1,48 @@
-import { concat, toBeHex, keccak256 } from "ethers";
-
-import type { BytesLike } from "ethers";
+import type { BytesLike } from "ethers"
+import { concat, keccak256, toBeHex } from "ethers"
 
 export const makeArray = <T>(len: number, getValue: (i: number) => T) =>
   Array(len)
     .fill(0)
-    .map((_, i) => getValue(i));
+    .map((_, i) => getValue(i))
 
 export const chunk = <T>(array: T[], size: number) => {
-  return makeArray(Math.ceil(array.length / size), (i) =>
+  return makeArray(Math.ceil(array.length / size), i =>
     array.slice(i * size, (i + 1) * size),
-  );
-};
+  )
+}
 
-export const bufferToHex = (buf: Buffer) => toBeHex(buf.toString("hex"));
+export const bufferToHex = (buf: Buffer) => toBeHex(buf.toString("hex"))
 
-export const hexToBuffer = (value: string) =>
-  Buffer.from(value.slice(2), "hex");
+export const hexToBuffer = (value: string) => Buffer.from(value.slice(2), "hex")
 
-export const bufferKeccak = (value: BytesLike) => hexToBuffer(keccak256(value));
+export const bufferKeccak = (value: BytesLike) => hexToBuffer(keccak256(value))
 
-export const hashConcat = (arr: BytesLike[]) => bufferKeccak(concat(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));
-  return arr;
-};
+  if (length > arr.length) arr.push(...Array(length - arr.length).fill(value))
+  return arr
+}
 
 export const getRoot = (elements: (Buffer | string)[], hashLeaves = true) => {
-  if (elements.length === 0) throw new Error("empty tree");
+  if (elements.length === 0) throw new Error("empty tree")
 
-  const leaves = elements.map((e) => {
-    const leaf = Buffer.isBuffer(e) ? e : hexToBuffer(e);
-    return hashLeaves ? bufferKeccak(leaf) : leaf;
-  });
+  const leaves = elements.map(e => {
+    const leaf = Buffer.isBuffer(e) ? e : hexToBuffer(e)
+    return hashLeaves ? bufferKeccak(leaf) : leaf
+  })
 
-  const layers: Buffer[][] = [leaves];
+  const layers: Buffer[][] = [leaves]
 
   // Get next layer until we reach the root
   while (layers[layers.length - 1].length > 1) {
-    layers.push(getNextLayer(layers[layers.length - 1]));
+    layers.push(getNextLayer(layers[layers.length - 1]))
   }
 
-  return layers[layers.length - 1][0];
-};
+  return layers[layers.length - 1][0]
+}
 
 export const getNextLayer = (elements: Buffer[]) => {
-  return chunk(elements, 2).map(hashConcat);
-};
+  return chunk(elements, 2).map(hashConcat)
+}