@carrot-foundation/schemas 0.1.36 → 0.1.38

package/dist/index.cjs

@@ -15,7 +15,7 @@ var UuidSchema = zod.z.uuidv4("Must be a valid UUID v4 string").meta({
   ]
 });
 var EthereumAddressSchema = zod.z.string().regex(
-  /^0x[a-fA-F0-9]{40}$/,
+  /^0x[a-f0-9]{40}$/,
   "Must be a valid Ethereum address in lowercase hexadecimal format"
 ).meta({
   title: "Ethereum Address",
@@ -90,6 +90,11 @@ var CountryNameSchema = NonEmptyStringSchema.max(50).meta({
   description: "Full country name in English",
   examples: ["Brazil", "United States", "Germany", "Japan"]
 });
+var CollectionNameSchema = NonEmptyStringSchema.max(150).meta({
+  title: "Collection Name",
+  description: "Display name of the collection",
+  examples: ["BOLD Cold Start - Carazinho", "BOLD Brazil"]
+});
 var MethodologyNameSchema = NonEmptyStringSchema.max(100).meta({
   title: "Methodology Name",
   description: "Name of the methodology used for certification",
@@ -111,6 +116,11 @@ var SlugSchema = NonEmptyStringSchema.regex(
   description: "URL-friendly identifier with lowercase letters, numbers, and hyphens",
   examples: ["mass-id-123", "recycled-plastic", "organic-waste"]
 });
+var CollectionSlugSchema = SlugSchema.meta({
+  title: "Collection Slug",
+  description: "URL-friendly identifier for a collection",
+  examples: ["bold-cold-start-carazinho", "bold-brazil"]
+});
 var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
   title: "Waste Type",
   description: "Category or type of waste material",
@@ -150,6 +160,23 @@ var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
   description: "Blockchain network identifier",
   examples: [1, 137, 11155111]
 });
+var BlockchainNetworkNameSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Blockchain Network Name",
+  description: "Name of the blockchain network",
+  examples: ["Polygon", "Ethereum mainnet", "Sepolia"]
+});
+var SmartContractAddressSchema = EthereumAddressSchema.meta({
+  title: "Smart Contract Address",
+  description: "Address of the smart contract"
+});
+var SmartContractSchema = zod.z.strictObject({
+  address: SmartContractAddressSchema,
+  chain_id: BlockchainChainIdSchema,
+  network_name: BlockchainNetworkNameSchema
+}).meta({
+  title: "Smart Contract",
+  description: "Smart contract details for on-chain references"
+});
 var PercentageSchema = zod.z.number().min(0).max(100).meta({
   title: "Percentage",
   description: "Percentage value between 0 and 100",
@@ -264,7 +291,8 @@ var RecordSchemaTypeSchema = zod.z.enum([
   "MassID Audit",
   "RecycledID",
   "GasID",
-  "PurchaseID",
+  "CreditPurchaseReceipt",
+  "CreditRetirementReceipt",
   "Methodology",
   "Credit",
   "Collection"
@@ -281,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",
@@ -288,12 +321,13 @@ var RecordRelationshipTypeSchema = zod.z.enum([
   "mass-id",
   "mass-id-audit",
   "methodology",
-  "purchase-id",
+  "credit-purchase-receipt",
+  "credit-retirement-receipt",
   "recycled-id"
 ]).meta({
   title: "Relationship Type",
   description: "Type of relationship between different entities in the system",
-  examples: ["mass-id", "audit", "collection"]
+  examples: ["mass-id", "collection", "credit-purchase-receipt"]
 });
 function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
   return zod.z.array(schema).refine((items) => new Set(items).size === items.length, {
@@ -706,7 +740,8 @@ var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   "MassID",
   "RecycledID",
   "GasID",
-  "PurchaseID"
+  "CreditPurchaseReceipt",
+  "CreditRetirementReceipt"
 ]).meta({
   title: "NFT Schema Type",
   description: "Type of schema for NFT records"
@@ -883,16 +918,16 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.36";
+  return "0.1.38";
 }
-var MethodologyAttributeSchema = NftAttributeSchema.extend({
+var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
   value: MethodologyNameSchema
 }).meta({
   title: "Methodology Attribute",
   description: "Methodology used for certification"
 });
-var CreditAmountAttributeSchema = NftAttributeSchema.extend({
+var CreditAmountAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Credit Amount"),
   value: CreditAmountSchema,
   display_type: zod.z.literal("number")
@@ -900,21 +935,21 @@ var CreditAmountAttributeSchema = NftAttributeSchema.extend({
   title: "Credit Amount Attribute",
   description: "Credit amount attribute with numeric display"
 });
-var CreditTypeAttributeSchema = NftAttributeSchema.extend({
+var CreditTypeAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Credit Type"),
   value: CreditTypeSchema
 }).meta({
   title: "Credit Type Attribute",
   description: "Credit type attribute"
 });
-var SourceWasteTypeAttributeSchema = NftAttributeSchema.extend({
+var SourceWasteTypeAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Source Waste Type"),
   value: WasteTypeSchema
 }).meta({
   title: "Source Waste Type Attribute",
   description: "Source waste type attribute"
 });
-var SourceWeightAttributeSchema = NftAttributeSchema.extend({
+var SourceWeightAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Source Weight (kg)"),
   value: WeightKgSchema.meta({
     title: "Source Weight",
@@ -925,21 +960,21 @@ var SourceWeightAttributeSchema = NftAttributeSchema.extend({
   title: "Source Weight Attribute",
   description: "Source weight attribute with numeric display"
 });
-var OriginCountryAttributeSchema = NftAttributeSchema.extend({
+var OriginCountryAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Country"),
   value: CountryNameSchema
 }).meta({
   title: "Origin Country Attribute",
   description: "Origin country attribute"
 });
-var OriginMunicipalityAttributeSchema = NftAttributeSchema.extend({
+var OriginMunicipalityAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Municipality"),
   value: MunicipalitySchema
 }).meta({
   title: "Origin Municipality Attribute",
   description: "Origin municipality attribute"
 });
-var RecyclerAttributeSchema = NftAttributeSchema.extend({
+var RecyclerAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycler"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycler",
@@ -950,7 +985,7 @@ var RecyclerAttributeSchema = NftAttributeSchema.extend({
   title: "Recycler Attribute",
   description: "Recycler attribute"
 });
-var MassIDTokenIdAttributeSchema = NftAttributeSchema.extend({
+var MassIDTokenIdAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("MassID"),
   value: StringifiedTokenIdSchema.meta({
     title: "MassID Token ID",
@@ -962,7 +997,7 @@ var MassIDTokenIdAttributeSchema = NftAttributeSchema.extend({
 });
 var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
   max_value: true
-}).extend({
+}).safeExtend({
   trait_type: zod.z.literal("MassID Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "MassID Recycling Date",
@@ -973,23 +1008,433 @@ var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
   title: "MassID Recycling Date Attribute",
   description: "MassID recycling date attribute using Unix timestamp in milliseconds"
 });
+var AuditRuleDefinitionSchema = zod.z.strictObject({
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the audit rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  rule_name: NonEmptyStringSchema.max(100).meta({
+    title: "Rule Name",
+    description: "Human-readable name of the rule",
+    examples: ["Waste Mass is Unique", "No Conflicting GasID or Credit"]
+  }),
+  description: zod.z.string().min(10).max(500).meta({
+    title: "Rule Description",
+    description: "Detailed description of what the rule validates and why it is necessary",
+    examples: [
+      "Validates that each MassID is unique within the system to prevent duplicate entries"
+    ]
+  }),
+  source_code_url: zod.z.url().regex(/^https:\/\/github\.com\/.*$/, "Must be a GitHub URL").meta({
+    title: "Rule Source Code URL",
+    description: "GitHub URL pointing to the implementation source code for this rule",
+    examples: [
+      "https://github.com/carrot-foundation/methodologies/blob/main/bold-carbon/rules/waste-mass-unique.js"
+    ]
+  }),
+  mandatory: zod.z.boolean().meta({
+    title: "Mandatory",
+    description: "Whether this rule is mandatory for methodology compliance"
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule must be executed"
+  })
+}).meta({
+  title: "Audit Rule Definition",
+  description: "Definition of an audit rule that must be executed for methodology compliance"
+});
+var AuditRuleDefinitionsSchema = zod.z.array(AuditRuleDefinitionSchema).min(1).meta({
+  title: "Audit Rule Definitions",
+  description: "List of audit rules that must be executed to check methodology compliance"
+});
+var AuditRuleExecutionResultSchema = zod.z.strictObject({
+  rule_name: NonEmptyStringSchema.meta({
+    title: "Rule Name",
+    description: "Human-readable name of the audit rule"
+  }),
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule was executed"
+  }),
+  result: MethodologyComplianceSchema.meta({
+    title: "Rule Execution Result",
+    description: "Result of the rule execution"
+  }),
+  description: zod.z.string().min(1).max(2e3).meta({
+    title: "Rule Description",
+    description: "Detailed description of what this rule validates"
+  }),
+  rule_processor_checksum: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Processor Checksum",
+    description: "Checksum for rule processor integrity verification"
+  }),
+  rule_source_code_version: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Source Code Version",
+    description: "Version identifier for the rule source code"
+  })
+}).meta({
+  title: "Audit Rule Execution Result",
+  description: "Detailed result of an audit rule execution"
+});
+var AuditRuleExecutionResultsSchema = zod.z.array(AuditRuleExecutionResultSchema).meta({
+  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.extend({
+var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Type"),
   value: WasteTypeSchema
 }).meta({
   title: "Waste Type Attribute",
   description: "Waste type attribute"
 });
-var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Subtype"),
   value: WasteSubtypeSchema
 }).meta({
   title: "Waste Subtype Attribute",
   description: "Waste subtype attribute"
 });
-var MassIDAttributeWeightSchema = NftAttributeSchema.extend({
+var MassIDAttributeWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weight (kg)"),
   value: WeightKgSchema,
   display_type: zod.z.literal("number")
@@ -997,20 +1442,20 @@ var MassIDAttributeWeightSchema = NftAttributeSchema.extend({
   title: "Weight Attribute",
   description: "Weight attribute with numeric display"
 });
-var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.extend({
+var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.safeExtend({
   value: CountryNameSchema
 });
-var MassIDAttributeOriginMunicipalitySchema = OriginMunicipalityAttributeSchema.extend({
+var MassIDAttributeOriginMunicipalitySchema = OriginMunicipalityAttributeSchema.safeExtend({
   value: MunicipalitySchema
 });
-var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.extend({
+var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Administrative Division"),
   value: AdministrativeDivisionSchema
 }).meta({
   title: "Origin Administrative Division Attribute",
   description: "Origin administrative division attribute"
 });
-var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Vehicle Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Vehicle Type",
@@ -1021,7 +1466,7 @@ var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.extend({
   title: "Vehicle Type Attribute",
   description: "Vehicle type attribute"
 });
-var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Method",
@@ -1036,7 +1481,7 @@ var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.extend({
   title: "Recycling Method Attribute",
   description: "Recycling method attribute"
 });
-var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.extend({
+var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Processing Time (hours)"),
   value: HoursSchema,
   trait_description: NonEmptyStringSchema.max(200).optional().meta({
@@ -1047,7 +1492,7 @@ var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.extend({
   title: "Processing Time Attribute",
   description: "Processing time attribute with optional trait description"
 });
-var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.extend({
+var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Local Waste Classification ID"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Local Waste Classification ID",
@@ -1058,7 +1503,7 @@ var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.extend(
   title: "Local Waste Classification ID Attribute",
   description: "Local waste classification ID attribute"
 });
-var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Manifest Code"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Manifest Code",
@@ -1069,7 +1514,7 @@ var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.extend({
   title: "Recycling Manifest Code Attribute",
   description: "Recycling manifest code attribute (optional)"
 });
-var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.extend({
+var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Transport Manifest Code"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Transport Manifest Code",
@@ -1080,7 +1525,7 @@ var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.extend({
   title: "Transport Manifest Code Attribute",
   description: "Transport manifest code attribute (optional)"
 });
-var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.extend({
+var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weighing Capture Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Weighing Capture Method",
@@ -1091,7 +1536,7 @@ var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.extend({
   title: "Weighing Capture Method Attribute",
   description: "Weighing capture method attribute (optional)"
 });
-var MassIDAttributeScaleTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Scale Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Scale Type",
@@ -1107,7 +1552,7 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.extend({
   title: "Scale Type Attribute",
   description: "Scale type attribute (optional)"
 });
-var MassIDAttributeContainerTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeContainerTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Container Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Container Type",
@@ -1118,7 +1563,7 @@ var MassIDAttributeContainerTypeSchema = NftAttributeSchema.extend({
   title: "Container Type Attribute",
   description: "Container type attribute (optional)"
 });
-var MassIDAttributePickUpDateSchema = NftAttributeSchema.extend({
+var MassIDAttributePickUpDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Pick-up Date"),
   value: UnixTimestampSchema.meta({
     title: "Pick-up Date",
@@ -1130,7 +1575,7 @@ var MassIDAttributePickUpDateSchema = NftAttributeSchema.extend({
   title: "Pick-up Date Attribute",
   description: "Pick-up date attribute with Unix timestamp"
 });
-var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "Recycling Date",
@@ -1469,7 +1914,7 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   data: MassIDDataSchema
 }).meta(MassIDIpfsSchemaMeta);
 var GasIDAttributeMethodologySchema = MethodologyAttributeSchema;
-var GasIDAttributeGasTypeSchema = NftAttributeSchema.extend({
+var GasIDAttributeGasTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Gas Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Gas Type",
@@ -1480,7 +1925,7 @@ var GasIDAttributeGasTypeSchema = NftAttributeSchema.extend({
   title: "Gas Type Attribute",
   description: "Gas type attribute"
 });
-var GasIDAttributeCo2ePreventedSchema = NftAttributeSchema.extend({
+var GasIDAttributeCo2ePreventedSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("CO\u2082e Prevented (kg)"),
   value: NonNegativeFloatSchema.meta({
     title: "CO\u2082e Prevented",
@@ -1614,7 +2059,7 @@ var GasIDIpfsSchema = NftIpfsSchema.safeExtend({
   data: GasIDDataSchema
 }).meta(GasIDIpfsSchemaMeta);
 var RecycledIDAttributeMethodologySchema = MethodologyAttributeSchema;
-var RecycledIDAttributeRecycledMassWeightSchema = NftAttributeSchema.extend({
+var RecycledIDAttributeRecycledMassWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycled Mass Weight (kg)"),
   value: WeightKgSchema.meta({
     title: "Recycled Mass Weight",
@@ -1693,20 +2138,1296 @@ var RecycledIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: RecycledIDAttributesSchema,
   data: RecycledIDDataSchema
 }).meta(RecycledIDIpfsSchemaMeta);
+var CreditPurchaseReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: TokenSymbolSchema.meta({
+    title: "Credit Token Symbol",
+    description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
+    examples: ["C-CARB", "C-BIOW"]
+  }),
+  value: CreditAmountSchema.meta({
+    title: "Credit Amount",
+    description: "Amount of credits purchased for the token symbol"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Credit Attribute",
+  description: "Attribute representing purchased amount per credit token symbol"
+});
+var CreditPurchaseReceiptTotalCreditsAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Total Credits Purchased"),
+  value: CreditAmountSchema.meta({
+    title: "Total Credits Purchased",
+    description: "Total number of credits purchased across all tokens"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Total Credits Purchased Attribute",
+  description: "Aggregate credits purchased attribute"
+});
+var CreditPurchaseReceiptTotalUsdcAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Total USDC Amount"),
+  value: CreditAmountSchema.meta({
+    title: "Total USDC Amount",
+    description: "Total USDC amount paid for the purchase"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Total USDC Amount Attribute",
+  description: "Aggregate USDC amount attribute"
+});
+var CreditPurchaseReceiptPurchaseDateAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Purchase Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Purchase Date",
+    description: "Unix timestamp in milliseconds when the purchase was completed"
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Purchase Date Attribute",
+  description: "Purchase date attribute using Unix timestamp in milliseconds"
+});
+var CreditPurchaseReceiptCertificatesAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Certificates Purchased"),
+  value: PositiveIntegerSchema.meta({
+    title: "Certificates Purchased",
+    description: "Total number of certificates purchased"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Certificates Purchased Attribute",
+  description: "Attribute representing how many certificates were purchased"
+});
+var CreditPurchaseReceiptReceiverAttributeSchema = NftAttributeSchema.omit({
+  display_type: true,
+  max_value: true
+}).safeExtend({
+  trait_type: zod.z.literal("Receiver"),
+  value: ParticipantNameSchema.meta({
+    title: "Receiver",
+    description: "Organization or individual receiving the credits from the purchase",
+    examples: ["EcoTech Solutions Inc."]
+  })
+}).meta({
+  title: "Receiver Attribute",
+  description: "Attribute containing the receiver 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")
+}).meta({
+  title: "Collection Attribute",
+  description: "Attribute representing the amount of credits purchased from a collection"
+});
+var CreditPurchaseReceiptAttributesSchema = uniqueBy(
+  zod.z.union([
+    CreditPurchaseReceiptCreditAttributeSchema,
+    CreditPurchaseReceiptTotalCreditsAttributeSchema,
+    CreditPurchaseReceiptTotalUsdcAttributeSchema,
+    CreditPurchaseReceiptPurchaseDateAttributeSchema,
+    CreditPurchaseReceiptCertificatesAttributeSchema,
+    CreditPurchaseReceiptReceiverAttributeSchema,
+    CreditPurchaseReceiptCollectionAttributeSchema
+  ]),
+  (attribute) => attribute.trait_type,
+  "Attribute trait_type values must be unique"
+).min(5).meta({
+  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 CreditPurchaseReceiptIdentitySchema = ReceiptIdentitySchema;
+var CreditPurchaseReceiptReceiverSchema = zod.z.strictObject({
+  wallet_address: EthereumAddressSchema.meta({
+    title: "Receiver Wallet Address",
+    description: "Ethereum address of the receiver"
+  }),
+  identity: CreditPurchaseReceiptIdentitySchema.optional()
+}).meta({
+  title: "Receiver",
+  description: "Receiver wallet and optional identity information"
+});
+var CreditPurchaseReceiptBuyerSchema = zod.z.strictObject({
+  buyer_id: ExternalIdSchema.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"
+});
+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"
+  }
+});
+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({
+    title: "Participant ID Hash",
+    description: "Hash representing the participant identifier (SHA-256 hex string)"
+  }),
+  participant_name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Legal name of the participant receiving the reward"
+  }),
+  roles: uniqueArrayItems(
+    ParticipantRoleSchema,
+    "Participant roles must be unique"
+  ).min(1).meta({
+    title: "Participant Roles",
+    description: "Roles the participant has in the supply chain"
+  }),
+  usdc_amount: NonNegativeFloatSchema.meta({
+    title: "USDC Reward Amount",
+    description: "USDC amount allocated to this participant"
+  })
+}).meta({
+  title: "Participant Reward",
+  description: "Reward distribution for a participant"
+});
+var CreditPurchaseReceiptRetirementReceiptSchema = zod.z.strictObject({
+  token_id: TokenIdSchema.meta({
+    title: "Retirement Receipt Token ID",
+    description: "Token ID of the retirement receipt NFT"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Retirement Receipt External ID",
+    description: "External identifier for the retirement receipt"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Retirement Receipt External URL",
+    description: "External URL for the retirement receipt"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Retirement Receipt URI",
+    description: "IPFS URI for the retirement receipt metadata"
+  }),
+  smart_contract: SmartContractSchema
+}).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,
+  collections: uniqueBy(
+    CreditPurchaseReceiptCollectionSchema,
+    (collection) => collection.slug,
+    "Collection slugs must be unique"
+  ).min(1).meta({
+    title: "Collections",
+    description: "Collections included in the purchase"
+  }),
+  credits: uniqueBy(
+    CreditPurchaseReceiptCreditSchema,
+    (credit) => credit.slug,
+    "Credit slugs must be unique"
+  ).min(1).meta({
+    title: "Credits",
+    description: "Credits included in the purchase"
+  }),
+  certificates: uniqueBy(
+    CreditPurchaseReceiptCertificateSchema,
+    (certificate) => certificate.token_id,
+    "Certificate token_ids must be unique"
+  ).min(1).meta({
+    title: "Certificates",
+    description: "Certificates involved in the purchase"
+  }),
+  participant_rewards: uniqueBy(
+    CreditPurchaseReceiptParticipantRewardSchema,
+    (reward) => reward.id_hash,
+    "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()
+}).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,
+    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) => 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 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();
+  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) {
+      ctx.addIssue({
+        code: "custom",
+        message: "purchased_amount cannot exceed total_amount",
+        path: ["certificates", index, "purchased_amount"]
+      });
+    }
+    totalCreditsFromCertificates += Number(certificate.purchased_amount);
+    creditPurchaseTotalsBySlug.set(
+      String(certificate.credit_slug),
+      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + Number(certificate.purchased_amount)
+    );
+    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)
+    );
+  });
+  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
+  );
+  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(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"]
+      });
+    }
+  });
+  const participantRewardTotal = data.participant_rewards.reduce(
+    (sum, reward) => sum + Number(reward.usdc_amount),
+    0
+  );
+  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"
+});
+var CreditPurchaseReceiptIpfsSchemaMeta = {
+  title: "CreditPurchaseReceipt NFT IPFS Record",
+  description: "Complete CreditPurchaseReceipt NFT IPFS record including attributes and credit purchase data",
+  $id: buildSchemaUrl(
+    "credit-purchase-receipt/credit-purchase-receipt.schema.json"
+  ),
+  version: getSchemaVersionOrDefault()
+};
+var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
+  schema: NftIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("CreditPurchaseReceipt").meta({
+      title: "CreditPurchaseReceipt Schema Type",
+      description: "CreditPurchaseReceipt NFT schema type"
+    })
+  }),
+  attributes: CreditPurchaseReceiptAttributesSchema,
+  data: CreditPurchaseReceiptDataSchema
+}).superRefine((value, ctx) => {
+  const attributes = value.attributes;
+  const data = value.data;
+  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'
+    });
+  }
+  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"
+  }
+});
+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"
+  }
+});
+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"
+    }
+  }
+);
+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: "collection_slug must match a collection slug in collections",
+        path: ["certificates", index, "collection_slug"]
+      });
+    }
+    if (certificate.retired_amount > certificate.total_amount) {
+      ctx.addIssue({
+        code: "custom",
+        message: "retired_amount cannot exceed total_amount",
+        path: ["certificates", index, "retired_amount"]
+      });
+    }
+    const creditsRetiredTotal = certificate.credits_retired.reduce(
+      (sum, credit) => sum + Number(credit.amount),
+      0
+    );
+    if (!nearlyEqual(creditsRetiredTotal, certificate.retired_amount)) {
+      ctx.addIssue({
+        code: "custom",
+        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"]
+      });
+    }
+  });
+  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: "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"]
+      });
+    }
+  });
+}).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",
+  $id: buildSchemaUrl("collection/collection.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var CollectionSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Collection").meta({
+      title: "Collection Schema Type",
+      description: "Collection schema type"
+    })
+  }),
+  name: CollectionNameSchema,
+  slug: CollectionSlugSchema.optional(),
+  image: IpfsUriSchema.meta({
+    title: "Collection Image",
+    description: "IPFS URI pointing to the collection's visual representation",
+    examples: ["ipfs://QmCollectionImageHash/collection-icon.png"]
+  }),
+  description: zod.z.string().min(50).max(1e3).meta({
+    title: "Collection Description",
+    description: "Comprehensive description of the collection, its purpose, and context",
+    examples: [
+      "Cold Start is a limited-edition collection created for early supporters of BOLD - Breakthrough in Organic Landfill Diversion. This purchase contributes to reducing global waste and promoting circularity, with funds distributed via smart contract to local recycling operations and communities."
+    ]
+  })
+}).meta(CollectionSchemaMeta);
+var CreditSchemaMeta = {
+  title: "Credit IPFS Record",
+  description: "Credit token metadata stored in IPFS, extending the base schema with ERC20-specific details",
+  $id: buildSchemaUrl("credit/credit.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var CreditSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Credit").meta({
+      title: "Credit Schema Type",
+      description: "Credit schema type"
+    })
+  }),
+  symbol: TokenSymbolSchema,
+  slug: SlugSchema.meta({
+    title: "Token Slug",
+    description: "URL-friendly identifier for the token",
+    examples: ["carbon"]
+  }).optional(),
+  name: NonEmptyStringSchema.meta({
+    title: "Token Name",
+    description: "Full human-readable name of the ERC20 token",
+    examples: ["Carrot Carbon"]
+  }),
+  decimals: zod.z.number().int().min(0).max(18).meta({
+    title: "Token Decimals",
+    description: "Number of decimal places for the ERC20 token",
+    examples: [18]
+  }),
+  image: IpfsUriSchema.meta({
+    title: "Token Image",
+    description: "IPFS URI pointing to the token's visual representation image",
+    examples: ["ipfs://QmTokenImageHash/credit-icon.png"]
+  }),
+  description: zod.z.string().min(50).max(1e3).meta({
+    title: "Token Description",
+    description: "Comprehensive description of the credit token, its purpose, and impact",
+    examples: [
+      "Carrot Carbon (C-CARB) represents verified carbon emissions reductions from organic waste composting projects. Each token equals one metric ton of CO2 equivalent prevented from entering the atmosphere through sustainable waste management practices."
+    ]
+  })
+}).meta(CreditSchemaMeta);
+var MethodologyDataSchema = zod.z.strictObject({
+  name: MethodologyNameSchema.meta({
+    title: "Methodology Name",
+    description: "Full official name of the methodology"
+  }),
+  short_name: NonEmptyStringSchema.max(50).meta({
+    title: "Methodology Short Name",
+    description: "Abbreviated name for UI display and references",
+    examples: ["BOLD Carbon", "BOLD Recycling"]
+  }),
+  slug: SlugSchema.meta({
+    title: "Methodology Slug",
+    description: "URL-friendly identifier for the methodology",
+    examples: ["bold-carbon-ch4", "bold-recycling"]
+  }),
+  version: SemanticVersionSchema.meta({
+    title: "Methodology Version",
+    description: "Version of the methodology"
+  }),
+  description: zod.z.string().min(50).max(2e3).meta({
+    title: "Methodology Description",
+    description: "Comprehensive methodology description including purpose, scope, and implementation approach"
+  }),
+  revision_date: IsoDateSchema.meta({
+    title: "Revision Date",
+    description: "ISO 8601 date of the last revision to this methodology"
+  }),
+  publication_date: IsoDateSchema.meta({
+    title: "Publication Date",
+    description: "ISO 8601 date of the original publication of this methodology"
+  }),
+  methodology_pdf: IpfsUriSchema.meta({
+    title: "Methodology PDF",
+    description: "IPFS URI pointing to the complete methodology PDF document"
+  }),
+  mass_id_audit_rules: AuditRuleDefinitionsSchema.meta({
+    title: "MassID Audit Rules",
+    description: "Audit rules that must be executed to check MassID compliance with the methodology"
+  })
+}).meta({
+  title: "Methodology Data",
+  description: "Methodology-specific data including audit rules"
+});
+
+// src/methodology/methodology.schema.ts
+var MethodologySchemaMeta = {
+  title: "Methodology IPFS Record",
+  description: "Methodology metadata stored in IPFS, extending the base schema with methodology data and audit rules",
+  $id: buildSchemaUrl("methodology/methodology.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var MethodologySchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Methodology").meta({
+      title: "Methodology Schema Type",
+      description: "Methodology schema type"
+    })
+  }),
+  data: MethodologyDataSchema
+}).meta(MethodologySchemaMeta);
+var MassIDAuditSummarySchema = zod.z.strictObject({
+  audit_date: IsoDateSchema.meta({
+    title: "Audit Date",
+    description: "Date when the audit was completed"
+  }),
+  methodology_compliance: MethodologyComplianceSchema.meta({
+    title: "Methodology Compliance",
+    description: "Overall outcome of the audit process"
+  }),
+  total_rules_executed: NonNegativeIntegerSchema.meta({
+    title: "Total Rules Executed",
+    description: "Total number of audit rules executed"
+  }),
+  passed_rules: NonNegativeIntegerSchema.meta({
+    title: "Passed Rules Count",
+    description: "Number of rules that passed verification"
+  }),
+  failed_rules: NonNegativeIntegerSchema.meta({
+    title: "Failed Rules Count",
+    description: "Number of rules that failed verification"
+  })
+}).meta({
+  title: "Audit Summary",
+  description: "Summary of audit execution results"
+});
+var MassIDAuditDataSchema = zod.z.strictObject({
+  methodology: MethodologyReferenceSchema,
+  mass_id: MassIDReferenceSchema,
+  gas_id: GasIDReferenceSchema,
+  audit_summary: MassIDAuditSummarySchema,
+  rules_execution_results: AuditRuleExecutionResultsSchema
+}).meta({
+  title: "MassID Audit Data",
+  description: "Complete data structure for MassID Audit records"
+});
+
+// src/mass-id-audit/mass-id-audit.schema.ts
+var MassIDAuditSchemaMeta = {
+  title: "MassID Audit IPFS Record",
+  description: "MassID audit metadata stored in IPFS, extending the base schema with audit results and references",
+  $id: buildSchemaUrl("mass-id-audit/mass-id-audit.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var MassIDAuditSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("MassID Audit").meta({
+      title: "MassID Audit Schema Type",
+      description: "MassID Audit schema type"
+    })
+  }),
+  data: MassIDAuditDataSchema
+}).meta(MassIDAuditSchemaMeta);
 
 exports.AccreditedParticipantSchema = AccreditedParticipantSchema;
 exports.AccreditedParticipantsSchema = AccreditedParticipantsSchema;
 exports.AdministrativeDivisionSchema = AdministrativeDivisionSchema;
 exports.AuditReferenceSchema = AuditReferenceSchema;
+exports.AuditRuleDefinitionSchema = AuditRuleDefinitionSchema;
+exports.AuditRuleDefinitionsSchema = AuditRuleDefinitionsSchema;
+exports.AuditRuleExecutionResultSchema = AuditRuleExecutionResultSchema;
+exports.AuditRuleExecutionResultsSchema = AuditRuleExecutionResultsSchema;
 exports.BaseIpfsSchema = BaseIpfsSchema;
 exports.BlockchainChainIdSchema = BlockchainChainIdSchema;
+exports.BlockchainNetworkNameSchema = BlockchainNetworkNameSchema;
+exports.CollectionNameSchema = CollectionNameSchema;
+exports.CollectionSchema = CollectionSchema;
+exports.CollectionSchemaMeta = CollectionSchemaMeta;
+exports.CollectionSlugSchema = CollectionSlugSchema;
 exports.CoordinatesSchema = CoordinatesSchema;
 exports.CountryNameSchema = CountryNameSchema;
 exports.CreditAmountAttributeSchema = CreditAmountAttributeSchema;
 exports.CreditAmountSchema = CreditAmountSchema;
+exports.CreditPurchaseReceiptAttributesSchema = CreditPurchaseReceiptAttributesSchema;
+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;
@@ -1728,16 +3449,23 @@ exports.LatitudeSchema = LatitudeSchema;
 exports.LocationSchema = LocationSchema;
 exports.LongitudeSchema = LongitudeSchema;
 exports.MassIDAttributesSchema = MassIDAttributesSchema;
+exports.MassIDAuditDataSchema = MassIDAuditDataSchema;
+exports.MassIDAuditSchema = MassIDAuditSchema;
+exports.MassIDAuditSchemaMeta = MassIDAuditSchemaMeta;
 exports.MassIDDataSchema = MassIDDataSchema;
 exports.MassIDIpfsSchema = MassIDIpfsSchema;
 exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
 exports.MassIDRecyclingDateAttributeSchema = MassIDRecyclingDateAttributeSchema;
 exports.MassIDReferenceSchema = MassIDReferenceSchema;
 exports.MassIDTokenIdAttributeSchema = MassIDTokenIdAttributeSchema;
+exports.MassIdReferenceWithContractSchema = MassIdReferenceWithContractSchema;
 exports.MethodologyAttributeSchema = MethodologyAttributeSchema;
 exports.MethodologyComplianceSchema = MethodologyComplianceSchema;
+exports.MethodologyDataSchema = MethodologyDataSchema;
 exports.MethodologyNameSchema = MethodologyNameSchema;
 exports.MethodologyReferenceSchema = MethodologyReferenceSchema;
+exports.MethodologySchema = MethodologySchema;
+exports.MethodologySchemaMeta = MethodologySchemaMeta;
 exports.MinutesSchema = MinutesSchema;
 exports.MunicipalitySchema = MunicipalitySchema;
 exports.NftAttributeSchema = NftAttributeSchema;
@@ -1753,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;
@@ -1765,6 +3494,8 @@ exports.RewardAllocationSchema = RewardAllocationSchema;
 exports.SemanticVersionSchema = SemanticVersionSchema;
 exports.Sha256HashSchema = Sha256HashSchema;
 exports.SlugSchema = SlugSchema;
+exports.SmartContractAddressSchema = SmartContractAddressSchema;
+exports.SmartContractSchema = SmartContractSchema;
 exports.SourceWasteTypeAttributeSchema = SourceWasteTypeAttributeSchema;
 exports.SourceWeightAttributeSchema = SourceWeightAttributeSchema;
 exports.StringifiedTokenIdSchema = StringifiedTokenIdSchema;
@@ -1777,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