@carrot-foundation/schemas 0.1.56 → 0.1.57

package/dist/index.cjs

@@ -29271,54 +29271,33 @@ 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",
+  total_amount_usdc: NonNegativeFloatSchema.meta({
+    title: "Total Amount (USDC)",
     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)"
+  purchased_at: IsoDateTimeSchema.meta({
+    title: "Purchased At",
+    description: "ISO 8601 timestamp when the purchase was completed"
   })
 }).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",
+  total_credits_retired: CreditAmountSchema.meta({
+    title: "Total Credits Retired",
     description: "Total amount of credits retired"
   }),
-  retirement_date: IsoDateSchema.meta({
-    title: "Retirement Date",
-    description: "Date when the retirement occurred (YYYY-MM-DD)"
+  retired_at: IsoDateTimeSchema.meta({
+    title: "Retired At",
+    description: "ISO 8601 timestamp when the retirement occurred"
   })
 }).meta({
   title: "Credit Retirement Receipt Summary",
@@ -29342,14 +29321,17 @@ var ReceiptIdentitySchema = zod.z.strictObject({
   title: "Identity",
   description: "Participant identity information"
 });
-var MassIdReferenceWithContractSchema = MassIDReferenceSchema.safeExtend({
-  smart_contract: SmartContractSchema
+var MassIDReferenceWithContractSchema = MassIDReferenceSchema.safeExtend({
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address",
+    description: "Ethereum address of the smart contract"
+  })
 }).meta({
   title: "MassID Reference with Smart Contract",
-  description: "Reference to a MassID record including smart contract details"
+  description: "Reference to a MassID record with smart contract address"
 });
 function createReceiptCollectionSchema(params) {
-  const { amountKey, amountMeta, meta } = params;
+  const { meta } = params;
   return zod.z.strictObject({
     slug: CollectionSlugSchema,
     external_id: ExternalIdSchema.meta({
@@ -29361,16 +29343,19 @@ function createReceiptCollectionSchema(params) {
       title: "Collection External URL",
       description: "External URL for the collection"
     }),
-    uri: IpfsUriSchema.meta({
-      title: "Collection URI",
+    ipfs_uri: IpfsUriSchema.meta({
+      title: "Collection IPFS URI",
       description: "IPFS URI for the collection metadata"
     }),
-    [amountKey]: CreditAmountSchema.meta(amountMeta)
+    smart_contract_address: EthereumAddressSchema.meta({
+      title: "Smart Contract Address",
+      description: "Ethereum address of the smart contract"
+    })
   }).meta(meta);
 }
 function createReceiptCreditSchema(params) {
-  const { amountKey, amountMeta, meta, retirementAmountMeta } = params;
-  const creditShape = {
+  const { meta } = params;
+  return zod.z.strictObject({
     slug: SlugSchema.meta({
       title: "Credit Slug",
       description: "URL-friendly identifier for the credit"
@@ -29387,24 +29372,52 @@ function createReceiptCreditSchema(params) {
       title: "Credit External URL",
       description: "External URL for the credit"
     }),
-    uri: IpfsUriSchema.meta({
-      title: "Credit URI",
+    ipfs_uri: IpfsUriSchema.meta({
+      title: "Credit IPFS 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);
+    smart_contract_address: EthereumAddressSchema.meta({
+      title: "Smart Contract Address",
+      description: "Ethereum address of the smart contract"
+    })
+  }).meta(meta);
 }
+var CertificateCollectionItemPurchaseSchema = zod.z.strictObject({
+  slug: CollectionSlugSchema.meta({
+    title: "Collection Slug",
+    description: "Slug of the collection"
+  }),
+  purchased_amount: CreditAmountSchema.meta({
+    title: "Collection Purchased Amount",
+    description: "Credits purchased from this collection for this certificate"
+  }),
+  retired_amount: CreditAmountSchema.meta({
+    title: "Collection Retired Amount",
+    description: "Credits retired from this collection for this certificate (0 if none)"
+  })
+}).meta({
+  title: "Certificate Collection Item (Purchase)",
+  description: "Collection reference with purchased and retired amounts for a certificate in a purchase receipt"
+});
+var CertificateCollectionItemRetirementSchema = zod.z.strictObject({
+  slug: CollectionSlugSchema.meta({
+    title: "Collection Slug",
+    description: "Slug of the collection"
+  }),
+  retired_amount: CreditAmountSchema.meta({
+    title: "Collection Retired Amount",
+    description: "Credits retired from this collection for this certificate"
+  })
+}).meta({
+  title: "Certificate Collection Item (Retirement)",
+  description: "Collection reference with retired amount for a certificate in a retirement receipt"
+});
 var certificateBaseShape = {
   token_id: TokenIdSchema.meta({
     title: "Certificate Token ID",
     description: "Token ID of the certificate"
   }),
-  type: RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]).meta({
+  type: zod.z.enum(["GasID", "RecycledID"]).meta({
     title: "Certificate Type",
     description: "Type of certificate (e.g., GasID, RecycledID)"
   }),
@@ -29416,20 +29429,19 @@ var certificateBaseShape = {
     title: "Certificate External URL",
     description: "External URL for the certificate"
   }),
-  uri: IpfsUriSchema.meta({
-    title: "Certificate URI",
+  ipfs_uri: IpfsUriSchema.meta({
+    title: "Certificate IPFS 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"
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address",
+    description: "Ethereum address of the smart contract"
   }),
   total_amount: CreditAmountSchema.meta({
     title: "Certificate Total Amount",
     description: "Total credits available in this certificate"
   }),
-  mass_id: MassIdReferenceWithContractSchema
+  mass_id: MassIDReferenceWithContractSchema
 };
 function createReceiptCertificateSchema(params) {
   return zod.z.strictObject({
@@ -29445,7 +29457,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.56";
+  return "0.1.57";
 }
 
 // src/shared/schema-validation.ts
@@ -29601,6 +29613,104 @@ function validateAttributesForItems(params) {
     }
   });
 }
+function validateCertificateCollectionSlugs(params) {
+  const {
+    ctx,
+    certificateCollections,
+    validCollectionSlugs,
+    certificateIndex,
+    message = "certificate.collections[].slug must match a collection slug in collections"
+  } = params;
+  certificateCollections.forEach((collectionItem, collectionIndex) => {
+    if (!validCollectionSlugs.has(collectionItem.slug)) {
+      ctx.addIssue({
+        code: "custom",
+        message,
+        path: [
+          "certificates",
+          certificateIndex,
+          "collections",
+          collectionIndex,
+          "slug"
+        ]
+      });
+    }
+  });
+}
+function validateRetirementReceiptRequirement(params) {
+  const {
+    ctx,
+    hasRetirementReceipt,
+    totalRetiredAmount,
+    messageWhenPresentButNoRetired = "retirement_receipt is present but no certificate has retired_amount greater than 0",
+    messageWhenRetiredButNotPresent = "certificates with retired amounts > 0 require retirement_receipt"
+  } = params;
+  if (hasRetirementReceipt) {
+    if (totalRetiredAmount === 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: messageWhenPresentButNoRetired,
+        path: ["retirement_receipt"]
+      });
+    }
+  } else if (totalRetiredAmount > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: messageWhenRetiredButNotPresent,
+      path: ["retirement_receipt"]
+    });
+  }
+}
+function validateCollectionsHaveRetiredAmounts(params) {
+  const {
+    ctx,
+    collections,
+    retiredTotalsBySlug,
+    message = "collection must be referenced by at least one certificate with retired amounts > 0"
+  } = params;
+  collections.forEach((collection, index) => {
+    const retiredTotal = retiredTotalsBySlug.get(String(collection.slug)) ?? 0;
+    if (retiredTotal === 0) {
+      ctx.addIssue({
+        code: "custom",
+        message,
+        path: ["collections", index, "slug"]
+      });
+    }
+  });
+}
+function validateCreditSlugExists(params) {
+  const {
+    ctx,
+    creditSlug,
+    validCreditSlugs,
+    path,
+    message = "credit_slug must match a credit slug in credits"
+  } = params;
+  if (!validCreditSlugs.has(creditSlug)) {
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path
+    });
+  }
+}
+function validateCreditSymbolExists(params) {
+  const {
+    ctx,
+    creditSymbol,
+    validCreditSymbols,
+    path,
+    message = "credit_symbol must match a credit symbol in credits"
+  } = params;
+  if (!validCreditSymbols.has(creditSymbol)) {
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path
+    });
+  }
+}
 function canonicalizeForHash(value) {
   const canonical = canonicalize__default.default(value);
   if (canonical === void 0) {
@@ -30382,9 +30492,9 @@ var CreditPurchaseReceiptTotalCreditsAttributeSchema = createNumericAttributeSch
   description: "Total number of credits purchased across all tokens",
   valueSchema: CreditAmountSchema
 });
-var CreditPurchaseReceiptTotalUsdcAttributeSchema = createNumericAttributeSchema({
-  traitType: "Total USDC Amount",
-  title: "Total USDC Amount",
+var CreditPurchaseReceiptPurchasePriceAttributeSchema = createNumericAttributeSchema({
+  traitType: "Total Amount (USDC)",
+  title: "Total Amount (USDC)",
   description: "Total USDC amount paid for the purchase",
   valueSchema: CreditAmountSchema
 });
@@ -30399,43 +30509,48 @@ var CreditPurchaseReceiptCertificatesAttributeSchema = createNumericAttributeSch
   description: "Total number of certificates purchased",
   valueSchema: PositiveIntegerSchema
 });
-var CreditPurchaseReceiptReceiverAttributeSchema = NftAttributeSchema.omit({
+var CreditPurchaseReceiptBuyerAttributeSchema = NftAttributeSchema.omit({
   display_type: true,
   max_value: true
 }).safeExtend({
-  trait_type: zod.z.literal("Receiver"),
+  trait_type: zod.z.literal("Buyer"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Receiver",
-    description: "Organization or individual receiving the credits from the purchase",
+    title: "Buyer",
+    description: "Organization or individual purchasing the credits",
     examples: ["EcoTech Solutions Inc."]
   })
 }).meta({
-  title: "Receiver Attribute",
-  description: "Attribute containing the receiver display name"
+  title: "Buyer Attribute",
+  description: "Attribute containing the buyer display name"
 });
-var CreditPurchaseReceiptCollectionAttributeSchema = NftAttributeSchema.safeExtend({
-  trait_type: CollectionNameSchema,
-  value: CreditAmountSchema.meta({
-    title: "Credits from Collection",
-    description: "Amount of credits purchased from the collection"
-  }),
-  display_type: zod.z.literal("number")
+var CreditPurchaseReceiptRetirementDateAttributeSchema = createDateAttributeSchema({
+  traitType: "Retirement Date",
+  title: "Retirement Date",
+  description: "Unix timestamp in milliseconds when credits were retired (if retirement occurred)"
+});
+var CreditPurchaseReceiptRetirementReceiptAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Retirement Receipt"),
+  value: StringifiedTokenIdSchema.meta({
+    title: "Retirement Receipt Token ID",
+    description: "Token ID of the retirement receipt NFT as #<token_id> (if retirement occurred)"
+  })
 }).meta({
-  title: "Collection Attribute",
-  description: "Attribute representing the amount of credits purchased from a collection"
+  title: "Retirement Receipt Attribute",
+  description: "Retirement receipt token ID attribute"
 });
 var REQUIRED_CREDIT_PURCHASE_RECEIPT_ATTRIBUTES = [
   CreditPurchaseReceiptTotalCreditsAttributeSchema,
-  CreditPurchaseReceiptTotalUsdcAttributeSchema,
+  CreditPurchaseReceiptPurchasePriceAttributeSchema,
   CreditPurchaseReceiptPurchaseDateAttributeSchema,
   CreditPurchaseReceiptCertificatesAttributeSchema
 ];
 var CONDITIONAL_CREDIT_PURCHASE_RECEIPT_ATTRIBUTES = [
-  CreditPurchaseReceiptReceiverAttributeSchema
+  CreditPurchaseReceiptBuyerAttributeSchema,
+  CreditPurchaseReceiptRetirementDateAttributeSchema,
+  CreditPurchaseReceiptRetirementReceiptAttributeSchema
 ];
 var DYNAMIC_CREDIT_PURCHASE_RECEIPT_ATTRIBUTES = [
-  CreditPurchaseReceiptCreditAttributeSchema,
-  CreditPurchaseReceiptCollectionAttributeSchema
+  CreditPurchaseReceiptCreditAttributeSchema
 ];
 var CreditPurchaseReceiptAttributesSchema = createOrderedAttributesSchema({
   required: REQUIRED_CREDIT_PURCHASE_RECEIPT_ATTRIBUTES,
@@ -30444,68 +30559,37 @@ var CreditPurchaseReceiptAttributesSchema = createOrderedAttributesSchema({
     ...DYNAMIC_CREDIT_PURCHASE_RECEIPT_ATTRIBUTES
   ],
   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. Fixed required attributes: Total Credits Purchased, Total USDC Amount, Purchase Date, Certificates Purchased. Conditional attributes: Receiver (required when receiver.identity.name is provided). Dynamic attributes: Credit attributes (one per credit symbol in data.credits), Collection attributes (one per collection name in data.collections).",
+  description: "Attributes for credit purchase receipts including per-credit breakdowns, totals, buyer, purchase date, and optional retirement info. Fixed required attributes: Total Credits Purchased, Total Amount (USDC), Purchase Date, Certificates Purchased. Conditional attributes: Buyer (required when buyer.identity.name is provided), Retirement Date (optional, when retirement_receipt is present), Retirement Receipt (optional, when retirement_receipt is present). Dynamic attributes: Credit attributes (one per credit symbol in data.credits).",
   uniqueBySelector: (attribute) => attribute.trait_type,
   requiredTraitTypes: [
     "Total Credits Purchased",
-    "Total USDC Amount",
+    "Total Amount (USDC)",
     "Purchase Date",
     "Certificates Purchased"
   ]
 });
 var CreditPurchaseReceiptIdentitySchema = ReceiptIdentitySchema;
-var CreditPurchaseReceiptReceiverSchema = zod.z.strictObject({
+var CreditPurchaseReceiptBuyerSchema = zod.z.strictObject({
   wallet_address: EthereumAddressSchema.meta({
-    title: "Receiver Wallet Address",
-    description: "Ethereum address of the receiver"
+    title: "Buyer Wallet Address",
+    description: "Ethereum address receiving the credits"
   }),
-  identity: CreditPurchaseReceiptIdentitySchema.optional()
-}).meta({
-  title: "Receiver",
-  description: "Receiver wallet and optional identity information"
-});
-var CreditPurchaseReceiptBuyerSchema = zod.z.strictObject({
-  buyer_id: ExternalIdSchema.meta({
+  id: ExternalIdSchema.optional().meta({
     title: "Buyer ID",
     description: "Unique identifier for the buyer"
   }),
   identity: CreditPurchaseReceiptIdentitySchema.optional()
 }).meta({
   title: "Buyer",
-  description: "Buyer identifier and optional identity information"
-});
-var CreditPurchaseReceiptPartiesSchema = zod.z.strictObject({
-  payer: EthereumAddressSchema.meta({
-    title: "Payer Wallet Address",
-    description: "Ethereum address paying for the purchase"
-  }),
-  receiver: CreditPurchaseReceiptReceiverSchema,
-  buyer: CreditPurchaseReceiptBuyerSchema.optional()
-}).meta({
-  title: "Parties",
-  description: "Parties involved in the purchase including payer, receiver, and optional buyer"
+  description: "Buyer information including wallet address, optional ID, and optional identity"
 });
 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"
   }
 });
 var CreditPurchaseReceiptCreditSchema = createReceiptCreditSchema({
-  amountKey: "purchase_amount",
-  amountMeta: {
-    title: "Credit Purchase Amount",
-    description: "Total credits purchased for this credit type"
-  },
-  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"
@@ -30513,18 +30597,18 @@ var CreditPurchaseReceiptCreditSchema = createReceiptCreditSchema({
 });
 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"]
+    }),
+    collections: uniqueBy(
+      CertificateCollectionItemPurchaseSchema,
+      (item) => item.slug,
+      "Collection slugs within certificate collections must be unique"
+    ).min(1).meta({
+      title: "Certificate Collections",
+      description: "Collections associated with this certificate, each with purchased and retired amounts"
     })
   },
   meta: {
@@ -30533,15 +30617,10 @@ var CreditPurchaseReceiptCertificateSchema = createReceiptCertificateSchema({
   }
 });
 var CreditPurchaseReceiptParticipantRewardSchema = zod.z.strictObject({
-  id_hash: Sha256HashSchema.meta({
+  participant_id_hash: Sha256HashSchema.meta({
     title: "Participant ID Hash",
     description: "Hash representing the participant identifier (SHA-256 hex string)"
   }),
-  participant_name: NonEmptyStringSchema.max(100).meta({
-    title: "Participant Name",
-    description: "Legal name of the participant receiving the reward",
-    examples: ["EcoTech Solutions Inc.", "Green Tech Corp"]
-  }),
   roles: uniqueArrayItems(
     ParticipantRoleSchema,
     "Participant roles must be unique"
@@ -30570,28 +30649,21 @@ var CreditPurchaseReceiptRetirementReceiptSchema = zod.z.strictObject({
     title: "Retirement Receipt External URL",
     description: "External URL for the retirement receipt"
   }),
-  uri: IpfsUriSchema.meta({
-    title: "Retirement Receipt URI",
+  ipfs_uri: IpfsUriSchema.meta({
+    title: "Retirement Receipt IPFS URI",
     description: "IPFS URI for the retirement receipt metadata"
   }),
-  smart_contract: SmartContractSchema
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address",
+    description: "Ethereum address of the smart contract"
+  })
 }).meta({
   title: "Retirement Receipt Reference",
   description: "Reference to the retirement receipt NFT"
 });
-var CreditPurchaseReceiptRetirementSchema = zod.z.strictObject({
-  beneficiary_id: ExternalIdSchema.meta({
-    title: "Retirement Beneficiary ID",
-    description: "UUID identifying the beneficiary of the retirement (bytes16 normalized to UUID)"
-  }),
-  retirement_receipt: CreditPurchaseReceiptRetirementReceiptSchema.optional()
-}).meta({
-  title: "Retirement",
-  description: "Immediate retirement details performed as part of purchase"
-});
 var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   summary: CreditPurchaseReceiptSummarySchema,
-  parties: CreditPurchaseReceiptPartiesSchema,
+  buyer: CreditPurchaseReceiptBuyerSchema,
   collections: uniqueBy(
     CreditPurchaseReceiptCollectionSchema,
     (collection) => collection.slug,
@@ -30618,41 +30690,14 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   }),
   participant_rewards: uniqueBy(
     CreditPurchaseReceiptParticipantRewardSchema,
-    (reward) => reward.id_hash,
-    "Participant id_hash must be unique"
+    (reward) => reward.participant_id_hash,
+    "Participant participant_id_hash must be unique"
   ).min(1).meta({
     title: "Participant Rewards",
     description: "Rewards distributed to participants in the supply chain for this purchase"
   }),
-  retirement: CreditPurchaseReceiptRetirementSchema.optional()
+  retirement_receipt: CreditPurchaseReceiptRetirementReceiptSchema.optional()
 }).superRefine((data, ctx) => {
-  const retirementProvided = Boolean(data.retirement);
-  const creditsWithRetirement = data.credits.reduce(
-    (indices, credit, index) => {
-      const retirementAmount = Number(credit.retirement_amount ?? 0);
-      if (retirementAmount > 0) {
-        indices.push(index);
-      }
-      return indices;
-    },
-    []
-  );
-  if (retirementProvided && creditsWithRetirement.length === 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: "retirement is present but no credit has retirement_amount greater than 0",
-      path: ["retirement"]
-    });
-  }
-  if (!retirementProvided && creditsWithRetirement.length > 0) {
-    creditsWithRetirement.forEach((index) => {
-      ctx.addIssue({
-        code: "custom",
-        message: "credit retirement_amount greater than 0 requires retirement details",
-        path: ["credits", index, "retirement_amount"]
-      });
-    });
-  }
   validateCountMatches({
     ctx,
     actualCount: data.certificates.length,
@@ -30666,140 +30711,82 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   const creditSlugs = new Set(
     data.credits.map((credit) => String(credit.slug))
   );
-  const creditSymbols = new Set(
-    data.credits.map((credit) => String(credit.symbol))
-  );
-  const certificateTypes = new Set(
-    data.certificates.map((certificate) => String(certificate.type))
-  );
-  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 creditPurchaseTotalsBySlug = /* @__PURE__ */ new Map();
   const creditRetiredTotalsBySlug = /* @__PURE__ */ new Map();
-  const collectionTotalsBySlug = /* @__PURE__ */ new Map();
+  const collectionPurchasedTotalsBySlug = /* @__PURE__ */ new Map();
+  const collectionRetiredTotalsBySlug = /* @__PURE__ */ new Map();
   let totalCreditsFromCertificates = 0;
   data.certificates.forEach((certificate, index) => {
-    if (!collectionSlugs.has(certificate.collection_slug)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "collection_slug must match a collection slug in collections",
-        path: ["certificates", index, "collection_slug"]
-      });
-    }
-    if (!creditSlugs.has(certificate.credit_slug)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "credit_slug must match a credit slug in credits",
-        path: ["certificates", index, "credit_slug"]
-      });
-    }
-    if (certificate.retired_amount > certificate.purchased_amount) {
-      ctx.addIssue({
-        code: "custom",
-        message: "retired_amount cannot exceed purchased_amount",
-        path: ["certificates", index, "retired_amount"]
-      });
-    }
-    if (certificate.purchased_amount > certificate.total_amount) {
+    validateCreditSlugExists({
+      ctx,
+      creditSlug: certificate.credit_slug,
+      validCreditSlugs: creditSlugs,
+      path: ["certificates", index, "credit_slug"]
+    });
+    let certificatePurchasedTotal = 0;
+    let certificateRetiredTotal = 0;
+    validateCertificateCollectionSlugs({
+      ctx,
+      certificateCollections: certificate.collections,
+      validCollectionSlugs: collectionSlugs,
+      certificateIndex: index
+    });
+    certificate.collections.forEach((collectionItem, collectionIndex) => {
+      if (collectionItem.retired_amount > collectionItem.purchased_amount) {
+        ctx.addIssue({
+          code: "custom",
+          message: "certificate.collections[].retired_amount cannot exceed purchased_amount",
+          path: [
+            "certificates",
+            index,
+            "collections",
+            collectionIndex,
+            "retired_amount"
+          ]
+        });
+      }
+      certificatePurchasedTotal += Number(collectionItem.purchased_amount);
+      certificateRetiredTotal += Number(collectionItem.retired_amount);
+      collectionPurchasedTotalsBySlug.set(
+        collectionItem.slug,
+        (collectionPurchasedTotalsBySlug.get(collectionItem.slug) ?? 0) + Number(collectionItem.purchased_amount)
+      );
+      collectionRetiredTotalsBySlug.set(
+        collectionItem.slug,
+        (collectionRetiredTotalsBySlug.get(collectionItem.slug) ?? 0) + Number(collectionItem.retired_amount)
+      );
+    });
+    if (certificatePurchasedTotal > certificate.total_amount) {
       ctx.addIssue({
         code: "custom",
-        message: "purchased_amount cannot exceed total_amount",
-        path: ["certificates", index, "purchased_amount"]
+        message: "Sum of certificate.collections[].purchased_amount cannot exceed certificate.total_amount",
+        path: ["certificates", index]
       });
     }
-    totalCreditsFromCertificates += Number(certificate.purchased_amount);
+    totalCreditsFromCertificates += certificatePurchasedTotal;
     creditPurchaseTotalsBySlug.set(
       String(certificate.credit_slug),
-      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + Number(certificate.purchased_amount)
+      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificatePurchasedTotal
     );
     creditRetiredTotalsBySlug.set(
       String(certificate.credit_slug),
-      (creditRetiredTotalsBySlug.get(certificate.credit_slug) ?? 0) + Number(certificate.retired_amount)
-    );
-    collectionTotalsBySlug.set(
-      String(certificate.collection_slug),
-      (collectionTotalsBySlug.get(certificate.collection_slug) ?? 0) + Number(certificate.purchased_amount)
+      (creditRetiredTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificateRetiredTotal
     );
   });
-  const totalCreditsFromCollections = data.collections.reduce(
-    (sum, collection) => sum + Number(collection.credit_amount),
-    0
-  );
-  const totalCreditsFromCredits = data.credits.reduce(
-    (sum, credit) => sum + Number(credit.purchase_amount),
-    0
-  );
+  const certificateCollectionRetiredTotal = Array.from(
+    collectionRetiredTotalsBySlug.values()
+  ).reduce((sum, amount) => sum + amount, 0);
   validateTotalMatches({
     ctx,
     actualTotal: totalCreditsFromCertificates,
     expectedTotal: data.summary.total_credits,
     path: ["summary", "total_credits"],
-    message: "summary.total_credits must equal sum of certificates.purchased_amount"
+    message: "summary.total_credits must equal sum of certificate.collections[].purchased_amount"
   });
-  validateTotalMatches({
+  validateRetirementReceiptRequirement({
     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(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(String(credit.slug)) ?? 0;
-    const retirementAmount = Number(credit.retirement_amount ?? 0);
-    if (!nearlyEqual(retirementAmount, retiredTotal)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "credit.retirement_amount must equal sum of certificate retired_amount for the credit slug",
-        path: ["credits", index, "retirement_amount"]
-      });
-    }
-  });
-  data.collections.forEach((collection, index) => {
-    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",
-        path: ["collections", index, "credit_amount"]
-      });
-    }
+    hasRetirementReceipt: !!data.retirement_receipt,
+    totalRetiredAmount: certificateCollectionRetiredTotal
   });
   const participantRewardTotal = data.participant_rewards.reduce(
     (sum, reward) => sum + Number(reward.usdc_amount),
@@ -30808,9 +30795,9 @@ var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   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"
+    expectedTotal: data.summary.total_amount_usdc,
+    path: ["summary", "total_amount_usdc"],
+    message: "summary.total_amount_usdc must equal sum of participant_rewards.usdc_amount"
   });
 }).meta({
   title: "Credit Purchase Receipt Data",
@@ -30848,10 +30835,10 @@ var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
   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'
+    traitType: "Total Amount (USDC)",
+    expectedValue: data.summary.total_amount_usdc,
+    missingMessage: 'Attribute "Total Amount (USDC)" is required',
+    mismatchMessage: 'Attribute "Total Amount (USDC)" must match data.summary.total_amount_usdc'
   });
   validateAttributeValue({
     ctx,
@@ -30861,44 +30848,86 @@ var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
     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) {
+  const buyerName = data.buyer.identity?.name;
+  if (buyerName) {
     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'
+      traitType: "Buyer",
+      expectedValue: String(buyerName),
+      missingMessage: 'Attribute "Buyer" is required when buyer.identity.name is provided',
+      mismatchMessage: 'Attribute "Buyer" must match buyer.identity.name'
     });
   }
-  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`
+  const purchaseDateAttribute = attributeByTraitType.get("Purchase Date");
+  if (purchaseDateAttribute) {
+    const dateMs = Date.parse(data.summary.purchased_at);
+    if (Number.isNaN(dateMs)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "data.summary.purchased_at must be a valid ISO 8601 date-time string",
+        path: ["data", "summary", "purchased_at"]
+      });
+    } else if (purchaseDateAttribute.value !== dateMs) {
+      ctx.addIssue({
+        code: "custom",
+        message: 'Attribute "Purchase Date" must match data.summary.purchased_at as a Unix timestamp in milliseconds',
+        path: ["attributes"]
+      });
+    }
+  } else {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Purchase Date" is required',
+      path: ["attributes"]
+    });
+  }
+  if (data.retirement_receipt) {
+    const retirementReceiptAttribute = attributeByTraitType.get("Retirement Receipt");
+    if (retirementReceiptAttribute) {
+      const expectedTokenId = `#${data.retirement_receipt.token_id}`;
+      if (retirementReceiptAttribute.value !== expectedTokenId) {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Attribute "Retirement Receipt" must match retirement_receipt.token_id as #<token_id> when present',
+          path: ["attributes"]
+        });
+      }
+    }
+  }
+  const creditTotalsBySymbol = /* @__PURE__ */ new Map();
+  data.certificates.forEach((certificate) => {
+    const credit = data.credits.find(
+      (c) => c.slug === certificate.credit_slug
+    );
+    if (credit) {
+      const certificatePurchasedTotal = certificate.collections.reduce(
+        (sum, collection) => sum + Number(collection.purchased_amount),
+        0
+      );
+      const currentTotal = creditTotalsBySymbol.get(credit.symbol) ?? 0;
+      creditTotalsBySymbol.set(
+        credit.symbol,
+        currentTotal + certificatePurchasedTotal
+      );
+    }
   });
-  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`
+  data.credits.forEach((credit) => {
+    const expectedTotal = creditTotalsBySymbol.get(credit.symbol) ?? 0;
+    const attribute = attributeByTraitType.get(credit.symbol);
+    if (!attribute) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} is required`,
+        path: ["attributes"]
+      });
+    } else if (Number(attribute.value) !== expectedTotal) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} must match sum of certificate.collections[].purchased_amount for the credit symbol`,
+        path: ["attributes"]
+      });
+    }
   });
 }).meta(CreditPurchaseReceiptIpfsSchemaMeta);
 var CreditRetirementReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
@@ -30951,16 +30980,20 @@ var CreditRetirementReceiptCertificatesAttributeSchema = createNumericAttributeS
   description: "Total number of certificates retired",
   valueSchema: PositiveIntegerSchema
 });
-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")
+var CreditRetirementReceiptPurchaseDateAttributeSchema = createDateAttributeSchema({
+  traitType: "Purchase Date",
+  title: "Purchase Date",
+  description: "Unix timestamp in milliseconds when credits were purchased (if purchase_receipt is present)"
+});
+var CreditRetirementReceiptPurchaseReceiptAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Purchase Receipt"),
+  value: StringifiedTokenIdSchema.meta({
+    title: "Purchase Receipt Token ID",
+    description: "Token ID of the purchase receipt NFT as #<token_id> (if purchase_receipt is present)"
+  })
 }).meta({
-  title: "Collection Attribute",
-  description: "Attribute representing the amount of credits retired from a collection"
+  title: "Purchase Receipt Attribute",
+  description: "Attribute representing the purchase receipt token ID"
 });
 var REQUIRED_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES = [
   CreditRetirementReceiptTotalCreditsAttributeSchema,
@@ -30969,11 +31002,12 @@ var REQUIRED_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES = [
   CreditRetirementReceiptCertificatesAttributeSchema
 ];
 var CONDITIONAL_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES = [
-  CreditRetirementReceiptCreditHolderAttributeSchema
+  CreditRetirementReceiptCreditHolderAttributeSchema,
+  CreditRetirementReceiptPurchaseDateAttributeSchema,
+  CreditRetirementReceiptPurchaseReceiptAttributeSchema
 ];
 var DYNAMIC_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES = [
-  CreditRetirementReceiptCreditAttributeSchema,
-  CreditRetirementReceiptCollectionAttributeSchema
+  CreditRetirementReceiptCreditAttributeSchema
 ];
 var CreditRetirementReceiptAttributesSchema = createOrderedAttributesSchema({
   required: REQUIRED_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES,
@@ -30982,7 +31016,7 @@ var CreditRetirementReceiptAttributesSchema = createOrderedAttributesSchema({
     ...DYNAMIC_CREDIT_RETIREMENT_RECEIPT_ATTRIBUTES
   ],
   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. Fixed required attributes: Total Credits Retired, Beneficiary, Retirement Date, Certificates Retired. Conditional attributes: Credit Holder (required when credit_holder.identity.name is provided). Dynamic attributes: Credit attributes (one per credit symbol in data.credits), Collection attributes (one per collection name in data.collections).",
+  description: "Attributes for credit retirement receipts including per-credit breakdowns, totals, beneficiary, credit holder, retirement date, certificate count, and optional purchase info. Fixed required attributes: Total Credits Retired, Beneficiary, Retirement Date, Certificates Retired. Conditional attributes: Credit Holder (required when credit_holder.identity.name is provided), Purchase Date (optional, when purchase_receipt is present), Purchase Receipt (optional, when purchase_receipt is present). Dynamic attributes: Credit attributes (one per credit symbol in data.credits).",
   uniqueBySelector: (attribute) => attribute.trait_type,
   requiredTraitTypes: [
     "Total Credits Retired",
@@ -31013,22 +31047,12 @@ var CreditRetirementReceiptCreditHolderSchema = zod.z.strictObject({
   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"
   }
 });
 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"
@@ -31070,11 +31094,14 @@ var CreditPurchaseReceiptReferenceSchema = zod.z.strictObject({
     title: "Purchase Receipt External URL",
     description: "External URL for the purchase receipt"
   }),
-  uri: IpfsUriSchema.meta({
-    title: "Purchase Receipt URI",
+  ipfs_uri: IpfsUriSchema.meta({
+    title: "Purchase Receipt IPFS URI",
     description: "IPFS URI for the purchase receipt metadata"
   }),
-  smart_contract: SmartContractSchema
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address",
+    description: "Ethereum address of the smart contract"
+  })
 }).meta({
   title: "Credit Purchase Receipt Reference",
   description: "Reference to the credit purchase receipt when retirement occurs during purchase"
@@ -31082,9 +31109,13 @@ var CreditPurchaseReceiptReferenceSchema = zod.z.strictObject({
 var CreditRetirementReceiptCertificateSchema = createReceiptCertificateSchema(
   {
     additionalShape: {
-      retired_amount: CreditAmountSchema.meta({
-        title: "Certificate Retired Amount",
-        description: "Credits retired from this certificate"
+      collections: uniqueBy(
+        CertificateCollectionItemRetirementSchema,
+        (item) => item.slug,
+        "Collection slugs within certificate collections must be unique"
+      ).min(1).meta({
+        title: "Certificate Collections",
+        description: "Collections associated with this certificate, each with retired amounts"
       }),
       credits_retired: uniqueBy(
         CreditRetirementReceiptCertificateCreditSchema,
@@ -31134,15 +31165,15 @@ var CreditRetirementReceiptDataSchema = zod.z.strictObject({
   const creditSymbols = new Set(
     data.credits.map((credit) => String(credit.symbol))
   );
+  const creditSlugs = new Set(
+    data.credits.map((credit) => String(credit.slug))
+  );
   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,
@@ -31150,87 +31181,70 @@ var CreditRetirementReceiptDataSchema = zod.z.strictObject({
     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();
+  const collectionRetiredTotalsBySlug = /* @__PURE__ */ new Map();
   let totalRetiredFromCertificates = 0;
   data.certificates.forEach((certificate, index) => {
-    if (!collectionSlugs.has(certificate.collection_slug)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "collection_slug must match a collection slug in collections",
-        path: ["certificates", index, "collection_slug"]
-      });
-    }
-    if (certificate.retired_amount > certificate.total_amount) {
+    const certificateCollectionRetiredTotal = certificate.collections.reduce(
+      (sum, item) => sum + Number(item.retired_amount),
+      0
+    );
+    if (certificateCollectionRetiredTotal > certificate.total_amount) {
       ctx.addIssue({
         code: "custom",
-        message: "retired_amount cannot exceed total_amount",
-        path: ["certificates", index, "retired_amount"]
+        message: "Sum of certificate.collections[].retired_amount cannot exceed certificate.total_amount",
+        path: ["certificates", index]
       });
     }
+    validateCertificateCollectionSlugs({
+      ctx,
+      certificateCollections: certificate.collections,
+      validCollectionSlugs: collectionSlugs,
+      certificateIndex: index
+    });
+    certificate.collections.forEach((collectionItem) => {
+      collectionRetiredTotalsBySlug.set(
+        collectionItem.slug,
+        (collectionRetiredTotalsBySlug.get(collectionItem.slug) ?? 0) + Number(collectionItem.retired_amount)
+      );
+    });
     const creditsRetiredTotal = certificate.credits_retired.reduce(
       (sum, credit) => sum + Number(credit.amount),
       0
     );
-    if (!nearlyEqual(creditsRetiredTotal, certificate.retired_amount)) {
+    if (!nearlyEqual(creditsRetiredTotal, certificateCollectionRetiredTotal)) {
       ctx.addIssue({
         code: "custom",
-        message: "certificates.credits_retired amounts must sum to certificates.retired_amount",
+        message: "certificates.credits_retired amounts must sum to certificate.collections[].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"
-          ]
-        });
-      }
+      validateCreditSlugExists({
+        ctx,
+        creditSlug: credit.credit_slug,
+        validCreditSlugs: creditSlugs,
+        path: [
+          "certificates",
+          index,
+          "credits_retired",
+          creditIndex,
+          "credit_slug"
+        ]
+      });
+      validateCreditSymbolExists({
+        ctx,
+        creditSymbol: credit.credit_symbol,
+        validCreditSymbols: creditSymbols,
+        path: [
+          "certificates",
+          index,
+          "credits_retired",
+          creditIndex,
+          "credit_symbol"
+        ]
+      });
       if (referencedCredit && referencedCredit.symbol !== credit.credit_symbol) {
         ctx.addIssue({
           code: "custom",
@@ -31249,83 +31263,19 @@ var CreditRetirementReceiptDataSchema = zod.z.strictObject({
         (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"]
-      });
-    }
+    totalRetiredFromCertificates += certificateCollectionRetiredTotal;
   });
   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"
+    expectedTotal: data.summary.total_credits_retired,
+    path: ["summary", "total_credits_retired"],
+    message: "summary.total_credits_retired must equal sum of certificate.collections[].retired_amount"
   });
-  validateTotalMatches({
+  validateCollectionsHaveRetiredAmounts({
     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: "credit.amount must equal sum of retired amounts for the credit symbol across certificates",
-        path: ["credits", index, "amount"]
-      });
-    }
-  });
-  data.collections.forEach((collection, index) => {
-    const retiredTotal = collectionTotalsBySlug.get(String(collection.slug)) ?? 0;
-    if (retiredTotal === 0) {
-      ctx.addIssue({
-        code: "custom",
-        message: "collection must be referenced by at least one certificate with retired_amount > 0",
-        path: ["collections", index, "slug"]
-      });
-    }
-    if (Number(collection.amount) <= 0) {
-      ctx.addIssue({
-        code: "custom",
-        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"]
-      });
-    }
+    collections: data.collections,
+    retiredTotalsBySlug: collectionRetiredTotalsBySlug
   });
 }).meta({
   title: "Credit Retirement Receipt Data",
@@ -31359,9 +31309,9 @@ var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.sa
     ctx,
     attributeByTraitType,
     traitType: "Total Credits Retired",
-    expectedValue: data.summary.total_retirement_amount,
+    expectedValue: data.summary.total_credits_retired,
     missingMessage: 'Attribute "Total Credits Retired" is required',
-    mismatchMessage: 'Attribute "Total Credits Retired" must match data.summary.total_retirement_amount'
+    mismatchMessage: 'Attribute "Total Credits Retired" must match data.summary.total_credits_retired'
   });
   validateAttributeValue({
     ctx,
@@ -31390,33 +31340,68 @@ var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.sa
       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`
+  const retirementDateAttribute = attributeByTraitType.get("Retirement Date");
+  if (retirementDateAttribute) {
+    const dateMs = Date.parse(data.summary.retired_at);
+    if (Number.isNaN(dateMs)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "data.summary.retired_at must be a valid ISO 8601 date-time string",
+        path: ["data", "summary", "retired_at"]
+      });
+    } else if (retirementDateAttribute.value !== dateMs) {
+      ctx.addIssue({
+        code: "custom",
+        message: 'Attribute "Retirement Date" must match data.summary.retired_at as a Unix timestamp in milliseconds',
+        path: ["attributes"]
+      });
+    }
+  } else {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Retirement Date" is required',
+      path: ["attributes"]
+    });
+  }
+  if (data.purchase_receipt) {
+    const purchaseReceiptAttribute = attributeByTraitType.get("Purchase Receipt");
+    if (purchaseReceiptAttribute) {
+      const expectedTokenId = `#${data.purchase_receipt.token_id}`;
+      if (purchaseReceiptAttribute.value !== expectedTokenId) {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Attribute "Purchase Receipt" must match purchase_receipt.token_id as #<token_id> when present',
+          path: ["attributes"]
+        });
+      }
+    }
+  }
+  const creditTotalsBySymbol = /* @__PURE__ */ new Map();
+  data.certificates.forEach((certificate) => {
+    certificate.credits_retired.forEach((creditRetired) => {
+      const currentTotal = creditTotalsBySymbol.get(creditRetired.credit_symbol) ?? 0;
+      creditTotalsBySymbol.set(
+        creditRetired.credit_symbol,
+        currentTotal + Number(creditRetired.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`
+  data.credits.forEach((credit) => {
+    const expectedTotal = creditTotalsBySymbol.get(credit.symbol) ?? 0;
+    const attribute = attributeByTraitType.get(credit.symbol);
+    if (!attribute) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} is required`,
+        path: ["attributes"]
+      });
+    } else if (Number(attribute.value) !== expectedTotal) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} must match sum of certificate credits_retired amounts for the credit symbol`,
+        path: ["attributes"]
+      });
+    }
   });
 }).meta(CreditRetirementReceiptIpfsSchemaMeta);
 var CollectionSchemaMeta = {
@@ -31605,6 +31590,8 @@ exports.BRAZIL_SUBDIVISION_CODES = BRAZIL_SUBDIVISION_CODES;
 exports.BaseIpfsSchema = BaseIpfsSchema;
 exports.BlockchainChainIdSchema = BlockchainChainIdSchema;
 exports.BlockchainNetworkNameSchema = BlockchainNetworkNameSchema;
+exports.CertificateCollectionItemPurchaseSchema = CertificateCollectionItemPurchaseSchema;
+exports.CertificateCollectionItemRetirementSchema = CertificateCollectionItemRetirementSchema;
 exports.CertificateIssuanceDateAttributeSchema = CertificateIssuanceDateAttributeSchema;
 exports.CitySchema = CitySchema;
 exports.CollectionNameSchema = CollectionNameSchema;
@@ -31666,8 +31653,8 @@ exports.MassIDIpfsSchema = MassIDIpfsSchema;
 exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
 exports.MassIDRecyclingDateAttributeSchema = MassIDRecyclingDateAttributeSchema;
 exports.MassIDReferenceSchema = MassIDReferenceSchema;
+exports.MassIDReferenceWithContractSchema = MassIDReferenceWithContractSchema;
 exports.MassIDTokenIdAttributeSchema = MassIDTokenIdAttributeSchema;
-exports.MassIdReferenceWithContractSchema = MassIdReferenceWithContractSchema;
 exports.MethodologyAttributeSchema = MethodologyAttributeSchema;
 exports.MethodologyDataSchema = MethodologyDataSchema;
 exports.MethodologyNameSchema = MethodologyNameSchema;
@@ -31736,9 +31723,14 @@ exports.uniqueArrayItems = uniqueArrayItems;
 exports.uniqueBy = uniqueBy;
 exports.validateAttributeValue = validateAttributeValue;
 exports.validateAttributesForItems = validateAttributesForItems;
+exports.validateCertificateCollectionSlugs = validateCertificateCollectionSlugs;
+exports.validateCollectionsHaveRetiredAmounts = validateCollectionsHaveRetiredAmounts;
 exports.validateCountMatches = validateCountMatches;
+exports.validateCreditSlugExists = validateCreditSlugExists;
+exports.validateCreditSymbolExists = validateCreditSymbolExists;
 exports.validateDateAttribute = validateDateAttribute;
 exports.validateLocationBrazilData = validateLocationBrazilData;
+exports.validateRetirementReceiptRequirement = validateRetirementReceiptRequirement;
 exports.validateSummaryListMatchesData = validateSummaryListMatchesData;
 exports.validateTotalMatches = validateTotalMatches;
 //# sourceMappingURL=index.cjs.map