feat: adapt check exchange policy for bundle offers

data/exchangePolicies/exchangePolicyRules.template.json

@@ -4,6 +4,7 @@
     "title": "Boson Protocol - Exchange Policy Rules",
     "description": "Rules to check whether the exchange policy of an offer is fair or not",
     "type": "object",
+    "metadataType": "PRODUCT_V1",
     "properties": {
       "disputePeriodDuration": {
         "description": "Dispute Period Duration",
@@ -75,6 +76,97 @@
       }
     }
   },
+  "yupSchemas": [{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Boson Protocol - Exchange Policy Rules",
+    "description": "Rules to check whether the exchange policy of an offer is fair or not",
+    "type": "object",
+    "metadataType": "BUNDLE",
+    "properties": {
+      "disputePeriodDuration": {
+        "description": "Dispute Period Duration",
+        "type": "number",
+        "min": 2592000,
+        "required": true
+      },
+      "disputeResolverId": {
+        "description": "Dispute Resolver",
+        "type": "string",
+        "matches": "^(<DEFAULT_DISPUTE_RESOLVER_ID>)$",
+        "required": true
+      },
+      "exchangeToken": {
+        "type": "object",
+        "properties": {
+          "address": {
+            "description": "Exchange Token",
+            "type": "string",
+            "flags": "i",
+            "pattern": "^(<TOKENS_LIST>)$",
+            "required": true
+          }
+        },
+        "required": true
+      },
+      "resolutionPeriodDuration": {
+        "description": "Resolution Period Duration",
+        "type": "number",
+        "min": 1296000,
+        "required": true
+      },
+      "metadata": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "description": "Metadata Type",
+            "type": "string",
+            "matches": "^BUNDLE$",
+            "required": true
+          }
+        },
+        "required": true
+      }
+    }
+  }, {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Boson Protocol - Exchange Policy Rules",
+    "description": "Rules to check whether the exchange policy of an offer is fair or not",
+    "type": "object",
+    "metadataType": "ITEM_PRODUCT_V1",
+    "properties": {
+      "type": {
+        "description": "Metadata Type",
+        "type": "string",
+        "matches": "^ITEM_PRODUCT_V1$",
+        "required": true
+      },
+      "exchangePolicy": {
+        "type": "object",
+        "properties": {
+          "template": {
+            "description": "Buyer/Seller Agreement Template",
+            "type": "string",
+            "flags": "i",
+            "pattern": "^(fairExchangePolicy|ipfs://QmS6SUVL1mhRq9wyNho914vcHwj3gC491vq7wtdoe34SUz|ipfs://QmZEYfG31PR1SgStg1wCFawQPxtbY9N44vDK9fjj3J9oz2|ipfs://QmXfDShmggHm7BzMbkzv2rRowwPyJ55mypGp32qKSPGto4|ipfs://QmXxRznUVMkQMb6hLiojbiv9uDw22RcEpVk6Gr3YywihcJ|ipfs://QmQ8ZTmmRV15rFaWG9KRyjFRrpaD1o2sDwZoYiWgBaAto6|ipfs://QmaNj7vGuCEvaM5vyucp5z1S9VprMnZWmVxYGn6FHhgePF|ipfs://QmbkoWec4NcmxJk7xpooNyfvj9ZarkW6RXq2ZJ9W6UGXZu|ipfs://QmaUobgQYrMnm2jZ3WowPtwRs4MpMR2TSinp3ChebjnZwe)$",
+            "required": true
+          }
+        },
+        "required": true
+      },
+      "shipping": {
+        "type": "object",
+        "properties": {
+          "returnPeriodInDays": {
+            "description": "Return Period (in days)",
+            "type": "number",
+            "min": 15,
+            "required": true
+          }
+        },
+        "required": true
+      }
+    }
+  }],
   "yupConfig": {
     "errMessages": {
       "disputePeriodDuration": {
@@ -90,7 +182,7 @@
         "min": "Resolution Period Duration is less than 15 days"
       },
       "type": {
-        "matches": "Metadata Type is not PRODUCT_V1 standard",
+        "matches": "Metadata Type is not a supported standard (PRODUCT_V1, BUNDLE or ITEM_PRODUCT_V1)",
         "required": "Metadata Type is not specified"
       },
       "template": {

data/ipfs.txt

@@ -3,4 +3,4 @@ HERE AFTER THE IPFS HASH OF THE UPLOADED FILES (FOR RECORDING AND TRACEABILITY)
 
 contractualAgreement.template.md QmaUobgQYrMnm2jZ3WowPtwRs4MpMR2TSinp3ChebjnZwe
 rNFTLicense.template.md QmPbzbp7xcSKhQPjT5VacLRMVgM1U6DB4LiF2GVyHhvcA7
-exchangePolicyRules.template.json QmX8Wnq1eWbf7pRhEDQqdAqWp17YSKXQq8ckZVe4YdqAvt
+exchangePolicyRules.template.json QmPBjCyxLdYFGQRJnD1xfdtBTEUsviwJV5Y4ZN3rCBo2QQ

packages/core-sdk/src/offers/checkExchangePolicy.ts

@@ -27,12 +27,14 @@ export type YupPropertyDef = {
 };
 
 export type CheckExchangePolicyRules = {
+  // Keep default type for backward compatibility, but also support multiple schemas for different metadata types (e.g., PRODUCT_V1 and BUNDLE)
   yupSchema: {
     $schema?: string;
     $id?: string;
     title?: string;
     description?: string;
     type: string;
+    metadataType?: string;
     properties: {
       [key: string]: YupPropertyDef;
     };
@@ -49,29 +51,152 @@ export type CheckExchangePolicyRules = {
       };
     };
   };
+  // Extend the type to support multiple schemas (for different metadata types, e.g., PRODUCT_V1 and BUNDLE)
+  yupSchemas?: {
+    $schema?: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+    type: string;
+    metadataType: string;
+    properties: {
+      [key: string]: YupPropertyDef;
+    };
+  }[];
 };
 
+/**
+ * Helper function to safely extract validation errors from a Yup ValidationError.
+ *
+ * @param error - The error object to extract validation errors from
+ * @returns An array of error objects, each containing:
+ *   - message: The error message string
+ *   - path: The path to the invalid field
+ *   - value: The invalid value
+ *
+ * Returns an empty array if:
+ * - The error is not a valid Yup ValidationError
+ * - The error doesn't have an `inner` property
+ * - The `inner` property is not an array
+ */
+function extractValidationErrors(
+  error: unknown
+): Array<{ message: string; path: string; value: unknown }> {
+  if (
+    error &&
+    typeof error === "object" &&
+    "inner" in error &&
+    Array.isArray(error.inner)
+  ) {
+    return error.inner.map((e: unknown) => {
+      // Extract only the needed properties from the error object
+      if (e && typeof e === "object") {
+        return {
+          message: "message" in e ? String(e.message) : "",
+          path: (e as { path: string }).path || "",
+          value: (e as { value?: unknown }).value || undefined
+        };
+      }
+      return { message: "", path: "", value: undefined };
+    });
+  }
+  return [];
+}
+
 export function checkExchangePolicy(
   offerData: OfferFieldsFragment,
   rules: CheckExchangePolicyRules
 ): CheckExchangePolicyResult {
-  const baseSchema: Schema<unknown> = buildYup(
-    rules.yupSchema,
-    rules.yupConfig
-  );
+  let baseSchema: Schema<unknown>;
+
+  const metadataType = offerData.metadata?.type;
+
+  if (
+    !rules.yupSchema.metadataType ||
+    metadataType === rules.yupSchema.metadataType
+  ) {
+    baseSchema = buildYup(rules.yupSchema, rules.yupConfig);
+  } else {
+    // For multiple schemas, use the one matching metadata.type
+    const rulesTemplate = rules.yupSchemas?.find(
+      (schema) => schema.metadataType === metadataType
+    );
+
+    if (!rulesTemplate) {
+      return {
+        isValid: false,
+        errors: [
+          {
+            message: `Unsupported metadata type: ${String(metadataType)}`,
+            path: "metadata.type",
+            value: metadataType
+          }
+        ]
+      };
+    }
+
+    baseSchema = buildYup(rulesTemplate, rules.yupConfig);
+  }
+
+  let result = {
+    isValid: true,
+    errors: []
+  };
   try {
     baseSchema.validateSync(offerData, { abortEarly: false });
   } catch (e) {
-    return {
+    result = {
       isValid: false,
-      errors:
-        e.inner?.map((error) => {
-          return { ...error };
-        }) || []
+      errors: extractValidationErrors(e)
     };
   }
-  return {
-    isValid: true,
-    errors: []
-  };
+  if (metadataType === "BUNDLE") {
+    // For BUNDLE metadata, check each item in the bundle
+    const bundleItems =
+      (offerData.metadata as { items?: { type?: string }[] })?.items || [];
+    if (bundleItems.length === 0) {
+      // An empty bundle is semantically invalid
+      result.isValid = false;
+      result.errors = result.errors.concat([
+        {
+          message: "Bundle metadata must contain at least one item.",
+          path: "metadata.items",
+          value: bundleItems
+        }
+      ]);
+    } else {
+      for (const item of bundleItems) {
+        const itemType = item.type;
+        const itemRulesTemplate = Array.isArray(rules.yupSchemas)
+          ? rules.yupSchemas.find((schema) => schema.metadataType === itemType)
+          : undefined;
+        const itemSchema = itemRulesTemplate
+          ? buildYup(itemRulesTemplate, rules.yupConfig)
+          : undefined;
+        if (itemSchema) {
+          try {
+            itemSchema.validateSync(item, { abortEarly: false });
+          } catch (e) {
+            result.isValid = false;
+            result.errors = result.errors.concat(extractValidationErrors(e));
+          }
+        }
+      }
+    }
+    // Ensure bundle contains at least one ITEM_PRODUCT_V1 item,
+    // as required by the UI logic to extract exchange policy and shipping data.
+    const hasRequiredProductItem = bundleItems.some(
+      (item) => item.type === "ITEM_PRODUCT_V1"
+    );
+    if (!hasRequiredProductItem) {
+      result.isValid = false;
+      result.errors = result.errors.concat({
+        message:
+          "Bundle metadata must contain at least one ITEM_PRODUCT_V1 item to provide exchange policy and shipping information.",
+        path: "metadata.items",
+        value: bundleItems
+      });
+    }
+  }
+  return result;
 }

packages/core-sdk/src/offers/renderContractualAgreement.ts

@@ -9,7 +9,10 @@ import { CreateOfferArgs } from "./types";
 import {
   OfferFieldsFragment,
   MetadataType,
-  ProductV1MetadataEntity
+  ProductV1MetadataEntity,
+  ProductV1ItemMetadataEntity,
+  ItemMetadataType,
+  BundleMetadataEntity
 } from "../subgraph";
 import { AddressZero } from "@ethersproject/constants";
 
@@ -172,6 +175,13 @@ function convertExistingOfferData(offerDataSubGraph: OfferFieldsFragment): {
   offerMetadata: AdditionalOfferMetadata;
   tokenInfo: ITokenInfo;
 } {
+  const productItemMetadata =
+    offerDataSubGraph.metadata?.type === MetadataType.BUNDLE
+      ? (offerDataSubGraph.metadata as BundleMetadataEntity).items?.find(
+          (item): item is ProductV1ItemMetadataEntity =>
+            item.type === ItemMetadataType.ITEM_PRODUCT_V1
+        )
+      : undefined;
   return {
     offerData: {
       ...offerDataSubGraph,
@@ -182,6 +192,7 @@ function convertExistingOfferData(offerDataSubGraph: OfferFieldsFragment): {
         offerDataSubGraph.voucherRedeemableFromDate,
       voucherRedeemableUntilDateInMS:
         offerDataSubGraph.voucherRedeemableUntilDate,
+      voucherValidDurationInMS: offerDataSubGraph.voucherValidDuration,
       disputePeriodDurationInMS: offerDataSubGraph.disputePeriodDuration,
       resolutionPeriodDurationInMS: offerDataSubGraph.resolutionPeriodDuration,
       exchangeToken: offerDataSubGraph.exchangeToken.address,
@@ -197,16 +208,20 @@ function convertExistingOfferData(offerDataSubGraph: OfferFieldsFragment): {
         offerDataSubGraph.metadata as ProductV1MetadataEntity
       )?.exchangePolicy.sellerContactMethod,
       disputeResolverContactMethod: (
-        offerDataSubGraph.metadata as ProductV1MetadataEntity
+        productItemMetadata ||
+        (offerDataSubGraph.metadata as ProductV1MetadataEntity)
       )?.exchangePolicy.disputeResolverContactMethod,
       escalationDeposit:
         offerDataSubGraph.disputeResolutionTerms.buyerEscalationDeposit,
       escalationResponsePeriodInSec:
         offerDataSubGraph.disputeResolutionTerms.escalationResponsePeriod,
-      sellerTradingName: (offerDataSubGraph.metadata as ProductV1MetadataEntity)
-        ?.productV1Seller?.name,
+      sellerTradingName: (
+        productItemMetadata ||
+        (offerDataSubGraph.metadata as ProductV1MetadataEntity)
+      )?.productV1Seller?.name,
       returnPeriodInDays: (
-        offerDataSubGraph.metadata as ProductV1MetadataEntity
+        productItemMetadata ||
+        (offerDataSubGraph.metadata as ProductV1MetadataEntity)
       )?.shipping.returnPeriodInDays
     },
     tokenInfo: {