@carrot-foundation/schemas 0.1.37 → 0.1.38

package/dist/index.cjs

@@ -292,6 +292,7 @@ var RecordSchemaTypeSchema = zod.z.enum([
   "RecycledID",
   "GasID",
   "CreditPurchaseReceipt",
+  "CreditRetirementReceipt",
   "Methodology",
   "Credit",
   "Collection"
@@ -308,6 +309,11 @@ var TokenSymbolSchema = NonEmptyStringSchema.max(10).regex(
   description: "Symbol representing a token or cryptocurrency",
   examples: ["MASS", "REC", "GAS"]
 });
+var CreditTokenSymbolSchema = TokenSymbolSchema.meta({
+  title: "Credit Token Symbol",
+  description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
+  examples: ["C-CARB", "C-BIOW"]
+});
 var RecordRelationshipTypeSchema = zod.z.enum([
   "collection",
   "credit",
@@ -316,6 +322,7 @@ var RecordRelationshipTypeSchema = zod.z.enum([
   "mass-id-audit",
   "methodology",
   "credit-purchase-receipt",
+  "credit-retirement-receipt",
   "recycled-id"
 ]).meta({
   title: "Relationship Type",
@@ -733,7 +740,8 @@ var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   "MassID",
   "RecycledID",
   "GasID",
-  "CreditPurchaseReceipt"
+  "CreditPurchaseReceipt",
+  "CreditRetirementReceipt"
 ]).meta({
   title: "NFT Schema Type",
   description: "Type of schema for NFT records"
@@ -910,7 +918,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.37";
+  return "0.1.38";
 }
 var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
@@ -1085,6 +1093,331 @@ var AuditRuleExecutionResultsSchema = zod.z.array(AuditRuleExecutionResultSchema
   title: "Audit Rule Execution Results",
   description: "Detailed results of each audit rule execution"
 });
+var EPSILON = 1e-9;
+function nearlyEqual(a, b, epsilon = EPSILON) {
+  return Math.abs(a - b) <= epsilon;
+}
+var SummaryBaseSchema = zod.z.strictObject({
+  total_certificates: PositiveIntegerSchema.meta({
+    title: "Total Certificates",
+    description: "Total number of certificates represented in the receipt"
+  }),
+  credit_symbols: uniqueArrayItems(
+    CreditTokenSymbolSchema,
+    "Credit symbols must be unique"
+  ).min(1).meta({
+    title: "Credit Symbols",
+    description: "Array of credit token symbols represented in the receipt"
+  }),
+  certificate_types: uniqueArrayItems(
+    RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]),
+    "Certificate types must be unique"
+  ).min(1).meta({
+    title: "Certificate Types",
+    description: "Array of certificate types represented in the receipt"
+  }),
+  collection_slugs: uniqueArrayItems(
+    CollectionSlugSchema,
+    "Collection slugs must be unique"
+  ).min(1).meta({
+    title: "Collection Slugs",
+    description: "Array of collection slugs represented in the receipt"
+  })
+});
+var CreditPurchaseReceiptSummarySchema = SummaryBaseSchema.extend({
+  total_usdc_amount: NonNegativeFloatSchema.meta({
+    title: "Total USDC Amount",
+    description: "Total amount paid in USDC for the purchase"
+  }),
+  total_credits: CreditAmountSchema.meta({
+    title: "Total Credits",
+    description: "Total amount of credits purchased"
+  }),
+  purchase_date: IsoDateSchema.meta({
+    title: "Purchase Date",
+    description: "Date when the purchase was made (YYYY-MM-DD)"
+  })
+}).meta({
+  title: "Credit Purchase Receipt Summary",
+  description: "Summary totals for the credit purchase including amounts and collections represented"
+});
+var CreditRetirementReceiptSummarySchema = SummaryBaseSchema.extend({
+  total_retirement_amount: CreditAmountSchema.meta({
+    title: "Total Retirement Amount",
+    description: "Total amount of credits retired"
+  }),
+  retirement_date: IsoDateSchema.meta({
+    title: "Retirement Date",
+    description: "Date when the retirement occurred (YYYY-MM-DD)"
+  })
+}).meta({
+  title: "Credit Retirement Receipt Summary",
+  description: "Summary totals for the credit retirement including amounts and collections represented"
+});
+var ReceiptIdentitySchema = zod.z.strictObject({
+  name: ParticipantNameSchema.meta({
+    title: "Identity Name",
+    description: "Display name for the participant",
+    examples: ["EcoTech Solutions Inc.", "Climate Action Corp"]
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Identity External ID",
+    description: "External identifier for the participant"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Identity External URL",
+    description: "External URL for the participant profile"
+  })
+}).meta({
+  title: "Identity",
+  description: "Participant identity information"
+});
+var MassIdReferenceWithContractSchema = MassIDReferenceSchema.safeExtend({
+  smart_contract: SmartContractSchema
+}).meta({
+  title: "MassID Reference with Smart Contract",
+  description: "Reference to a MassID record including smart contract details"
+});
+function createReceiptCollectionSchema(params) {
+  const { amountKey, amountMeta, meta } = params;
+  return zod.z.strictObject({
+    slug: CollectionSlugSchema,
+    external_id: ExternalIdSchema.meta({
+      title: "Collection External ID",
+      description: "External identifier for the collection"
+    }),
+    name: CollectionNameSchema,
+    external_url: ExternalUrlSchema.meta({
+      title: "Collection External URL",
+      description: "External URL for the collection"
+    }),
+    uri: IpfsUriSchema.meta({
+      title: "Collection URI",
+      description: "IPFS URI for the collection metadata"
+    }),
+    [amountKey]: CreditAmountSchema.meta(amountMeta)
+  }).meta(meta);
+}
+function createReceiptCreditSchema(params) {
+  const { amountKey, amountMeta, meta, retirementAmountMeta } = params;
+  const creditShape = {
+    slug: SlugSchema.meta({
+      title: "Credit Slug",
+      description: "URL-friendly identifier for the credit"
+    }),
+    symbol: CreditTokenSymbolSchema.meta({
+      title: "Credit Token Symbol",
+      description: "Symbol of the credit token",
+      examples: ["CARBON", "ORGANIC", "C-CARB", "C-BIOW"]
+    }),
+    external_id: ExternalIdSchema.meta({
+      title: "Credit External ID",
+      description: "External identifier for the credit"
+    }),
+    external_url: ExternalUrlSchema.meta({
+      title: "Credit External URL",
+      description: "External URL for the credit"
+    }),
+    uri: IpfsUriSchema.meta({
+      title: "Credit URI",
+      description: "IPFS URI for the credit details"
+    }),
+    smart_contract: SmartContractSchema,
+    [amountKey]: CreditAmountSchema.meta(amountMeta)
+  };
+  if (retirementAmountMeta) {
+    creditShape.retirement_amount = CreditAmountSchema.optional().meta(retirementAmountMeta);
+  }
+  return zod.z.strictObject(creditShape).meta(meta);
+}
+var certificateBaseShape = {
+  token_id: TokenIdSchema.meta({
+    title: "Certificate Token ID",
+    description: "Token ID of the certificate"
+  }),
+  type: RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]).meta({
+    title: "Certificate Type",
+    description: "Type of certificate (e.g., GasID, RecycledID)"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Certificate External ID",
+    description: "External identifier for the certificate"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Certificate External URL",
+    description: "External URL for the certificate"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Certificate URI",
+    description: "IPFS URI for the certificate metadata"
+  }),
+  smart_contract: SmartContractSchema,
+  collection_slug: CollectionSlugSchema.meta({
+    title: "Collection Slug",
+    description: "Slug of the collection this certificate belongs to"
+  }),
+  total_amount: CreditAmountSchema.meta({
+    title: "Certificate Total Amount",
+    description: "Total credits available in this certificate"
+  }),
+  mass_id: MassIdReferenceWithContractSchema
+};
+function createReceiptCertificateSchema(params) {
+  return zod.z.strictObject({
+    ...certificateBaseShape,
+    ...params.additionalShape
+  }).meta(params.meta);
+}
+
+// src/shared/receipt/receipt.validation.ts
+function buildMessage(message, value) {
+  return typeof message === "function" ? message(value) : message;
+}
+function createAttributeMap(attributes) {
+  return new Map(
+    attributes.map((attribute) => [attribute.trait_type, attribute])
+  );
+}
+function validateSummaryListMatchesData(params) {
+  const { ctx, summaryValues, dataValues, summaryPath } = params;
+  const summarySet = new Set(summaryValues);
+  const dataSet = new Set(dataValues);
+  summarySet.forEach((value) => {
+    if (!dataSet.has(value)) {
+      ctx.addIssue({
+        code: "custom",
+        message: buildMessage(params.missingFromDataMessage, value),
+        path: summaryPath
+      });
+    }
+  });
+  dataSet.forEach((value) => {
+    if (!summarySet.has(value)) {
+      ctx.addIssue({
+        code: "custom",
+        message: buildMessage(params.missingFromSummaryMessage, value),
+        path: summaryPath
+      });
+    }
+  });
+}
+function validateTotalMatches(params) {
+  const { ctx, actualTotal, expectedTotal, path, message } = params;
+  if (!nearlyEqual(actualTotal, expectedTotal)) {
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path
+    });
+  }
+}
+function validateCountMatches(params) {
+  const { ctx, actualCount, expectedCount, path, message } = params;
+  if (actualCount !== expectedCount) {
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path
+    });
+  }
+}
+function validateAttributeValue(params) {
+  const {
+    ctx,
+    attributeByTraitType,
+    traitType,
+    expectedValue,
+    missingMessage,
+    mismatchMessage,
+    path = ["attributes"]
+  } = params;
+  const attribute = attributeByTraitType.get(traitType);
+  if (!attribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: missingMessage,
+      path
+    });
+    return;
+  }
+  if (attribute.value !== expectedValue) {
+    ctx.addIssue({
+      code: "custom",
+      message: mismatchMessage,
+      path
+    });
+  }
+}
+function validateDateAttribute(params) {
+  const {
+    ctx,
+    attributeByTraitType,
+    traitType,
+    dateValue,
+    missingMessage,
+    invalidDateMessage,
+    mismatchMessage,
+    attributePath = ["attributes"],
+    datePath
+  } = params;
+  const attribute = attributeByTraitType.get(traitType);
+  if (!attribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: missingMessage,
+      path: attributePath
+    });
+    return;
+  }
+  const dateMs = Date.parse(`${dateValue}T00:00:00.000Z`);
+  if (Number.isNaN(dateMs)) {
+    ctx.addIssue({
+      code: "custom",
+      message: invalidDateMessage,
+      path: datePath ?? attributePath
+    });
+    return;
+  }
+  if (attribute.value !== dateMs) {
+    ctx.addIssue({
+      code: "custom",
+      message: mismatchMessage,
+      path: attributePath
+    });
+  }
+}
+function validateAttributesForItems(params) {
+  const {
+    ctx,
+    attributeByTraitType,
+    items,
+    traitSelector,
+    valueSelector,
+    missingMessage,
+    mismatchMessage,
+    path = ["attributes"]
+  } = params;
+  items.forEach((item) => {
+    const traitType = traitSelector(item);
+    const expectedValue = valueSelector(item);
+    const attribute = attributeByTraitType.get(traitType);
+    if (!attribute) {
+      ctx.addIssue({
+        code: "custom",
+        message: missingMessage(traitType),
+        path
+      });
+      return;
+    }
+    if (attribute.value !== expectedValue) {
+      ctx.addIssue({
+        code: "custom",
+        message: mismatchMessage(traitType),
+        path
+      });
+    }
+  });
+}
 
 // src/mass-id/mass-id.attributes.ts
 var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
@@ -1905,66 +2238,7 @@ var CreditPurchaseReceiptAttributesSchema = uniqueBy(
   title: "Credit Purchase Receipt NFT Attribute Array",
   description: "Attributes for credit purchase receipts including per-credit breakdowns, totals, receiver, purchase date, and per-collection amounts. Attributes must have unique trait types."
 });
-var CreditPurchaseReceiptSummarySchema = zod.z.strictObject({
-  total_usdc_amount: NonNegativeFloatSchema.meta({
-    title: "Total USDC Amount",
-    description: "Total amount paid in USDC for the purchase"
-  }),
-  total_credits: CreditAmountSchema.meta({
-    title: "Total Credits",
-    description: "Total amount of credits purchased"
-  }),
-  total_certificates: PositiveIntegerSchema.meta({
-    title: "Total Certificates",
-    description: "Total number of certificates purchased"
-  }),
-  purchase_date: IsoDateSchema.meta({
-    title: "Purchase Date",
-    description: "Date when the purchase was made (YYYY-MM-DD)"
-  }),
-  credit_symbols: uniqueArrayItems(
-    TokenSymbolSchema,
-    "Credit symbols must be unique"
-  ).min(1).meta({
-    title: "Credit Symbols",
-    description: "Array of credit token symbols included in the purchase"
-  }),
-  certificate_types: uniqueArrayItems(
-    RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]),
-    "Certificate types must be unique"
-  ).min(1).meta({
-    title: "Certificate Types",
-    description: "Array of certificate types included in the purchase"
-  }),
-  collection_slugs: uniqueArrayItems(
-    CollectionSlugSchema,
-    "Collection slugs must be unique"
-  ).min(1).meta({
-    title: "Collection Slugs",
-    description: "Array of collection slugs represented in the purchase"
-  })
-}).meta({
-  title: "Credit Purchase Receipt Summary",
-  description: "Summary totals for the credit purchase including amounts and collections represented"
-});
-var CreditPurchaseReceiptIdentitySchema = zod.z.strictObject({
-  name: ParticipantNameSchema.meta({
-    title: "Identity Name",
-    description: "Display name for the participant",
-    examples: ["EcoTech Solutions Inc."]
-  }),
-  external_id: ExternalIdSchema.meta({
-    title: "Identity External ID",
-    description: "External identifier for the participant"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Identity External URL",
-    description: "External URL for the participant profile"
-  })
-}).meta({
-  title: "Identity",
-  description: "Participant identity information"
-});
+var CreditPurchaseReceiptIdentitySchema = ReceiptIdentitySchema;
 var CreditPurchaseReceiptReceiverSchema = zod.z.strictObject({
   wallet_address: EthereumAddressSchema.meta({
     title: "Receiver Wallet Address",
@@ -1996,123 +2270,52 @@ var CreditPurchaseReceiptPartiesSchema = zod.z.strictObject({
   title: "Parties",
   description: "Parties involved in the purchase including payer, receiver, and optional buyer"
 });
-var CreditPurchaseReceiptCollectionSchema = zod.z.strictObject({
-  slug: CollectionSlugSchema,
-  external_id: ExternalIdSchema.meta({
-    title: "Collection External ID",
-    description: "External identifier for the collection"
-  }),
-  name: CollectionNameSchema,
-  external_url: ExternalUrlSchema.meta({
-    title: "Collection External URL",
-    description: "External URL for the collection"
-  }),
-  uri: IpfsUriSchema.meta({
-    title: "Collection URI",
-    description: "IPFS URI for the collection metadata"
-  }),
-  credit_amount: CreditAmountSchema.meta({
+var CreditPurchaseReceiptCollectionSchema = createReceiptCollectionSchema({
+  amountKey: "credit_amount",
+  amountMeta: {
     title: "Collection Credit Amount",
     description: "Total credits purchased from this collection"
-  })
-}).meta({
-  title: "Collection",
-  description: "Collection included in the purchase"
+  },
+  meta: {
+    title: "Collection",
+    description: "Collection included in the purchase"
+  }
 });
-var CreditPurchaseReceiptCreditSchema = zod.z.strictObject({
-  slug: SlugSchema.meta({
-    title: "Credit Slug",
-    description: "URL-friendly identifier for the credit"
-  }),
-  symbol: TokenSymbolSchema.meta({
-    title: "Credit Token Symbol",
-    description: "Symbol of the credit token",
-    examples: ["C-CARB", "C-BIOW"]
-  }),
-  external_id: ExternalIdSchema.meta({
-    title: "Credit External ID",
-    description: "External identifier for the credit"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Credit External URL",
-    description: "External URL for the credit"
-  }),
-  uri: IpfsUriSchema.meta({
-    title: "Credit URI",
-    description: "IPFS URI for the credit details"
-  }),
-  smart_contract: SmartContractSchema,
-  purchase_amount: CreditAmountSchema.meta({
+var CreditPurchaseReceiptCreditSchema = createReceiptCreditSchema({
+  amountKey: "purchase_amount",
+  amountMeta: {
     title: "Credit Purchase Amount",
     description: "Total credits purchased for this credit type"
-  }),
-  retirement_amount: CreditAmountSchema.optional().meta({
+  },
+  retirementAmountMeta: {
     title: "Credit Retirement Amount",
     description: "Credits retired immediately for this credit type during purchase"
-  })
-}).meta({
-  title: "Credit",
-  description: "Credit token included in the purchase"
+  },
+  meta: {
+    title: "Credit",
+    description: "Credit token included in the purchase"
+  }
 });
-var MassIDReferenceWithContractSchema = MassIDReferenceSchema.omit({
-  external_id: true
-}).safeExtend({
-  external_id: ExternalIdSchema.meta({
-    title: "MassID External ID",
-    description: "Unique identifier for the referenced MassID"
-  }),
-  smart_contract: SmartContractSchema
-}).meta({
-  title: "MassID Reference with Smart Contract",
-  description: "Reference to a MassID record including smart contract details"
-});
-var CreditPurchaseReceiptCertificateSchema = zod.z.strictObject({
-  token_id: TokenIdSchema.meta({
-    title: "Certificate Token ID",
-    description: "Token ID of the certificate"
-  }),
-  type: RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]).meta({
-    title: "Certificate Type",
-    description: "Type of certificate (e.g., GasID, RecycledID)"
-  }),
-  external_id: ExternalIdSchema.meta({
-    title: "Certificate External ID",
-    description: "External identifier for the certificate"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Certificate External URL",
-    description: "External URL for the certificate"
-  }),
-  uri: IpfsUriSchema.meta({
-    title: "Certificate URI",
-    description: "IPFS URI for the certificate metadata"
-  }),
-  smart_contract: SmartContractSchema,
-  collection_slug: CollectionSlugSchema.meta({
-    title: "Collection Slug",
-    description: "Slug of the collection this certificate belongs to"
-  }),
-  total_amount: CreditAmountSchema.meta({
-    title: "Certificate Total Amount",
-    description: "Total credits available in this certificate"
-  }),
-  purchased_amount: CreditAmountSchema.meta({
-    title: "Certificate Purchased Amount",
-    description: "Credits purchased from this certificate"
-  }),
-  retired_amount: CreditAmountSchema.meta({
-    title: "Certificate Retired Amount",
-    description: "Credits retired from this certificate during the purchase (0 if none)"
-  }),
-  credit_slug: SlugSchema.meta({
-    title: "Credit Slug",
-    description: "Slug of the credit type for this certificate",
-    examples: ["carbon", "organic"]
-  }),
-  mass_id: MassIDReferenceWithContractSchema
-}).meta({
-  title: "Certificate",
-  description: "Certificate associated with the purchase"
+var CreditPurchaseReceiptCertificateSchema = createReceiptCertificateSchema({
+  additionalShape: {
+    purchased_amount: CreditAmountSchema.meta({
+      title: "Certificate Purchased Amount",
+      description: "Credits purchased from this certificate"
+    }),
+    retired_amount: CreditAmountSchema.meta({
+      title: "Certificate Retired Amount",
+      description: "Credits retired from this certificate during the purchase (0 if none)"
+    }),
+    credit_slug: SlugSchema.meta({
+      title: "Credit Slug",
+      description: "Slug of the credit type for this certificate",
+      examples: ["carbon", "organic"]
+    })
+  },
+  meta: {
+    title: "Certificate",
+    description: "Certificate associated with the purchase"
+  }
 });
 var CreditPurchaseReceiptParticipantRewardSchema = zod.z.strictObject({
   id_hash: Sha256HashSchema.meta({
@@ -2170,10 +2373,6 @@ var CreditPurchaseReceiptRetirementSchema = zod.z.strictObject({
   title: "Retirement",
   description: "Immediate retirement details performed as part of purchase"
 });
-var EPSILON = 1e-9;
-function nearlyEqual(a, b) {
-  return Math.abs(a - b) <= EPSILON;
-}
 var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   summary: CreditPurchaseReceiptSummarySchema,
   parties: CreditPurchaseReceiptPartiesSchema,
@@ -2214,7 +2413,8 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   const retirementProvided = Boolean(data.retirement);
   const creditsWithRetirement = data.credits.reduce(
     (indices, credit, index) => {
-      if ((credit.retirement_amount ?? 0) > 0) {
+      const retirementAmount = Number(credit.retirement_amount ?? 0);
+      if (retirementAmount > 0) {
         indices.push(index);
       }
       return indices;
@@ -2237,77 +2437,48 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
       });
     });
   }
+  validateCountMatches({
+    ctx,
+    actualCount: data.certificates.length,
+    expectedCount: data.summary.total_certificates,
+    path: ["summary", "total_certificates"],
+    message: "summary.total_certificates must equal the number of certificates"
+  });
   const collectionSlugs = new Set(
-    data.collections.map((collection) => collection.slug)
+    data.collections.map((collection) => String(collection.slug))
+  );
+  const creditSlugs = new Set(
+    data.credits.map((credit) => String(credit.slug))
+  );
+  const creditSymbols = new Set(
+    data.credits.map((credit) => String(credit.symbol))
   );
-  const creditSlugs = new Set(data.credits.map((credit) => credit.slug));
-  const creditSymbols = new Set(data.credits.map((credit) => credit.symbol));
-  const summaryCreditSymbols = new Set(data.summary.credit_symbols);
-  const summaryCollectionSlugs = new Set(data.summary.collection_slugs);
-  const summaryCertificateTypes = new Set(data.summary.certificate_types);
-  if (data.summary.total_certificates !== data.certificates.length) {
-    ctx.addIssue({
-      code: "custom",
-      message: "summary.total_certificates must equal the number of certificates",
-      path: ["summary", "total_certificates"]
-    });
-  }
-  data.summary.credit_symbols.forEach((symbol) => {
-    if (!creditSymbols.has(symbol)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "summary.credit_symbols must reference symbols from credits",
-        path: ["summary", "credit_symbols"]
-      });
-    }
-  });
-  creditSymbols.forEach((symbol) => {
-    if (!summaryCreditSymbols.has(symbol)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "All credit symbols must be listed in summary.credit_symbols",
-        path: ["summary", "credit_symbols"]
-      });
-    }
-  });
-  data.summary.collection_slugs.forEach((slug) => {
-    if (!collectionSlugs.has(slug)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "summary.collection_slugs must reference slugs from collections",
-        path: ["summary", "collection_slugs"]
-      });
-    }
-  });
-  collectionSlugs.forEach((slug) => {
-    if (!summaryCollectionSlugs.has(slug)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "All collection slugs must be listed in summary.collection_slugs",
-        path: ["summary", "collection_slugs"]
-      });
-    }
-  });
   const certificateTypes = new Set(
-    data.certificates.map((certificate) => certificate.type)
+    data.certificates.map((certificate) => String(certificate.type))
   );
-  data.summary.certificate_types.forEach((type) => {
-    if (!certificateTypes.has(type)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "summary.certificate_types must reference types present in certificates",
-        path: ["summary", "certificate_types"]
-      });
-    }
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.credit_symbols,
+    dataValues: creditSymbols,
+    summaryPath: ["summary", "credit_symbols"],
+    missingFromDataMessage: "summary.credit_symbols must reference symbols from credits",
+    missingFromSummaryMessage: "All credit symbols must be listed in summary.credit_symbols"
   });
-  certificateTypes.forEach((type) => {
-    if (!summaryCertificateTypes.has(type)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "All certificate types must be listed in summary.certificate_types",
-        path: ["summary", "certificate_types"]
-      });
-    }
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.collection_slugs,
+    dataValues: collectionSlugs,
+    summaryPath: ["summary", "collection_slugs"],
+    missingFromDataMessage: "summary.collection_slugs must reference slugs from collections",
+    missingFromSummaryMessage: "All collection slugs must be listed in summary.collection_slugs"
+  });
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.certificate_types,
+    dataValues: certificateTypes,
+    summaryPath: ["summary", "certificate_types"],
+    missingFromDataMessage: "summary.certificate_types must reference types present in certificates",
+    missingFromSummaryMessage: "All certificate types must be listed in summary.certificate_types"
   });
   const creditPurchaseTotalsBySlug = /* @__PURE__ */ new Map();
   const creditRetiredTotalsBySlug = /* @__PURE__ */ new Map();
@@ -2342,60 +2513,60 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
         path: ["certificates", index, "purchased_amount"]
       });
     }
-    totalCreditsFromCertificates += certificate.purchased_amount;
+    totalCreditsFromCertificates += Number(certificate.purchased_amount);
     creditPurchaseTotalsBySlug.set(
-      certificate.credit_slug,
-      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificate.purchased_amount
+      String(certificate.credit_slug),
+      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + Number(certificate.purchased_amount)
     );
     creditRetiredTotalsBySlug.set(
-      certificate.credit_slug,
-      (creditRetiredTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificate.retired_amount
+      String(certificate.credit_slug),
+      (creditRetiredTotalsBySlug.get(certificate.credit_slug) ?? 0) + Number(certificate.retired_amount)
     );
     collectionTotalsBySlug.set(
-      certificate.collection_slug,
-      (collectionTotalsBySlug.get(certificate.collection_slug) ?? 0) + certificate.purchased_amount
+      String(certificate.collection_slug),
+      (collectionTotalsBySlug.get(certificate.collection_slug) ?? 0) + Number(certificate.purchased_amount)
     );
   });
   const totalCreditsFromCollections = data.collections.reduce(
-    (sum, collection) => sum + collection.credit_amount,
+    (sum, collection) => sum + Number(collection.credit_amount),
     0
   );
   const totalCreditsFromCredits = data.credits.reduce(
-    (sum, credit) => sum + credit.purchase_amount,
+    (sum, credit) => sum + Number(credit.purchase_amount),
     0
   );
-  if (!nearlyEqual(totalCreditsFromCertificates, data.summary.total_credits)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "summary.total_credits must equal sum of certificates.purchased_amount",
-      path: ["summary", "total_credits"]
-    });
-  }
-  if (!nearlyEqual(totalCreditsFromCredits, data.summary.total_credits)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "summary.total_credits must equal sum of credits.purchase_amount",
-      path: ["summary", "total_credits"]
-    });
-  }
-  if (!nearlyEqual(totalCreditsFromCollections, data.summary.total_credits)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "summary.total_credits must equal sum of collections.credit_amount",
-      path: ["summary", "total_credits"]
-    });
-  }
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalCreditsFromCertificates,
+    expectedTotal: data.summary.total_credits,
+    path: ["summary", "total_credits"],
+    message: "summary.total_credits must equal sum of certificates.purchased_amount"
+  });
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalCreditsFromCredits,
+    expectedTotal: data.summary.total_credits,
+    path: ["summary", "total_credits"],
+    message: "summary.total_credits must equal sum of credits.purchase_amount"
+  });
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalCreditsFromCollections,
+    expectedTotal: data.summary.total_credits,
+    path: ["summary", "total_credits"],
+    message: "summary.total_credits must equal sum of collections.credit_amount"
+  });
   data.credits.forEach((credit, index) => {
-    const purchasedTotal = creditPurchaseTotalsBySlug.get(credit.slug) ?? 0;
-    if (!nearlyEqual(credit.purchase_amount, purchasedTotal)) {
+    const purchasedTotal = creditPurchaseTotalsBySlug.get(String(credit.slug)) ?? 0;
+    if (!nearlyEqual(Number(credit.purchase_amount), purchasedTotal)) {
       ctx.addIssue({
         code: "custom",
         message: "credit.purchase_amount must equal sum of certificate purchased_amount for the credit slug",
         path: ["credits", index, "purchase_amount"]
       });
     }
-    const retiredTotal = creditRetiredTotalsBySlug.get(credit.slug) ?? 0;
-    const retirementAmount = credit.retirement_amount ?? 0;
+    const retiredTotal = creditRetiredTotalsBySlug.get(String(credit.slug)) ?? 0;
+    const retirementAmount = Number(credit.retirement_amount ?? 0);
     if (!nearlyEqual(retirementAmount, retiredTotal)) {
       ctx.addIssue({
         code: "custom",
@@ -2405,8 +2576,8 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
     }
   });
   data.collections.forEach((collection, index) => {
-    const purchasedTotal = collectionTotalsBySlug.get(collection.slug) ?? 0;
-    if (!nearlyEqual(collection.credit_amount, purchasedTotal)) {
+    const purchasedTotal = collectionTotalsBySlug.get(String(collection.slug)) ?? 0;
+    if (!nearlyEqual(Number(collection.credit_amount), purchasedTotal)) {
       ctx.addIssue({
         code: "custom",
         message: "collection.credit_amount must equal sum of certificate purchased_amount for the collection slug",
@@ -2415,16 +2586,16 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
     }
   });
   const participantRewardTotal = data.participant_rewards.reduce(
-    (sum, reward) => sum + reward.usdc_amount,
+    (sum, reward) => sum + Number(reward.usdc_amount),
     0
   );
-  if (!nearlyEqual(participantRewardTotal, data.summary.total_usdc_amount)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "summary.total_usdc_amount must equal sum of participant_rewards.usdc_amount",
-      path: ["summary", "total_usdc_amount"]
-    });
-  }
+  validateTotalMatches({
+    ctx,
+    actualTotal: participantRewardTotal,
+    expectedTotal: data.summary.total_usdc_amount,
+    path: ["summary", "total_usdc_amount"],
+    message: "summary.total_usdc_amount must equal sum of participant_rewards.usdc_amount"
+  });
 }).meta({
   title: "Credit Purchase Receipt Data",
   description: "Complete data structure for a credit purchase receipt"
@@ -2449,133 +2620,595 @@ var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
 }).superRefine((value, ctx) => {
   const attributes = value.attributes;
   const data = value.data;
-  const attributeByTraitType = new Map(
-    attributes.map((attribute) => [attribute.trait_type, attribute])
-  );
-  const totalCreditsAttribute = attributeByTraitType.get(
-    "Total Credits Purchased"
-  );
-  const totalCreditsAttr = totalCreditsAttribute;
-  if (!totalCreditsAttr) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Total Credits Purchased" is required',
-      path: ["attributes"]
-    });
-  } else if (totalCreditsAttr.value !== data.summary.total_credits) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Total Credits Purchased" must match data.summary.total_credits',
-      path: ["attributes"]
+  const attributeByTraitType = createAttributeMap(attributes);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Total Credits Purchased",
+    expectedValue: data.summary.total_credits,
+    missingMessage: 'Attribute "Total Credits Purchased" is required',
+    mismatchMessage: 'Attribute "Total Credits Purchased" must match data.summary.total_credits'
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Total USDC Amount",
+    expectedValue: data.summary.total_usdc_amount,
+    missingMessage: 'Attribute "Total USDC Amount" is required',
+    mismatchMessage: 'Attribute "Total USDC Amount" must match data.summary.total_usdc_amount'
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Certificates Purchased",
+    expectedValue: data.summary.total_certificates,
+    missingMessage: 'Attribute "Certificates Purchased" is required',
+    mismatchMessage: 'Attribute "Certificates Purchased" must match data.summary.total_certificates'
+  });
+  const receiverName = data.parties.receiver.identity?.name;
+  if (receiverName) {
+    validateAttributeValue({
+      ctx,
+      attributeByTraitType,
+      traitType: "Receiver",
+      expectedValue: String(receiverName),
+      missingMessage: 'Attribute "Receiver" is required when receiver.identity.name is provided',
+      mismatchMessage: 'Attribute "Receiver" must match receiver.identity.name'
     });
   }
-  const totalUsdcAttribute = attributeByTraitType.get("Total USDC Amount");
-  if (!totalUsdcAttribute) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Total USDC Amount" is required',
-      path: ["attributes"]
-    });
-  } else if (totalUsdcAttribute.value !== data.summary.total_usdc_amount) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Total USDC Amount" must match data.summary.total_usdc_amount',
-      path: ["attributes"]
-    });
+  validateDateAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Purchase Date",
+    dateValue: data.summary.purchase_date,
+    missingMessage: 'Attribute "Purchase Date" is required',
+    invalidDateMessage: "data.summary.purchase_date must be a valid date string",
+    mismatchMessage: 'Attribute "Purchase Date" must match data.summary.purchase_date as a Unix timestamp in milliseconds',
+    datePath: ["data", "summary", "purchase_date"]
+  });
+  validateAttributesForItems({
+    ctx,
+    attributeByTraitType,
+    items: data.credits,
+    traitSelector: (credit) => String(credit.symbol),
+    valueSelector: (credit) => Number(credit.purchase_amount),
+    missingMessage: (symbol) => `Attribute for credit symbol ${symbol} is required`,
+    mismatchMessage: (symbol) => `Attribute for credit symbol ${symbol} must match credit.purchase_amount`
+  });
+  validateAttributesForItems({
+    ctx,
+    attributeByTraitType,
+    items: data.collections,
+    traitSelector: (collection) => String(collection.name),
+    valueSelector: (collection) => Number(collection.credit_amount),
+    missingMessage: (name) => `Attribute for collection ${name} is required`,
+    mismatchMessage: (name) => `Attribute for collection ${name} must match collection.credit_amount`
+  });
+}).meta(CreditPurchaseReceiptIpfsSchemaMeta);
+var CreditRetirementReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: CreditTokenSymbolSchema,
+  value: CreditAmountSchema.meta({
+    title: "Credit Retirement Amount",
+    description: "Amount of credits retired for the token symbol"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Credit Attribute",
+  description: "Attribute representing retired amount per credit token symbol"
+});
+var CreditRetirementReceiptTotalCreditsAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Total Credits Retired"),
+  value: CreditAmountSchema.meta({
+    title: "Total Credits Retired",
+    description: "Total number of credits retired across all tokens"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Total Credits Retired Attribute",
+  description: "Aggregate credits retired attribute"
+});
+var CreditRetirementReceiptBeneficiaryAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Beneficiary"),
+  value: ParticipantNameSchema.meta({
+    title: "Beneficiary",
+    description: "Beneficiary receiving the retirement benefit",
+    examples: ["Climate Action Corp"]
+  })
+}).meta({
+  title: "Beneficiary Attribute",
+  description: "Attribute containing the beneficiary display name"
+});
+var CreditRetirementReceiptCreditHolderAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Credit Holder"),
+  value: ParticipantNameSchema.meta({
+    title: "Credit Holder",
+    description: "Entity that surrendered the credits",
+    examples: ["EcoTech Solutions Inc."]
+  })
+}).meta({
+  title: "Credit Holder Attribute",
+  description: "Attribute containing the credit holder display name"
+});
+var CreditRetirementReceiptRetirementDateAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Retirement Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Retirement Date",
+    description: "Unix timestamp in milliseconds when the retirement was completed"
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Retirement Date Attribute",
+  description: "Retirement date attribute using Unix timestamp in milliseconds"
+});
+var CreditRetirementReceiptCertificatesAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Certificates Retired"),
+  value: PositiveIntegerSchema.meta({
+    title: "Certificates Retired",
+    description: "Total number of certificates retired"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Certificates Retired Attribute",
+  description: "Attribute representing how many certificates were retired in total"
+});
+var CreditRetirementReceiptCollectionAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: CollectionNameSchema,
+  value: CreditAmountSchema.meta({
+    title: "Credits from Collection",
+    description: "Amount of credits retired from the collection"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Collection Attribute",
+  description: "Attribute representing the amount of credits retired from a collection"
+});
+var CreditRetirementReceiptAttributesSchema = uniqueBy(
+  zod.z.union([
+    CreditRetirementReceiptCreditAttributeSchema,
+    CreditRetirementReceiptTotalCreditsAttributeSchema,
+    CreditRetirementReceiptBeneficiaryAttributeSchema,
+    CreditRetirementReceiptCreditHolderAttributeSchema,
+    CreditRetirementReceiptRetirementDateAttributeSchema,
+    CreditRetirementReceiptCertificatesAttributeSchema,
+    CreditRetirementReceiptCollectionAttributeSchema
+  ]),
+  (attribute) => attribute.trait_type,
+  "Attribute trait_type values must be unique"
+).min(6).meta({
+  title: "Credit Retirement Receipt NFT Attribute Array",
+  description: "Attributes for credit retirement receipts including per-credit breakdowns, totals, beneficiary, credit holder, retirement date, certificate count, and per-collection amounts. Attributes must have unique trait types."
+});
+var CreditRetirementReceiptIdentitySchema = ReceiptIdentitySchema;
+var CreditRetirementReceiptBeneficiarySchema = zod.z.strictObject({
+  beneficiary_id: ExternalIdSchema.meta({
+    title: "Retirement Beneficiary ID",
+    description: "UUID identifying the beneficiary of the retirement (bytes16 normalized to UUID)"
+  }),
+  identity: CreditRetirementReceiptIdentitySchema
+}).meta({
+  title: "Beneficiary",
+  description: "Beneficiary receiving the retirement benefit"
+});
+var CreditRetirementReceiptCreditHolderSchema = zod.z.strictObject({
+  wallet_address: EthereumAddressSchema.meta({
+    title: "Credit Holder Wallet Address",
+    description: "Ethereum address of the credit holder surrendering credits"
+  }),
+  identity: CreditRetirementReceiptIdentitySchema.optional()
+}).meta({
+  title: "Credit Holder",
+  description: "Credit holder wallet and optional identity information"
+});
+var CreditRetirementReceiptCollectionSchema = createReceiptCollectionSchema({
+  amountKey: "amount",
+  amountMeta: {
+    title: "Collection Retirement Amount",
+    description: "Total credits retired from this collection"
+  },
+  meta: {
+    title: "Collection",
+    description: "Collection included in the retirement"
   }
-  const certificatesAttribute = attributeByTraitType.get(
-    "Certificates Purchased"
-  );
-  if (!certificatesAttribute) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Certificates Purchased" is required',
-      path: ["attributes"]
-    });
-  } else if (certificatesAttribute.value !== data.summary.total_certificates) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Certificates Purchased" must match data.summary.total_certificates',
-      path: ["attributes"]
-    });
+});
+var CreditRetirementReceiptCreditSchema = createReceiptCreditSchema({
+  amountKey: "amount",
+  amountMeta: {
+    title: "Credit Retirement Amount",
+    description: "Total credits retired for this credit type"
+  },
+  meta: {
+    title: "Credit",
+    description: "Credit token retired in this receipt"
   }
-  const receiverAttribute = attributeByTraitType.get("Receiver");
-  if (data.parties.receiver.identity?.name && !receiverAttribute) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Receiver" is required when receiver.identity.name is provided',
-      path: ["attributes"]
-    });
-  } else if (receiverAttribute && data.parties.receiver.identity?.name && receiverAttribute.value !== data.parties.receiver.identity.name) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Receiver" must match receiver.identity.name',
-      path: ["attributes"]
-    });
+});
+var CreditRetirementReceiptCertificateCreditSchema = zod.z.strictObject({
+  credit_symbol: CreditTokenSymbolSchema.meta({
+    title: "Credit Token Symbol",
+    description: "Symbol of the credit token retired from the certificate"
+  }),
+  credit_slug: SlugSchema.meta({
+    title: "Credit Slug",
+    description: "Slug of the credit type retired from the certificate",
+    examples: ["carbon", "organic"]
+  }),
+  amount: CreditAmountSchema.meta({
+    title: "Retired Credit Amount",
+    description: "Credits retired of this type from the certificate"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Retired Credit External ID",
+    description: "External identifier for the retired credit entry"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Retired Credit External URL",
+    description: "External URL for the retired credit entry"
+  })
+}).meta({
+  title: "Certificate Credit Retirement",
+  description: "Credit retirement breakdown for a certificate"
+});
+var CreditPurchaseReceiptReferenceSchema = zod.z.strictObject({
+  token_id: TokenIdSchema.meta({
+    title: "Purchase Receipt Token ID",
+    description: "Token ID of the credit purchase receipt"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Purchase Receipt External ID",
+    description: "External identifier for the purchase receipt"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Purchase Receipt External URL",
+    description: "External URL for the purchase receipt"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Purchase Receipt URI",
+    description: "IPFS URI for the purchase receipt metadata"
+  }),
+  smart_contract: SmartContractSchema
+}).meta({
+  title: "Credit Purchase Receipt Reference",
+  description: "Reference to the credit purchase receipt when retirement occurs during purchase"
+});
+var CreditRetirementReceiptCertificateSchema = createReceiptCertificateSchema(
+  {
+    additionalShape: {
+      retired_amount: CreditAmountSchema.meta({
+        title: "Certificate Retired Amount",
+        description: "Credits retired from this certificate"
+      }),
+      credits_retired: uniqueBy(
+        CreditRetirementReceiptCertificateCreditSchema,
+        (credit) => credit.credit_symbol,
+        "Credit symbols within credits_retired must be unique"
+      ).min(1).meta({
+        title: "Credits Retired",
+        description: "Breakdown of credits retired from this certificate by symbol"
+      })
+    },
+    meta: {
+      title: "Certificate",
+      description: "Certificate associated with the retirement"
+    }
   }
-  const purchaseDateAttribute = attributeByTraitType.get("Purchase Date");
-  const purchaseDateAttr = purchaseDateAttribute;
-  if (!purchaseDateAttr) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Attribute "Purchase Date" is required',
-      path: ["attributes"]
-    });
-  } else {
-    const purchaseDateMs = Date.parse(
-      `${data.summary.purchase_date}T00:00:00.000Z`
-    );
-    if (Number.isNaN(purchaseDateMs)) {
+);
+var CreditRetirementReceiptDataSchema = zod.z.strictObject({
+  summary: CreditRetirementReceiptSummarySchema,
+  beneficiary: CreditRetirementReceiptBeneficiarySchema,
+  credit_holder: CreditRetirementReceiptCreditHolderSchema,
+  collections: uniqueBy(
+    CreditRetirementReceiptCollectionSchema,
+    (collection) => collection.slug,
+    "Collection slugs must be unique"
+  ).min(1).meta({
+    title: "Collections",
+    description: "Collections included in the retirement"
+  }),
+  credits: uniqueBy(
+    CreditRetirementReceiptCreditSchema,
+    (credit) => credit.slug,
+    "Credit slugs must be unique"
+  ).min(1).meta({
+    title: "Credits",
+    description: "Credits included in the retirement"
+  }),
+  certificates: uniqueBy(
+    CreditRetirementReceiptCertificateSchema,
+    (certificate) => certificate.token_id,
+    "Certificate token_ids must be unique"
+  ).min(1).meta({
+    title: "Certificates",
+    description: "Certificates retired in this receipt"
+  }),
+  purchase_receipt: CreditPurchaseReceiptReferenceSchema.optional()
+}).superRefine((data, ctx) => {
+  const creditSymbols = new Set(
+    data.credits.map((credit) => String(credit.symbol))
+  );
+  const creditBySlug = new Map(
+    data.credits.map((credit) => [credit.slug, credit])
+  );
+  const collectionSlugs = new Set(
+    data.collections.map((collection) => String(collection.slug))
+  );
+  const certificateTypes = new Set(
+    data.certificates.map((certificate) => String(certificate.type))
+  );
+  validateCountMatches({
+    ctx,
+    actualCount: data.certificates.length,
+    expectedCount: data.summary.total_certificates,
+    path: ["summary", "total_certificates"],
+    message: "summary.total_certificates must equal the number of certificates"
+  });
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.credit_symbols,
+    dataValues: creditSymbols,
+    summaryPath: ["summary", "credit_symbols"],
+    missingFromDataMessage: "summary.credit_symbols must reference symbols from credits",
+    missingFromSummaryMessage: "All credit symbols must be listed in summary.credit_symbols"
+  });
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.collection_slugs,
+    dataValues: collectionSlugs,
+    summaryPath: ["summary", "collection_slugs"],
+    missingFromDataMessage: "summary.collection_slugs must reference slugs from collections",
+    missingFromSummaryMessage: "All collection slugs must be listed in summary.collection_slugs"
+  });
+  validateSummaryListMatchesData({
+    ctx,
+    summaryValues: data.summary.certificate_types,
+    dataValues: certificateTypes,
+    summaryPath: ["summary", "certificate_types"],
+    missingFromDataMessage: "summary.certificate_types must reference types present in certificates",
+    missingFromSummaryMessage: "All certificate types must be listed in summary.certificate_types"
+  });
+  const creditTotalsBySymbol = /* @__PURE__ */ new Map();
+  const collectionTotalsBySlug = /* @__PURE__ */ new Map();
+  let totalRetiredFromCertificates = 0;
+  data.certificates.forEach((certificate, index) => {
+    if (!collectionSlugs.has(certificate.collection_slug)) {
       ctx.addIssue({
         code: "custom",
-        message: "data.summary.purchase_date must be a valid date string",
-        path: ["data", "summary", "purchase_date"]
+        message: "collection_slug must match a collection slug in collections",
+        path: ["certificates", index, "collection_slug"]
       });
-    } else if (purchaseDateAttr.value !== purchaseDateMs) {
+    }
+    if (certificate.retired_amount > certificate.total_amount) {
       ctx.addIssue({
         code: "custom",
-        message: 'Attribute "Purchase Date" must match data.summary.purchase_date as a Unix timestamp in milliseconds',
-        path: ["attributes"]
+        message: "retired_amount cannot exceed total_amount",
+        path: ["certificates", index, "retired_amount"]
       });
     }
-  }
-  data.credits.forEach((credit) => {
-    const creditAttribute = attributeByTraitType.get(credit.symbol);
-    if (!creditAttribute) {
+    const creditsRetiredTotal = certificate.credits_retired.reduce(
+      (sum, credit) => sum + Number(credit.amount),
+      0
+    );
+    if (!nearlyEqual(creditsRetiredTotal, certificate.retired_amount)) {
       ctx.addIssue({
         code: "custom",
-        message: `Attribute for credit symbol ${credit.symbol} is required`,
-        path: ["attributes"]
+        message: "certificates.credits_retired amounts must sum to certificates.retired_amount",
+        path: ["certificates", index, "credits_retired"]
+      });
+    }
+    certificate.credits_retired.forEach((credit, creditIndex) => {
+      const referencedCredit = creditBySlug.get(credit.credit_slug);
+      if (!referencedCredit) {
+        ctx.addIssue({
+          code: "custom",
+          message: "credit_slug must match a credit slug in credits",
+          path: [
+            "certificates",
+            index,
+            "credits_retired",
+            creditIndex,
+            "credit_slug"
+          ]
+        });
+      }
+      if (!creditSymbols.has(credit.credit_symbol)) {
+        ctx.addIssue({
+          code: "custom",
+          message: "credit_symbol must match a credit symbol in credits",
+          path: [
+            "certificates",
+            index,
+            "credits_retired",
+            creditIndex,
+            "credit_symbol"
+          ]
+        });
+      }
+      if (referencedCredit && referencedCredit.symbol !== credit.credit_symbol) {
+        ctx.addIssue({
+          code: "custom",
+          message: "credit_symbol must match the symbol for the referenced credit_slug",
+          path: [
+            "certificates",
+            index,
+            "credits_retired",
+            creditIndex,
+            "credit_symbol"
+          ]
+        });
+      }
+      creditTotalsBySymbol.set(
+        credit.credit_symbol,
+        (creditTotalsBySymbol.get(credit.credit_symbol) ?? 0) + credit.amount
+      );
+    });
+    collectionTotalsBySlug.set(
+      String(certificate.collection_slug),
+      (collectionTotalsBySlug.get(certificate.collection_slug) ?? 0) + Number(certificate.retired_amount)
+    );
+    totalRetiredFromCertificates += Number(certificate.retired_amount);
+  });
+  const totalRetiredFromCollections = data.collections.reduce(
+    (sum, collection) => sum + Number(collection.amount),
+    0
+  );
+  const totalRetiredFromCredits = data.credits.reduce(
+    (sum, credit) => sum + Number(credit.amount),
+    0
+  );
+  data.summary.credit_symbols.forEach((symbol) => {
+    if ((creditTotalsBySymbol.get(symbol) ?? 0) === 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Each summary credit symbol must appear in certificates.credits_retired with a retired amount",
+        path: ["summary", "credit_symbols"]
       });
-      return;
     }
-    if (creditAttribute.value !== credit.purchase_amount) {
+  });
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalRetiredFromCertificates,
+    expectedTotal: data.summary.total_retirement_amount,
+    path: ["summary", "total_retirement_amount"],
+    message: "summary.total_retirement_amount must equal sum of certificates.retired_amount"
+  });
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalRetiredFromCredits,
+    expectedTotal: data.summary.total_retirement_amount,
+    path: ["summary", "total_retirement_amount"],
+    message: "summary.total_retirement_amount must equal sum of credits.amount"
+  });
+  validateTotalMatches({
+    ctx,
+    actualTotal: totalRetiredFromCollections,
+    expectedTotal: data.summary.total_retirement_amount,
+    path: ["summary", "total_retirement_amount"],
+    message: "summary.total_retirement_amount must equal sum of collections.amount"
+  });
+  data.credits.forEach((credit, index) => {
+    const retiredTotal = creditTotalsBySymbol.get(String(credit.symbol)) ?? 0;
+    if (!nearlyEqual(Number(credit.amount), retiredTotal)) {
       ctx.addIssue({
         code: "custom",
-        message: `Attribute for credit symbol ${credit.symbol} must match credit.purchase_amount`,
-        path: ["attributes"]
+        message: "credit.amount must equal sum of retired amounts for the credit symbol across certificates",
+        path: ["credits", index, "amount"]
       });
     }
   });
-  data.collections.forEach((collection) => {
-    const collectionAttribute = attributeByTraitType.get(collection.name);
-    if (!collectionAttribute) {
+  data.collections.forEach((collection, index) => {
+    const retiredTotal = collectionTotalsBySlug.get(String(collection.slug)) ?? 0;
+    if (retiredTotal === 0) {
       ctx.addIssue({
         code: "custom",
-        message: `Attribute for collection ${collection.name} is required`,
-        path: ["attributes"]
+        message: "collection must be referenced by at least one certificate with retired_amount > 0",
+        path: ["collections", index, "slug"]
       });
-      return;
     }
-    if (collectionAttribute.value !== collection.credit_amount) {
+    if (Number(collection.amount) <= 0) {
       ctx.addIssue({
         code: "custom",
-        message: `Attribute for collection ${collection.name} must match collection.credit_amount`,
-        path: ["attributes"]
+        message: "collection.amount must be greater than zero",
+        path: ["collections", index, "amount"]
+      });
+    }
+    if (!nearlyEqual(Number(collection.amount), retiredTotal)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "collection.amount must equal sum of certificate retired_amount for the collection slug",
+        path: ["collections", index, "amount"]
       });
     }
   });
-}).meta(CreditPurchaseReceiptIpfsSchemaMeta);
+}).meta({
+  title: "Credit Retirement Receipt Data",
+  description: "Complete data structure for a credit retirement receipt"
+});
+var CreditRetirementReceiptIpfsSchemaBase = NftIpfsSchema.omit({
+  original_content_hash: true
+});
+var CreditRetirementReceiptIpfsSchemaMeta = {
+  title: "CreditRetirementReceipt NFT IPFS Record",
+  description: "Complete CreditRetirementReceipt NFT IPFS record including attributes and credit retirement data",
+  $id: buildSchemaUrl(
+    "credit-retirement-receipt/credit-retirement-receipt.schema.json"
+  ),
+  version: getSchemaVersionOrDefault()
+};
+var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.safeExtend({
+  schema: CreditRetirementReceiptIpfsSchemaBase.shape.schema.safeExtend({
+    type: zod.z.literal("CreditRetirementReceipt").meta({
+      title: "CreditRetirementReceipt Schema Type",
+      description: "CreditRetirementReceipt NFT schema type"
+    })
+  }),
+  attributes: CreditRetirementReceiptAttributesSchema,
+  data: CreditRetirementReceiptDataSchema
+}).superRefine((value, ctx) => {
+  const attributes = value.attributes;
+  const data = value.data;
+  const attributeByTraitType = createAttributeMap(attributes);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Total Credits Retired",
+    expectedValue: data.summary.total_retirement_amount,
+    missingMessage: 'Attribute "Total Credits Retired" is required',
+    mismatchMessage: 'Attribute "Total Credits Retired" must match data.summary.total_retirement_amount'
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Certificates Retired",
+    expectedValue: data.summary.total_certificates,
+    missingMessage: 'Attribute "Certificates Retired" is required',
+    mismatchMessage: 'Attribute "Certificates Retired" must match data.summary.total_certificates'
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Beneficiary",
+    expectedValue: String(data.beneficiary.identity.name),
+    missingMessage: 'Attribute "Beneficiary" is required',
+    mismatchMessage: 'Attribute "Beneficiary" must match beneficiary.identity.name'
+  });
+  const creditHolderName = data.credit_holder.identity?.name;
+  if (creditHolderName) {
+    validateAttributeValue({
+      ctx,
+      attributeByTraitType,
+      traitType: "Credit Holder",
+      expectedValue: String(creditHolderName),
+      missingMessage: 'Attribute "Credit Holder" is required when credit_holder.identity.name is provided',
+      mismatchMessage: 'Attribute "Credit Holder" must match credit_holder.identity.name'
+    });
+  }
+  validateDateAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Retirement Date",
+    dateValue: data.summary.retirement_date,
+    missingMessage: 'Attribute "Retirement Date" is required',
+    invalidDateMessage: "data.summary.retirement_date must be a valid date string",
+    mismatchMessage: 'Attribute "Retirement Date" must match data.summary.retirement_date as a Unix timestamp in milliseconds',
+    datePath: ["data", "summary", "retirement_date"]
+  });
+  validateAttributesForItems({
+    ctx,
+    attributeByTraitType,
+    items: data.credits,
+    traitSelector: (credit) => String(credit.symbol),
+    valueSelector: (credit) => Number(credit.amount),
+    missingMessage: (symbol) => `Attribute for credit symbol ${symbol} is required`,
+    mismatchMessage: (symbol) => `Attribute for credit symbol ${symbol} must match credit.amount`
+  });
+  validateAttributesForItems({
+    ctx,
+    attributeByTraitType,
+    items: data.collections,
+    traitSelector: (collection) => String(collection.name),
+    valueSelector: (collection) => Number(collection.amount),
+    missingMessage: (name) => `Attribute for collection ${name} is required`,
+    mismatchMessage: (name) => `Attribute for collection ${name} must match collection.amount`
+  });
+}).meta(CreditRetirementReceiptIpfsSchemaMeta);
 var CollectionSchemaMeta = {
   title: "Collection IPFS Record",
   description: "Collection metadata stored in IPFS, extending the base schema with collection-specific fields required for NFT collection definitions in Carrot's ecosystem",
@@ -2782,11 +3415,19 @@ exports.CreditPurchaseReceiptAttributesSchema = CreditPurchaseReceiptAttributesS
 exports.CreditPurchaseReceiptDataSchema = CreditPurchaseReceiptDataSchema;
 exports.CreditPurchaseReceiptIpfsSchema = CreditPurchaseReceiptIpfsSchema;
 exports.CreditPurchaseReceiptIpfsSchemaMeta = CreditPurchaseReceiptIpfsSchemaMeta;
+exports.CreditPurchaseReceiptSummarySchema = CreditPurchaseReceiptSummarySchema;
+exports.CreditRetirementReceiptAttributesSchema = CreditRetirementReceiptAttributesSchema;
+exports.CreditRetirementReceiptDataSchema = CreditRetirementReceiptDataSchema;
+exports.CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchema;
+exports.CreditRetirementReceiptIpfsSchemaMeta = CreditRetirementReceiptIpfsSchemaMeta;
+exports.CreditRetirementReceiptSummarySchema = CreditRetirementReceiptSummarySchema;
 exports.CreditSchema = CreditSchema;
 exports.CreditSchemaMeta = CreditSchemaMeta;
+exports.CreditTokenSymbolSchema = CreditTokenSymbolSchema;
 exports.CreditTypeAttributeSchema = CreditTypeAttributeSchema;
 exports.CreditTypeSchema = CreditTypeSchema;
 exports.DistributionNotesSchema = DistributionNotesSchema;
+exports.EPSILON = EPSILON;
 exports.EthereumAddressSchema = EthereumAddressSchema;
 exports.ExternalIdSchema = ExternalIdSchema;
 exports.ExternalUrlSchema = ExternalUrlSchema;
@@ -2817,6 +3458,7 @@ exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
 exports.MassIDRecyclingDateAttributeSchema = MassIDRecyclingDateAttributeSchema;
 exports.MassIDReferenceSchema = MassIDReferenceSchema;
 exports.MassIDTokenIdAttributeSchema = MassIDTokenIdAttributeSchema;
+exports.MassIdReferenceWithContractSchema = MassIdReferenceWithContractSchema;
 exports.MethodologyAttributeSchema = MethodologyAttributeSchema;
 exports.MethodologyComplianceSchema = MethodologyComplianceSchema;
 exports.MethodologyDataSchema = MethodologyDataSchema;
@@ -2839,6 +3481,7 @@ exports.ParticipantRoleSchema = ParticipantRoleSchema;
 exports.ParticipantSchema = ParticipantSchema;
 exports.PercentageSchema = PercentageSchema;
 exports.PositiveIntegerSchema = PositiveIntegerSchema;
+exports.ReceiptIdentitySchema = ReceiptIdentitySchema;
 exports.RecordEnvironmentSchema = RecordEnvironmentSchema;
 exports.RecordRelationshipTypeSchema = RecordRelationshipTypeSchema;
 exports.RecordSchemaTypeSchema = RecordSchemaTypeSchema;
@@ -2865,9 +3508,20 @@ exports.WasteSubtypeSchema = WasteSubtypeSchema;
 exports.WasteTypeSchema = WasteTypeSchema;
 exports.WeightKgSchema = WeightKgSchema;
 exports.buildSchemaUrl = buildSchemaUrl;
+exports.createAttributeMap = createAttributeMap;
+exports.createReceiptCertificateSchema = createReceiptCertificateSchema;
+exports.createReceiptCollectionSchema = createReceiptCollectionSchema;
+exports.createReceiptCreditSchema = createReceiptCreditSchema;
 exports.getSchemaBaseUrl = getSchemaBaseUrl;
 exports.getSchemaVersionOrDefault = getSchemaVersionOrDefault;
+exports.nearlyEqual = nearlyEqual;
 exports.uniqueArrayItems = uniqueArrayItems;
 exports.uniqueBy = uniqueBy;
+exports.validateAttributeValue = validateAttributeValue;
+exports.validateAttributesForItems = validateAttributesForItems;
+exports.validateCountMatches = validateCountMatches;
+exports.validateDateAttribute = validateDateAttribute;
+exports.validateSummaryListMatchesData = validateSummaryListMatchesData;
+exports.validateTotalMatches = validateTotalMatches;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map