@bosonprotocol/core-sdk 1.12.0-alpha.17 → 1.12.0-alpha.2

package/src/offers/renderContractualAgreement.ts

@@ -1,206 +0,0 @@
-import * as yup from "yup";
-import { ITokenInfo } from "./../utils/tokenInfoManager";
-import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
-import { utils } from "@bosonprotocol/common";
-import Mustache from "mustache";
-import { formatUnits } from "@ethersproject/units";
-import { productV1 } from "@bosonprotocol/metadata";
-
-import { CreateOfferArgs } from "./types";
-import { OfferFieldsFragment, MetadataType } from "../subgraph";
-
-export type TemplateRenderingData = 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: OfferFieldsFragment): {
-  offerData: 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: 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: 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: 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 !== 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/utils/signature.ts

@@ -1,65 +0,0 @@
-import { Web3LibAdapter } from "@bosonprotocol/common";
-import { isHexString, hexZeroPad } from "@ethersproject/bytes";
-import { BigNumber } from "@ethersproject/bignumber";
-
-type SignatureArgs = {
-  web3Lib: Web3LibAdapter;
-  verifyingContractAddress: string;
-  chainId: number;
-  customSignatureType?: Record<string, unknown>;
-  primaryType: string;
-  message: Record<string, unknown>;
-};
-
-export async function prepareDataSignatureParameters(args: SignatureArgs) {
-  const domainType = [
-    { name: "name", type: "string" },
-    { name: "version", type: "string" },
-    { name: "verifyingContract", type: "address" },
-    { name: "salt", type: "bytes32" }
-  ];
-
-  const domainData = {
-    name: "BosonProtocolDiamond",
-    version: "V1",
-    verifyingContract: args.verifyingContractAddress,
-    salt: hexZeroPad(BigNumber.from(args.chainId).toHexString(), 32)
-  };
-
-  const signatureTypes = {
-    EIP712Domain: domainType,
-    ...args.customSignatureType
-  };
-
-  const dataToSign = JSON.stringify({
-    types: signatureTypes,
-    domain: domainData,
-    primaryType: args.primaryType,
-    message: args.message
-  });
-
-  const signer = await args.web3Lib.getSignerAddress();
-  const signature = await args.web3Lib.send("eth_signTypedData_v4", [
-    signer,
-    dataToSign
-  ]);
-
-  return getSignatureParameters(signature);
-}
-
-export function getSignatureParameters(signature: string) {
-  if (!isHexString(signature)) {
-    throw new Error(`Value "${signature}" is not a valid hex string`);
-  }
-
-  signature = signature.substring(2);
-  const r = "0x" + signature.substring(0, 64);
-  const s = "0x" + signature.substring(64, 128);
-  const v = parseInt(signature.substring(128, 130), 16);
-
-  return {
-    r,
-    s,
-    v
-  };
-}

package/src/utils/tokenInfoManager.ts

@@ -1,97 +0,0 @@
-import { Web3LibAdapter } from "@bosonprotocol/common";
-import { AddressZero } from "@ethersproject/constants";
-import { getDecimals, getName, getSymbol } from "../erc20/handler";
-
-export interface ITokenInfo {
-  name: string;
-  decimals: number;
-  symbol: string;
-}
-
-export interface ITokenInfoManager {
-  getExchangeTokenInfo: (tokenAddress: string) => Promise<ITokenInfo>;
-}
-
-export const NATIVE_TOKENS: { [key: number]: ITokenInfo } = {
-  1: {
-    // Ethereum Mainnet
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  },
-  3: {
-    // Ethereum Ropsten
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  },
-  4: {
-    // Ethereum Rinkeby
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  },
-  5: {
-    // Ethereum Goerli
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  },
-  137: {
-    // Polygon Mainnet
-    name: "MATIC",
-    decimals: 18,
-    symbol: "MATIC"
-  },
-  80001: {
-    // Polygon Mumbai
-    name: "MATIC",
-    decimals: 18,
-    symbol: "MATIC"
-  },
-  1234: {
-    // Private Node
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  },
-  31337: {
-    // Local Hardhat
-    name: "Ether",
-    decimals: 18,
-    symbol: "ETH"
-  }
-};
-
-export class TokenInfoManager implements ITokenInfoManager {
-  private _tokenInfos = new Map<string, ITokenInfo>();
-  private _web3Lib: Web3LibAdapter;
-
-  public constructor(chainId: number, web3Lib: Web3LibAdapter) {
-    if (!NATIVE_TOKENS[chainId]) {
-      throw new Error(`Unexpected chainId value '${chainId}'`);
-    }
-    this._tokenInfos.set(AddressZero, NATIVE_TOKENS[chainId]);
-    this._web3Lib = web3Lib;
-  }
-
-  public async getExchangeTokenInfo(tokenAddress: string): Promise<ITokenInfo> {
-    if (!this._tokenInfos.has(tokenAddress.toLowerCase())) {
-      const args = {
-        web3Lib: this._web3Lib,
-        contractAddress: tokenAddress
-      };
-      const [decimals, name, symbol] = await Promise.all([
-        getDecimals(args),
-        getName(args),
-        getSymbol(args)
-      ]);
-      this._tokenInfos.set(tokenAddress.toLowerCase(), {
-        decimals,
-        name,
-        symbol
-      });
-    }
-    return this._tokenInfos.get(tokenAddress.toLowerCase());
-  }
-}