@carrot-foundation/schemas 0.1.25 → 0.1.27

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var zod = require('zod');
 
-// src/mass-id/mass-id.data.schema.ts
+// src/mass-id/mass-id.attributes.ts
 var UuidSchema = zod.z.uuidv4("Must be a valid UUID v4 string").meta({
   title: "UUID",
   description: "A universally unique identifier version 4",
@@ -30,7 +30,7 @@ var IsoTimestampSchema = zod.z.iso.datetime({
   description: "ISO 8601 formatted timestamp with timezone information",
   examples: ["2024-12-05T11:02:47.000Z", "2025-02-22T10:35:12.000Z"]
 });
-var IsoDateSchema = zod.z.iso.date("Must be a valid ISO 8601 date (YYYY-MM-DD)").meta({
+zod.z.iso.date("Must be a valid ISO 8601 date (YYYY-MM-DD)").meta({
   title: "ISO Date",
   description: "ISO 8601 formatted date in YYYY-MM-DD format",
   examples: ["2024-12-05", "2025-02-22", "2024-02-10"]
@@ -81,7 +81,7 @@ NonEmptyStringSchema.regex(
   description: "URL-friendly identifier with lowercase letters, numbers, and hyphens",
   examples: ["mass-id-123", "recycled-plastic", "organic-waste"]
 });
-var WasteTypeSchema = NonEmptyStringSchema.meta({
+var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
   title: "Waste Type",
   description: "Category or type of waste material",
   examples: ["Organic", "Plastic", "Metal"]
@@ -145,6 +145,11 @@ var HoursSchema = zod.z.number().min(0).multipleOf(0.1).meta({
   description: "Time duration in hours with 0.1 hour precision",
   examples: [72.5, 24, 168.5]
 });
+var MinutesSchema = zod.z.number().int().min(0).meta({
+  title: "Minutes",
+  description: "Time duration in minutes",
+  examples: [4350, 1440, 10110]
+});
 var IpfsUriSchema = NonEmptyStringSchema.regex(
   /^ipfs:\/\/[a-zA-Z0-9]+(\/.*)?$/,
   "Must be a valid IPFS URI with CID"
@@ -251,65 +256,117 @@ var RecordRelationshipTypeSchema = zod.z.enum([
   description: "Type of relationship between different entities in the system",
   examples: ["mass-id", "audit", "collection"]
 });
-var PrecisionLevelSchema = zod.z.enum(["exact", "neighborhood", "city", "region", "country"]).meta({
-  title: "Precision Level",
-  description: "Level of coordinate precision",
-  examples: ["city", "exact", "neighborhood"]
+var SchemaInfoSchema = zod.z.strictObject({
+  hash: Keccak256HashSchema.meta({
+    title: "Schema Hash",
+    description: "Keccak256 hash of the JSON Schema this record was validated against"
+  }),
+  type: RecordSchemaTypeSchema.meta({
+    title: "Schema Type",
+    description: "Type/category of this schema"
+  }),
+  version: SemanticVersionSchema.meta({
+    title: "Schema Version",
+    description: "Version of the schema, using semantic versioning"
+  })
+}).meta({
+  title: "Schema Information"
 });
-var CoordinatesSchema = zod.z.strictObject({
-  latitude: LatitudeSchema.meta({
-    title: "Latitude",
-    description: "GPS latitude coordinate"
+var RecordCreatorSchema = zod.z.strictObject({
+  name: zod.z.string().meta({
+    title: "Creator Name",
+    description: "Company or individual name that created this record",
+    examples: ["Carrot Foundation"]
   }),
-  longitude: LongitudeSchema.meta({
-    title: "Longitude",
-    description: "GPS longitude coordinate"
+  id: UuidSchema.meta({
+    title: "Creator ID",
+    description: "Unique identifier for the creator"
+  })
+}).meta({
+  title: "Creator",
+  description: "Entity that created this record"
+});
+var RecordRelationshipSchema = zod.z.strictObject({
+  target_uri: IpfsUriSchema.meta({
+    title: "Target IPFS URI",
+    description: "Target IPFS URI of the referenced record"
   }),
-  precision_level: PrecisionLevelSchema
+  type: RecordRelationshipTypeSchema.meta({
+    title: "Relationship Type",
+    description: "Type of relationship to the referenced record"
+  }),
+  description: zod.z.string().optional().meta({
+    title: "Relationship Description",
+    description: "Human-readable description of the relationship",
+    examples: [
+      "This record supersedes the previous version",
+      "Related carbon credit batch",
+      "Source document for this verification",
+      "Child record derived from this parent",
+      "Updated version of original record"
+    ]
+  })
 }).meta({
-  title: "Coordinates",
-  description: "GPS coordinates of the location"
+  title: "Relationship",
+  description: "Relationship to another IPFS record"
 });
-var LocationSchema = zod.z.strictObject({
-  id_hash: Sha256HashSchema.meta({
-    title: "Location ID Hash",
-    description: "Anonymized identifier for the location"
+var RecordEnvironmentSchema = zod.z.strictObject({
+  blockchain_network: zod.z.enum(["mainnet", "testnet"]).meta({
+    title: "Blockchain Network",
+    description: "Blockchain Network Environment"
   }),
-  municipality: NonEmptyStringSchema.max(50).meta({
-    title: "Municipality",
-    description: "Municipality or city name",
-    examples: ["New York", "S\xE3o Paulo", "London", "Tokyo"]
+  deployment: zod.z.enum(["production", "development", "testing"]).meta({
+    title: "Deployment Environment",
+    description: "System environment where this record was generated"
   }),
-  administrative_division: NonEmptyStringSchema.max(50).meta({
-    title: "Administrative Division",
-    description: "State, province, or administrative region",
-    examples: ["California", "Ontario", "Bavaria", "Queensland"]
+  data_set_name: zod.z.enum(["TEST", "PROD"]).meta({
+    title: "Data Set Name",
+    description: "Name of the data set for this record"
+  })
+}).meta({
+  title: "Environment",
+  description: "Environment information"
+});
+var BaseIpfsSchema = zod.z.strictObject({
+  $schema: zod.z.url("Must be a valid URI").meta({
+    title: "JSON Schema URI",
+    description: "URI of the JSON Schema used to validate this record",
+    example: "https://raw.githubusercontent.com/carrot-foundation/schemas/refs/heads/main/schemas/ipfs/shared/base/base.schema.json"
   }),
-  administrative_division_code: IsoAdministrativeDivisionCodeSchema.optional().meta({
-    title: "Administrative Division Code",
-    description: "ISO 3166-2 administrative division code"
+  schema: SchemaInfoSchema,
+  created_at: IsoTimestampSchema.meta({
+    title: "Created At",
+    description: "ISO 8601 creation timestamp for this record"
   }),
-  country: NonEmptyStringSchema.max(50).meta({
-    title: "Country",
-    description: "Full country name in English",
-    examples: ["United States", "Canada", "Germany", "Australia"]
+  external_id: ExternalIdSchema.meta({
+    title: "External ID",
+    description: "Off-chain reference ID (UUID from Carrot backend)"
   }),
-  country_code: IsoCountryCodeSchema.meta({
-    title: "Country Code",
-    description: "ISO 3166-1 alpha-2 country code"
+  external_url: ExternalUrlSchema.meta({
+    title: "External URL",
+    description: "External URL of the content"
   }),
-  responsible_participant_id_hash: Sha256HashSchema.meta({
-    title: "Responsible Participant ID Hash",
-    description: "Anonymized ID of the participant responsible for this location"
+  original_content_hash: Sha256HashSchema.meta({
+    title: "Original Content Hash",
+    description: "SHA-256 hash of the original JSON content including private data before schema validation"
   }),
-  coordinates: CoordinatesSchema,
-  facility_type: FacilityTypeSchema.optional().meta({
-    title: "Facility Type",
-    description: "Type of facility at this location"
+  content_hash: Sha256HashSchema.meta({
+    title: "Content Hash",
+    description: "SHA-256 hash of RFC 8785 canonicalized JSON after schema validation"
+  }),
+  creator: RecordCreatorSchema.optional(),
+  relationships: zod.z.array(RecordRelationshipSchema).optional().meta({
+    title: "Relationships",
+    description: "References to other IPFS records this record relates to"
+  }),
+  environment: RecordEnvironmentSchema.optional(),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).optional().meta({
+    title: "Custom Data",
+    description: "Custom data block that includes the record's data"
   })
 }).meta({
-  title: "Location",
-  description: "Geographic location with address and coordinate information"
+  title: "Base IPFS Record",
+  description: "Base fields for all Carrot IPFS records, providing common structure for any JSON content stored in IPFS"
 });
 function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
   return zod.z.array(schema).refine((items) => new Set(items).size === items.length, {
@@ -328,86 +385,527 @@ function uniqueBy(schema, selector, errorMessage = "Items must be unique") {
   );
 }
 
-// src/shared/entities/participant.schema.ts
-var ParticipantSchema = zod.z.strictObject({
-  id_hash: Sha256HashSchema.meta({
-    title: "Participant ID Hash",
-    description: "Anonymized identifier for the participant"
+// src/shared/nft.schema.ts
+var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
+  "MassID",
+  "RecycledID",
+  "GasID",
+  "PurchaseID"
+]).meta({
+  title: "NFT Schema Type",
+  description: "Type of schema for NFT records"
+});
+var BlockchainReferenceSchema = zod.z.strictObject({
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address"
   }),
-  name: ParticipantNameSchema.meta({
-    title: "Participant Name",
-    description: "Name of the participant"
+  chain_id: BlockchainChainIdSchema.meta({
+    title: "Chain ID",
+    description: "Blockchain chain ID"
   }),
-  roles: uniqueArrayItems(
-    ParticipantRoleSchema,
-    "Participant roles must be unique"
-  ).min(1).meta({
-    title: "Participant Roles",
-    description: "Roles of the participant in the waste management supply chain"
+  network_name: zod.z.string().min(5).max(100).meta({
+    title: "Network Name",
+    description: "Name of the blockchain network"
+  }),
+  token_id: TokenIdSchema.meta({
+    title: "Token ID",
+    description: "NFT token ID"
   })
 }).meta({
-  title: "Participant",
-  description: "A participant in the waste management supply chain"
+  title: "Blockchain Information",
+  description: "Blockchain-specific information for the NFT"
 });
-
-// src/mass-id/mass-id.data.schema.ts
-var MassIDLocalClassificationSchema = zod.z.strictObject({
-  code: NonEmptyStringSchema.max(20).meta({
-    title: "Classification Code",
-    description: "Local waste classification code",
-    examples: ["20 01 01", "D001", "EWC-150101", "IBAMA-A001"]
+var ExternalLinkSchema = zod.z.strictObject({
+  label: zod.z.string().min(1).max(50).meta({
+    title: "Link Label",
+    description: "Display name for the external link"
   }),
-  description: NonEmptyStringSchema.max(200).meta({
-    title: "Classification Description",
-    description: "Local waste classification description",
-    examples: [
-      "Paper and cardboard packaging",
-      "Ignitable waste",
-      "Paper and cardboard packaging waste",
-      "Municipal solid waste - organic fraction"
-    ]
+  url: zod.z.url("Must be a valid URI").meta({
+    title: "Link URL",
+    description: "Direct URI to the linked resource"
   }),
-  system: zod.z.enum(["IBAMA"]).meta({
-    title: "Classification System",
-    description: "Classification system name - currently supports IBAMA (Instituto Brasileiro do Meio Ambiente e dos Recursos Naturais Renov\xE1veis)",
-    examples: ["IBAMA"]
+  description: zod.z.string().min(10).max(100).optional().meta({
+    title: "Link Description",
+    description: "Optional context about what the link provides"
   })
 }).meta({
-  title: "Local Classification",
-  description: "Local or regional waste classification codes and descriptions"
-});
-var MassIDMeasurementUnitSchema = zod.z.enum(["kg", "ton"]).meta({
-  title: "Measurement Unit",
-  description: "Unit of measurement for the waste quantity",
-  examples: ["kg", "ton"]
-});
-var ContaminationLevelSchema = zod.z.enum(["None", "Low", "Medium", "High"]).meta({
-  title: "Contamination Level",
-  description: "Level of contamination in the waste batch",
-  examples: ["Low", "Medium", "None"]
+  title: "External Link",
+  description: "External link with label and description"
 });
-var MassIDWastePropertiesSchema = zod.z.strictObject({
-  type: WasteTypeSchema.meta({
-    title: "Waste Type",
-    description: "Waste material category"
+var NftAttributeSchema = zod.z.strictObject({
+  trait_type: zod.z.string().max(50).meta({
+    title: "Trait Type",
+    description: "Name of the trait or attribute"
   }),
-  subtype: WasteSubtypeSchema.meta({
-    title: "Waste Subtype",
-    description: "Specific subcategory of waste material"
+  value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).meta({
+    title: "Trait Value",
+    description: "Value of the trait - can be string, number, or boolean"
   }),
-  local_classification: MassIDLocalClassificationSchema.optional(),
-  measurement_unit: MassIDMeasurementUnitSchema,
-  net_weight: NonNegativeFloatSchema.meta({
-    title: "Net Weight",
-    description: "Net weight of the waste batch in the specified measurement unit"
+  display_type: zod.z.enum(["number", "date", "boost_number", "boost_percentage"]).optional().meta({
+    title: "Display Type",
+    description: "How the trait should be displayed in marketplace UIs"
   }),
-  contamination_level: ContaminationLevelSchema.optional()
+  max_value: NonNegativeFloatSchema.optional().meta({
+    title: "Max Value",
+    description: "Maximum possible value for numeric traits"
+  })
 }).meta({
-  title: "Waste Properties",
-  description: "Standardized waste material properties and regulatory information"
+  title: "NFT Attribute",
+  description: "NFT attribute or trait with type and value"
 });
-var EventAttributeFormatSchema = zod.z.enum(["KILOGRAM", "DATE", "CURRENCY", "PERCENTAGE", "COORDINATE"]).meta({
-  title: "Event Attribute Format",
+var NftIpfsSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: NftSchemaTypeSchema.meta({
+      title: "NFT Schema Type",
+      description: "Type/category of this NFT schema"
+    })
+  }),
+  blockchain: BlockchainReferenceSchema,
+  name: zod.z.string().min(1).max(100).meta({
+    title: "NFT Name",
+    description: "Full display name for this NFT, including extra context",
+    examples: [
+      "MassID #123 \u2022 Organic \u2022 3.0t",
+      "RecycledID #456 \u2022 Plastic \u2022 2.5t",
+      "GasID #789 \u2022 Methane \u2022 1000 m\xB3"
+    ]
+  }),
+  short_name: zod.z.string().min(1).max(50).meta({
+    title: "Short Name",
+    description: "Compact name for UI summaries, tables, or tooltips",
+    examples: ["MassID #123", "RecycledID #456", "GasID #789"]
+  }),
+  description: zod.z.string().min(10).max(500).meta({
+    title: "Description",
+    description: "Human-readable summary of the NFT's role and context. Ideally, maximum 300 characters.",
+    examples: [
+      "This MassID represents 3 metric tons of organic food waste from Enlatados Produ\xE7\xE3o, tracked through complete chain of custody from generation to composting.",
+      "This RecycledID represents 2.5 metric tons of recycled plastic bottles processed by Green Solutions Ltd."
+    ]
+  }),
+  image: IpfsUriSchema.meta({
+    title: "Image URI",
+    description: "IPFS URI pointing to the preview image"
+  }),
+  background_color: HexColorSchema.optional().meta({
+    title: "Background Color",
+    description: "Hex color code for marketplace background display"
+  }),
+  animation_url: IpfsUriSchema.optional().meta({
+    title: "Animation URL",
+    description: "IPFS URI pointing to an animated or interactive media file",
+    examples: [
+      "ipfs://QmAnimation123/mass-id-animation.mp4",
+      "ipfs://QmInteractive456/recycled-visualization.webm"
+    ]
+  }),
+  external_links: uniqueBy(
+    ExternalLinkSchema,
+    (link) => link.url,
+    "External link URLs must be unique"
+  ).max(10).optional().meta({
+    title: "External Links",
+    description: "Optional list of public resource links with labels",
+    examples: [
+      [
+        {
+          label: "Carrot Explorer",
+          url: "https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
+          description: "Complete chain of custody and audit trail"
+        },
+        {
+          label: "Carrot White Paper",
+          url: "https://carrot.eco/whitepaper.pdf",
+          description: "Carrot Foundation technical and impact white paper"
+        }
+      ]
+    ]
+  }),
+  attributes: uniqueBy(
+    NftAttributeSchema,
+    (attr) => attr.trait_type,
+    "Attribute trait_type values must be unique"
+  ).meta({
+    title: "NFT Attributes",
+    description: "List of visual traits and filterable attributes compatible with NFT marketplaces",
+    examples: [
+      [
+        {
+          trait_type: "Waste Type",
+          value: "Organic"
+        },
+        {
+          trait_type: "Waste Subtype",
+          value: "Food, Food Waste and Beverages"
+        },
+        {
+          trait_type: "Weight (kg)",
+          value: 3e3,
+          display_type: "number"
+        },
+        {
+          trait_type: "Origin Country",
+          value: "Brazil"
+        },
+        {
+          trait_type: "Pick-up Date",
+          value: "2024-12-05",
+          display_type: "date"
+        }
+      ]
+    ]
+  })
+}).meta({
+  title: "NFT IPFS Record",
+  description: "NFT-specific fields for Carrot IPFS records"
+});
+
+// src/mass-id/mass-id.attributes.ts
+var MassIDAttributeWasteTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Waste Type"),
+  value: WasteTypeSchema
+}).meta({
+  title: "Waste Type Attribute",
+  description: "Waste type attribute"
+});
+var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Waste Subtype"),
+  value: WasteSubtypeSchema
+}).meta({
+  title: "Waste Subtype Attribute",
+  description: "Waste subtype attribute"
+});
+var MassIDAttributeWeightSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Weight (kg)"),
+  value: WeightKgSchema,
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Weight Attribute",
+  description: "Weight attribute with numeric display"
+});
+var MassIDAttributeOriginCountrySchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Origin Country"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Origin Country Value",
+    description: "Country where the waste was generated",
+    examples: ["Brazil", "United States", "Germany", "Japan"]
+  })
+}).meta({
+  title: "Origin Country Attribute",
+  description: "Origin country attribute"
+});
+var MassIDAttributeOriginMunicipalitySchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Origin Municipality"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Origin Municipality Value",
+    description: "Municipality where the waste was generated",
+    examples: ["S\xE3o Paulo", "New York", "Berlin", "Tokyo"]
+  })
+}).meta({
+  title: "Origin Municipality Attribute",
+  description: "Origin municipality attribute"
+});
+var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Origin Administrative Division"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Origin Division Value",
+    description: "Administrative division (state/province) where the waste was generated",
+    examples: ["S\xE3o Paulo", "California", "Bavaria"]
+  })
+}).meta({
+  title: "Origin Administrative Division Attribute",
+  description: "Origin administrative division attribute"
+});
+var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Vehicle Type"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Vehicle Type Value",
+    description: "Type of vehicle used for waste transportation",
+    examples: ["Garbage Truck", "Box Truck", "Flatbed Truck", "Roll-off Truck"]
+  })
+}).meta({
+  title: "Vehicle Type Attribute",
+  description: "Vehicle type attribute"
+});
+var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Recycling Method"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Recycling Method Value",
+    description: "Method used for recycling or processing the waste",
+    examples: [
+      "Composting",
+      "Mechanical Recycling",
+      "Incineration with Energy Recovery"
+    ]
+  })
+}).meta({
+  title: "Recycling Method Attribute",
+  description: "Recycling method attribute"
+});
+var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Processing Time (hours)"),
+  value: HoursSchema,
+  trait_description: NonEmptyStringSchema.max(200).optional().meta({
+    title: "Processing Time Description",
+    description: "Custom description for the processing time"
+  })
+}).meta({
+  title: "Processing Time Attribute",
+  description: "Processing time attribute with optional trait description"
+});
+var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Local Waste Classification ID"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Local Waste Classification ID Value",
+    description: "Local or regional waste classification identifier",
+    examples: ["04 02 20", "IBAMA-A001", "EWC-150101"]
+  })
+}).meta({
+  title: "Local Waste Classification ID Attribute",
+  description: "Local waste classification ID attribute"
+});
+var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Recycling Manifest Code"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Recycling Manifest Code Value",
+    description: "Concatenated recycling manifest code (Document Type + Document Number)",
+    examples: ["CDF-2353", "RC-12345", "REC-MANIFEST-789"]
+  })
+}).meta({
+  title: "Recycling Manifest Code Attribute",
+  description: "Recycling manifest code attribute (optional)"
+});
+var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Transport Manifest Code"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Transport Manifest Code Value",
+    description: "Concatenated transport manifest code (Document Type + Document Number)",
+    examples: ["MTR-4126", "TRN-67890", "TRANS-MANIFEST-456"]
+  })
+}).meta({
+  title: "Transport Manifest Code Attribute",
+  description: "Transport manifest code attribute (optional)"
+});
+var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Weighing Capture Method"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Weighing Capture Method Value",
+    description: "Method used to capture weight data",
+    examples: ["Digital", "Manual", "Automated", "Electronic Scale"]
+  })
+}).meta({
+  title: "Weighing Capture Method Attribute",
+  description: "Weighing capture method attribute (optional)"
+});
+var MassIDAttributeScaleTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Scale Type"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Scale Type Value",
+    description: "Type of scale used for weighing",
+    examples: [
+      "Weighbridge (Truck Scale)",
+      "Floor Scale",
+      "Bench Scale",
+      "Crane Scale"
+    ]
+  })
+}).meta({
+  title: "Scale Type Attribute",
+  description: "Scale type attribute (optional)"
+});
+var MassIDAttributeContainerTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Container Type"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Container Type Value",
+    description: "Type of container used for waste storage or transport",
+    examples: ["Truck", "Dumpster", "Roll-off Container", "Compactor", "Bin"]
+  })
+}).meta({
+  title: "Container Type Attribute",
+  description: "Container type attribute (optional)"
+});
+var MassIDAttributePickUpDateSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Pick-up Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Pick-up Date Value",
+    description: "Unix timestamp in milliseconds when the waste was picked up from the source",
+    examples: [17105184e5, 17040672e5, 17152704e5]
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Pick-up Date Attribute",
+  description: "Pick-up date attribute with Unix timestamp"
+});
+var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Recycling Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Recycling Date Value",
+    description: "Unix timestamp in milliseconds when the waste was recycled/processed",
+    examples: [17106048e5, 17041536e5, 17153568e5]
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Recycling Date Attribute",
+  description: "Recycling date attribute with Unix timestamp"
+});
+var MassIDAttributesSchema = uniqueBy(
+  zod.z.union([
+    MassIDAttributeWasteTypeSchema,
+    MassIDAttributeWasteSubtypeSchema,
+    MassIDAttributeWeightSchema,
+    MassIDAttributeOriginCountrySchema,
+    MassIDAttributeOriginMunicipalitySchema,
+    MassIDAttributeOriginDivisionSchema,
+    MassIDAttributeVehicleTypeSchema,
+    MassIDAttributeRecyclingMethodSchema,
+    MassIDAttributeProcessingTimeSchema,
+    MassIDAttributeLocalWasteClassificationIdSchema,
+    MassIDAttributeRecyclingManifestCodeSchema,
+    MassIDAttributeTransportManifestCodeSchema,
+    MassIDAttributeWeighingCaptureMethodSchema,
+    MassIDAttributeScaleTypeSchema,
+    MassIDAttributeContainerTypeSchema,
+    MassIDAttributePickUpDateSchema,
+    MassIDAttributeRecyclingDateSchema
+  ]),
+  (attr) => attr.trait_type
+).min(12).max(17).meta({
+  title: "MassID Attributes",
+  description: "MassID NFT attributes array containing attributes selected from the available attribute types. The schema validates array length but does not enforce which specific attributes must be present."
+});
+var PrecisionLevelSchema = zod.z.enum(["exact", "neighborhood", "city", "region", "country"]).meta({
+  title: "Precision Level",
+  description: "Level of coordinate precision",
+  examples: ["city", "exact", "neighborhood"]
+});
+var CoordinatesSchema = zod.z.strictObject({
+  latitude: LatitudeSchema.meta({
+    title: "Latitude",
+    description: "GPS latitude coordinate"
+  }),
+  longitude: LongitudeSchema.meta({
+    title: "Longitude",
+    description: "GPS longitude coordinate"
+  }),
+  precision_level: PrecisionLevelSchema
+}).meta({
+  title: "Coordinates",
+  description: "GPS coordinates of the location"
+});
+var LocationSchema = zod.z.strictObject({
+  id_hash: Sha256HashSchema.meta({
+    title: "Location ID Hash",
+    description: "Anonymized identifier for the location"
+  }),
+  municipality: NonEmptyStringSchema.max(50).meta({
+    title: "Municipality",
+    description: "Municipality or city name",
+    examples: ["New York", "S\xE3o Paulo", "London", "Tokyo"]
+  }),
+  administrative_division: NonEmptyStringSchema.max(50).meta({
+    title: "Administrative Division",
+    description: "State, province, or administrative region",
+    examples: ["California", "Ontario", "Bavaria", "Queensland"]
+  }),
+  administrative_division_code: IsoAdministrativeDivisionCodeSchema.optional().meta({
+    title: "Administrative Division Code",
+    description: "ISO 3166-2 administrative division code"
+  }),
+  country: NonEmptyStringSchema.max(50).meta({
+    title: "Country",
+    description: "Full country name in English",
+    examples: ["United States", "Canada", "Germany", "Australia"]
+  }),
+  country_code: IsoCountryCodeSchema.meta({
+    title: "Country Code",
+    description: "ISO 3166-1 alpha-2 country code"
+  }),
+  responsible_participant_id_hash: Sha256HashSchema.meta({
+    title: "Responsible Participant ID Hash",
+    description: "Anonymized ID of the participant responsible for this location"
+  }),
+  coordinates: CoordinatesSchema,
+  facility_type: FacilityTypeSchema.optional().meta({
+    title: "Facility Type",
+    description: "Type of facility at this location"
+  })
+}).meta({
+  title: "Location",
+  description: "Geographic location with address and coordinate information"
+});
+var ParticipantSchema = zod.z.strictObject({
+  id_hash: Sha256HashSchema.meta({
+    title: "Participant ID Hash",
+    description: "Anonymized identifier for the participant"
+  }),
+  name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Name of the participant"
+  }),
+  roles: uniqueArrayItems(
+    ParticipantRoleSchema,
+    "Participant roles must be unique"
+  ).min(1).meta({
+    title: "Participant Roles",
+    description: "Roles of the participant in the waste management supply chain"
+  })
+}).meta({
+  title: "Participant",
+  description: "A participant in the waste management supply chain"
+});
+
+// src/mass-id/mass-id.data.schema.ts
+var MassIDLocalClassificationSchema = zod.z.strictObject({
+  code: NonEmptyStringSchema.max(20).meta({
+    title: "Classification Code",
+    description: "Local waste classification code",
+    examples: ["20 01 01", "D001", "EWC-150101", "IBAMA-A001"]
+  }),
+  description: NonEmptyStringSchema.max(200).meta({
+    title: "Classification Description",
+    description: "Local waste classification description",
+    examples: [
+      "Paper and cardboard packaging",
+      "Ignitable waste",
+      "Paper and cardboard packaging waste",
+      "Municipal solid waste - organic fraction"
+    ]
+  }),
+  system: zod.z.enum(["IBAMA"]).meta({
+    title: "Classification System",
+    description: "Classification system name - currently supports IBAMA (Instituto Brasileiro do Meio Ambiente e dos Recursos Naturais Renov\xE1veis)",
+    examples: ["IBAMA"]
+  })
+}).meta({
+  title: "Local Classification",
+  description: "Local or regional waste classification codes and descriptions"
+});
+var MassIDMeasurementUnitSchema = zod.z.enum(["kg", "ton"]).meta({
+  title: "Measurement Unit",
+  description: "Unit of measurement for the waste quantity",
+  examples: ["kg", "ton"]
+});
+var MassIDWastePropertiesSchema = zod.z.strictObject({
+  type: WasteTypeSchema.meta({
+    title: "Waste Type",
+    description: "Waste material category"
+  }),
+  subtype: WasteSubtypeSchema.meta({
+    title: "Waste Subtype",
+    description: "Specific subcategory of waste material"
+  }),
+  local_classification: MassIDLocalClassificationSchema.optional(),
+  measurement_unit: MassIDMeasurementUnitSchema,
+  net_weight: NonNegativeFloatSchema.meta({
+    title: "Net Weight",
+    description: "Net weight of the waste batch in the specified measurement unit"
+  })
+}).meta({
+  title: "Waste Properties",
+  description: "Standardized waste material properties and regulatory information"
+});
+var EventAttributeFormatSchema = zod.z.enum(["KILOGRAM", "DATE", "CURRENCY", "PERCENTAGE", "COORDINATE"]).meta({
+  title: "Event Attribute Format",
   description: "Data format hint for proper display",
   examples: ["KILOGRAM", "DATE", "PERCENTAGE"]
 });
@@ -486,9 +984,10 @@ var EventAttachmentSchema = zod.z.strictObject({
       "processing_receipt_20240315.jpg"
     ]
   }),
-  issue_date: IsoDateSchema.optional().meta({
-    title: "Issue Date",
-    description: "Date the attachment was issued"
+  issue_timestamp: UnixTimestampSchema.optional().meta({
+    title: "Issue Timestamp",
+    description: "Unix timestamp in milliseconds when the attachment was issued",
+    examples: [17105184e5, 17040672e5, 17152704e5]
   }),
   issuer: NonEmptyStringSchema.max(100).optional().meta({
     title: "Attachment Issuer",
@@ -528,9 +1027,10 @@ var MassIDChainOfCustodyEventSchema = zod.z.strictObject({
       "Quality inspection and contamination assessment completed"
     ]
   }),
-  timestamp: IsoTimestampSchema.meta({
+  timestamp: UnixTimestampSchema.meta({
     title: "Event Timestamp",
-    description: "ISO 8601 timestamp when the event occurred"
+    description: "Unix timestamp in milliseconds when the event occurred",
+    examples: [17105184e5, 17040672e5, 17152704e5]
   }),
   participant_id_hash: Sha256HashSchema.meta({
     title: "Participant ID Hash",
@@ -546,386 +1046,99 @@ var MassIDChainOfCustodyEventSchema = zod.z.strictObject({
   }),
   attributes: zod.z.array(EventAttributeSchema).optional().meta({
     title: "Event Attributes",
-    description: "Additional attributes specific to this event"
-  }),
-  attachments: zod.z.array(EventAttachmentSchema).optional().meta({
-    title: "Event Attachments",
-    description: "Associated attachments for this event"
-  })
-}).meta({
-  title: "Chain of Custody Event",
-  description: "Chain of custody event"
-});
-var MassIDChainOfCustodySchema = zod.z.strictObject({
-  events: zod.z.array(MassIDChainOfCustodyEventSchema).min(1).meta({
-    title: "Custody Events",
-    description: "Chronological sequence of custody transfer and processing events"
-  }),
-  total_duration_hours: HoursSchema.meta({
-    title: "Total Duration (hours)",
-    description: "Total time from first to last event in hours"
-  })
-}).meta({
-  title: "Chain of Custody",
-  description: "Complete chain of custody tracking from waste generation to final processing"
-});
-var MassIDGeographicDataSchema = zod.z.strictObject({
-  from_location_id_hash: Sha256HashSchema.meta({
-    title: "From Location ID Hash",
-    description: "Reference hash of the location where the waste started movement"
-  }),
-  to_location_id_hash: Sha256HashSchema.meta({
-    title: "To Location ID Hash",
-    description: "Reference hash of the location where the waste ended movement"
-  }),
-  first_reported_timestamp: IsoTimestampSchema.meta({
-    title: "First Reported Timestamp",
-    description: "ISO 8601 timestamp when the waste was first reported/collected at the origin location"
-  }),
-  last_reported_timestamp: IsoTimestampSchema.meta({
-    title: "Last Reported Timestamp",
-    description: "ISO 8601 timestamp when the waste was last reported/processed at the destination location"
-  })
-}).refine((data) => {
-  const first = new Date(data.first_reported_timestamp);
-  const last = new Date(data.last_reported_timestamp);
-  return first <= last;
-}, "first_reported_timestamp must be before or equal to last_reported_timestamp").meta({
-  title: "Geographic Data",
-  description: "Simplified geographic information tracking waste movement from origin to destination with temporal bounds"
-});
-var MassIDDataSchema = zod.z.strictObject({
-  waste_properties: MassIDWastePropertiesSchema,
-  locations: uniqueBy(
-    LocationSchema,
-    (loc) => loc.id_hash,
-    "Location ID hashes must be unique"
-  ).min(1).meta({
-    title: "Locations",
-    description: "All locations referenced in this MassID, indexed by ID"
-  }),
-  participants: uniqueBy(
-    ParticipantSchema,
-    (p) => p.id_hash,
-    "Participant ID hashes must be unique"
-  ).min(1).meta({
-    title: "Participants",
-    description: "All participants referenced in this MassID, indexed by ID"
-  }),
-  chain_of_custody: MassIDChainOfCustodySchema,
-  geographic_data: MassIDGeographicDataSchema
-}).refine((data) => {
-  const participantIdSet = new Set(
-    data.participants.map((participant) => participant.id_hash)
-  );
-  const eventParticipantIds = data.chain_of_custody.events.map(
-    (event) => event.participant_id_hash
-  );
-  const allEventParticipantsExist = eventParticipantIds.every(
-    (participantId) => participantIdSet.has(participantId)
-  );
-  return allEventParticipantsExist;
-}, "All participant ID hashes in chain of custody events must exist in participants array").refine((data) => {
-  const locationIdSet = new Set(
-    data.locations.map((location) => location.id_hash)
-  );
-  const eventLocationIds = data.chain_of_custody.events.map(
-    (event) => event.location_id_hash
-  );
-  const allEventLocationsExist = eventLocationIds.every(
-    (locationId) => locationIdSet.has(locationId)
-  );
-  return allEventLocationsExist;
-}, "All location ID hashes in chain of custody events must exist in locations array").meta({
-  title: "MassID Data",
-  description: "MassID data containing waste tracking and chain of custody information"
-});
-var SchemaInfoSchema = zod.z.strictObject({
-  hash: Keccak256HashSchema.meta({
-    title: "Schema Hash",
-    description: "Keccak256 hash of the JSON Schema this record was validated against"
-  }),
-  type: RecordSchemaTypeSchema.meta({
-    title: "Schema Type",
-    description: "Type/category of this schema"
-  }),
-  version: SemanticVersionSchema.meta({
-    title: "Schema Version",
-    description: "Version of the schema, using semantic versioning"
-  })
-}).meta({
-  title: "Schema Information"
-});
-var RecordCreatorSchema = zod.z.strictObject({
-  name: zod.z.string().meta({
-    title: "Creator Name",
-    description: "Company or individual name that created this record",
-    examples: ["Carrot Foundation"]
-  }),
-  id: UuidSchema.meta({
-    title: "Creator ID",
-    description: "Unique identifier for the creator"
-  })
-}).meta({
-  title: "Creator",
-  description: "Entity that created this record"
-});
-var RecordRelationshipSchema = zod.z.strictObject({
-  target_uri: IpfsUriSchema.meta({
-    title: "Target IPFS URI",
-    description: "Target IPFS URI of the referenced record"
-  }),
-  type: RecordRelationshipTypeSchema.meta({
-    title: "Relationship Type",
-    description: "Type of relationship to the referenced record"
-  }),
-  description: zod.z.string().optional().meta({
-    title: "Relationship Description",
-    description: "Human-readable description of the relationship",
-    examples: [
-      "This record supersedes the previous version",
-      "Related carbon credit batch",
-      "Source document for this verification",
-      "Child record derived from this parent",
-      "Updated version of original record"
-    ]
-  })
-}).meta({
-  title: "Relationship",
-  description: "Relationship to another IPFS record"
-});
-var RecordEnvironmentSchema = zod.z.strictObject({
-  blockchain_network: zod.z.enum(["mainnet", "testnet"]).meta({
-    title: "Blockchain Network",
-    description: "Blockchain Network Environment"
-  }),
-  deployment: zod.z.enum(["production", "development", "testing"]).meta({
-    title: "Deployment Environment",
-    description: "System environment where this record was generated"
-  }),
-  data_set_name: zod.z.enum(["TEST", "PROD"]).meta({
-    title: "Data Set Name",
-    description: "Name of the data set for this record"
-  })
-}).meta({
-  title: "Environment",
-  description: "Environment information"
-});
-var BaseIpfsSchema = zod.z.strictObject({
-  $schema: zod.z.url("Must be a valid URI").meta({
-    title: "JSON Schema URI",
-    description: "URI of the JSON Schema used to validate this record",
-    example: "https://raw.githubusercontent.com/carrot-foundation/schemas/refs/heads/main/schemas/ipfs/shared/base/base.schema.json"
-  }),
-  schema: SchemaInfoSchema,
-  created_at: IsoTimestampSchema.meta({
-    title: "Created At",
-    description: "ISO 8601 creation timestamp for this record"
-  }),
-  external_id: ExternalIdSchema.meta({
-    title: "External ID",
-    description: "Off-chain reference ID (UUID from Carrot backend)"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "External URL",
-    description: "External URL of the content"
-  }),
-  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"
-  }),
-  creator: RecordCreatorSchema.optional(),
-  relationships: zod.z.array(RecordRelationshipSchema).optional().meta({
-    title: "Relationships",
-    description: "References to other IPFS records this record relates to"
-  }),
-  environment: RecordEnvironmentSchema.optional(),
-  data: zod.z.record(zod.z.string(), zod.z.unknown()).optional().meta({
-    title: "Custom Data",
-    description: "Custom data block that includes the record's data"
-  })
-}).meta({
-  title: "Base IPFS Record",
-  description: "Base fields for all Carrot IPFS records, providing common structure for any JSON content stored in IPFS"
-});
-
-// src/shared/nft.schema.ts
-var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
-  "MassID",
-  "RecycledID",
-  "GasID",
-  "PurchaseID"
-]).meta({
-  title: "NFT Schema Type",
-  description: "Type of schema for NFT records"
-});
-var BlockchainReferenceSchema = zod.z.strictObject({
-  smart_contract_address: EthereumAddressSchema.meta({
-    title: "Smart Contract Address"
-  }),
-  chain_id: BlockchainChainIdSchema.meta({
-    title: "Chain ID",
-    description: "Blockchain chain ID"
-  }),
-  network_name: zod.z.string().min(5).max(100).meta({
-    title: "Network Name",
-    description: "Name of the blockchain network"
-  }),
-  token_id: TokenIdSchema.meta({
-    title: "Token ID",
-    description: "NFT token ID"
-  })
-}).meta({
-  title: "Blockchain Information",
-  description: "Blockchain-specific information for the NFT"
-});
-var ExternalLinkSchema = zod.z.strictObject({
-  label: zod.z.string().min(1).max(50).meta({
-    title: "Link Label",
-    description: "Display name for the external link"
-  }),
-  url: zod.z.url("Must be a valid URI").meta({
-    title: "Link URL",
-    description: "Direct URI to the linked resource"
+    description: "Additional attributes specific to this event"
   }),
-  description: zod.z.string().min(10).max(100).optional().meta({
-    title: "Link Description",
-    description: "Optional context about what the link provides"
+  attachments: zod.z.array(EventAttachmentSchema).optional().meta({
+    title: "Event Attachments",
+    description: "Associated attachments for this event"
   })
 }).meta({
-  title: "External Link",
-  description: "External link with label and description"
+  title: "Chain of Custody Event",
+  description: "Chain of custody event"
 });
-var NftAttributeSchema = zod.z.strictObject({
-  trait_type: zod.z.string().max(50).meta({
-    title: "Trait Type",
-    description: "Name of the trait or attribute"
-  }),
-  value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).meta({
-    title: "Trait Value",
-    description: "Value of the trait - can be string, number, or boolean"
-  }),
-  display_type: zod.z.enum(["number", "date", "boost_number", "boost_percentage"]).optional().meta({
-    title: "Display Type",
-    description: "How the trait should be displayed in marketplace UIs"
+var MassIDChainOfCustodySchema = zod.z.strictObject({
+  events: zod.z.array(MassIDChainOfCustodyEventSchema).min(1).meta({
+    title: "Custody Events",
+    description: "Chronological sequence of custody transfer and processing events"
   }),
-  max_value: NonNegativeFloatSchema.optional().meta({
-    title: "Max Value",
-    description: "Maximum possible value for numeric traits"
+  total_duration_minutes: MinutesSchema.meta({
+    title: "Total Duration (minutes)",
+    description: "Total time from first to last event in minutes"
   })
 }).meta({
-  title: "NFT Attribute",
-  description: "NFT attribute or trait with type and value"
+  title: "Chain of Custody",
+  description: "Complete chain of custody tracking from waste generation to final processing"
 });
-var NftIpfsSchema = BaseIpfsSchema.safeExtend({
-  schema: BaseIpfsSchema.shape.schema.safeExtend({
-    type: NftSchemaTypeSchema.meta({
-      title: "NFT Schema Type",
-      description: "Type/category of this NFT schema"
-    })
-  }),
-  blockchain: BlockchainReferenceSchema,
-  name: zod.z.string().min(1).max(100).meta({
-    title: "NFT Name",
-    description: "Full display name for this NFT, including extra context",
-    examples: [
-      "MassID #123 \u2022 Organic \u2022 3.0t",
-      "RecycledID #456 \u2022 Plastic \u2022 2.5t",
-      "GasID #789 \u2022 Methane \u2022 1000 m\xB3"
-    ]
-  }),
-  short_name: zod.z.string().min(1).max(50).meta({
-    title: "Short Name",
-    description: "Compact name for UI summaries, tables, or tooltips",
-    examples: ["MassID #123", "RecycledID #456", "GasID #789"]
-  }),
-  description: zod.z.string().min(10).max(500).meta({
-    title: "Description",
-    description: "Human-readable summary of the NFT's role and context. Ideally, maximum 300 characters.",
-    examples: [
-      "This MassID represents 3 metric tons of organic food waste from Enlatados Produ\xE7\xE3o, tracked through complete chain of custody from generation to composting.",
-      "This RecycledID represents 2.5 metric tons of recycled plastic bottles processed by Green Solutions Ltd."
-    ]
+var MassIDGeographicDataSchema = zod.z.strictObject({
+  from_location_id_hash: Sha256HashSchema.meta({
+    title: "From Location ID Hash",
+    description: "Reference hash of the location where the waste started movement"
   }),
-  image: IpfsUriSchema.meta({
-    title: "Image URI",
-    description: "IPFS URI pointing to the preview image"
+  to_location_id_hash: Sha256HashSchema.meta({
+    title: "To Location ID Hash",
+    description: "Reference hash of the location where the waste ended movement"
   }),
-  background_color: HexColorSchema.optional().meta({
-    title: "Background Color",
-    description: "Hex color code for marketplace background display"
+  first_reported_timestamp: UnixTimestampSchema.meta({
+    title: "First Reported Timestamp",
+    description: "Unix timestamp in milliseconds when the waste was first reported/collected at the origin location",
+    examples: [17105184e5, 17040672e5, 17152704e5]
   }),
-  animation_url: IpfsUriSchema.optional().meta({
-    title: "Animation URL",
-    description: "IPFS URI pointing to an animated or interactive media file",
-    examples: [
-      "ipfs://QmAnimation123/mass-id-animation.mp4",
-      "ipfs://QmInteractive456/recycled-visualization.webm"
-    ]
+  last_reported_timestamp: UnixTimestampSchema.meta({
+    title: "Last Reported Timestamp",
+    description: "Unix timestamp in milliseconds when the waste was last reported/processed at the destination location",
+    examples: [17106048e5, 17041536e5, 17153568e5]
+  })
+}).refine((data) => {
+  return data.first_reported_timestamp <= data.last_reported_timestamp;
+}, "first_reported_timestamp must be before or equal to last_reported_timestamp").meta({
+  title: "Geographic Data",
+  description: "Simplified geographic information tracking waste movement from origin to destination with temporal bounds"
+});
+var MassIDDataSchema = zod.z.strictObject({
+  waste_properties: MassIDWastePropertiesSchema,
+  locations: uniqueBy(
+    LocationSchema,
+    (loc) => loc.id_hash,
+    "Location ID hashes must be unique"
+  ).min(1).meta({
+    title: "Locations",
+    description: "All locations referenced in this MassID, indexed by ID"
   }),
-  external_links: uniqueBy(
-    ExternalLinkSchema,
-    (link) => link.url,
-    "External link URLs must be unique"
-  ).max(10).optional().meta({
-    title: "External Links",
-    description: "Optional list of public resource links with labels",
-    examples: [
-      [
-        {
-          label: "Carrot Explorer",
-          url: "https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-          description: "Complete chain of custody and audit trail"
-        },
-        {
-          label: "Carrot White Paper",
-          url: "https://carrot.eco/whitepaper.pdf",
-          description: "Carrot Foundation technical and impact white paper"
-        }
-      ]
-    ]
+  participants: uniqueBy(
+    ParticipantSchema,
+    (p) => p.id_hash,
+    "Participant ID hashes must be unique"
+  ).min(1).meta({
+    title: "Participants",
+    description: "All participants referenced in this MassID, indexed by ID"
   }),
-  attributes: uniqueBy(
-    NftAttributeSchema,
-    (attr) => attr.trait_type,
-    "Attribute trait_type values must be unique"
-  ).meta({
-    title: "NFT Attributes",
-    description: "List of visual traits and filterable attributes compatible with NFT marketplaces",
-    examples: [
-      [
-        {
-          trait_type: "Waste Type",
-          value: "Organic"
-        },
-        {
-          trait_type: "Waste Subtype",
-          value: "Food, Food Waste and Beverages"
-        },
-        {
-          trait_type: "Weight (kg)",
-          value: 3e3,
-          display_type: "number"
-        },
-        {
-          trait_type: "Origin Country",
-          value: "Brazil"
-        },
-        {
-          trait_type: "Pick-up Date",
-          value: "2024-12-05",
-          display_type: "date"
-        }
-      ]
-    ]
-  })
-}).meta({
-  title: "NFT IPFS Record",
-  description: "NFT-specific fields for Carrot IPFS records"
+  chain_of_custody: MassIDChainOfCustodySchema,
+  geographic_data: MassIDGeographicDataSchema
+}).refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id_hash)
+  );
+  const eventParticipantIds = data.chain_of_custody.events.map(
+    (event) => event.participant_id_hash
+  );
+  const allEventParticipantsExist = eventParticipantIds.every(
+    (participantId) => participantIdSet.has(participantId)
+  );
+  return allEventParticipantsExist;
+}, "All participant ID hashes in chain of custody events must exist in participants array").refine((data) => {
+  const locationIdSet = new Set(
+    data.locations.map((location) => location.id_hash)
+  );
+  const eventLocationIds = data.chain_of_custody.events.map(
+    (event) => event.location_id_hash
+  );
+  const allEventLocationsExist = eventLocationIds.every(
+    (locationId) => locationIdSet.has(locationId)
+  );
+  return allEventLocationsExist;
+}, "All location ID hashes in chain of custody events must exist in locations array").meta({
+  title: "MassID Data",
+  description: "MassID data containing waste tracking and chain of custody information"
 });
 
 // src/shared/schema-version.ts
@@ -941,115 +1154,6 @@ function getSchemaVersionOrDefault() {
 }
 
 // src/mass-id/mass-id.schema.ts
-var AttributeWasteTypeSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Waste Type"),
-  value: WasteTypeSchema
-}).meta({
-  title: "Waste Type Attribute",
-  description: "Waste type attribute"
-});
-var AttributeWasteSubtypeSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Waste Subtype"),
-  value: WasteSubtypeSchema
-}).meta({
-  title: "Waste Subtype Attribute",
-  description: "Waste subtype attribute"
-});
-var AttributeWeightSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Weight (kg)"),
-  value: WeightKgSchema,
-  display_type: zod.z.literal("number")
-}).meta({
-  title: "Weight Attribute",
-  description: "Weight attribute with numeric display"
-});
-var AttributeOriginCountrySchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Origin Country"),
-  value: zod.z.string().max(100).meta({
-    title: "Origin Country Value",
-    description: "Country where the waste was generated"
-  })
-}).meta({
-  title: "Origin Country Attribute",
-  description: "Origin country attribute"
-});
-var AttributeOriginMunicipalitySchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Origin Municipality"),
-  value: zod.z.string().max(100).meta({
-    title: "Origin Municipality Value",
-    description: "Municipality where the waste was generated"
-  })
-}).meta({
-  title: "Origin Municipality Attribute",
-  description: "Origin municipality attribute"
-});
-var AttributeOriginDivisionSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Origin Administrative Division"),
-  value: zod.z.string().max(100).meta({
-    title: "Origin Division Value",
-    description: "Administrative division (state/province) where the waste was generated"
-  })
-}).meta({
-  title: "Origin Administrative Division Attribute",
-  description: "Origin administrative division attribute"
-});
-var AttributeRecyclerSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Recycler"),
-  value: zod.z.string().max(100).meta({
-    title: "Recycler Value",
-    description: "Organization that processed the waste"
-  })
-}).meta({
-  title: "Recycler Attribute",
-  description: "Recycler attribute"
-});
-var AttributeIntegratorSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Integrator"),
-  value: zod.z.string().max(100).meta({
-    title: "Integrator Value",
-    description: "Organization that integrated the waste into the Carrot network"
-  })
-}).meta({
-  title: "Integrator Attribute",
-  description: "Integrator attribute"
-});
-var AttributePickUpDateSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Pick-up Date"),
-  value: UnixTimestampSchema.meta({
-    title: "Pick-up Date Value",
-    description: "Unix timestamp in milliseconds when the waste was picked up from the source"
-  }),
-  display_type: zod.z.literal("date")
-}).meta({
-  title: "Pick-up Date Attribute",
-  description: "Pick-up date attribute with Unix timestamp"
-});
-var AttributeRecyclingDateSchema = zod.z.strictObject({
-  trait_type: zod.z.literal("Recycling Date"),
-  value: zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be a valid date in YYYY-MM-DD format").meta({
-    title: "Recycling Date Value",
-    description: "Date when the waste was recycled/processed"
-  }),
-  display_type: zod.z.literal("date")
-}).meta({
-  title: "Recycling Date Attribute",
-  description: "Recycling date attribute"
-});
-var MassIDAttributesSchema = zod.z.tuple([
-  AttributeWasteTypeSchema,
-  AttributeWasteSubtypeSchema,
-  AttributeWeightSchema,
-  AttributeOriginCountrySchema,
-  AttributeOriginMunicipalitySchema,
-  AttributeOriginDivisionSchema,
-  AttributeRecyclerSchema,
-  AttributeIntegratorSchema,
-  AttributePickUpDateSchema,
-  AttributeRecyclingDateSchema
-]).meta({
-  title: "MassID Attributes",
-  description: "Fixed set of MassID NFT attributes in required order"
-});
 var MassIDIpfsSchemaMeta = {
   title: "MassID NFT IPFS Record",
   description: "Complete MassID NFT IPFS record including fixed attributes and detailed waste tracking data",
@@ -1063,16 +1167,11 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
       description: "MassID NFT schema type"
     })
   }),
-  attributes: MassIDAttributesSchema.meta({
-    title: "MassID NFT Attributes",
-    description: "Fixed set of MassID NFT attributes enforcing order and type for each trait"
-  }).check(zod.z.minLength(10), zod.z.maxLength(10)),
-  data: MassIDDataSchema.meta({
-    title: "MassID Data",
-    description: "MassID-specific data containing waste tracking and chain of custody information"
-  })
+  attributes: MassIDAttributesSchema,
+  data: MassIDDataSchema
 }).meta(MassIDIpfsSchemaMeta);
 
+exports.MassIDAttributesSchema = MassIDAttributesSchema;
 exports.MassIDDataSchema = MassIDDataSchema;
 exports.MassIDIpfsSchema = MassIDIpfsSchema;
 exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;