@opensea/seaport-js 4.0.7 → 4.1.0

package/src/typechain-types/src/contracts/test/index.ts

@@ -1,9 +1,9 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import type * as testErc1271WalletSol from "./TestERC1271Wallet.sol";
+import type * as testErc1271WalletSol from './TestERC1271Wallet.sol/index.js';
 export type { testErc1271WalletSol };
-export type { TestERC1155 } from "./TestERC1155";
-export type { TestERC20 } from "./TestERC20";
-export type { TestERC20USDC } from "./TestERC20USDC";
-export type { TestERC721 } from "./TestERC721";
+export type { TestERC1155 } from './TestERC1155.js';
+export type { TestERC20 } from './TestERC20.js';
+export type { TestERC20USDC } from './TestERC20USDC.js';
+export type { TestERC721 } from './TestERC721.js';

package/src/typechain-types/src/index.ts

@@ -1,5 +1,5 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import type * as contracts from "./contracts";
-export type { contracts };
+import type * as contracts from './contracts/index.js';
+export type { contracts };

package/src/types.ts

@@ -1,206 +1,206 @@
-import { BigNumberish, ContractTransaction } from "ethers";
-import { ItemType, OrderType } from "./constants";
-import type { TestERC20, TestERC721 } from "./typechain-types";
-import { TransactionMethods } from "./utils/usecase";
-import { Seaport as SeaportContract } from "./typechain-types/seaport/contracts/Seaport";
+import type { BigNumberish, ContractTransaction } from "ethers"
+import type { ItemType, OrderType } from "./constants"
+import type { TestERC20, TestERC721 } from "./typechain-types/index"
+import type { Seaport as SeaportContract } from "./typechain-types/seaport/contracts/Seaport"
+import type { TransactionMethods } from "./utils/usecase"
 
-export type { SeaportContract };
+export type { SeaportContract }
 
 export type SeaportConfig = {
   // Used because fulfillments may be invalid if confirmations take too long. Default buffer is 5 minutes
-  ascendingAmountFulfillmentBuffer?: number;
+  ascendingAmountFulfillmentBuffer?: number
 
   // Allow users to optionally skip balance and approval checks on order creation
-  balanceAndApprovalChecksOnOrderCreation?: boolean;
+  balanceAndApprovalChecksOnOrderCreation?: boolean
 
   // A mapping of conduit key to conduit
-  conduitKeyToConduit?: Record<string, string>;
+  conduitKeyToConduit?: Record<string, string>
 
   overrides?: {
     // The Seaport version to use
-    seaportVersion?: string;
+    seaportVersion?: string
     // The Seaport contract address to use
-    contractAddress?: string;
+    contractAddress?: string
     // The domain registry address to use
-    domainRegistryAddress?: string;
+    domainRegistryAddress?: string
     // The default conduit key to use when creating and fulfilling orders
-    defaultConduitKey?: string;
-  };
-};
+    defaultConduitKey?: string
+  }
+}
 
 export type OfferItem = {
-  itemType: ItemType;
-  token: string;
-  identifierOrCriteria: string;
-  startAmount: string;
-  endAmount: string;
-};
+  itemType: ItemType
+  token: string
+  identifierOrCriteria: string
+  startAmount: string
+  endAmount: string
+}
 
 export type ConsiderationItem = {
-  itemType: ItemType;
-  token: string;
-  identifierOrCriteria: string;
-  startAmount: string;
-  endAmount: string;
-  recipient: string;
-};
+  itemType: ItemType
+  token: string
+  identifierOrCriteria: string
+  startAmount: string
+  endAmount: string
+  recipient: string
+}
 
-export type Item = OfferItem | ConsiderationItem;
+export type Item = OfferItem | ConsiderationItem
 
 export type OrderParameters = {
-  offerer: string;
-  zone: string;
-  orderType: OrderType;
-  startTime: BigNumberish;
-  endTime: BigNumberish;
-  zoneHash: string;
-  salt: string;
-  offer: OfferItem[];
-  consideration: ConsiderationItem[];
-  totalOriginalConsiderationItems: BigNumberish;
-  conduitKey: string;
-};
-
-export type OrderComponents = OrderParameters & { counter: BigNumberish };
+  offerer: string
+  zone: string
+  orderType: OrderType
+  startTime: BigNumberish
+  endTime: BigNumberish
+  zoneHash: string
+  salt: string
+  offer: OfferItem[]
+  consideration: ConsiderationItem[]
+  totalOriginalConsiderationItems: BigNumberish
+  conduitKey: string
+}
+
+export type OrderComponents = OrderParameters & { counter: BigNumberish }
 
 export type Order = {
-  parameters: OrderParameters;
-  signature: string;
-};
+  parameters: OrderParameters
+  signature: string
+}
 
 export type AdvancedOrder = Order & {
-  numerator: bigint;
-  denominator: bigint;
-  extraData: string;
-};
+  numerator: bigint
+  denominator: bigint
+  extraData: string
+}
 
 export type BasicErc721Item = {
-  itemType: ItemType.ERC721;
-  token: string;
-  identifier: string;
-};
+  itemType: ItemType.ERC721
+  token: string
+  identifier: string
+}
 
 export type Erc721ItemWithCriteria = {
-  itemType: ItemType.ERC721;
-  token: string;
-  amount?: string;
-  endAmount?: string;
+  itemType: ItemType.ERC721
+  token: string
+  amount?: string
+  endAmount?: string
   // Used for criteria based items i.e. offering to buy 5 NFTs for a collection
-} & ({ identifiers: string[] } | { criteria: string });
+} & ({ identifiers: string[] } | { criteria: string })
 
-type Erc721Item = BasicErc721Item | Erc721ItemWithCriteria;
+type Erc721Item = BasicErc721Item | Erc721ItemWithCriteria
 
 export type BasicErc1155Item = {
-  itemType: ItemType.ERC1155;
-  token: string;
-  identifier: string;
-  amount: string;
-  endAmount?: string;
-};
+  itemType: ItemType.ERC1155
+  token: string
+  identifier: string
+  amount: string
+  endAmount?: string
+}
 
 export type Erc1155ItemWithCriteria = {
-  itemType: ItemType.ERC1155;
-  token: string;
-  amount: string;
-  endAmount?: string;
-} & ({ identifiers: string[] } | { criteria: string });
+  itemType: ItemType.ERC1155
+  token: string
+  amount: string
+  endAmount?: string
+} & ({ identifiers: string[] } | { criteria: string })
 
-type Erc1155Item = BasicErc1155Item | Erc1155ItemWithCriteria;
+type Erc1155Item = BasicErc1155Item | Erc1155ItemWithCriteria
 
 export type CurrencyItem = {
-  token?: string;
-  amount: string;
-  endAmount?: string;
-};
+  token?: string
+  amount: string
+  endAmount?: string
+}
 
-export type CreateInputItem = Erc721Item | Erc1155Item | CurrencyItem;
+export type CreateInputItem = Erc721Item | Erc1155Item | CurrencyItem
 
-export type ConsiderationInputItem = CreateInputItem & { recipient?: string };
+export type ConsiderationInputItem = CreateInputItem & { recipient?: string }
 
-export type TipInputItem = CreateInputItem & { recipient: string };
+export type TipInputItem = CreateInputItem & { recipient: string }
 
 export type Fee = {
-  recipient: string;
-  basisPoints: number;
-};
+  recipient: string
+  basisPoints: number
+}
 
 export type CreateOrderInput = {
-  conduitKey?: string;
-  zone?: string;
-  zoneHash?: string;
-  startTime?: BigNumberish;
-  endTime?: BigNumberish;
-  offer: readonly CreateInputItem[];
-  consideration: readonly ConsiderationInputItem[];
-  counter?: BigNumberish;
-  fees?: readonly Fee[];
-  allowPartialFills?: boolean;
-  restrictedByZone?: boolean;
-  domain?: string;
-  salt?: BigNumberish;
-};
+  conduitKey?: string
+  zone?: string
+  zoneHash?: string
+  startTime?: BigNumberish
+  endTime?: BigNumberish
+  offer: readonly CreateInputItem[]
+  consideration: readonly ConsiderationInputItem[]
+  counter?: BigNumberish
+  fees?: readonly Fee[]
+  allowPartialFills?: boolean
+  restrictedByZone?: boolean
+  domain?: string
+  salt?: BigNumberish
+}
 
 export type InputCriteria = {
-  identifier: string;
-  proof: string[];
-};
+  identifier: string
+  proof: string[]
+}
 
 export type OrderStatus = {
-  isValidated: boolean;
-  isCancelled: boolean;
-  totalFilled: bigint;
-  totalSize: bigint;
-};
+  isValidated: boolean
+  isCancelled: boolean
+  totalFilled: bigint
+  totalSize: bigint
+}
 
 export type OrderWithCounter = {
-  parameters: OrderComponents;
-  signature: string;
-};
+  parameters: OrderComponents
+  signature: string
+}
 
 export type ApprovalAction = {
-  type: "approval";
-  token: string;
-  identifierOrCriteria: string;
-  itemType: ItemType;
-  operator: string;
+  type: "approval"
+  token: string
+  identifierOrCriteria: string
+  itemType: ItemType
+  operator: string
   transactionMethods: TransactionMethods<
     TestERC721["setApprovalForAll"] | TestERC20["approve"]
-  >;
-};
+  >
+}
 
 export type ExchangeAction<T = unknown> = {
-  type: "exchange";
-  transactionMethods: TransactionMethods<T>;
-};
+  type: "exchange"
+  transactionMethods: TransactionMethods<T>
+}
 
 export type CreateOrderAction = {
-  type: "create";
-  getMessageToSign: () => Promise<string>;
-  createOrder: () => Promise<OrderWithCounter>;
-};
+  type: "create"
+  getMessageToSign: () => Promise<string>
+  createOrder: () => Promise<OrderWithCounter>
+}
 
 export type CreateBulkOrdersAction = {
-  type: "createBulk";
-  getMessageToSign: () => Promise<string>;
-  createBulkOrders: () => Promise<OrderWithCounter[]>;
-};
+  type: "createBulk"
+  getMessageToSign: () => Promise<string>
+  createBulkOrders: () => Promise<OrderWithCounter[]>
+}
 
-export type TransactionAction = ApprovalAction | ExchangeAction;
+export type TransactionAction = ApprovalAction | ExchangeAction
 
 export type CreateOrderActions = readonly [
   ...ApprovalAction[],
   CreateOrderAction,
-];
+]
 
 export type CreateBulkOrdersActions = readonly [
   ...ApprovalAction[],
   CreateBulkOrdersAction,
-];
+]
 
 export type OrderExchangeActions<T> = readonly [
   ...ApprovalAction[],
   ExchangeAction<T>,
-];
+]
 
 export type OrderUseCase<
   T extends CreateOrderAction | CreateBulkOrdersAction | ExchangeAction,
@@ -209,32 +209,32 @@ export type OrderUseCase<
     ? CreateOrderActions
     : T extends CreateBulkOrdersAction
       ? CreateBulkOrdersActions
-      : OrderExchangeActions<T extends ExchangeAction<infer U> ? U : never>;
+      : OrderExchangeActions<T extends ExchangeAction<infer U> ? U : never>
   executeAllActions: () => Promise<
     T extends CreateOrderAction
       ? OrderWithCounter
       : T extends CreateBulkOrdersAction
         ? OrderWithCounter[]
         : ContractTransaction
-  >;
-};
+  >
+}
 
 export type FulfillmentComponent = {
-  orderIndex: number;
-  itemIndex: number;
-}[];
+  orderIndex: number
+  itemIndex: number
+}[]
 
 export type Fulfillment = {
-  offerComponents: FulfillmentComponent[];
-  considerationComponents: FulfillmentComponent[];
-};
+  offerComponents: FulfillmentComponent[]
+  considerationComponents: FulfillmentComponent[]
+}
 
 type MatchOrdersFulfillmentComponent = {
-  orderIndex: number;
-  itemIndex: number;
-};
+  orderIndex: number
+  itemIndex: number
+}
 
 export type MatchOrdersFulfillment = {
-  offerComponents: MatchOrdersFulfillmentComponent[];
-  considerationComponents: MatchOrdersFulfillmentComponent[];
-};
+  offerComponents: MatchOrdersFulfillmentComponent[]
+  considerationComponents: MatchOrdersFulfillmentComponent[]
+}

package/src/utils/approval.ts

@@ -1,10 +1,13 @@
-import { Signer, ethers } from "ethers";
-import { ItemType, MAX_INT } from "../constants";
-import { TestERC721__factory, TestERC20__factory } from "../typechain-types";
-import type { ApprovalAction, Item } from "../types";
-import type { InsufficientApprovals } from "./balanceAndApprovalCheck";
-import { isErc1155Item, isErc721Item } from "./item";
-import { getTransactionMethods } from "./usecase";
+import type { ethers, Signer } from "ethers"
+import { ItemType, MAX_INT } from "../constants"
+import {
+  TestERC20__factory,
+  TestERC721__factory,
+} from "../typechain-types/index"
+import type { ApprovalAction, Item } from "../types"
+import type { InsufficientApprovals } from "./balanceAndApprovalCheck"
+import { isErc721Item, isErc1155Item } from "./item"
+import { getTransactionMethods } from "./usecase"
 
 export const approvedItemAmount = async (
   owner: string,
@@ -14,20 +17,20 @@ export const approvedItemAmount = async (
 ) => {
   if (isErc721Item(item.itemType) || isErc1155Item(item.itemType)) {
     // isApprovedForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-    const contract = TestERC721__factory.connect(item.token, provider);
+    const contract = TestERC721__factory.connect(item.token, provider)
 
-    const isApprovedForAll = await contract.isApprovedForAll(owner, operator);
+    const isApprovedForAll = await contract.isApprovedForAll(owner, operator)
     // Setting to the max int to consolidate types and simplify
-    return isApprovedForAll ? MAX_INT : 0n;
+    return isApprovedForAll ? MAX_INT : 0n
   } else if (item.itemType === ItemType.ERC20) {
-    const contract = TestERC20__factory.connect(item.token, provider);
+    const contract = TestERC20__factory.connect(item.token, provider)
 
-    return contract.allowance(owner, operator);
+    return contract.allowance(owner, operator)
   }
 
   // We don't need to check approvals for native tokens
-  return MAX_INT;
-};
+  return MAX_INT
+}
 
 /**
  * Get approval actions given a list of insufficient approvals.
@@ -51,10 +54,10 @@ export function getApprovalActions(
         identifierOrCriteria,
         requiredApprovedAmount,
       }) => {
-        const isErc1155 = isErc1155Item(itemType);
+        const isErc1155 = isErc1155Item(itemType)
         if (isErc721Item(itemType) || isErc1155) {
           // setApprovalForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
-          const contract = TestERC721__factory.connect(token, signer);
+          const contract = TestERC721__factory.connect(token, signer)
           const transactionMethods =
             exactApproval && !isErc1155
               ? getTransactionMethods(signer, contract, "approve", [
@@ -64,7 +67,7 @@ export function getApprovalActions(
               : getTransactionMethods(signer, contract, "setApprovalForAll", [
                   operator,
                   true,
-                ]);
+                ])
 
           return {
             type: "approval",
@@ -73,9 +76,9 @@ export function getApprovalActions(
             itemType,
             operator,
             transactionMethods,
-          };
+          }
         } else {
-          const contract = TestERC20__factory.connect(token, signer);
+          const contract = TestERC20__factory.connect(token, signer)
 
           return {
             type: "approval",
@@ -89,8 +92,8 @@ export function getApprovalActions(
               [operator, exactApproval ? requiredApprovedAmount : MAX_INT],
             ),
             operator,
-          };
+          }
         }
       },
-    );
+    )
 }

package/src/utils/balance.ts

@@ -1,12 +1,12 @@
-import { ethers } from "ethers";
-import { ItemType } from "../constants";
+import type { ethers } from "ethers"
+import { ItemType } from "../constants"
 import {
+  TestERC20__factory,
   TestERC721__factory,
   TestERC1155__factory,
-  TestERC20__factory,
-} from "../typechain-types";
-import type { InputCriteria, Item } from "../types";
-import { isErc1155Item, isErc20Item, isErc721Item } from "./item";
+} from "../typechain-types/index"
+import type { InputCriteria, Item } from "../types"
+import { isErc20Item, isErc721Item, isErc1155Item } from "./item"
 
 export const balanceOf = async (
   owner: string,
@@ -15,43 +15,43 @@ export const balanceOf = async (
   criteria?: InputCriteria,
 ): Promise<bigint> => {
   if (isErc721Item(item.itemType)) {
-    const contract = TestERC721__factory.connect(item.token, provider);
+    const contract = TestERC721__factory.connect(item.token, provider)
 
     if (item.itemType === ItemType.ERC721_WITH_CRITERIA) {
       return criteria
         ? contract
             .ownerOf(criteria.identifier)
-            .then((ownerOf) =>
+            .then(ownerOf =>
               BigInt(ownerOf.toLowerCase() === owner.toLowerCase()),
             )
-        : contract.balanceOf(owner);
+        : contract.balanceOf(owner)
     }
 
     return contract
       .ownerOf(item.identifierOrCriteria)
-      .then((ownerOf) => BigInt(ownerOf.toLowerCase() === owner.toLowerCase()));
+      .then(ownerOf => BigInt(ownerOf.toLowerCase() === owner.toLowerCase()))
   } else if (isErc1155Item(item.itemType)) {
-    const contract = TestERC1155__factory.connect(item.token, provider);
+    const contract = TestERC1155__factory.connect(item.token, provider)
 
     if (item.itemType === ItemType.ERC1155_WITH_CRITERIA) {
       if (!criteria) {
         // We don't have a good way to determine the balance of an erc1155 criteria item unless explicit
         // identifiers are provided, so just assume the offerer has sufficient balance
-        const startAmount = BigInt(item.startAmount);
-        const endAmount = BigInt(item.endAmount);
+        const startAmount = BigInt(item.startAmount)
+        const endAmount = BigInt(item.endAmount)
 
-        return startAmount > endAmount ? startAmount : endAmount;
+        return startAmount > endAmount ? startAmount : endAmount
       }
-      return contract.balanceOf(owner, criteria.identifier);
+      return contract.balanceOf(owner, criteria.identifier)
     }
 
-    return contract.balanceOf(owner, item.identifierOrCriteria);
+    return contract.balanceOf(owner, item.identifierOrCriteria)
   }
 
   if (isErc20Item(item.itemType)) {
-    const contract = TestERC20__factory.connect(item.token, provider);
-    return contract.balanceOf(owner);
+    const contract = TestERC20__factory.connect(item.token, provider)
+    return contract.balanceOf(owner)
   }
 
-  return provider.getBalance(owner);
-};
+  return provider.getBalance(owner)
+}