@bosonprotocol/core-sdk 1.12.0-alpha.7 → 1.12.0-alpha.9

package/src/core-sdk.ts

@@ -1,3 +1,4 @@
+import { ITokenInfo, TokenInfoManager } from "./utils/tokenInfoManager";
 import {
   Web3LibAdapter,
   TransactionResponse,
@@ -31,6 +32,7 @@ export class CoreSDK {
   private _subgraphUrl: string;
   private _protocolDiamond: string;
   private _chainId: number;
+  private _tokenInfoManager: TokenInfoManager;
 
   /**
    * Creates an instance of `CoreSDK`
@@ -647,22 +649,21 @@ export class CoreSDK {
    * @param exchangeToken - Address exchange token.
    * @returns Decimals, name and symbol.
    */
-  public async getExchangeTokenInfo(exchangeToken: string): Promise<{
-    name: string;
-    decimals: number;
-    symbol: string;
-  }> {
-    const args = {
-      web3Lib: this._web3Lib,
-      contractAddress: exchangeToken
-    };
-    const [decimals, name, symbol] = await Promise.all([
-      erc20.handler.getDecimals(args),
-      erc20.handler.getName(args),
-      erc20.handler.getSymbol(args)
-    ]);
+  public async getExchangeTokenInfo(
+    exchangeToken: string
+  ): Promise<ITokenInfo> {
+    if (this._chainId === undefined) {
+      this._chainId = await this._web3Lib.getChainId();
+    }
+
+    if (this._tokenInfoManager === undefined) {
+      this._tokenInfoManager = new TokenInfoManager(
+        this._chainId,
+        this._web3Lib
+      );
+    }
 
-    return { decimals, name, symbol };
+    return this._tokenInfoManager.getExchangeTokenInfo(exchangeToken);
   }
 
   /**
@@ -1150,4 +1151,22 @@ export class CoreSDK {
       ...args
     });
   }
+
+  public async renderContractualAgreementForOffer(
+    offerId: BigNumberish
+  ): Promise<string> {
+    const offerData = await offers.subgraph.getOfferById(
+      this._subgraphUrl,
+      offerId
+    );
+    return offers.renderContractualAgreementForOffer(offerData);
+  }
+
+  public async renderContractualAgreement(
+    template: string,
+    offerData: offers.CreateOfferArgs
+  ): Promise<string> {
+    const tokenInfo = await this.getExchangeTokenInfo(offerData.exchangeToken);
+    return offers.renderContractualAgreement(template, offerData, tokenInfo);
+  }
 }

package/src/metadata/product-v1.graphql

@@ -107,6 +107,9 @@ fragment BaseProductV1MetadataEntityFields on ProductV1MetadataEntity {
   productV1Seller {
     ...BaseProductV1SellerFields
   }
+  exchangePolicy {
+    ...BaseProductV1ExchangePolicyFields
+  }
 }
 
 fragment BaseProductV1ProductFields on ProductV1Product {

package/src/offers/index.ts

@@ -6,6 +6,7 @@ export * as iface from "./interface";
 export * as storage from "./storage";
 export * from "./types";
 export * from "./getOfferStatus";
+export * from "./renderContractualAgreement";
 
 export const validation = {
   createOfferArgsSchema: utils.validation.createOfferArgsSchema

package/src/offers/queries.graphql

@@ -89,5 +89,34 @@ fragment BaseOfferFields on Offer {
     externalUrl
     schemaUrl
     type
+    ... on ProductV1MetadataEntity {
+      image
+      attributes {
+        traitType
+        value
+        displayType
+      }
+      createdAt
+      voided
+      validFromDate
+      validUntilDate
+      quantityAvailable
+      uuid
+      product {
+        ...BaseProductV1ProductFields
+      }
+      variations {
+        ...BaseProductV1VariationFields
+      }
+      productV1Seller {
+        ...BaseProductV1SellerFields
+      }
+      exchangePolicy {
+        ...BaseProductV1ExchangePolicyFields
+      }
+      shipping {
+        ...BaseProductV1ShippingOptionFields
+      }
+    }
   }
 }

package/src/offers/renderContractualAgreement.ts

@@ -0,0 +1,203 @@
+import * as yup from "yup";
+import { ITokenInfo } from "./../utils/tokenInfoManager";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import { offers, subgraph } from "..";
+import { utils } from "@bosonprotocol/common";
+import Mustache from "mustache";
+import { formatUnits } from "ethers/lib/utils";
+import { productV1 } from "@bosonprotocol/metadata";
+
+export type TemplateRenderingData = offers.CreateOfferArgs & {
+  priceValue: string; // Convert in decimals value
+  sellerDepositValue: string; // Convert in decimals value
+  buyerCancelPenaltyValue: string; // Convert in decimals value
+  agentFeeValue: string; // Convert in decimals value
+  exchangeTokenSymbol: string;
+  sellerContactMethod: string;
+  disputeResolverContactMethod: string;
+  toISOString: () => void;
+  msecToDay: () => void;
+};
+
+export class InvalidOfferDataError extends Error {
+  constructor(public missingProperties: string[]) {
+    super(
+      `InvalidOfferData - missing properties: [${missingProperties.join(",")}]`
+    );
+  }
+}
+
+export const baseOfferDataSchema: yup.SchemaOf<BaseOfferData> = yup.object({
+  price: yup.mixed().required(),
+  sellerDeposit: yup.mixed().required(),
+  agentId: yup.mixed().required(),
+  buyerCancelPenalty: yup.mixed().required(),
+  quantityAvailable: yup.mixed().required(),
+  validFromDateInMS: yup.mixed().required(),
+  validUntilDateInMS: yup.mixed().required(),
+  voucherRedeemableFromDateInMS: yup.mixed().required(),
+  voucherRedeemableUntilDateInMS: yup.mixed().required(),
+  fulfillmentPeriodDurationInMS: yup.mixed().required(),
+  resolutionPeriodDurationInMS: yup.mixed().required(),
+  exchangeToken: yup.string().required(),
+  disputeResolverId: yup.mixed().required(),
+  metadataUri: yup.string().required(),
+  metadataHash: yup.string().required()
+});
+
+export type BaseOfferData = {
+  price: BigNumberish;
+  sellerDeposit: BigNumberish;
+  agentId: BigNumberish;
+  buyerCancelPenalty: BigNumberish;
+  quantityAvailable: BigNumberish;
+  validFromDateInMS: BigNumberish;
+  validUntilDateInMS: BigNumberish;
+  voucherRedeemableFromDateInMS: BigNumberish;
+  voucherRedeemableUntilDateInMS: BigNumberish;
+  fulfillmentPeriodDurationInMS: BigNumberish;
+  resolutionPeriodDurationInMS: BigNumberish;
+  exchangeToken: string;
+  disputeResolverId: BigNumberish;
+  metadataUri: string;
+  metadataHash: string;
+};
+
+function checkOfferDataIsValid(
+  offerData: unknown,
+  throwIfInvalid = false
+): boolean {
+  if (offerData === undefined || offerData === null) {
+    throw new Error("InvalidOfferData - undefined");
+  }
+  if (typeof offerData !== "object") {
+    throw new Error("InvalidOfferData - expecting an object");
+  }
+  try {
+    baseOfferDataSchema.validateSync(offerData, { abortEarly: false });
+  } catch (e) {
+    const missingProperties = [];
+    const getMissingProp = (error) => {
+      return error.match(/(.*) is a required field/)[1] || error;
+    };
+    if (throwIfInvalid) {
+      if (e.errors) {
+        e.errors.forEach((error: string) => {
+          missingProperties.push(getMissingProp(error));
+        });
+      } else {
+        missingProperties.push(getMissingProp(e));
+      }
+      throw new InvalidOfferDataError(missingProperties);
+    }
+    return false;
+  }
+  return true;
+}
+
+function convertExistingOfferData(
+  offerDataSubGraph: subgraph.OfferFieldsFragment
+): { offerData: offers.CreateOfferArgs; tokenInfo: ITokenInfo } {
+  return {
+    offerData: {
+      ...offerDataSubGraph,
+      validFromDateInMS: offerDataSubGraph.validFromDate,
+      validUntilDateInMS: offerDataSubGraph.validUntilDate,
+      voucherRedeemableFromDateInMS:
+        offerDataSubGraph.voucherRedeemableFromDate,
+      voucherRedeemableUntilDateInMS:
+        offerDataSubGraph.voucherRedeemableUntilDate,
+      fulfillmentPeriodDurationInMS:
+        offerDataSubGraph.fulfillmentPeriodDuration,
+      resolutionPeriodDurationInMS: offerDataSubGraph.resolutionPeriodDuration,
+      exchangeToken: offerDataSubGraph.exchangeToken.address
+    },
+    tokenInfo: {
+      ...offerDataSubGraph.exchangeToken,
+      decimals: parseInt(offerDataSubGraph.exchangeToken.decimals)
+    }
+  };
+}
+
+export async function prepareRenderingData(
+  offerData: offers.CreateOfferArgs,
+  tokenInfo: ITokenInfo
+): Promise<TemplateRenderingData> {
+  return {
+    ...offerData,
+    priceValue: formatUnits(offerData.price, tokenInfo.decimals),
+    exchangeTokenSymbol: tokenInfo.symbol,
+    sellerDepositValue: formatUnits(
+      offerData.sellerDeposit,
+      tokenInfo.decimals
+    ),
+    agentFeeValue: "0", // TODO: get the agentFee of the specified offerData.agentId
+    buyerCancelPenaltyValue: formatUnits(
+      offerData.buyerCancelPenalty,
+      tokenInfo.decimals
+    ),
+    sellerContactMethod: "TBD", // TODO: what is the sellerContactMethod?
+    disputeResolverContactMethod: "TBD", // TODO: what is the disputeResolverContactMethod?
+    toISOString: function () {
+      return function (num, render) {
+        return new Date(parseInt(render(num))).toISOString();
+      };
+    },
+    msecToDay: function () {
+      return function (num, render) {
+        return BigNumber.from(render(num))
+          .div(utils.timestamp.MSEC_PER_DAY)
+          .toString();
+      };
+    }
+  };
+}
+
+// inject a template + all offer details
+export async function renderContractualAgreement(
+  template: string,
+  offerData: offers.CreateOfferArgs,
+  tokenInfo: ITokenInfo
+): Promise<string> {
+  // Check the passed offerData is matching the required type
+  checkOfferDataIsValid(offerData, true);
+  const preparedData = await prepareRenderingData(offerData, tokenInfo);
+  return Mustache.render(template, preparedData);
+}
+
+export async function renderContractualAgreementForOffer(
+  existingOfferData: subgraph.OfferFieldsFragment
+): Promise<string> {
+  if (!existingOfferData) {
+    throw new Error(`offerData is undefined`);
+  }
+  if (!existingOfferData.metadata) {
+    throw new Error(`Offer Metadata is undefined`);
+  }
+  if (existingOfferData.metadata.type !== subgraph.MetadataType.ProductV1) {
+    throw new Error(
+      `Invalid Offer Metadata: Type is not supported: '${existingOfferData.metadata.type}'`
+    );
+  }
+  if (
+    !(existingOfferData.metadata as productV1.ProductV1Metadata).exchangePolicy
+  ) {
+    throw new Error(`Invalid Offer Metadata: exchangePolicy is not defined`);
+  }
+  if (
+    !(existingOfferData.metadata as productV1.ProductV1Metadata).exchangePolicy
+      .template
+  ) {
+    throw new Error(
+      `Invalid Offer Metadata: exchangePolicy.template is not defined`
+    );
+  }
+  const template = (existingOfferData.metadata as productV1.ProductV1Metadata)
+    .exchangePolicy.template;
+  const convertedOfferArgs = convertExistingOfferData(existingOfferData);
+  return renderContractualAgreement(
+    template,
+    convertedOfferArgs.offerData,
+    convertedOfferArgs.tokenInfo
+  );
+}

package/src/offers/subgraph.ts

@@ -21,7 +21,6 @@ export async function getOfferById(
     offerId: offerId.toString(),
     ...queryVars
   });
-
   return offer;
 }