@bosonprotocol/core-sdk 1.1.0 → 1.1.1-alpha.1

package/src/offers/index.ts

@@ -0,0 +1,12 @@
+import { utils } from "@bosonprotocol/common";
+
+export * as handler from "./handler";
+export * as subgraph from "./subgraph";
+export * as iface from "./interface";
+export * from "./types";
+
+export const validation = {
+  createOfferArgsSchema: utils.validation.createOfferArgsSchema,
+  baseMetadataSchema: utils.validation.baseMetadataSchema,
+  productV1MetadataSchema: utils.validation.productV1MetadataSchema
+};

package/src/offers/interface.ts

@@ -0,0 +1,59 @@
+import { OfferStruct, utils, abis, Log } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { getAddress } from "@ethersproject/address";
+import { CreateOfferArgs } from "./types";
+
+export const bosonOfferHandlerIface = new Interface(abis.IBosonOfferHandlerABI);
+
+export function getCreatedOfferIdFromLogs(logs: Log[]) {
+  const parsedLogs = logs.map((log) => parseLog(log.data, log.topics));
+
+  const [offerCreatedLog] = parsedLogs.filter(
+    (log) => log.name === "OfferCreated"
+  );
+
+  if (!offerCreatedLog) {
+    return null;
+  }
+
+  return String(offerCreatedLog.args.offerId);
+}
+
+export function parseLog(data: string, topics: string[]) {
+  return bosonOfferHandlerIface.parseLog({ data, topics });
+}
+
+export function encodeCreateOffer(args: CreateOfferArgs) {
+  return bosonOfferHandlerIface.encodeFunctionData("createOffer", [
+    createOfferArgsToStruct(args)
+  ]);
+}
+
+export function createOfferArgsToStruct(
+  args: CreateOfferArgs
+): Partial<OfferStruct> {
+  const {
+    exchangeToken,
+    seller,
+    validFromDateInMS,
+    validUntilDateInMS,
+    redeemableDateInMS,
+    fulfillmentPeriodDurationInMS,
+    voucherValidDurationInMS,
+    ...restArgs
+  } = args;
+
+  return {
+    id: "0",
+    ...restArgs,
+    exchangeToken: getAddress(exchangeToken),
+    seller: getAddress(seller),
+    validFromDate: utils.timestamp.msToSec(validFromDateInMS),
+    validUntilDate: utils.timestamp.msToSec(validUntilDateInMS),
+    redeemableDate: utils.timestamp.msToSec(redeemableDateInMS),
+    fulfillmentPeriodDuration: utils.timestamp.msToSec(
+      fulfillmentPeriodDurationInMS
+    ),
+    voucherValidDuration: utils.timestamp.msToSec(voucherValidDurationInMS)
+  };
+}

package/src/offers/subgraph.ts

@@ -0,0 +1,105 @@
+import { BigNumberish } from "@ethersproject/bignumber";
+import { fetchSubgraph, MultiQueryOpts } from "../utils/subgraph";
+import { RawOfferFromSubgraph } from "./types";
+
+export const offerFieldsFragment = `
+fragment offerFields on Offer {
+  id
+  createdAt
+  price
+  deposit
+  penalty
+  quantity
+  validFromDate
+  validUntilDate
+  redeemableDate
+  fulfillmentPeriodDuration
+  voucherValidDuration
+  metadataUri
+  metadataHash
+  voidedAt
+  seller {
+    address
+  }
+  exchangeToken {
+    address
+    decimals
+    name
+    symbol
+  }
+  metadata {
+    name 
+    description
+    externalUrl
+    schemaUrl
+    type
+  }
+}
+`;
+
+export const getOfferByIdQuery = `
+query GetOfferById($offerId: ID!) {
+  offer(id: $offerId) {
+    ...offerFields
+  }
+}
+${offerFieldsFragment}
+`;
+
+export async function getOfferById(
+  subgraphUrl: string,
+  offerId: BigNumberish
+): Promise<RawOfferFromSubgraph> {
+  const { offer } = await fetchSubgraph<{ offer: RawOfferFromSubgraph }>(
+    subgraphUrl,
+    getOfferByIdQuery,
+    { offerId: offerId.toString() }
+  );
+
+  return offer;
+}
+
+export const getAllOffersOfSellerQuery = `
+query GetAllOffersOfSellerQuery(
+  $seller: ID!,
+  $first: Int,
+  $skip: Int,
+  $orderBy: String,
+  $orderDirection: String
+) {
+  seller(id: $seller) {
+    offers(
+      first: $first
+      skip: $skip
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+    ) {
+      ...offerFields
+    }
+  }
+}
+${offerFieldsFragment}
+`;
+
+export async function getAllOffersOfSeller(
+  subgraphUrl: string,
+  sellerAddress: string,
+  opts: MultiQueryOpts = {}
+): Promise<RawOfferFromSubgraph[]> {
+  const { seller } = await fetchSubgraph<{
+    seller: { offers: RawOfferFromSubgraph[] };
+  }>(subgraphUrl, getAllOffersOfSellerQuery, {
+    seller: sellerAddress.toLowerCase(),
+    first: 100,
+    skip: 0,
+    orderBy: "createdAt",
+    orderDirection: "desc",
+    ...opts
+  });
+
+  if (!seller) {
+    return [];
+  }
+
+  return seller.offers;
+}

package/src/offers/types.ts

@@ -0,0 +1,34 @@
+export { CreateOfferArgs } from "@bosonprotocol/common";
+
+export type RawOfferFromSubgraph = {
+  id: string;
+  createdAt: string;
+  price: string;
+  deposit: string;
+  penalty: string;
+  quantity: string;
+  validFromDate: string;
+  validUntilDate: string;
+  redeemableDate: string;
+  fulfillmentPeriodDuration: string;
+  voucherValidDuration: string;
+  metadataUri: string;
+  metadataHash: string;
+  voidedAt: null | string;
+  seller: {
+    address: string;
+  };
+  exchangeToken: {
+    address: string;
+    decimals: string;
+    name: string;
+    symbol: string;
+  };
+  metadata: null | {
+    name: string;
+    description: string;
+    externalUrl: string;
+    schemaUrl: string;
+    type: string;
+  };
+};

package/src/utils/errors.ts

@@ -0,0 +1,14 @@
+export class FetchError extends Error {
+  statusCode?: number;
+  statusText?: string;
+
+  constructor(args: {
+    message?: string;
+    statusCode?: number;
+    statusText?: string;
+  }) {
+    super(args.message);
+    this.statusCode = args.statusCode;
+    this.statusText = args.statusText;
+  }
+}

package/src/utils/subgraph.ts

@@ -0,0 +1,43 @@
+import fetch from "cross-fetch";
+import { FetchError } from "./errors";
+
+export type MultiQueryOpts = Partial<{
+  first: number;
+  skip: number;
+  orderBy: string;
+  orderDirection: "asc" | "desc";
+}>;
+
+export async function fetchSubgraph<T>(
+  subgraphUrl: string,
+  query: string,
+  variables?: Record<string, unknown>
+): Promise<T> {
+  const response = await fetch(subgraphUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query,
+      variables
+    })
+  });
+
+  if (!response.ok) {
+    throw new FetchError({
+      message: `Failed to fetch: ${response.status} ${response.statusText}`,
+      statusCode: response.status,
+      statusText: response.statusText
+    });
+  }
+
+  const body = await response.json();
+  const { data = {}, errors = [] } = body || {};
+
+  if (errors.length > 0) {
+    throw new Error(`GraphQL errors: ${JSON.stringify(errors)}`);
+  }
+
+  return data as T;
+}