@opensea/seaport-js 1.2.1 → 2.0.0

package/src/types.ts

@@ -0,0 +1,335 @@
+import type { DomainRegistry as TypeChainDomainRegistryContract } from "./typechain-types";
+import type {
+  OrderStruct,
+  Seaport as TypeChainSeaportContract,
+} from "./typechain-types/seaport_v1_4/contracts/Seaport";
+import {
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  Contract,
+  ContractTransaction,
+  ethers,
+  Overrides,
+  PayableOverrides,
+  PopulatedTransaction,
+} from "ethers";
+import { ItemType, OrderType } from "./constants";
+import type { TestERC20, TestERC721 } from "./typechain-types";
+
+export type SeaportConfig = {
+  // Used because fulfillments may be invalid if confirmations take too long. Default buffer is 5 minutes
+  ascendingAmountFulfillmentBuffer?: number;
+
+  // Allow users to optionally skip balance and approval checks on order creation
+  balanceAndApprovalChecksOnOrderCreation?: boolean;
+
+  // A mapping of conduit key to conduit
+  conduitKeyToConduit?: Record<string, string>;
+
+  // The Seaport version to use
+  seaportVersion?: "1.4" | "1.5";
+
+  overrides?: {
+    contractAddress?: string;
+    domainRegistryAddress?: string;
+    // A default conduit key to use when creating and fulfilling orders
+    defaultConduitKey?: string;
+  };
+};
+
+type TypedDataDomain = {
+  name?: string;
+  version?: string;
+  chainId?: BigNumberish;
+  verifyingContract?: string;
+  salt?: BytesLike;
+};
+
+type TypedDataField = {
+  name: string;
+  type: string;
+};
+
+// Temporary until TypedDataSigner is added in ethers (in v6)
+export type Signer = ethers.Signer & {
+  _signTypedData(
+    domain: TypedDataDomain,
+    types: Record<string, Array<TypedDataField>>,
+    value: Record<string, any>
+  ): Promise<string>;
+};
+
+export type OfferItem = {
+  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;
+};
+
+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 };
+
+export type Order = {
+  parameters: OrderParameters;
+  signature: string;
+};
+
+export type AdvancedOrder = Order & {
+  numerator: BigNumber;
+  denominator: BigNumber;
+  extraData: string;
+};
+
+export type BasicErc721Item = {
+  itemType: ItemType.ERC721;
+  token: string;
+  identifier: string;
+};
+
+export type Erc721ItemWithCriteria = {
+  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 });
+
+type Erc721Item = BasicErc721Item | Erc721ItemWithCriteria;
+
+export type BasicErc1155Item = {
+  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 });
+
+type Erc1155Item = BasicErc1155Item | Erc1155ItemWithCriteria;
+
+export type CurrencyItem = {
+  token?: string;
+  amount: string;
+  endAmount?: string;
+};
+
+export type CreateInputItem = Erc721Item | Erc1155Item | CurrencyItem;
+
+export type ConsiderationInputItem = CreateInputItem & { recipient?: string };
+
+export type TipInputItem = CreateInputItem & { recipient: string };
+
+export type Fee = {
+  recipient: string;
+  basisPoints: number;
+};
+
+export type CreateOrderInput = {
+  conduitKey?: string;
+  zone?: 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[];
+};
+
+export type OrderStatus = {
+  isValidated: boolean;
+  isCancelled: boolean;
+  totalFilled: BigNumber;
+  totalSize: BigNumber;
+};
+
+export type OrderWithCounter = {
+  parameters: OrderComponents;
+  signature: string;
+};
+
+export type ContractMethodReturnType<
+  T extends Contract,
+  U extends keyof T["callStatic"]
+  // eslint-disable-next-line no-undef
+> = Awaited<ReturnType<T["callStatic"][U]>>;
+
+export type TransactionMethods<T = unknown> = {
+  buildTransaction: (overrides?: Overrides) => Promise<PopulatedTransaction>;
+  callStatic: (overrides?: Overrides) => Promise<T>;
+  estimateGas: (overrides?: Overrides) => Promise<BigNumber>;
+  transact: (overrides?: Overrides) => Promise<ContractTransaction>;
+};
+
+export type ApprovalAction = {
+  type: "approval";
+  token: string;
+  identifierOrCriteria: string;
+  itemType: ItemType;
+  operator: string;
+  transactionMethods:
+    | TransactionMethods<
+        ContractMethodReturnType<TestERC721, "setApprovalForAll">
+      >
+    | TransactionMethods<ContractMethodReturnType<TestERC20, "approve">>;
+};
+
+export type ExchangeAction<T = unknown> = {
+  type: "exchange";
+  transactionMethods: TransactionMethods<T>;
+};
+
+export type CreateOrderAction = {
+  type: "create";
+  getMessageToSign: () => Promise<string>;
+  createOrder: () => Promise<OrderWithCounter>;
+};
+
+export type CreateBulkOrdersAction = {
+  type: "createBulk";
+  getMessageToSign: () => Promise<string>;
+  createBulkOrders: () => Promise<OrderWithCounter[]>;
+};
+
+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
+> = {
+  actions: T extends CreateOrderAction
+    ? CreateOrderActions
+    : T extends CreateBulkOrdersAction
+    ? CreateBulkOrdersActions
+    : 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;
+}[];
+
+export type Fulfillment = {
+  offerComponents: FulfillmentComponent[];
+  considerationComponents: FulfillmentComponent[];
+};
+
+type MatchOrdersFulfillmentComponent = {
+  orderIndex: number;
+  itemIndex: number;
+};
+
+export type MatchOrdersFulfillment = {
+  offerComponents: MatchOrdersFulfillmentComponent[];
+  considerationComponents: MatchOrdersFulfillmentComponent[];
+};
+
+// Overrides matchOrders types to fix fulfillments type which is generated
+// by TypeChain incorrectly
+export type SeaportContract = TypeChainSeaportContract & {
+  encodeFunctionData(
+    functionFragment: "matchOrders",
+    values: [OrderStruct[], MatchOrdersFulfillment[]]
+  ): string;
+
+  matchOrders(
+    orders: OrderStruct[],
+    fulfillments: MatchOrdersFulfillment[],
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  functions: TypeChainSeaportContract["functions"] & {
+    matchOrders(
+      orders: OrderStruct[],
+      fulfillments: MatchOrdersFulfillment[],
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  callStatic: TypeChainSeaportContract["callStatic"] & {
+    matchOrders(
+      orders: OrderStruct[],
+      fulfillments: MatchOrdersFulfillment[],
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  estimateGas: TypeChainSeaportContract["estimateGas"] & {
+    matchOrders(
+      orders: OrderStruct[],
+      fulfillments: MatchOrdersFulfillment[],
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: TypeChainSeaportContract["populateTransaction"] & {
+    matchOrders(
+      orders: OrderStruct[],
+      fulfillments: MatchOrdersFulfillment[],
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+};
+
+export type DomainRegistryContract = TypeChainDomainRegistryContract;

package/src/utils/approval.ts

@@ -0,0 +1,103 @@
+import { providers as multicallProviders } from "@0xsequence/multicall";
+import { BigNumber, Contract, Signer } from "ethers";
+import { ERC20ABI } from "../abi/ERC20";
+import { ERC721ABI } from "../abi/ERC721";
+import { ItemType, MAX_INT } from "../constants";
+import type { TestERC20, TestERC721 } from "../typechain-types";
+import type { ApprovalAction, Item } from "../types";
+import type { InsufficientApprovals } from "./balanceAndApprovalCheck";
+import { isErc1155Item, isErc721Item } from "./item";
+import { getTransactionMethods } from "./usecase";
+
+export const approvedItemAmount = async (
+  owner: string,
+  item: Item,
+  operator: string,
+  multicallProvider: multicallProviders.MulticallProvider
+) => {
+  if (isErc721Item(item.itemType) || isErc1155Item(item.itemType)) {
+    // isApprovedForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
+    const contract = new Contract(
+      item.token,
+      ERC721ABI,
+      multicallProvider
+    ) as TestERC721;
+    return contract.isApprovedForAll(owner, operator).then((isApprovedForAll) =>
+      // Setting to the max int to consolidate types and simplify
+      isApprovedForAll ? MAX_INT : BigNumber.from(0)
+    );
+  } else if (item.itemType === ItemType.ERC20) {
+    const contract = new Contract(
+      item.token,
+      ERC20ABI,
+      multicallProvider
+    ) as TestERC20;
+
+    return contract.allowance(owner, operator);
+  }
+
+  // We don't need to check approvals for native tokens
+  return MAX_INT;
+};
+
+/**
+ * Get approval actions given a list of insufficent approvals.
+ */
+export function getApprovalActions(
+  insufficientApprovals: InsufficientApprovals,
+  exactApproval: boolean,
+  signer: Signer
+): ApprovalAction[] {
+  return insufficientApprovals
+    .filter(
+      (approval, index) =>
+        index === insufficientApprovals.length - 1 ||
+        insufficientApprovals[index + 1].token !== approval.token
+    )
+    .map(
+      ({
+        token,
+        operator,
+        itemType,
+        identifierOrCriteria,
+        requiredApprovedAmount,
+      }) => {
+        const isErc1155 = isErc1155Item(itemType);
+        if (isErc721Item(itemType) || isErc1155) {
+          // setApprovalForAll check is the same for both ERC721 and ERC1155, defaulting to ERC721
+          const contract = new Contract(token, ERC721ABI, signer) as TestERC721;
+
+          return {
+            type: "approval",
+            token,
+            identifierOrCriteria,
+            itemType,
+            operator,
+            transactionMethods: getTransactionMethods(
+              contract.connect(signer),
+              exactApproval && !isErc1155 ? "approve" : "setApprovalForAll",
+              [
+                operator,
+                exactApproval && !isErc1155 ? identifierOrCriteria : true,
+              ]
+            ),
+          };
+        } else {
+          const contract = new Contract(token, ERC20ABI, signer) as TestERC20;
+
+          return {
+            type: "approval",
+            token,
+            identifierOrCriteria,
+            itemType,
+            transactionMethods: getTransactionMethods(
+              contract.connect(signer),
+              "approve",
+              [operator, exactApproval ? requiredApprovedAmount : MAX_INT]
+            ),
+            operator,
+          };
+        }
+      }
+    );
+}

package/src/utils/balance.ts

@@ -0,0 +1,73 @@
+import { providers as multicallProviders } from "@0xsequence/multicall";
+import { BigNumber, Contract } from "ethers";
+import { ERC1155ABI } from "../abi/ERC1155";
+import { ERC20ABI } from "../abi/ERC20";
+import { ERC721ABI } from "../abi/ERC721";
+import { ItemType } from "../constants";
+import type { TestERC20, TestERC1155, TestERC721 } from "../typechain-types";
+import type { InputCriteria, Item } from "../types";
+import { isErc1155Item, isErc20Item, isErc721Item } from "./item";
+
+export const balanceOf = async (
+  owner: string,
+  item: Item,
+  multicallProvider: multicallProviders.MulticallProvider,
+  criteria?: InputCriteria
+): Promise<BigNumber> => {
+  if (isErc721Item(item.itemType)) {
+    const contract = new Contract(
+      item.token,
+      ERC721ABI,
+      multicallProvider
+    ) as TestERC721;
+
+    if (item.itemType === ItemType.ERC721_WITH_CRITERIA) {
+      return criteria
+        ? contract
+            .ownerOf(criteria.identifier)
+            .then((ownerOf) =>
+              BigNumber.from(
+                Number(ownerOf.toLowerCase() === owner.toLowerCase())
+              )
+            )
+        : contract.balanceOf(owner);
+    }
+
+    return contract
+      .ownerOf(item.identifierOrCriteria)
+      .then((ownerOf) =>
+        BigNumber.from(Number(ownerOf.toLowerCase() === owner.toLowerCase()))
+      );
+  } else if (isErc1155Item(item.itemType)) {
+    const contract = new Contract(
+      item.token,
+      ERC1155ABI,
+      multicallProvider
+    ) as TestERC1155;
+
+    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 = BigNumber.from(item.startAmount);
+        const endAmount = BigNumber.from(item.endAmount);
+
+        return startAmount.gt(endAmount) ? startAmount : endAmount;
+      }
+      return contract.balanceOf(owner, criteria.identifier);
+    }
+
+    return contract.balanceOf(owner, item.identifierOrCriteria);
+  }
+
+  if (isErc20Item(item.itemType)) {
+    const contract = new Contract(
+      item.token,
+      ERC20ABI,
+      multicallProvider
+    ) as TestERC20;
+    return contract.balanceOf(owner);
+  }
+
+  return multicallProvider.getBalance(owner);
+};