@bosonprotocol/core-sdk 1.12.0-alpha.0 → 1.12.0-alpha.10

package/src/disputes/handler.ts

@@ -0,0 +1,132 @@
+import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import {
+  encodeRaiseDispute,
+  encodeDecideDispute,
+  encodeEscalateDispute,
+  encodeExpireDispute,
+  encodeExpireDisputeBatch,
+  encodeExpireEscalatedDispute,
+  encodeExtendDisputeTimeout,
+  encodeRefuseEscalatedDispute,
+  encodeResolveDispute,
+  encodeRetractDispute
+} from "./interface";
+
+export async function raiseDispute(args: {
+  exchangeId: BigNumberish;
+  complaint: string;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRaiseDispute(args)
+  });
+}
+
+export async function retractDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRetractDispute(args.exchangeId)
+  });
+}
+
+export async function extendDisputeTimeout(args: {
+  exchangeId: BigNumberish;
+  newDisputeTimeout: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExtendDisputeTimeout(args)
+  });
+}
+
+export async function expireDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireDispute(args.exchangeId)
+  });
+}
+
+export async function expireDisputeBatch(args: {
+  exchangeIds: BigNumberish[];
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireDisputeBatch(args.exchangeIds)
+  });
+}
+
+export async function resolveDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeResolveDispute(args)
+  });
+}
+
+export async function escalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeEscalateDispute(args.exchangeId)
+  });
+}
+
+export async function decideDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeDecideDispute(args)
+  });
+}
+
+export async function refuseEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRefuseEscalatedDispute(args.exchangeId)
+  });
+}
+
+export async function expireEscalatedDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeExpireEscalatedDispute(args.exchangeId)
+  });
+}

package/src/disputes/index.ts

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

package/src/disputes/interface.ts

@@ -0,0 +1,90 @@
+import { abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+
+export const bosonDisputeHandlerIface = new Interface(
+  abis.IBosonDisputeHandlerABI
+);
+
+export function encodeDecideDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+}) {
+  return bosonDisputeHandlerIface.encodeFunctionData("decideDispute", [
+    args.exchangeId,
+    args.buyerPercent
+  ]);
+}
+
+export function encodeEscalateDispute(exchangeId: BigNumberish) {
+  return bosonDisputeHandlerIface.encodeFunctionData("escalateDispute", [
+    exchangeId
+  ]);
+}
+
+export function encodeExpireDispute(exchangeId: BigNumberish) {
+  return bosonDisputeHandlerIface.encodeFunctionData("expireDispute", [
+    exchangeId
+  ]);
+}
+
+export function encodeExpireDisputeBatch(exchangeIds: BigNumberish[]) {
+  return bosonDisputeHandlerIface.encodeFunctionData("expireDispute", [
+    exchangeIds
+  ]);
+}
+
+export function encodeExpireEscalatedDispute(exchangeId: BigNumberish) {
+  return bosonDisputeHandlerIface.encodeFunctionData("expireEscalatedDispute", [
+    exchangeId
+  ]);
+}
+
+export function encodeExtendDisputeTimeout(args: {
+  exchangeId: BigNumberish;
+  newDisputeTimeout: BigNumberish;
+}) {
+  return bosonDisputeHandlerIface.encodeFunctionData("extendDisputeTimeout", [
+    args.exchangeId,
+    args.newDisputeTimeout
+  ]);
+}
+
+export function encodeRaiseDispute(args: {
+  exchangeId: BigNumberish;
+  complaint: string;
+}) {
+  return bosonDisputeHandlerIface.encodeFunctionData("raiseDispute", [
+    args.exchangeId,
+    args.complaint
+  ]);
+}
+
+export function encodeRefuseEscalatedDispute(exchangeId: BigNumberish) {
+  return bosonDisputeHandlerIface.encodeFunctionData("refuseEscalatedDispute", [
+    exchangeId
+  ]);
+}
+
+export function encodeResolveDispute(args: {
+  exchangeId: BigNumberish;
+  buyerPercent: BigNumberish;
+  sigR: BytesLike;
+  sigS: BytesLike;
+  sigV: BigNumberish;
+}) {
+  return bosonDisputeHandlerIface.encodeFunctionData("resolveDispute", [
+    args.exchangeId,
+    args.buyerPercent,
+    args.sigR,
+    args.sigS,
+    args.sigV
+  ]);
+}
+
+export function encodeRetractDispute(exchangeId: BigNumberish) {
+  return bosonDisputeHandlerIface.encodeFunctionData("retractDispute", [
+    exchangeId
+  ]);
+}

package/src/disputes/queries.graphql

@@ -0,0 +1,56 @@
+query getDisputeByIdQuery(
+  $disputeId: ID!
+  $offersSkip: Int
+  $offersFirst: Int
+  $offersOrderBy: Offer_orderBy
+  $offersOrderDirection: OrderDirection
+  $offersFilter: Offer_filter
+  $includeOffers: Boolean = false
+) {
+  dispute(id: $disputeId) {
+    ...DisputeFields
+  }
+}
+
+query getDisputesQuery(
+  $disputesSkip: Int
+  $disputesFirst: Int
+  $disputesOrderBy: Dispute_orderBy
+  $disputesOrderDirection: OrderDirection
+  $disputesFilter: Dispute_filter
+) {
+  disputes(
+    skip: $disputesSkip
+    first: $disputesFirst
+    orderBy: $disputesOrderBy
+    orderDirection: $disputesOrderDirection
+    where: $disputesFilter
+  ) {
+    ...DisputeFields
+  }
+}
+
+fragment DisputeFields on Dispute {
+  ...BaseDisputeFields
+}
+
+fragment BaseDisputeFields on Dispute {
+  id
+  exchangeId
+  complaint
+  state
+  buyerPercent
+  disputedDate
+  escalatedDate
+  finalizedDate
+  timeout
+  exchange {
+    ...BaseExchangeFields
+  }
+  seller {
+    ...BaseSellerFields
+  }
+  buyer {
+    ...BaseBuyerFields
+  }
+}

package/src/disputes/subgraph.ts

@@ -0,0 +1,34 @@
+import { getSubgraphSdk } from "../utils/graphql";
+import {
+  DisputeFieldsFragment,
+  GetDisputesQueryQueryVariables,
+  GetDisputeByIdQueryQueryVariables
+} from "../subgraph";
+import { BigNumberish } from "@ethersproject/bignumber";
+
+export type SingleDisputeQueryVariables = Omit<
+  GetDisputeByIdQueryQueryVariables,
+  "disputeId"
+>;
+
+export async function getDisputeById(
+  subgraphUrl: string,
+  disputeId: BigNumberish,
+  queryVars: SingleDisputeQueryVariables = {}
+): Promise<DisputeFieldsFragment> {
+  const sdk = getSubgraphSdk(subgraphUrl);
+  const { dispute } = await sdk.getDisputeByIdQuery({
+    disputeId: disputeId.toString(),
+    ...queryVars
+  });
+  return dispute;
+}
+
+export async function getDisputes(
+  subgraphUrl: string,
+  queryVars: GetDisputesQueryQueryVariables = {}
+): Promise<DisputeFieldsFragment[]> {
+  const sdk = getSubgraphSdk(subgraphUrl);
+  const { disputes = [] } = await sdk.getDisputesQuery(queryVars);
+  return disputes;
+}

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/interface.ts

@@ -25,13 +25,15 @@ export function createOfferArgsToStructs(
   Partial<OfferStruct>,
   Partial<OfferDatesStruct>,
   Partial<OfferDurationsStruct>,
+  BigNumberish,
   BigNumberish
 ] {
   return [
     argsToOfferStruct(args),
     argsToOfferDatesStruct(args),
     argsToOfferDurationsStruct(args),
-    args.disputeResolverId
+    args.disputeResolverId,
+    args.agentId
   ];
 }
 

package/src/offers/queries.graphql

@@ -55,6 +55,8 @@ fragment BaseOfferFields on Offer {
   price
   sellerDeposit
   protocolFee
+  agentFee
+  agentId
   buyerCancelPenalty
   quantityAvailable
   quantityInitial
@@ -75,11 +77,46 @@ fragment BaseOfferFields on Offer {
   exchangeToken {
     ...BaseExchangeTokenFields
   }
+  disputeResolver {
+    ...BaseDisputeResolverFields
+  }
+  disputeResolutionTerms {
+    ...BaseDisputeResolutionTermsEntityFields
+  }
   metadata {
     name
     description
     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 "@ethersproject/units";
+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;
 }
 

package/src/orchestration/interface.ts

@@ -14,12 +14,19 @@ export function encodeCreateSellerAndOffer(
   seller: CreateSellerArgs,
   offer: CreateOfferArgs
 ) {
+  const sellerArgs = createSellerArgsToStruct(seller);
+  const offerArgs = createOfferArgsToStructs(offer);
   return bosonOrchestrationHandlerIface.encodeFunctionData(
     "createSellerAndOffer",
     [
-      createSellerArgsToStruct(seller),
+      sellerArgs.sellerStruct,
       seller.contractUri,
-      ...createOfferArgsToStructs(offer)
+      offerArgs[0], // offer
+      offerArgs[1], // offerDates
+      offerArgs[2], // offerDurations
+      offerArgs[3], // disputeResolverId
+      sellerArgs.authTokenStruct,
+      offerArgs[4] // agentId
     ]
   );
 }