@bosonprotocol/core-sdk 1.40.1 → 1.40.2-alpha.0

package/src/marketplaces/opensea.ts

@@ -0,0 +1,361 @@
+import { formatUnits } from "@ethersproject/units";
+import {
+  AssetWithTokenId,
+  FulfillmentDataResponse,
+  GetNFTResponse,
+  NFT,
+  OrderAPIOptions,
+  OrderSide,
+  OrderV2,
+  OrdersQueryOptions,
+  ProtocolData
+} from "opensea-js";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import {
+  Listing,
+  Marketplace,
+  MarketplaceType,
+  Order,
+  SignedOrder
+} from "./types";
+import {
+  ConsiderationItem,
+  CreateInputItem,
+  CreateOrderAction,
+  CreateOrderInput,
+  OfferItem,
+  OrderParameters,
+  OrderUseCase
+} from "@opensea/seaport-js/lib/types";
+import {
+  ItemType,
+  NO_CONDUIT,
+  OPENSEA_CONDUIT_ADDRESS
+} from "@opensea/seaport-js/lib/constants";
+import {
+  ContractAddresses,
+  PriceDiscoveryStruct,
+  Side
+} from "@bosonprotocol/common";
+import {
+  CriteriaResolver,
+  encodeMatchAdvancedOrders,
+  AdvancedOrder,
+  Fulfillment
+} from "../seaport/interface";
+
+export type OpenSeaListing = {
+  asset: AssetWithTokenId;
+  accountAddress: string;
+  startAmount: BigNumberish;
+  endAmount?: BigNumberish;
+  quantity?: BigNumberish;
+  domain?: string;
+  salt?: BigNumberish;
+  listingTime?: number;
+  expirationTime?: number;
+  paymentTokenAddress?: string;
+  buyerAddress?: string;
+  englishAuction?: boolean;
+  excludeOptionalCreatorFees?: boolean;
+};
+
+export type OpenSeaSDKHandler = {
+  api: {
+    apiBaseUrl: string;
+    getOrder(order: Omit<OrdersQueryOptions, "limit">): Promise<OrderV2>;
+    generateFulfillmentData(
+      fulfillerAddress: string,
+      orderHash: string,
+      protocolAddress: string,
+      side: OrderSide
+    ): Promise<FulfillmentDataResponse>;
+    getNFT(address: string, identifier: string): Promise<GetNFTResponse>;
+    postOrder(
+      order: ProtocolData,
+      apiOptions: OrderAPIOptions
+    ): Promise<OrderV2>;
+  };
+  seaport_v1_6: {
+    createOrder(
+      input: CreateOrderInput,
+      accountAddress?: string,
+      exactApproval?: boolean
+    ): Promise<OrderUseCase<CreateOrderAction>>;
+  };
+  createListing(listing: OpenSeaListing): Promise<OrderV2>;
+};
+
+export class OpenSeaMarketplace extends Marketplace {
+  constructor(
+    _type: MarketplaceType,
+    protected _handler: OpenSeaSDKHandler,
+    protected _contracts: ContractAddresses,
+    protected _feeRecipient: string
+  ) {
+    super(_type);
+  }
+
+  public async createListing(listing: Listing): Promise<Order> {
+    const osListing = this.convertListing(listing);
+    const osOrder = await this._handler.createListing(osListing);
+    return this.convertOsOrder(osOrder);
+  }
+
+  public async createBidOrder(listing: Listing): Promise<Order> {
+    const fees = BigNumber.from(listing.price).mul(250).div(10000);
+    const domain = undefined;
+    const salt = undefined;
+    const quantity = undefined;
+    const { nft } = await this._handler.api.getNFT(
+      listing.asset.contract,
+      listing.asset.tokenId
+    );
+    // getNFTItems(nfts: NFT[], quantities: bigint[]): CreateInputItem[]; is a private method in OpenSea SDK, but need to hack it here
+    const considerationAssetItems = this._handler["getNFTItems"](
+      [nft],
+      // [BigInt(quantity ?? 1)]
+      [BigInt(1)]
+    );
+    const considerationFeeItems = [
+      {
+        itemType: 1,
+        token: listing.exchangeToken.address,
+        identifierOrCriteria: "0",
+        amount: fees.toString(),
+        startAmount: fees.toString(),
+        endAmount: fees.toString(),
+        recipient: this._feeRecipient
+      }
+    ];
+    const orderParams = {
+      offer: [
+        {
+          itemType: 1,
+          token: listing.exchangeToken.address,
+          amount: listing.price,
+          startAmount: listing.price,
+          endAmount: listing.price
+        }
+      ],
+      consideration: [...considerationAssetItems, ...considerationFeeItems],
+      endTime: listing.expirationTime.toString(),
+      zone: listing.zone || "0x0000000000000000000000000000000000000000",
+      domain,
+      // salt: BigInt(salt ?? 0).toString(),
+      salt: BigInt(0).toString(),
+      restrictedByZone: true,
+      allowPartialFills: false
+    };
+
+    const { executeAllActions } = await this._handler.seaport_v1_6.createOrder(
+      orderParams,
+      listing.offerer
+    );
+    const order = await executeAllActions();
+    const protocolAddress = listing.protocolAddress || this._contracts.seaport;
+    if (!protocolAddress) {
+      throw new Error(
+        `Seaport protocol address must be specified in Lsiting or CoreSDK config`
+      );
+    }
+
+    const osOrder = await this._handler.api.postOrder(order, {
+      protocol: "seaport",
+      protocolAddress,
+      side: OrderSide.BID
+    });
+    return this.convertOsOrder(osOrder);
+  }
+
+  public async generateFulfilmentData(asset: {
+    contract: string;
+    tokenId: string;
+  }): Promise<PriceDiscoveryStruct> {
+    // Asumption: we're fulfilling a Bid Order (don't know if it makes sense with an Ask order)
+    const osOrder = await this._handler.api.getOrder({
+      assetContractAddress: asset.contract,
+      tokenId: asset.tokenId,
+      side: OrderSide.BID
+    });
+    const orderInfo = this.extractOrderInfo(osOrder.protocolData.parameters);
+    const ffd = await this._handler.api.generateFulfillmentData(
+      this._contracts.priceDiscoveryClient, // the address of the PriceDiscoveryClient contract, which will call the fulfilment method
+      osOrder.orderHash,
+      osOrder.protocolAddress,
+      osOrder.side
+    );
+    const inputData = ffd.fulfillment_data.transaction
+      .input_data as unknown as {
+      orders: AdvancedOrder[];
+      criteriaResolvers: CriteriaResolver[];
+      fulfillments: Fulfillment[];
+      recipient: string;
+    };
+    const price = inputData.orders[1].parameters.consideration[0].startAmount; // offer price minus opensea fees
+    const side = Side.Bid; // ?
+    const priceDiscoveryContract = osOrder.protocolAddress; // seaport contract address
+    const conduit =
+      osOrder.protocolData.parameters.conduitKey === NO_CONDUIT
+        ? osOrder.protocolAddress // Seaport is used as conduit
+        : OPENSEA_CONDUIT_ADDRESS; // TODO: might not work on mocked networks
+    const priceDiscoveryData = encodeMatchAdvancedOrders(
+      inputData.orders,
+      inputData.criteriaResolvers,
+      inputData.fulfillments,
+      inputData.recipient
+    );
+
+    return {
+      price,
+      side,
+      priceDiscoveryContract,
+      conduit,
+      priceDiscoveryData
+    };
+  }
+
+  protected convertListing(listing: Listing): OpenSeaListing {
+    return {
+      asset: {
+        tokenAddress: listing.asset.contract,
+        tokenId: listing.asset.tokenId
+      },
+      accountAddress: listing.offerer,
+      startAmount: formatUnits(listing.price, listing.exchangeToken.decimals),
+      expirationTime: listing.expirationTime,
+      paymentTokenAddress: listing.exchangeToken.address,
+      englishAuction: listing.auction
+    };
+  }
+
+  protected convertOsOrder(osOrder: OrderV2 | undefined): Order | undefined {
+    if (!osOrder) {
+      return undefined;
+    }
+    const orderInfo = this.extractOrderInfo(osOrder.protocolData.parameters);
+    const side = orderInfo.side === OrderSide.ASK ? Side.Ask : Side.Bid;
+    return {
+      offerer: orderInfo.offerer,
+      side,
+      contract: orderInfo.nftContract,
+      tokenId: orderInfo.tokenId,
+      exchangeToken: {
+        address: orderInfo.exchangeToken
+        // decimals: ???
+      },
+      price: orderInfo.price,
+      startTime: osOrder.listingTime,
+      endTime: osOrder.expirationTime,
+      orderHash: osOrder.orderHash,
+      protocolAddress: osOrder.protocolAddress,
+      maker: osOrder.maker ? { address: osOrder.maker.address } : undefined,
+      taker: osOrder.taker ? { address: osOrder.taker.address } : undefined
+    };
+  }
+
+  protected extractOrderInfo(
+    parameters: OrderParameters,
+    side?: OrderSide
+  ): {
+    offerer: string;
+    side: OrderSide;
+    nftContract: string;
+    tokenId: string;
+    price: string;
+    fees: string;
+    sellerProfit: string;
+    exchangeToken: string;
+  } {
+    let price: string;
+    let exchangeToken: string;
+    let nft: ConsiderationItem | OfferItem;
+    const nftBid = parameters.consideration.find(
+      (c) => c.itemType === ItemType.ERC721
+    );
+    const nftAsk = parameters.offer.find((c) => c.itemType === ItemType.ERC721);
+    if (side === OrderSide.BID && !nftBid) {
+      console.warn(`NFT not found in order consideration`);
+    }
+    if (side === OrderSide.ASK && !nftAsk) {
+      console.warn(`NFT not found in order offer`);
+    }
+    if (!side) {
+      if (nftBid && !nftAsk) {
+        side = OrderSide.BID;
+      } else if (!nftBid && nftAsk) {
+        side = OrderSide.ASK;
+      } else if (nftBid && nftAsk) {
+        console.warn(
+          `NFT found in both consideration and offer. Unable to detect the order side`
+        );
+      } else {
+        console.warn(
+          `No NFT found in consideration or offer. Unable to detect the order side`
+        );
+      }
+    }
+    if (side === OrderSide.BID) {
+      price = parameters.offer
+        .filter((c) => c.itemType === ItemType.ERC20)
+        .reduce(
+          (total, current) => total.add(current.startAmount),
+          BigNumber.from(0)
+        )
+        .toString();
+      exchangeToken = parameters.offer.find(
+        (c) => c.itemType === ItemType.ERC20
+      )?.token;
+      nft = nftBid;
+    } else {
+      // ASK
+      price = parameters.consideration
+        .filter((c) => c.itemType === ItemType.ERC20)
+        .reduce(
+          (total, current) => total.add(current.startAmount),
+          BigNumber.from(0)
+        )
+        .toString();
+      exchangeToken = parameters.consideration.find(
+        (c) => c.itemType === ItemType.ERC20
+      )?.token;
+      nft = nftAsk;
+    }
+    const fees = price
+      ? BigNumber.from(price).mul(250).div(10000).toString()
+      : "0";
+    const sellerProfit = price
+      ? BigNumber.from(price).mul(9750).div(10000).toString()
+      : "0";
+    return {
+      offerer: parameters.offerer,
+      side,
+      nftContract: nft?.token || "0x0",
+      tokenId: nft?.identifierOrCriteria || "0x0",
+      price,
+      fees,
+      sellerProfit,
+      exchangeToken
+    };
+  }
+
+  public async getOrder(
+    asset: {
+      contract: string;
+      tokenId: string;
+    },
+    side: Side
+  ): Promise<SignedOrder> {
+    const osOrder = await this._handler.api.getOrder({
+      assetContractAddress: asset.contract,
+      tokenId: asset.tokenId,
+      side: side === Side.Ask ? OrderSide.ASK : OrderSide.BID
+    });
+    return osOrder
+      ? {
+          ...this.convertOsOrder(osOrder),
+          signature: osOrder.protocolData?.signature
+        }
+      : undefined;
+  }
+}

package/src/marketplaces/types.ts

@@ -0,0 +1,73 @@
+import { PriceDiscoveryStruct, Side } from "@bosonprotocol/common";
+import { OpenSeaSDKHandler } from "./opensea";
+
+export type DefaultHandler = {
+  // Just here as an example for other type of merketplace in the future
+  dummy(): () => void;
+};
+
+export enum MarketplaceType {
+  DEFAULT,
+  OPENSEA
+}
+
+export enum OrderSide {}
+
+export type MarketplaceHandler = OpenSeaSDKHandler | DefaultHandler;
+
+export type Listing = {
+  asset: {
+    contract: string;
+    tokenId: string;
+  };
+  offerer: string;
+  price: string;
+  expirationTime: number;
+  exchangeToken: { address: string; decimals: number };
+  auction: boolean;
+  zone?: string;
+  protocolAddress?: string;
+};
+
+export type Order = {
+  offerer: string;
+  startTime: number;
+  endTime: number;
+  orderHash: string;
+  protocolAddress: string;
+  side: Side;
+  maker: {
+    address: string;
+  };
+  taker: {
+    address: string;
+  };
+  contract: string;
+  tokenId: string;
+  price: string;
+  exchangeToken: {
+    address: string;
+    decimals?: number;
+  };
+};
+
+export type SignedOrder = Order & {
+  signature: string;
+};
+
+export abstract class Marketplace {
+  constructor(protected _type: MarketplaceType) {}
+  public abstract createListing(listing: Listing): Promise<Order>;
+  public abstract createBidOrder(listing: Listing): Promise<Order>;
+  public abstract getOrder(
+    asset: {
+      contract: string;
+      tokenId: string;
+    },
+    side: Side
+  ): Promise<SignedOrder>;
+  public abstract generateFulfilmentData(asset: {
+    contract: string;
+    tokenId: string;
+  }): Promise<PriceDiscoveryStruct>;
+}

package/src/price-discovery/handler.ts

@@ -0,0 +1,37 @@
+import {
+  Web3LibAdapter,
+  PriceDiscoveryStruct,
+  TransactionResponse
+} from "@bosonprotocol/common";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import * as exchanges from "../exchanges/handler";
+import { getOfferById } from "../offers/subgraph";
+import { AddressZero } from "@ethersproject/constants";
+import { encodeCommitToPriceDiscoveryOffer } from "./interface";
+
+export async function commitToPriceDiscoveryOffer(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+  buyer: string;
+  tokenIdOrOfferId: BigNumberish;
+  priceDiscovery: PriceDiscoveryStruct;
+}): Promise<TransactionResponse> {
+  let { offerId } = exchanges.parseTokenId(args.tokenIdOrOfferId);
+  if (offerId.eq(0)) {
+    offerId = BigNumber.from(args.tokenIdOrOfferId);
+  }
+  const offer = await getOfferById(args.subgraphUrl, offerId);
+
+  // TODO: do we need to check allowance?
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCommitToPriceDiscoveryOffer(
+      args.buyer,
+      args.tokenIdOrOfferId,
+      args.priceDiscovery
+    ),
+    value: offer.exchangeToken.address === AddressZero ? offer.price : "0"
+  });
+}

package/src/price-discovery/index.ts

@@ -0,0 +1,2 @@
+export * as iface from "./interface";
+export * as handler from "./handler";

package/src/price-discovery/interface.ts

@@ -0,0 +1,18 @@
+import { abis, PriceDiscoveryStruct } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { BigNumberish } from "@ethersproject/bignumber";
+
+export const priceDiscoveryHandlerIface = new Interface(
+  abis.IBosonPriceDiscoveryHandlerABI
+);
+
+export function encodeCommitToPriceDiscoveryOffer(
+  buyer: string,
+  tokenIdOrOfferId: BigNumberish,
+  priceDiscovery: PriceDiscoveryStruct
+) {
+  return priceDiscoveryHandlerIface.encodeFunctionData(
+    "commitToPriceDiscoveryOffer",
+    [buyer, tokenIdOrOfferId, priceDiscovery]
+  );
+}

package/src/price-discovery/mixin.ts

@@ -0,0 +1,30 @@
+import {
+  TransactionResponse,
+  PriceDiscoveryStruct
+} from "@bosonprotocol/common";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import { commitToPriceDiscoveryOffer } from "./handler";
+import { BigNumberish } from "@ethersproject/bignumber";
+
+export class PriceDiscoveryMixin extends BaseCoreSDK {
+  /**
+   * Commits to a price discovery offer (first step of an exchange)
+   * @param groupToCreate -  group with the contract condition
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async commitToPriceDiscoveryOffer(
+    buyer: string,
+    tokenIdOrOfferId: BigNumberish,
+    priceDiscovery: PriceDiscoveryStruct
+  ): Promise<TransactionResponse> {
+    return commitToPriceDiscoveryOffer({
+      buyer,
+      tokenIdOrOfferId,
+      priceDiscovery,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: this._protocolDiamond
+    });
+  }
+}

package/src/seaport/handler.ts

@@ -1,57 +0,0 @@
-import { BigNumberish } from "@ethersproject/bignumber";
-import { Interface } from "@ethersproject/abi";
-import { seaportAbi } from "./abi";
-
-const seaportIface = new Interface(seaportAbi);
-
-export enum eOrderType {
-  FULL_OPEN = 0,
-  PARTIAL_OPEN = 1,
-  FULL_RESTRICTED = 2,
-  PARTIAL_RESTRICTED = 3,
-  CONTRACT = 4
-}
-
-export enum eItemType {
-  NATIVE = 0,
-  ERC20 = 1,
-  ERC721 = 2,
-  ERC1155 = 3,
-  ERC721_WITH_CRITERIA = 4,
-  ERC1155_WITH_CRITERIA = 5
-}
-
-type OfferItem = {
-  itemType: eItemType;
-  token: string;
-  identifierOrCriteria: BigNumberish;
-  startAmount: BigNumberish;
-  endAmount: BigNumberish;
-};
-
-type ConsiderationItem = OfferItem & {
-  recipient: string;
-};
-
-type OrderParameters = {
-  offerer: string;
-  zone: string;
-  offer: OfferItem[];
-  consideration: ConsiderationItem[];
-  orderType: eOrderType;
-  startTime: BigNumberish;
-  endTime: BigNumberish;
-  zoneHash: string;
-  salt: BigNumberish;
-  conduitKey: string;
-  totalOriginalConsiderationItems: BigNumberish;
-};
-
-export type Order = {
-  parameters: OrderParameters;
-  signature: string;
-};
-
-export function encodeValidate(orders: Order[]) {
-  return seaportIface.encodeFunctionData("validate", [orders]);
-}

package/src/seaport/index.ts

@@ -1 +1 @@
-export * as handler from "./handler";
+export * as iface from "./interface";

package/src/seaport/interface.ts

@@ -0,0 +1,100 @@
+import { abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { BigNumberish } from "@ethersproject/bignumber";
+
+const seaportIface = new Interface(abis.SeaportABI);
+
+export enum eOrderType {
+  FULL_OPEN = 0,
+  PARTIAL_OPEN = 1,
+  FULL_RESTRICTED = 2,
+  PARTIAL_RESTRICTED = 3,
+  CONTRACT = 4
+}
+
+export enum eItemType {
+  NATIVE = 0,
+  ERC20 = 1,
+  ERC721 = 2,
+  ERC1155 = 3,
+  ERC721_WITH_CRITERIA = 4,
+  ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+  itemType: eItemType;
+  token: string;
+  identifierOrCriteria: BigNumberish;
+  startAmount: BigNumberish;
+  endAmount: BigNumberish;
+};
+
+type ConsiderationItem = OfferItem & {
+  recipient: string;
+};
+
+type OrderParameters = {
+  offerer: string;
+  zone: string;
+  offer: OfferItem[];
+  consideration: ConsiderationItem[];
+  orderType: eOrderType;
+  startTime: BigNumberish;
+  endTime: BigNumberish;
+  zoneHash: string;
+  salt: BigNumberish;
+  conduitKey: string;
+  totalOriginalConsiderationItems: BigNumberish;
+};
+
+export type Order = {
+  parameters: OrderParameters;
+  signature: string;
+};
+
+export type AdvancedOrder = Order & {
+  numerator: BigNumberish;
+  denominator: BigNumberish;
+  extraData: string;
+};
+
+export enum Side {
+  OFFER = 0, // items that can be spent
+  CONSIDERATION = 1 // items that must be received
+}
+
+export type CriteriaResolver = {
+  orderIndex: BigNumberish;
+  side: number;
+  index: BigNumberish;
+  identifier: BigNumberish;
+  criteriaProof: string[];
+};
+
+export type Fulfillment = {
+  offerComponents: FulfillmentComponent[];
+  considerationComponents: FulfillmentComponent[];
+};
+
+export type FulfillmentComponent = {
+  orderIndex: BigNumberish;
+  itemIndex: BigNumberish;
+};
+
+export function encodeValidate(orders: Order[]) {
+  return seaportIface.encodeFunctionData("validate", [orders]);
+}
+
+export function encodeMatchAdvancedOrders(
+  advancedOrders: AdvancedOrder[],
+  criteriaResolvers: CriteriaResolver[],
+  fulfillments: Fulfillment[],
+  recipient: string
+) {
+  return seaportIface.encodeFunctionData("matchAdvancedOrders", [
+    advancedOrders,
+    criteriaResolvers,
+    fulfillments,
+    recipient
+  ]);
+}

package/src/seaport/mixin.ts

@@ -0,0 +1,3 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+export class SeaportMixin extends BaseCoreSDK {}