@carrot-foundation/schemas 0.1.59 → 0.1.61

package/dist/index.cjs

@@ -28409,9 +28409,9 @@ var RecordEnvironmentSchema = zod.z.strictObject({
   description: "Environment information for the record"
 });
 var ViewerReferenceSchema = zod.z.strictObject({
-  ipfs_cid: IpfsCidSchema.meta({
-    title: "Viewer IPFS CID",
-    description: "IPFS CID of the metadata viewer dApp build"
+  ipfs_uri: IpfsUriSchema.meta({
+    title: "Viewer IPFS URI",
+    description: "IPFS URI of the metadata viewer dApp build"
   }),
   integrity_hash: Sha256HashSchema.meta({
     title: "Viewer Integrity Hash",
@@ -28434,10 +28434,6 @@ var BaseIpfsSchema = zod.z.strictObject({
   }),
   external_id: ExternalIdSchema,
   external_url: ExternalUrlSchema,
-  original_content_hash: Sha256HashSchema.meta({
-    title: "Original Content Hash",
-    description: "SHA-256 hash of the original JSON content including private data before schema validation"
-  }),
   content_hash: Sha256HashSchema.meta({
     title: "Content Hash",
     description: "SHA-256 hash of RFC 8785 canonicalized JSON after schema validation"
@@ -28552,6 +28548,10 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
       description: "Type/category of this NFT schema"
     })
   }),
+  full_content_hash: Sha256HashSchema.meta({
+    title: "Full Content Hash",
+    description: "SHA-256 hash of the original JSON content including private data before schema validation"
+  }),
   viewer_reference: ViewerReferenceSchema,
   environment: RecordEnvironmentSchema,
   blockchain: BlockchainReferenceSchema,
@@ -29107,48 +29107,55 @@ var AuditReferenceSchema = zod.z.strictObject({
   title: "Audit Reference",
   description: "Reference to an audit record"
 });
-var GasIDReferenceSchema = zod.z.strictObject({
-  external_id: ExternalIdSchema.meta({
-    title: "GasID External ID",
-    description: "Unique identifier for the GasID"
-  }),
-  token_id: TokenIdSchema.meta({
-    title: "GasID Token ID",
-    description: "NFT token ID of the GasID"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "GasID External URL",
-    description: "URL to view the GasID on Carrot Explorer"
-  }),
-  ipfs_uri: IpfsUriSchema.meta({
-    title: "GasID IPFS URI",
-    description: "IPFS URI of the GasID record"
-  })
+var TokenReferenceBaseSchema = zod.z.strictObject({
+  external_id: ExternalIdSchema,
+  external_url: ExternalUrlSchema,
+  ipfs_uri: IpfsUriSchema,
+  smart_contract_address: SmartContractAddressSchema
 }).meta({
-  title: "GasID Reference",
-  description: "Reference to a GasID record"
+  title: "Token Reference",
+  description: "Base schema for all token references"
 });
-var MassIDReferenceSchema = zod.z.strictObject({
-  external_id: ExternalIdSchema.meta({
-    title: "MassID External ID",
-    description: "Unique identifier for the MassID"
-  }),
-  token_id: TokenIdSchema.meta({
-    title: "MassID Token ID",
-    description: "NFT token ID of the MassID"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "MassID External URL",
-    description: "URL to view the MassID on Carrot Explorer"
-  }),
-  ipfs_uri: IpfsUriSchema.meta({
-    title: "MassID IPFS URI",
-    description: "IPFS URI of the MassID record"
-  })
+var NftTokenReferenceBaseSchema = TokenReferenceBaseSchema.safeExtend({
+  token_id: TokenIdSchema
 }).meta({
+  title: "NFT Token Reference",
+  description: "Base schema for NFT token references"
+});
+
+// src/shared/schemas/references/mass-id-reference.schema.ts
+var MassIDReferenceSchema = NftTokenReferenceBaseSchema.meta({
   title: "MassID Reference",
   description: "Reference to a MassID record"
 });
+
+// src/shared/schemas/references/certificate-reference.schema.ts
+var CertificateReferenceBaseSchema = NftTokenReferenceBaseSchema.safeExtend({
+  type: CertificateTypeSchema,
+  total_amount: CreditAmountSchema.meta({
+    title: "Certificate Total Amount",
+    description: "Total credits available in this certificate"
+  }),
+  mass_id: MassIDReferenceSchema
+}).meta({
+  title: "Certificate Reference Base",
+  description: "Base schema for certificate references"
+});
+
+// src/shared/schemas/references/credit-reference.schema.ts
+var CreditReferenceSchema = TokenReferenceBaseSchema.safeExtend({
+  slug: CreditTokenSlugSchema,
+  symbol: CreditTokenSymbolSchema
+}).meta({
+  title: "Credit Reference",
+  description: "Reference to an ERC20 credit token"
+});
+
+// src/shared/schemas/references/gas-id-reference.schema.ts
+var GasIDReferenceSchema = NftTokenReferenceBaseSchema.meta({
+  title: "GasID Reference",
+  description: "Reference to a GasID record"
+});
 var MethodologyReferenceSchema = zod.z.strictObject({
   external_id: ExternalIdSchema.meta({
     title: "Methodology External ID",
@@ -29172,6 +29179,22 @@ var MethodologyReferenceSchema = zod.z.strictObject({
   description: "Reference to a methodology record"
 });
 
+// src/shared/schemas/references/receipt-reference.schema.ts
+var CreditPurchaseReceiptReferenceSchema = NftTokenReferenceBaseSchema.meta({
+  title: "Credit Purchase Receipt Reference",
+  description: "Reference to the credit purchase receipt when retirement occurs during purchase"
+});
+var CreditRetirementReceiptReferenceSchema = NftTokenReferenceBaseSchema.meta({
+  title: "Credit Retirement Receipt Reference",
+  description: "Reference to the retirement receipt NFT"
+});
+
+// src/shared/schemas/references/recycled-id-reference.schema.ts
+var RecycledIDReferenceSchema = NftTokenReferenceBaseSchema.meta({
+  title: "RecycledID Reference",
+  description: "Reference to a RecycledID record"
+});
+
 // src/shared/schemas/audit.schema.ts
 var AuditRuleDefinitionSchema = zod.z.strictObject({
   id: UuidSchema.meta({
@@ -29306,6 +29329,16 @@ var AuditRuleExecutionResultSchema = zod.z.strictObject({
     title: "Rule Execution Result",
     description: "Result of the rule execution"
   }),
+  execution_message: NonEmptyStringSchema.max(2e3).optional().meta({
+    title: "Execution Message",
+    description: "Human-readable message explaining the rule execution result, including details about what was validated or calculated",
+    examples: [
+      "No other MassIDs with the same attributes were found.",
+      "The MassID is not linked to a valid MassID Certificate",
+      'The time between the "Drop-off" and "Recycled" events is 90 days, within the valid range (60-180 days).',
+      "The prevented emissions were calculated as 419.93 kg CO\u2082e using the formula (1 - 0.029) x 0.067 x 6454.8 = 419.93"
+    ]
+  }),
   rule_processor_checksum: NonEmptyStringSchema.max(200).meta({
     title: "Rule Processor Checksum",
     description: "Checksum for rule processor integrity verification"
@@ -29560,12 +29593,6 @@ var ReceiptIdentitySchema = zod.z.strictObject({
   title: "Identity",
   description: "Participant identity information"
 });
-var MassIDReferenceWithContractSchema = MassIDReferenceSchema.safeExtend({
-  smart_contract_address: SmartContractAddressSchema
-}).meta({
-  title: "MassID Reference with Smart Contract",
-  description: "Reference to a MassID record with smart contract address"
-});
 function createReceiptCollectionSchema(params) {
   const { meta } = params;
   return zod.z.strictObject({
@@ -29585,26 +29612,6 @@ function createReceiptCollectionSchema(params) {
     })
   }).meta(meta);
 }
-function createReceiptCreditSchema(params) {
-  const { meta } = params;
-  return zod.z.strictObject({
-    slug: CreditTokenSlugSchema,
-    symbol: CreditTokenSymbolSchema,
-    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"
-    }),
-    ipfs_uri: IpfsUriSchema.meta({
-      title: "Credit IPFS URI",
-      description: "IPFS URI for the credit details"
-    }),
-    smart_contract_address: SmartContractAddressSchema
-  }).meta(meta);
-}
 var CertificateCollectionItemPurchaseSchema = zod.z.strictObject({
   slug: CollectionSlugSchema.meta({
     title: "Collection Slug",
@@ -29632,37 +29639,6 @@ var CertificateCollectionItemRetirementSchema = zod.z.strictObject({
   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: CertificateTypeSchema,
-  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"
-  }),
-  ipfs_uri: IpfsUriSchema.meta({
-    title: "Certificate IPFS URI",
-    description: "IPFS URI for the certificate metadata"
-  }),
-  smart_contract_address: SmartContractAddressSchema,
-  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);
-}
 function getSchemaBaseUrl() {
   return `https://raw.githubusercontent.com/carrot-foundation/schemas/refs/tags/${getSchemaVersionOrDefault()}/schemas/ipfs`;
 }
@@ -29671,7 +29647,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.59";
+  return "0.1.61";
 }
 
 // src/shared/schema-validation.ts
@@ -29730,6 +29706,48 @@ function validateCountMatches(params) {
     });
   }
 }
+function validateNumericAttributeValue(params) {
+  const {
+    ctx,
+    attributeByTraitType,
+    traitType,
+    expectedValue,
+    epsilon,
+    missingMessage,
+    mismatchMessage
+  } = params;
+  const attribute = attributeByTraitType.get(traitType);
+  if (!attribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: missingMessage,
+      path: ["attributes"]
+    });
+    return;
+  }
+  const attributeValue = attribute.value;
+  if (typeof attributeValue !== "number") {
+    const attributeIndex = Array.from(attributeByTraitType.keys()).indexOf(
+      traitType
+    );
+    ctx.addIssue({
+      code: "custom",
+      message: `${traitType} attribute value must be a number`,
+      path: ["attributes", attributeIndex, "value"]
+    });
+    return;
+  }
+  if (!nearlyEqual(attributeValue, expectedValue, epsilon)) {
+    const attributeIndex = Array.from(attributeByTraitType.keys()).indexOf(
+      traitType
+    );
+    ctx.addIssue({
+      code: "custom",
+      message: mismatchMessage,
+      path: ["attributes", attributeIndex, "value"]
+    });
+  }
+}
 function validateAttributeValue(params) {
   const {
     ctx,
@@ -29740,6 +29758,19 @@ function validateAttributeValue(params) {
     mismatchMessage,
     path = ["attributes"]
   } = params;
+  if (expectedValue === void 0 || expectedValue === null) {
+    const attributeIndex = Array.from(attributeByTraitType.keys()).indexOf(
+      traitType
+    );
+    if (attributeIndex >= 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: missingMessage,
+        path: ["attributes", attributeIndex]
+      });
+    }
+    return;
+  }
   const attribute = attributeByTraitType.get(traitType);
   if (!attribute) {
     ctx.addIssue({
@@ -29750,10 +29781,13 @@ function validateAttributeValue(params) {
     return;
   }
   if (attribute.value !== expectedValue) {
+    const attributeIndex = Array.from(attributeByTraitType.keys()).indexOf(
+      traitType
+    );
     ctx.addIssue({
       code: "custom",
       message: mismatchMessage,
-      path
+      path: ["attributes", attributeIndex, "value"]
     });
   }
 }
@@ -29795,6 +29829,55 @@ function validateDateAttribute(params) {
     });
   }
 }
+function validateDateTimeAttribute(params) {
+  const {
+    ctx,
+    attributeByTraitType,
+    traitType,
+    dateTimeValue,
+    missingMessage,
+    invalidDateMessage,
+    mismatchMessage,
+    attributePath = ["attributes"],
+    dateTimePath
+  } = params;
+  if (!dateTimeValue) {
+    const attribute2 = attributeByTraitType.get(traitType);
+    if (attribute2) {
+      ctx.addIssue({
+        code: "custom",
+        message: missingMessage,
+        path: attributePath
+      });
+    }
+    return;
+  }
+  const attribute = attributeByTraitType.get(traitType);
+  if (!attribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: missingMessage,
+      path: attributePath
+    });
+    return;
+  }
+  const dateMs = Date.parse(dateTimeValue);
+  if (Number.isNaN(dateMs)) {
+    ctx.addIssue({
+      code: "custom",
+      message: invalidDateMessage,
+      path: dateTimePath ?? attributePath
+    });
+    return;
+  }
+  if (attribute.value !== dateMs) {
+    ctx.addIssue({
+      code: "custom",
+      message: mismatchMessage,
+      path: attributePath
+    });
+  }
+}
 function validateAttributesForItems(params) {
   const {
     ctx,
@@ -29925,6 +30008,35 @@ function validateCreditSymbolExists(params) {
     });
   }
 }
+function validateTokenIdInName(params) {
+  const {
+    ctx,
+    name,
+    tokenId,
+    pattern,
+    path,
+    message = `Name token_id must match blockchain.token_id: ${tokenId}`
+  } = params;
+  const match = pattern.exec(name);
+  if (match?.[1] !== tokenId) {
+    ctx.addIssue({
+      code: "custom",
+      message,
+      path
+    });
+  }
+}
+function validateFormattedName(params) {
+  const { ctx, name, schema, path } = params;
+  const result = schema.safeParse(name);
+  if (!result.success) {
+    ctx.addIssue({
+      code: "custom",
+      message: result.error.issues[0].message,
+      path
+    });
+  }
+}
 function canonicalizeForHash(value) {
   const canonical = canonicalize__default.default(value);
   if (canonical === void 0) {
@@ -30350,151 +30462,143 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: MassIDAttributesSchema,
   data: MassIDDataSchema
 }).superRefine((record, ctx) => {
-  const nameTokenIdRegex = /^MassID #(\d+)/;
-  const nameTokenIdMatch = nameTokenIdRegex.exec(record.name);
-  if (!nameTokenIdMatch || nameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["name"]
-    });
-  }
-  const shortNameTokenIdRegex = /^MassID #(\d+)/;
-  const shortNameTokenIdMatch = shortNameTokenIdRegex.exec(record.short_name);
-  if (!shortNameTokenIdMatch || shortNameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["short_name"]
-    });
-  }
+  validateTokenIdInName({
+    ctx,
+    name: record.name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^MassID #(\d+)/,
+    path: ["name"]
+  });
+  validateTokenIdInName({
+    ctx,
+    name: record.short_name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^MassID #(\d+)/,
+    path: ["short_name"],
+    message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`
+  });
   const { data, attributes } = record;
-  const findAttribute = (traitType) => {
-    const index = attributes.findIndex(
-      (attribute) => attribute.trait_type === traitType
-    );
-    return {
-      attribute: index >= 0 ? attributes[index] : void 0,
-      index
-    };
-  };
-  const assertAttributeMatches = (traitType, expectedValue, sourceDescription) => {
-    const { attribute, index } = findAttribute(traitType);
-    if (expectedValue === void 0 || expectedValue === null) {
-      if (attribute) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["attributes", index],
-          message: `${traitType} attribute must be omitted when ${sourceDescription} is not provided`
-        });
-      }
-      return;
-    }
-    if (!attribute) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["attributes"],
-        message: `${traitType} attribute must be present and match ${sourceDescription}`
-      });
-      return;
-    }
-    if (attribute.value !== expectedValue) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["attributes", index, "value"],
-        message: `${traitType} attribute must equal ${sourceDescription}`
-      });
-    }
-  };
-  const assertTimestampAttributeMatches = (traitType, isoTimestamp, sourceDescription) => {
-    if (!isoTimestamp) {
-      assertAttributeMatches(traitType, void 0, sourceDescription);
-      return;
-    }
-    const timestamp = Date.parse(isoTimestamp);
-    if (Number.isNaN(timestamp)) {
-      return;
-    }
-    assertAttributeMatches(traitType, timestamp, sourceDescription);
-  };
-  assertAttributeMatches(
-    "Waste Type",
-    data.waste_properties.type,
-    "waste_properties.type"
-  );
-  assertAttributeMatches(
-    "Waste Subtype",
-    data.waste_properties.subtype,
-    "waste_properties.subtype"
-  );
-  assertAttributeMatches(
-    "Weight (kg)",
-    data.waste_properties.net_weight_kg,
-    "waste_properties.net_weight_kg"
-  );
-  assertAttributeMatches(
-    "Local Waste Classification ID",
-    data.waste_properties.local_classification?.code,
-    "waste_properties.local_classification.code"
-  );
+  const attributeByTraitType = createAttributeMap(attributes);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Waste Type",
+    expectedValue: data.waste_properties.type,
+    missingMessage: "Waste Type attribute must be present and match waste_properties.type",
+    mismatchMessage: "Waste Type attribute must equal waste_properties.type"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Waste Subtype",
+    expectedValue: data.waste_properties.subtype,
+    missingMessage: "Waste Subtype attribute must be present and match waste_properties.subtype",
+    mismatchMessage: "Waste Subtype attribute must equal waste_properties.subtype"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Weight (kg)",
+    expectedValue: data.waste_properties.net_weight_kg,
+    missingMessage: "Weight (kg) attribute must be present and match waste_properties.net_weight_kg",
+    mismatchMessage: "Weight (kg) attribute must equal waste_properties.net_weight_kg"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Local Waste Classification ID",
+    expectedValue: data.waste_properties.local_classification?.code,
+    missingMessage: "Local Waste Classification ID attribute must be omitted when waste_properties.local_classification.code is not provided",
+    mismatchMessage: "Local Waste Classification ID attribute must equal waste_properties.local_classification.code"
+  });
   const pickUpEvent = data.events.find(isPickUpEvent);
   const pickUpLocation = pickUpEvent ? data.locations.find(
     (location) => location.id_hash === pickUpEvent.location_id_hash
   ) : void 0;
-  assertAttributeMatches(
-    "Origin City",
-    pickUpLocation?.city,
-    "Pick-up event location.city"
-  );
-  assertTimestampAttributeMatches(
-    "Pick-up Date",
-    pickUpEvent?.timestamp,
-    "Pick-up event timestamp"
-  );
-  assertAttributeMatches(
-    "Pick-up Vehicle Type",
-    pickUpEvent?.data?.vehicle_type,
-    "Pick-up event vehicle_type"
-  );
-  const dropOffEvent = data.events.find(isDropOffEvent);
-  assertTimestampAttributeMatches(
-    "Drop-off Date",
-    dropOffEvent?.timestamp,
-    "Drop-off event timestamp"
-  );
-  const recyclingEvent = data.events.find(isRecyclingEvent);
-  assertTimestampAttributeMatches(
-    "Recycling Date",
-    recyclingEvent?.timestamp,
-    "Recycling event timestamp"
-  );
-  const weighingEvent = data.events.find(isWeighingEvent);
-  assertAttributeMatches(
-    "Weighing Capture Method",
-    weighingEvent?.data?.weighing_capture_method,
-    "Weighing event weighing_capture_method"
-  );
-  assertAttributeMatches(
-    "Scale Type",
-    weighingEvent?.data?.scale_type,
-    "Weighing event scale_type"
-  );
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Origin City",
+    expectedValue: pickUpLocation?.city,
+    missingMessage: "Origin City attribute must be omitted when Pick-up event location.city is not provided",
+    mismatchMessage: "Origin City attribute must equal Pick-up event location.city"
+  });
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Pick-up Date",
+    dateTimeValue: pickUpEvent?.timestamp,
+    missingMessage: "Pick-up Date attribute must be omitted when Pick-up event timestamp is not provided",
+    invalidDateMessage: "Pick-up event timestamp must be a valid ISO 8601 date-time string",
+    mismatchMessage: "Pick-up Date attribute must equal Pick-up event timestamp"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Pick-up Vehicle Type",
+    expectedValue: pickUpEvent?.data?.vehicle_type,
+    missingMessage: "Pick-up Vehicle Type attribute must be omitted when Pick-up event vehicle_type is not provided",
+    mismatchMessage: "Pick-up Vehicle Type attribute must equal Pick-up event vehicle_type"
+  });
+  const dropOffEvent = data.events.find(isDropOffEvent);
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Drop-off Date",
+    dateTimeValue: dropOffEvent?.timestamp,
+    missingMessage: "Drop-off Date attribute must be omitted when Drop-off event timestamp is not provided",
+    invalidDateMessage: "Drop-off event timestamp must be a valid ISO 8601 date-time string",
+    mismatchMessage: "Drop-off Date attribute must equal Drop-off event timestamp"
+  });
+  const recyclingEvent = data.events.find(isRecyclingEvent);
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Recycling Date",
+    dateTimeValue: recyclingEvent?.timestamp,
+    missingMessage: "Recycling Date attribute must be omitted when Recycling event timestamp is not provided",
+    invalidDateMessage: "Recycling event timestamp must be a valid ISO 8601 date-time string",
+    mismatchMessage: "Recycling Date attribute must equal Recycling event timestamp"
+  });
+  const weighingEvent = data.events.find(isWeighingEvent);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Weighing Capture Method",
+    expectedValue: weighingEvent?.data?.weighing_capture_method,
+    missingMessage: "Weighing Capture Method attribute must be omitted when Weighing event weighing_capture_method is not provided",
+    mismatchMessage: "Weighing Capture Method attribute must equal Weighing event weighing_capture_method"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Scale Type",
+    expectedValue: weighingEvent?.data?.scale_type,
+    missingMessage: "Scale Type attribute must be omitted when Weighing event scale_type is not provided",
+    mismatchMessage: "Scale Type attribute must equal Weighing event scale_type"
+  });
   const recyclingManifest = data.attachments?.find(
     (attachment) => attachment.type === "Recycling Manifest" && attachment.document_number
   );
-  assertAttributeMatches(
-    "Recycling Manifest Number",
-    recyclingManifest?.document_number,
-    "Recycling Manifest attachment document_number"
-  );
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Recycling Manifest Number",
+    expectedValue: recyclingManifest?.document_number,
+    missingMessage: recyclingManifest?.document_number ? "Recycling Manifest Number attribute must be present and match Recycling Manifest attachment document_number" : "Recycling Manifest Number attribute must be omitted when Recycling Manifest attachment document_number is not provided",
+    mismatchMessage: "Recycling Manifest Number attribute must equal Recycling Manifest attachment document_number"
+  });
   const transportManifest = data.attachments?.find(
     (attachment) => attachment.type === "Transport Manifest" && attachment.document_number
   );
-  assertAttributeMatches(
-    "Transport Manifest Number",
-    transportManifest?.document_number,
-    "Transport Manifest attachment document_number"
-  );
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Transport Manifest Number",
+    expectedValue: transportManifest?.document_number,
+    missingMessage: transportManifest?.document_number ? "Transport Manifest Number attribute must be present and match Transport Manifest attachment document_number" : "Transport Manifest Number attribute must be omitted when Transport Manifest attachment document_number is not provided",
+    mismatchMessage: "Transport Manifest Number attribute must equal Transport Manifest attachment document_number"
+  });
 }).meta(MassIDIpfsSchemaMeta);
 var GasIDAttributeMethodologySchema = MethodologyAttributeSchema;
 var GasIDAttributeGasTypeSchema = NftAttributeSchema.safeExtend({
@@ -30631,42 +30735,144 @@ var GasIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: GasIDAttributesSchema,
   data: GasIDDataSchema
 }).superRefine((record, ctx) => {
-  const nameTokenIdRegex = /^GasID #(\d+)/;
-  const nameTokenIdMatch = nameTokenIdRegex.exec(record.name);
-  if (!nameTokenIdMatch || nameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["name"]
-    });
-  }
-  const shortNameTokenIdRegex = /^GasID #(\d+)/;
-  const shortNameTokenIdMatch = shortNameTokenIdRegex.exec(record.short_name);
-  if (!shortNameTokenIdMatch || shortNameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["short_name"]
-    });
-  }
+  validateTokenIdInName({
+    ctx,
+    name: record.name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^GasID #(\d+)/,
+    path: ["name"]
+  });
+  validateTokenIdInName({
+    ctx,
+    name: record.short_name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^GasID #(\d+)/,
+    path: ["short_name"],
+    message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`
+  });
   const nameSchema = createGasIDNameSchema(record.blockchain.token_id);
-  const nameResult = nameSchema.safeParse(record.name);
-  if (!nameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: nameResult.error.issues[0].message,
-      path: ["name"]
-    });
-  }
+  validateFormattedName({
+    ctx,
+    name: record.name,
+    schema: nameSchema,
+    path: ["name"]
+  });
   const shortNameSchema = createGasIDShortNameSchema(
     record.blockchain.token_id
   );
-  const shortNameResult = shortNameSchema.safeParse(record.short_name);
-  if (!shortNameResult.success) {
+  validateFormattedName({
+    ctx,
+    name: record.short_name,
+    schema: shortNameSchema,
+    path: ["short_name"]
+  });
+  const { data, attributes } = record;
+  const attributeByTraitType = createAttributeMap(attributes);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Methodology",
+    expectedValue: data.methodology.name,
+    missingMessage: "Methodology attribute must be present and match data.methodology.name",
+    mismatchMessage: "Methodology attribute must equal data.methodology.name"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Gas Type",
+    expectedValue: data.summary.gas_type,
+    missingMessage: "Gas Type attribute must be present and match data.summary.gas_type",
+    mismatchMessage: "Gas Type attribute must equal data.summary.gas_type"
+  });
+  validateNumericAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "CO\u2082e Prevented (kg)",
+    expectedValue: data.summary.prevented_co2e_kg,
+    epsilon: 0.01,
+    missingMessage: "CO\u2082e Prevented (kg) attribute must be present and match data.summary.prevented_co2e_kg",
+    mismatchMessage: "CO\u2082e Prevented (kg) attribute must equal data.summary.prevented_co2e_kg"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Credit Amount",
+    expectedValue: data.summary.credit_amount,
+    missingMessage: "Credit Amount attribute must be present and match data.summary.credit_amount",
+    mismatchMessage: "Credit Amount attribute must equal data.summary.credit_amount"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Credit Type",
+    expectedValue: data.summary.credit_type,
+    missingMessage: "Credit Type attribute must be present and match data.summary.credit_type",
+    mismatchMessage: "Credit Type attribute must equal data.summary.credit_type"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Source Waste Type",
+    expectedValue: data.waste_properties.type,
+    missingMessage: "Source Waste Type attribute must be present and match data.waste_properties.type",
+    mismatchMessage: "Source Waste Type attribute must equal data.waste_properties.type"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Source Weight (kg)",
+    expectedValue: data.waste_properties.net_weight_kg,
+    missingMessage: "Source Weight (kg) attribute must be present and match data.waste_properties.net_weight_kg",
+    mismatchMessage: "Source Weight (kg) attribute must equal data.waste_properties.net_weight_kg"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Origin City",
+    expectedValue: data.origin_location.city,
+    missingMessage: "Origin City attribute must be present and match data.origin_location.city",
+    mismatchMessage: "Origin City attribute must equal data.origin_location.city"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "MassID",
+    expectedValue: `#${data.mass_id.token_id}`,
+    missingMessage: "MassID attribute must be present and match data.mass_id.token_id as #<token_id>",
+    mismatchMessage: "MassID attribute must equal data.mass_id.token_id as #<token_id>"
+  });
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "MassID Recycling Date",
+    dateTimeValue: data.summary.issued_at,
+    missingMessage: "MassID Recycling Date attribute must be present and match data.summary.issued_at",
+    invalidDateMessage: "data.summary.issued_at must be a valid ISO 8601 date-time string",
+    mismatchMessage: "MassID Recycling Date attribute must equal data.summary.issued_at as a Unix timestamp in milliseconds"
+  });
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Certificate Issuance Date",
+    dateTimeValue: data.summary.issued_at,
+    missingMessage: "Certificate Issuance Date attribute must be present and match data.summary.issued_at",
+    invalidDateMessage: "data.summary.issued_at must be a valid ISO 8601 date-time string",
+    mismatchMessage: "Certificate Issuance Date attribute must equal data.summary.issued_at as a Unix timestamp in milliseconds"
+  });
+  const resultValue = data.prevented_emissions_calculation.values.find(
+    (value) => value.reference === "R"
+  );
+  if (!resultValue) {
     ctx.addIssue({
       code: "custom",
-      message: shortNameResult.error.issues[0].message,
-      path: ["short_name"]
+      message: 'prevented_emissions_calculation.values must include a value with reference "R"',
+      path: ["data", "prevented_emissions_calculation", "values"]
+    });
+  } else if (!nearlyEqual(resultValue.value, data.summary.prevented_co2e_kg, 0.01)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "prevented_emissions_calculation.values R value must match summary.prevented_co2e_kg",
+      path: ["data", "prevented_emissions_calculation", "values"]
     });
   }
 }).meta(GasIDIpfsSchemaMeta);
@@ -30749,44 +30955,122 @@ var RecycledIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: RecycledIDAttributesSchema,
   data: RecycledIDDataSchema
 }).superRefine((record, ctx) => {
-  const nameTokenIdRegex = /^RecycledID #(\d+)/;
-  const nameTokenIdMatch = nameTokenIdRegex.exec(record.name);
-  if (!nameTokenIdMatch || nameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["name"]
-    });
-  }
-  const shortNameTokenIdRegex = /^RecycledID #(\d+)/;
-  const shortNameTokenIdMatch = shortNameTokenIdRegex.exec(record.short_name);
-  if (!shortNameTokenIdMatch || shortNameTokenIdMatch[1] !== record.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`,
-      path: ["short_name"]
-    });
-  }
+  validateTokenIdInName({
+    ctx,
+    name: record.name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^RecycledID #(\d+)/,
+    path: ["name"]
+  });
+  validateTokenIdInName({
+    ctx,
+    name: record.short_name,
+    tokenId: record.blockchain.token_id,
+    pattern: /^RecycledID #(\d+)/,
+    path: ["short_name"],
+    message: `Short name token_id must match blockchain.token_id: ${record.blockchain.token_id}`
+  });
   const nameSchema = createRecycledIDNameSchema(record.blockchain.token_id);
-  const nameResult = nameSchema.safeParse(record.name);
-  if (!nameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: nameResult.error.issues[0].message,
-      path: ["name"]
-    });
-  }
+  validateFormattedName({
+    ctx,
+    name: record.name,
+    schema: nameSchema,
+    path: ["name"]
+  });
   const shortNameSchema = createRecycledIDShortNameSchema(
     record.blockchain.token_id
   );
-  const shortNameResult = shortNameSchema.safeParse(record.short_name);
-  if (!shortNameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: shortNameResult.error.issues[0].message,
-      path: ["short_name"]
-    });
-  }
+  validateFormattedName({
+    ctx,
+    name: record.short_name,
+    schema: shortNameSchema,
+    path: ["short_name"]
+  });
+  const { data, attributes } = record;
+  const attributeByTraitType = createAttributeMap(attributes);
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Methodology",
+    expectedValue: data.methodology.name,
+    missingMessage: "Methodology attribute must be present and match data.methodology.name",
+    mismatchMessage: "Methodology attribute must equal data.methodology.name"
+  });
+  validateNumericAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Recycled Mass Weight (kg)",
+    expectedValue: data.summary.recycled_mass_kg,
+    epsilon: 0.01,
+    missingMessage: "Recycled Mass Weight (kg) attribute must be present and match data.summary.recycled_mass_kg",
+    mismatchMessage: "Recycled Mass Weight (kg) attribute must equal data.summary.recycled_mass_kg"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Credit Amount",
+    expectedValue: data.summary.credit_amount,
+    missingMessage: "Credit Amount attribute must be present and match data.summary.credit_amount",
+    mismatchMessage: "Credit Amount attribute must equal data.summary.credit_amount"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Credit Type",
+    expectedValue: data.summary.credit_type,
+    missingMessage: "Credit Type attribute must be present and match data.summary.credit_type",
+    mismatchMessage: "Credit Type attribute must equal data.summary.credit_type"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Source Waste Type",
+    expectedValue: data.waste_properties.type,
+    missingMessage: "Source Waste Type attribute must be present and match data.waste_properties.type",
+    mismatchMessage: "Source Waste Type attribute must equal data.waste_properties.type"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Source Weight (kg)",
+    expectedValue: data.waste_properties.net_weight_kg,
+    missingMessage: "Source Weight (kg) attribute must be present and match data.waste_properties.net_weight_kg",
+    mismatchMessage: "Source Weight (kg) attribute must equal data.waste_properties.net_weight_kg"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "Origin City",
+    expectedValue: data.origin_location.city,
+    missingMessage: "Origin City attribute must be present and match data.origin_location.city",
+    mismatchMessage: "Origin City attribute must equal data.origin_location.city"
+  });
+  validateAttributeValue({
+    ctx,
+    attributeByTraitType,
+    traitType: "MassID",
+    expectedValue: `#${data.mass_id.token_id}`,
+    missingMessage: "MassID attribute must be present and match data.mass_id.token_id as #<token_id>",
+    mismatchMessage: "MassID attribute must equal data.mass_id.token_id as #<token_id>"
+  });
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "MassID Recycling Date",
+    dateTimeValue: data.summary.issued_at,
+    missingMessage: "MassID Recycling Date attribute must be present and match data.summary.issued_at",
+    invalidDateMessage: "data.summary.issued_at must be a valid ISO 8601 date-time string",
+    mismatchMessage: "MassID Recycling Date attribute must equal data.summary.issued_at as a Unix timestamp in milliseconds"
+  });
+  validateDateTimeAttribute({
+    ctx,
+    attributeByTraitType,
+    traitType: "Certificate Issuance Date",
+    dateTimeValue: data.summary.issued_at,
+    missingMessage: "Certificate Issuance Date attribute must be present and match data.summary.issued_at",
+    invalidDateMessage: "data.summary.issued_at must be a valid ISO 8601 date-time string",
+    mismatchMessage: "Certificate Issuance Date attribute must equal data.summary.issued_at as a Unix timestamp in milliseconds"
+  });
 }).meta(RecycledIDIpfsSchemaMeta);
 var CreditPurchaseReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: CreditTokenSymbolSchema,
@@ -30902,30 +31186,25 @@ var CreditPurchaseReceiptCollectionSchema = createReceiptCollectionSchema({
     description: "Collection included in the purchase"
   }
 });
-var CreditPurchaseReceiptCreditSchema = createReceiptCreditSchema({
-  meta: {
-    title: "Credit",
-    description: "Credit token included in the purchase"
-  }
+var CreditPurchaseReceiptCreditSchema = CreditReferenceSchema.meta({
+  title: "Credit",
+  description: "Credit token included in the purchase"
 });
-var CreditPurchaseReceiptCertificateSchema = createReceiptCertificateSchema({
-  additionalShape: {
-    credit_slug: CreditTokenSlugSchema.meta({
-      description: "Slug of the credit type for this certificate"
-    }),
-    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: {
-    title: "Certificate",
-    description: "Certificate associated with the purchase"
-  }
+var CreditPurchaseReceiptCertificateSchema = CertificateReferenceBaseSchema.safeExtend({
+  credit_slug: CreditTokenSlugSchema.meta({
+    description: "Slug of the credit type for this certificate"
+  }),
+  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({
+  title: "Certificate",
+  description: "Certificate associated with the purchase"
 });
 var CreditPurchaseReceiptParticipantRewardSchema = zod.z.strictObject({
   participant_id_hash: ParticipantIdHashSchema,
@@ -30944,28 +31223,7 @@ var CreditPurchaseReceiptParticipantRewardSchema = zod.z.strictObject({
   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"
-  }),
-  ipfs_uri: IpfsUriSchema.meta({
-    title: "Retirement Receipt IPFS URI",
-    description: "IPFS URI for the retirement receipt metadata"
-  }),
-  smart_contract_address: SmartContractAddressSchema
-}).meta({
-  title: "Retirement Receipt Reference",
-  description: "Reference to the retirement receipt NFT"
-});
+var CreditPurchaseReceiptRetirementReceiptSchema = CreditRetirementReceiptReferenceSchema;
 var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
   summary: CreditPurchaseReceiptSummarySchema,
   buyer: CreditPurchaseReceiptBuyerSchema,
@@ -31128,24 +31386,39 @@ var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: CreditPurchaseReceiptAttributesSchema,
   data: CreditPurchaseReceiptDataSchema
 }).superRefine((value, ctx) => {
-  const nameTokenIdRegex = /^Credit Purchase Receipt #(\d+)/;
-  const nameTokenIdMatch = nameTokenIdRegex.exec(value.name);
-  if (!nameTokenIdMatch || nameTokenIdMatch[1] !== value.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Name token_id must match blockchain.token_id: ${value.blockchain.token_id}`,
-      path: ["name"]
-    });
-  }
-  const shortNameTokenIdRegex = /^Purchase Receipt #(\d+)/;
-  const shortNameTokenIdMatch = shortNameTokenIdRegex.exec(value.short_name);
-  if (!shortNameTokenIdMatch || shortNameTokenIdMatch[1] !== value.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Short name token_id must match blockchain.token_id: ${value.blockchain.token_id}`,
-      path: ["short_name"]
-    });
-  }
+  validateTokenIdInName({
+    ctx,
+    name: value.name,
+    tokenId: value.blockchain.token_id,
+    pattern: /^Credit Purchase Receipt #(\d+)/,
+    path: ["name"]
+  });
+  validateTokenIdInName({
+    ctx,
+    name: value.short_name,
+    tokenId: value.blockchain.token_id,
+    pattern: /^Purchase Receipt #(\d+)/,
+    path: ["short_name"],
+    message: `Short name token_id must match blockchain.token_id: ${value.blockchain.token_id}`
+  });
+  const nameSchema = createCreditPurchaseReceiptNameSchema(
+    value.blockchain.token_id
+  );
+  validateFormattedName({
+    ctx,
+    name: value.name,
+    schema: nameSchema,
+    path: ["name"]
+  });
+  const shortNameSchema = createCreditPurchaseReceiptShortNameSchema(
+    value.blockchain.token_id
+  );
+  validateFormattedName({
+    ctx,
+    name: value.short_name,
+    schema: shortNameSchema,
+    path: ["short_name"]
+  });
   const attributes = value.attributes;
   const data = value.data;
   const attributeByTraitType = createAttributeMap(attributes);
@@ -31252,28 +31525,6 @@ var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
       });
     }
   });
-  const nameSchema = createCreditPurchaseReceiptNameSchema(
-    value.blockchain.token_id
-  );
-  const nameResult = nameSchema.safeParse(value.name);
-  if (!nameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: nameResult.error.issues[0].message,
-      path: ["name"]
-    });
-  }
-  const shortNameSchema = createCreditPurchaseReceiptShortNameSchema(
-    value.blockchain.token_id
-  );
-  const shortNameResult = shortNameSchema.safeParse(value.short_name);
-  if (!shortNameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: shortNameResult.error.issues[0].message,
-      path: ["short_name"]
-    });
-  }
 }).meta(CreditPurchaseReceiptIpfsSchemaMeta);
 var CreditRetirementReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: CreditTokenSymbolSchema,
@@ -31397,11 +31648,9 @@ var CreditRetirementReceiptCollectionSchema = createReceiptCollectionSchema({
     description: "Collection included in the retirement"
   }
 });
-var CreditRetirementReceiptCreditSchema = createReceiptCreditSchema({
-  meta: {
-    title: "Credit",
-    description: "Credit token retired in this receipt"
-  }
+var CreditRetirementReceiptCreditSchema = CreditReferenceSchema.meta({
+  title: "Credit",
+  description: "Credit token retired in this receipt"
 });
 var CreditRetirementReceiptCertificateCreditSchema = zod.z.strictObject({
   credit_symbol: CreditTokenSymbolSchema.meta({
@@ -31426,54 +31675,27 @@ var CreditRetirementReceiptCertificateCreditSchema = zod.z.strictObject({
   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"
-  }),
-  ipfs_uri: IpfsUriSchema.meta({
-    title: "Purchase Receipt IPFS URI",
-    description: "IPFS URI for the purchase receipt metadata"
+var CreditRetirementReceiptCertificateSchema = CertificateReferenceBaseSchema.safeExtend({
+  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"
   }),
-  smart_contract_address: SmartContractAddressSchema
+  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: "Credit Purchase Receipt Reference",
-  description: "Reference to the credit purchase receipt when retirement occurs during purchase"
+  title: "Certificate",
+  description: "Certificate associated with the retirement"
 });
-var CreditRetirementReceiptCertificateSchema = createReceiptCertificateSchema(
-  {
-    additionalShape: {
-      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,
-        (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,
@@ -31623,9 +31845,6 @@ var CreditRetirementReceiptDataSchema = zod.z.strictObject({
   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",
@@ -31634,8 +31853,8 @@ var CreditRetirementReceiptIpfsSchemaMeta = {
   ),
   version: getSchemaVersionOrDefault()
 };
-var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.safeExtend({
-  schema: CreditRetirementReceiptIpfsSchemaBase.shape.schema.safeExtend({
+var CreditRetirementReceiptIpfsSchema = NftIpfsSchema.safeExtend({
+  schema: NftIpfsSchema.shape.schema.safeExtend({
     type: zod.z.literal("CreditRetirementReceipt").meta({
       title: "CreditRetirementReceipt Schema Type",
       description: "Schema type identifier for this record"
@@ -31646,26 +31865,39 @@ var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.sa
   attributes: CreditRetirementReceiptAttributesSchema,
   data: CreditRetirementReceiptDataSchema
 }).superRefine((value, ctx) => {
-  const nameTokenIdRegex = /^Credit Retirement Receipt #(\d+)/;
-  const nameTokenIdMatch = nameTokenIdRegex.exec(value.name);
-  if (!nameTokenIdMatch || nameTokenIdMatch[1] !== value.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Name token_id must match blockchain.token_id: ${value.blockchain.token_id}`,
-      path: ["name"]
-    });
-  }
-  const shortNameTokenIdRegex = /^Retirement Receipt #(\d+)/;
-  const shortNameTokenIdMatch = shortNameTokenIdRegex.exec(
-    value.short_name
+  validateTokenIdInName({
+    ctx,
+    name: value.name,
+    tokenId: value.blockchain.token_id,
+    pattern: /^Credit Retirement Receipt #(\d+)/,
+    path: ["name"]
+  });
+  validateTokenIdInName({
+    ctx,
+    name: value.short_name,
+    tokenId: value.blockchain.token_id,
+    pattern: /^Retirement Receipt #(\d+)/,
+    path: ["short_name"],
+    message: `Short name token_id must match blockchain.token_id: ${value.blockchain.token_id}`
+  });
+  const nameSchema = createCreditRetirementReceiptNameSchema(
+    value.blockchain.token_id
   );
-  if (!shortNameTokenIdMatch || shortNameTokenIdMatch[1] !== value.blockchain.token_id) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Short name token_id must match blockchain.token_id: ${value.blockchain.token_id}`,
-      path: ["short_name"]
-    });
-  }
+  validateFormattedName({
+    ctx,
+    name: value.name,
+    schema: nameSchema,
+    path: ["name"]
+  });
+  const shortNameSchema = createCreditRetirementReceiptShortNameSchema(
+    value.blockchain.token_id
+  );
+  validateFormattedName({
+    ctx,
+    name: value.short_name,
+    schema: shortNameSchema,
+    path: ["short_name"]
+  });
   const attributes = value.attributes;
   const data = value.data;
   const attributeByTraitType = createAttributeMap(attributes);
@@ -31767,28 +31999,6 @@ var CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchemaBase.sa
       });
     }
   });
-  const nameSchema = createCreditRetirementReceiptNameSchema(
-    value.blockchain.token_id
-  );
-  const nameResult = nameSchema.safeParse(value.name);
-  if (!nameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: nameResult.error.issues[0].message,
-      path: ["name"]
-    });
-  }
-  const shortNameSchema = createCreditRetirementReceiptShortNameSchema(
-    value.blockchain.token_id
-  );
-  const shortNameResult = shortNameSchema.safeParse(value.short_name);
-  if (!shortNameResult.success) {
-    ctx.addIssue({
-      code: "custom",
-      message: shortNameResult.error.issues[0].message,
-      path: ["short_name"]
-    });
-  }
 }).meta(CreditRetirementReceiptIpfsSchemaMeta);
 var CollectionSchemaMeta = {
   title: "Collection IPFS Record",
@@ -31943,12 +32153,40 @@ var MassIDAuditSummarySchema = zod.z.strictObject({
 var MassIDAuditDataSchema = zod.z.strictObject({
   methodology: MethodologyReferenceSchema,
   mass_id: MassIDReferenceSchema,
-  gas_id: GasIDReferenceSchema,
+  gas_id: GasIDReferenceSchema.optional(),
+  recycled_id: RecycledIDReferenceSchema.optional(),
   audit_summary: MassIDAuditSummarySchema,
   rule_execution_results: AuditRuleExecutionResultsSchema
+}).superRefine((data, ctx) => {
+  const hasGasId = !!data.gas_id;
+  const hasRecycledId = !!data.recycled_id;
+  if (!hasGasId && !hasRecycledId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["gas_id"],
+      message: "Either gas_id or recycled_id must be provided"
+    });
+    ctx.addIssue({
+      code: "custom",
+      path: ["recycled_id"],
+      message: "Either gas_id or recycled_id must be provided"
+    });
+  }
+  if (hasGasId && hasRecycledId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["gas_id"],
+      message: "gas_id and recycled_id are mutually exclusive"
+    });
+    ctx.addIssue({
+      code: "custom",
+      path: ["recycled_id"],
+      message: "gas_id and recycled_id are mutually exclusive"
+    });
+  }
 }).meta({
   title: "MassID Audit Data",
-  description: "Complete data structure for MassID Audit records"
+  description: "Complete data structure for MassID Audit records. Must include exactly one of gas_id or recycled_id."
 });
 
 // src/mass-id-audit/mass-id-audit.schema.ts
@@ -31987,6 +32225,7 @@ exports.BlockchainNetworkNameSchema = BlockchainNetworkNameSchema;
 exports.CertificateCollectionItemPurchaseSchema = CertificateCollectionItemPurchaseSchema;
 exports.CertificateCollectionItemRetirementSchema = CertificateCollectionItemRetirementSchema;
 exports.CertificateIssuanceDateAttributeSchema = CertificateIssuanceDateAttributeSchema;
+exports.CertificateReferenceBaseSchema = CertificateReferenceBaseSchema;
 exports.CertificateTypeSchema = CertificateTypeSchema;
 exports.CitySchema = CitySchema;
 exports.CollectionNameSchema = CollectionNameSchema;
@@ -32002,13 +32241,16 @@ exports.CreditPurchaseReceiptDataSchema = CreditPurchaseReceiptDataSchema;
 exports.CreditPurchaseReceiptIpfsSchema = CreditPurchaseReceiptIpfsSchema;
 exports.CreditPurchaseReceiptIpfsSchemaMeta = CreditPurchaseReceiptIpfsSchemaMeta;
 exports.CreditPurchaseReceiptNameSchema = CreditPurchaseReceiptNameSchema;
+exports.CreditPurchaseReceiptReferenceSchema = CreditPurchaseReceiptReferenceSchema;
 exports.CreditPurchaseReceiptShortNameSchema = CreditPurchaseReceiptShortNameSchema;
 exports.CreditPurchaseReceiptSummarySchema = CreditPurchaseReceiptSummarySchema;
+exports.CreditReferenceSchema = CreditReferenceSchema;
 exports.CreditRetirementReceiptAttributesSchema = CreditRetirementReceiptAttributesSchema;
 exports.CreditRetirementReceiptDataSchema = CreditRetirementReceiptDataSchema;
 exports.CreditRetirementReceiptIpfsSchema = CreditRetirementReceiptIpfsSchema;
 exports.CreditRetirementReceiptIpfsSchemaMeta = CreditRetirementReceiptIpfsSchemaMeta;
 exports.CreditRetirementReceiptNameSchema = CreditRetirementReceiptNameSchema;
+exports.CreditRetirementReceiptReferenceSchema = CreditRetirementReceiptReferenceSchema;
 exports.CreditRetirementReceiptShortNameSchema = CreditRetirementReceiptShortNameSchema;
 exports.CreditRetirementReceiptSummarySchema = CreditRetirementReceiptSummarySchema;
 exports.CreditSchema = CreditSchema;
@@ -32055,7 +32297,6 @@ exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
 exports.MassIDNameSchema = MassIDNameSchema;
 exports.MassIDRecyclingDateAttributeSchema = MassIDRecyclingDateAttributeSchema;
 exports.MassIDReferenceSchema = MassIDReferenceSchema;
-exports.MassIDReferenceWithContractSchema = MassIDReferenceWithContractSchema;
 exports.MassIDShortNameSchema = MassIDShortNameSchema;
 exports.MassIDTokenIdAttributeSchema = MassIDTokenIdAttributeSchema;
 exports.MethodologyAttributeSchema = MethodologyAttributeSchema;
@@ -32068,6 +32309,7 @@ exports.MethodologyShortNameSchema = MethodologyShortNameSchema;
 exports.MethodologySlugSchema = MethodologySlugSchema;
 exports.NftAttributeSchema = NftAttributeSchema;
 exports.NftIpfsSchema = NftIpfsSchema;
+exports.NftTokenReferenceBaseSchema = NftTokenReferenceBaseSchema;
 exports.NonEmptyStringSchema = NonEmptyStringSchema;
 exports.NonNegativeFloatSchema = NonNegativeFloatSchema;
 exports.NonNegativeIntegerSchema = NonNegativeIntegerSchema;
@@ -32086,6 +32328,7 @@ exports.RecycledIDDataSchema = RecycledIDDataSchema;
 exports.RecycledIDIpfsSchema = RecycledIDIpfsSchema;
 exports.RecycledIDIpfsSchemaMeta = RecycledIDIpfsSchemaMeta;
 exports.RecycledIDNameSchema = RecycledIDNameSchema;
+exports.RecycledIDReferenceSchema = RecycledIDReferenceSchema;
 exports.RecycledIDShortNameSchema = RecycledIDShortNameSchema;
 exports.RewardAllocationSchema = RewardAllocationSchema;
 exports.RewardDiscountSchema = RewardDiscountSchema;
@@ -32101,6 +32344,7 @@ exports.SourceWasteTypeAttributeSchema = SourceWasteTypeAttributeSchema;
 exports.SourceWeightAttributeSchema = SourceWeightAttributeSchema;
 exports.StringifiedTokenIdSchema = StringifiedTokenIdSchema;
 exports.TokenIdSchema = TokenIdSchema;
+exports.TokenReferenceBaseSchema = TokenReferenceBaseSchema;
 exports.UnixTimestampSchema = UnixTimestampSchema;
 exports.UsdcAmountSchema = UsdcAmountSchema;
 exports.UuidSchema = UuidSchema;
@@ -32125,9 +32369,7 @@ exports.createMassIDNameSchema = createMassIDNameSchema;
 exports.createMassIDShortNameSchema = createMassIDShortNameSchema;
 exports.createNumericAttributeSchema = createNumericAttributeSchema;
 exports.createOrderedAttributesSchema = createOrderedAttributesSchema;
-exports.createReceiptCertificateSchema = createReceiptCertificateSchema;
 exports.createReceiptCollectionSchema = createReceiptCollectionSchema;
-exports.createReceiptCreditSchema = createReceiptCreditSchema;
 exports.createRecycledIDNameSchema = createRecycledIDNameSchema;
 exports.createRecycledIDShortNameSchema = createRecycledIDShortNameSchema;
 exports.createWeightAttributeSchema = createWeightAttributeSchema;
@@ -32146,9 +32388,13 @@ exports.validateCountMatches = validateCountMatches;
 exports.validateCreditSlugExists = validateCreditSlugExists;
 exports.validateCreditSymbolExists = validateCreditSymbolExists;
 exports.validateDateAttribute = validateDateAttribute;
+exports.validateDateTimeAttribute = validateDateTimeAttribute;
+exports.validateFormattedName = validateFormattedName;
 exports.validateLocationBrazilData = validateLocationBrazilData;
+exports.validateNumericAttributeValue = validateNumericAttributeValue;
 exports.validateRetirementReceiptRequirement = validateRetirementReceiptRequirement;
 exports.validateSummaryListMatchesData = validateSummaryListMatchesData;
+exports.validateTokenIdInName = validateTokenIdInName;
 exports.validateTotalMatches = validateTotalMatches;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map