@carrot-foundation/schemas 0.1.40 → 0.1.42

package/dist/index.cjs

@@ -5,69 +5,6 @@ require('fs');
 require('path');
 
 // 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",
-  examples: [
-    "ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "6f520d88-864d-432d-bf9f-5c3166c4818f",
-    "f77afa89-1c58-40fd-9bf5-8a86703a8af4"
-  ]
-});
-var EthereumAddressSchema = zod.z.string().regex(
-  /^0x[a-f0-9]{40}$/,
-  "Must be a valid Ethereum address in lowercase hexadecimal format"
-).meta({
-  title: "Ethereum Address",
-  description: "A valid Ethereum address in hexadecimal format",
-  examples: [
-    "0x1234567890abcdef1234567890abcdef12345678",
-    "0xabcdef1234567890abcdef1234567890abcdef12"
-  ]
-});
-var IsoTimestampSchema = zod.z.iso.datetime().meta({
-  title: "ISO Timestamp",
-  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({
-  title: "ISO Date",
-  description: "ISO 8601 formatted date in YYYY-MM-DD format",
-  examples: ["2024-12-05", "2025-02-22", "2024-02-10"]
-});
-var UnixTimestampSchema = zod.z.number().int().positive().meta({
-  title: "Unix Timestamp",
-  description: "Unix timestamp in milliseconds since epoch (January 1, 1970 00:00:00 UTC)",
-  examples: [17040672e5, 17356896e5, 1762371245149]
-});
-var IsoCountryCodeSchema = zod.z.string().regex(/^[A-Z]{2}$/, "Must be a valid ISO 3166-1 alpha-2 country code").meta({
-  title: "ISO Country Code",
-  description: "Two-letter country code following ISO 3166-1 alpha-2 standard",
-  examples: ["BR", "US", "DE"]
-});
-var IsoAdministrativeDivisionCodeSchema = zod.z.string().regex(
-  /^[A-Z]{2}-[A-Z0-9]{1,3}$/,
-  "Must be a valid ISO 3166-2 administrative division code"
-).meta({
-  title: "ISO Administrative Division Code",
-  description: "Administrative division code following ISO 3166-2 standard",
-  examples: ["BR-AP", "BR-ES", "US-CA"]
-});
-var LatitudeSchema = zod.z.number().min(-90).max(90).multipleOf(1e-3).meta({
-  title: "Latitude",
-  description: "Geographic latitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level, non-PII compliance)",
-  examples: [-0.02, -20.38, 40.713]
-});
-var LongitudeSchema = zod.z.number().min(-180).max(180).multipleOf(1e-3).meta({
-  title: "Longitude",
-  description: "Geographic longitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level, non-PII compliance)",
-  examples: [-51.06, -40.34, -74.006]
-});
-var WeightKgSchema = zod.z.number().min(0).meta({
-  title: "Weight (kg)",
-  description: "Weight measurement in kilograms",
-  examples: [3e3, 1500, 500]
-});
 var NonEmptyStringSchema = zod.z.string().min(1, "Cannot be empty").meta({
   title: "Non-Empty String",
   description: "A string that contains at least one character",
@@ -98,14 +35,6 @@ var MethodologyNameSchema = NonEmptyStringSchema.max(100).meta({
   description: "Name of the methodology used for certification",
   examples: ["BOLD Recycling", "BOLD Carbon (CH\u2084)"]
 });
-var StringifiedTokenIdSchema = NonEmptyStringSchema.regex(
-  /^#\d+$/,
-  "Must match pattern #<token_id>"
-).meta({
-  title: "Token ID",
-  description: "Token ID represented as #<token_id>",
-  example: "#123"
-});
 var SlugSchema = NonEmptyStringSchema.regex(
   /^[a-z0-9-]+$/,
   "Must contain only lowercase letters, numbers, and hyphens"
@@ -119,16 +48,6 @@ var CollectionSlugSchema = SlugSchema.meta({
   description: "URL-friendly identifier for a collection",
   examples: ["bold-cold-start-carazinho", "bold-brazil"]
 });
-var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
-  title: "Waste Type",
-  description: "Category or type of waste material",
-  examples: ["Organic", "Plastic", "Metal"]
-});
-var WasteSubtypeSchema = NonEmptyStringSchema.max(100).meta({
-  title: "Waste Subtype",
-  description: "Specific subcategory of waste within a waste type",
-  examples: ["Food, Food Waste and Beverages", "PET Bottles", "Aluminum Cans"]
-});
 var ParticipantRoleSchema = NonEmptyStringSchema.max(100).meta({
   title: "Participant Role",
   description: "Role that a participant plays in the waste management supply chain",
@@ -139,29 +58,40 @@ var ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
   description: "Name of a participant in the waste management system",
   examples: ["Enlatados Produ\xE7\xE3o", "Eco Reciclagem", "Green Tech Corp"]
 });
-var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
-  title: "Chain ID",
-  description: "Blockchain network identifier",
-  examples: [137, 80002]
+var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Waste Type",
+  description: "Category or type of waste material",
+  examples: ["Organic", "Plastic", "Metal"]
 });
-var BlockchainNetworkNameSchema = NonEmptyStringSchema.max(100).meta({
-  title: "Blockchain Network Name",
-  description: "Name of the blockchain network",
-  examples: ["Polygon", "Amoy"]
+var WasteSubtypeSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Waste Subtype",
+  description: "Specific subcategory of waste within a waste type",
+  examples: ["Food, Food Waste and Beverages", "Domestic Sludge"]
 });
-var SmartContractAddressSchema = EthereumAddressSchema.meta({
-  title: "Smart Contract Address",
-  description: "Address of the smart contract"
+var CreditTypeSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Credit Type",
+  description: "Type of credit issued",
+  examples: ["Organic", "Carbon (CH\u2084)"]
 });
-var SmartContractSchema = zod.z.strictObject({
-  address: SmartContractAddressSchema,
-  chain_id: BlockchainChainIdSchema,
-  network_name: BlockchainNetworkNameSchema
-}).meta({
-  title: "Smart Contract",
-  description: "Smart contract details for on-chain references"
+var HexColorSchema = NonEmptyStringSchema.regex(
+  /^#[0-9A-F]{6}$/,
+  "Must be a hex color code with # prefix and uppercase"
+).meta({
+  title: "Hex Color",
+  description: "Hexadecimal color code with hash prefix",
+  examples: ["#2D5A27", "#FF5733"]
+});
+var NonNegativeFloatSchema = zod.z.number().min(0).meta({
+  title: "Non-Negative Float",
+  description: "Floating-point number that is zero or positive",
+  examples: [0, 45.2, 72.5]
+});
+var WeightKgSchema = NonNegativeFloatSchema.meta({
+  title: "Weight (kg)",
+  description: "Weight measurement in kilograms",
+  examples: [3e3, 1500, 500]
 });
-var PercentageSchema = zod.z.number().min(0).max(100).meta({
+var PercentageSchema = NonNegativeFloatSchema.max(100).meta({
   title: "Percentage",
   description: "Percentage value between 0 and 100",
   examples: [50, 75.5, 100]
@@ -176,48 +106,107 @@ var PositiveIntegerSchema = zod.z.number().int().min(1).meta({
   description: "Integer value that is greater than zero",
   examples: [1, 123, 456]
 });
-var NonNegativeFloatSchema = zod.z.number().min(0).meta({
-  title: "Non-Negative Float",
-  description: "Floating-point number that is zero or positive",
-  examples: [0, 45.2, 72.5]
-});
-var CreditTypeSchema = NonEmptyStringSchema.max(100).meta({
-  title: "Credit Type",
-  description: "Type of credit issued",
-  examples: ["Organic", "Carbon (CH\u2084)"]
-});
 var CreditAmountSchema = NonNegativeFloatSchema.meta({
   title: "Credit Amount",
   description: "Amount of credits issued"
 });
-var HoursSchema = zod.z.number().min(0).multipleOf(0.1).meta({
-  title: "Hours",
-  description: "Time duration in hours with 0.1 hour precision",
-  examples: [72.5, 24, 168.5]
+var IsoTimestampSchema = zod.z.string().datetime({
+  message: "Must be a valid ISO 8601 timestamp with timezone information",
+  offset: true
+}).meta({
+  title: "ISO Timestamp",
+  description: "ISO 8601 formatted timestamp with timezone information",
+  examples: ["2024-12-05T11:02:47.000Z"]
+});
+var IsoDateSchema = 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"]
 });
-var MinutesSchema = zod.z.number().int().min(0).meta({
-  title: "Minutes",
-  description: "Time duration in minutes",
-  examples: [4350, 1440, 10110]
+var UnixTimestampSchema = zod.z.number().int().positive().meta({
+  title: "Unix Timestamp",
+  description: "Unix timestamp in milliseconds since epoch (January 1, 1970 00:00:00 UTC)",
+  examples: [17040672e5]
 });
-var IpfsUriSchema = NonEmptyStringSchema.regex(
-  /^ipfs:\/\/[a-zA-Z0-9]+(\/.*)?$/,
-  "Must be a valid IPFS URI with CID"
+var IsoCountryCodeSchema = zod.z.string().regex(/^[A-Z]{2}$/, "Must be a valid ISO 3166-1 alpha-2 country code").meta({
+  title: "ISO Country Code",
+  description: "Two-letter country code following ISO 3166-1 alpha-2 standard",
+  examples: ["BR", "US", "DE"]
+});
+var IsoAdministrativeDivisionCodeSchema = zod.z.string().regex(
+  /^[A-Z]{2}-[A-Z0-9]{1,3}$/,
+  "Must be a valid ISO 3166-2 administrative division code"
 ).meta({
-  title: "IPFS URI",
-  description: "InterPlanetary File System URI pointing to distributed content",
-  examples: [
-    "ipfs://QmTy8w65yBXgyfG2ZBg5TrfB2hPjrDQH3RCQFJGkARStJb/mass-id-organic.png",
-    "ipfs://QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o"
-  ]
+  title: "ISO Administrative Division Code",
+  description: "Administrative division code following ISO 3166-2 standard",
+  examples: ["BR-AP", "BR-ES", "US-CA"]
 });
-var SemanticVersionSchema = NonEmptyStringSchema.regex(
-  /^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/,
-  "Must be a valid semantic version string"
+var LatitudeSchema = zod.z.number().min(-90).max(90).multipleOf(1e-3).meta({
+  title: "Latitude",
+  description: "Geographic latitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level)",
+  examples: [-0.02, -20.38, 40.713]
+});
+var LongitudeSchema = zod.z.number().min(-180).max(180).multipleOf(1e-3).meta({
+  title: "Longitude",
+  description: "Geographic longitude coordinate in decimal degrees with maximum 3 decimal places precision (~100m-1km accuracy for city-level)",
+  examples: [-51.06, -40.34, -74.006]
+});
+var BLOCKCHAIN_NETWORK_CONFIG = {
+  mainnet: { chain_id: 137, network_name: "Polygon" },
+  testnet: { chain_id: 80002, network_name: "Amoy" }
+};
+var ALLOWED_BLOCKCHAIN_NETWORKS = Object.values(
+  BLOCKCHAIN_NETWORK_CONFIG
+);
+var BLOCKCHAIN_CHAIN_IDS = [
+  BLOCKCHAIN_NETWORK_CONFIG.mainnet.chain_id,
+  BLOCKCHAIN_NETWORK_CONFIG.testnet.chain_id
+];
+var BLOCKCHAIN_NETWORK_NAMES = [
+  BLOCKCHAIN_NETWORK_CONFIG.mainnet.network_name,
+  BLOCKCHAIN_NETWORK_CONFIG.testnet.network_name
+];
+var EthereumAddressSchema = zod.z.string().regex(
+  /^0x[a-f0-9]{40}$/,
+  "Must be a valid Ethereum address in lowercase hexadecimal format"
 ).meta({
-  title: "Semantic Version",
-  description: "Version string following semantic versioning specification",
-  examples: ["0.1.0", "1.0.0", "2.1.3"]
+  title: "Ethereum Address",
+  description: "A valid Ethereum address in hexadecimal format",
+  examples: ["0x1234567890abcdef1234567890abcdef12345678"]
+});
+var BlockchainChainIdSchema = zod.z.union([
+  zod.z.literal(BLOCKCHAIN_NETWORK_CONFIG.mainnet.chain_id),
+  zod.z.literal(BLOCKCHAIN_NETWORK_CONFIG.testnet.chain_id)
+]).meta({
+  title: "Chain ID",
+  description: "Supported Polygon chain identifiers",
+  examples: BLOCKCHAIN_CHAIN_IDS
+});
+var BlockchainNetworkNameSchema = zod.z.enum(BLOCKCHAIN_NETWORK_NAMES).meta({
+  title: "Blockchain Network Name",
+  description: "Supported Polygon network names",
+  examples: BLOCKCHAIN_NETWORK_NAMES
+});
+var SmartContractAddressSchema = EthereumAddressSchema.meta({
+  title: "Smart Contract Address",
+  description: "Address of the smart contract"
+});
+var SmartContractSchema = zod.z.strictObject({
+  address: SmartContractAddressSchema,
+  chain_id: BlockchainChainIdSchema,
+  network_name: BlockchainNetworkNameSchema
+}).meta({
+  title: "Smart Contract",
+  description: "Smart contract details for on-chain references"
+});
+var UuidSchema = zod.z.uuidv4().meta({
+  title: "UUID V4",
+  description: "A universally unique identifier version 4",
+  examples: ["ad44dd3f-f176-4b98-bf78-5ee6e77d0530"]
+});
+var ExternalIdSchema = UuidSchema.meta({
+  title: "External ID",
+  description: "UUID identifier for external system references"
 });
 var TokenIdSchema = NonEmptyStringSchema.regex(
   /^\d+$/,
@@ -225,50 +214,52 @@ var TokenIdSchema = NonEmptyStringSchema.regex(
 ).meta({
   title: "Token ID",
   description: "Numeric identifier for blockchain tokens as string",
-  examples: ["123", "456789", "1000000"]
+  examples: ["456789", "1000000"]
 });
-var HexColorSchema = NonEmptyStringSchema.regex(
-  /^#[0-9A-F]{6}$/,
-  "Must be a hex color code with # prefix and uppercase"
+var StringifiedTokenIdSchema = NonEmptyStringSchema.regex(
+  /^#\d+$/,
+  "Must match pattern #<token_id>"
 ).meta({
-  title: "Hex Color",
-  description: "Hexadecimal color code with hash prefix",
-  examples: ["#2D5A27", "#FF5733", "#1E90FF"]
+  title: "Token ID",
+  description: "Token ID represented as #<token_id>",
+  example: "#123"
 });
 var Sha256HashSchema = zod.z.hash("sha256", {
   error: "Must be a SHA256 hash as 32-byte hex string"
 }).meta({
   format: void 0,
-  title: "SHA256 Hash",
+  title: "SHA-256 Hash",
   description: "SHA-256 cryptographic hash as hexadecimal string",
   examples: [
-    "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489",
-    "6e83b8e6373847bbdc056549bedda38dc88854ce41ba4fca11e0fc6ce3e07ef6"
+    "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489"
   ]
 });
-var Keccak256HashSchema = Sha256HashSchema.meta({
-  title: "Keccak256 Hash",
-  description: "Keccak256 cryptographic hash as hexadecimal string",
-  examples: [
-    "ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f",
-    "b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2"
-  ]
+var ExternalUrlSchema = zod.z.url().meta({
+  title: "External URL",
+  description: "URL pointing to external resources",
+  examples: ["https://explore.carrot.eco/", "https://whitepaper.carrot.eco/"]
 });
-var ExternalIdSchema = UuidSchema.meta({
-  title: "External ID",
-  description: "UUID identifier for external system references",
+var ipfsUriPattern = /^ipfs:\/\/(?:Qm[1-9A-HJ-NP-Za-km-z]{44}|[bB][a-z2-7]{58,}|[zZ][1-9A-HJ-NP-Za-km-z]{48,})(?:\/[^\s]*)?$/;
+var IpfsUriSchema = NonEmptyStringSchema.regex(
+  ipfsUriPattern,
+  "Must be a valid IPFS URI with CID"
+).meta({
+  title: "IPFS URI",
+  description: "InterPlanetary File System URI pointing to distributed content",
   examples: [
-    "ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "b2c4e6f8-a1b3-4c5d-9e8f-123456789abc"
+    "ipfs://bafybeigdyrztvzl5cceubvaxob7iqh6f3f7s36c74ojav2xsz2uib2g3vm/mass-id-organic.png",
+    "ipfs://bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku"
   ]
 });
-var ExternalUrlSchema = zod.z.url("Must be a valid URL").meta({
-  title: "External URL",
-  description: "Valid URL pointing to external resources",
-  examples: [
-    "https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
-    "https://carrot.eco/whitepaper.pdf"
-  ]
+
+// src/shared/schemas/primitives/version.schema.ts
+var SemanticVersionSchema = NonEmptyStringSchema.regex(
+  /^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/,
+  "Must be a valid semantic version string"
+).meta({
+  title: "Semantic Version",
+  description: "Version string following semantic versioning specification",
+  examples: ["0.1.0", "1.0.0", "2.1.3"]
 });
 var RecordSchemaTypeSchema = zod.z.enum([
   "MassID",
@@ -298,368 +289,21 @@ var CreditTokenSymbolSchema = TokenSymbolSchema.meta({
   description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
   examples: ["C-CARB", "C-BIOW"]
 });
-var RecordRelationshipTypeSchema = zod.z.enum([
-  "collection",
-  "credit",
-  "gas-id",
-  "mass-id",
-  "mass-id-audit",
-  "methodology",
-  "credit-purchase-receipt",
-  "credit-retirement-receipt",
-  "recycled-id"
-]).meta({
-  title: "Relationship Type",
-  description: "Type of relationship between different entities in the system",
-  examples: ["mass-id", "collection", "credit-purchase-receipt"]
-});
-function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
-  return zod.z.array(schema).refine((items) => new Set(items).size === items.length, {
-    message: errorMessage
-  });
-}
-function uniqueBy(schema, selector, errorMessage = "Items must be unique") {
-  return zod.z.array(schema).refine(
-    (items) => {
-      const values = items.map(selector);
-      return new Set(values).size === values.length;
-    },
-    {
-      message: errorMessage
-    }
-  );
-}
 
-// 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"
-  }),
-  name: ParticipantNameSchema.meta({
-    title: "Participant Name",
-    description: "Name of the participant"
+// src/shared/schemas/core/base.schema.ts
+var SchemaInfoSchema = zod.z.strictObject({
+  hash: Sha256HashSchema.meta({
+    title: "Schema Hash",
+    description: "SHA-256 hash of the JSON Schema this record was validated against"
   }),
-  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"
+  type: RecordSchemaTypeSchema,
+  version: SemanticVersionSchema.meta({
+    title: "Schema Version",
+    description: "Version of the schema, using semantic versioning"
   })
 }).meta({
-  title: "Participant",
-  description: "A participant in the waste management supply chain"
-});
-var PrecisionLevelSchema = zod.z.enum(["exact", "neighborhood", "city", "region", "country"]).meta({
-  title: "Coordinate Precision Level",
-  description: "Level of coordinate precision",
-  examples: ["city", "exact", "neighborhood"]
-});
-var CoordinatesSchema = zod.z.strictObject({
-  latitude: LatitudeSchema,
-  longitude: LongitudeSchema,
-  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: MunicipalitySchema,
-  administrative_division: AdministrativeDivisionSchema,
-  administrative_division_code: IsoAdministrativeDivisionCodeSchema.optional(),
-  country: CountryNameSchema,
-  country_code: IsoCountryCodeSchema,
-  responsible_participant_id_hash: Sha256HashSchema.meta({
-    title: "Responsible Participant ID Hash",
-    description: "Anonymized ID of the participant responsible for this location"
-  }),
-  coordinates: CoordinatesSchema
-}).meta({
-  title: "Location",
-  description: "Geographic location with address and coordinate information"
-});
-var MethodologyComplianceSchema = zod.z.enum(["PASSED", "FAILED"]).meta({
-  title: "Methodology Compliance",
-  description: "Result of methodology compliance check",
-  examples: ["PASSED", "FAILED"]
-});
-var AuditReferenceSchema = zod.z.strictObject({
-  date: IsoDateSchema.meta({
-    title: "Audit Date",
-    description: "Date when the audit was completed"
-  }),
-  external_id: ExternalIdSchema.meta({
-    title: "Audit External ID",
-    description: "Unique identifier for the audit"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Audit External URL",
-    description: "URL to view the audit on Carrot Explorer"
-  }),
-  methodology_compliance: MethodologyComplianceSchema.meta({
-    title: "Methodology Compliance",
-    description: "Result of methodology compliance check"
-  }),
-  rules_executed: NonNegativeIntegerSchema.meta({
-    title: "Rules Executed",
-    description: "Number of rules executed during the audit"
-  }),
-  report: IpfsUriSchema.meta({
-    title: "Audit Report",
-    description: "IPFS URI of the audit report"
-  })
-}).meta({
-  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"
-  }),
-  uri: IpfsUriSchema.meta({
-    title: "GasID IPFS URI",
-    description: "IPFS URI of the GasID record"
-  })
-}).meta({
-  title: "GasID Reference",
-  description: "Reference to a GasID record"
-});
-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"
-  }),
-  uri: IpfsUriSchema.meta({
-    title: "MassID IPFS URI",
-    description: "IPFS URI of the MassID record"
-  })
-}).meta({
-  title: "MassID Reference",
-  description: "Reference to a MassID record"
-});
-var MethodologyReferenceSchema = zod.z.strictObject({
-  external_id: ExternalIdSchema.meta({
-    title: "Methodology External ID",
-    description: "Unique identifier for the methodology"
-  }),
-  name: NonEmptyStringSchema.min(5).max(150).meta({
-    title: "Methodology Name",
-    description: "Human-readable name of the methodology",
-    examples: ["BOLD Carbon (CH\u2084)", "BOLD Recycling"]
-  }),
-  version: SemanticVersionSchema.meta({
-    title: "Methodology Version",
-    description: "Version of the methodology"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Methodology External URL",
-    description: "URL to view the methodology on Carrot Explorer"
-  }),
-  uri: IpfsUriSchema.optional().meta({
-    title: "Methodology IPFS URI",
-    description: "IPFS URI to the methodology record"
-  })
-}).meta({
-  title: "Methodology Reference",
-  description: "Reference to a methodology record"
-});
-var WasteClassificationSchema = zod.z.strictObject({
-  primary_type: WasteTypeSchema.meta({
-    title: "Source Waste Primary Type",
-    description: "Primary type of the source waste"
-  }),
-  subtype: WasteSubtypeSchema.meta({
-    title: "Source Waste Subtype",
-    description: "Subtype of the source waste"
-  }),
-  net_weight_kg: WeightKgSchema.meta({
-    title: "Source Waste Net Weight",
-    description: "Net weight of the source waste"
-  })
-}).meta({
-  title: "Waste Classification",
-  description: "Classification of the source waste (MassID)"
-});
-var AccreditedParticipantSchema = zod.z.strictObject({
-  participant_id: UuidSchema.meta({
-    title: "Participant ID",
-    description: "Unique identifier for the participant"
-  }),
-  name: ParticipantNameSchema.meta({
-    title: "Participant Name",
-    description: "Name of the participant"
-  }),
-  role: ParticipantRoleSchema.meta({
-    title: "Participant Role",
-    description: "Role of the participant in the supply chain"
-  }),
-  accreditation_id: UuidSchema.meta({
-    title: "Accreditation ID",
-    description: "Unique identifier for the participant accreditation"
-  }),
-  external_url: ExternalUrlSchema.meta({
-    title: "Participant Accreditation External URL",
-    description: "URL to view the participant accreditation on Carrot Explorer"
-  })
-}).meta({
-  title: "Accredited Participant",
-  description: "Participant with valid accreditation in the supply chain"
-});
-var AccreditedParticipantsSchema = zod.z.array(AccreditedParticipantSchema).min(1).meta({
-  title: "Accredited Participants",
-  description: "List of participants with valid accreditations"
-});
-var RewardAllocationSchema = zod.z.strictObject({
-  participant_id: UuidSchema.meta({
-    title: "Participant ID",
-    description: "Unique identifier for the participant receiving the reward"
-  }),
-  participant_name: ParticipantNameSchema.meta({
-    title: "Participant Name",
-    description: "Name of the participant receiving the reward"
-  }),
-  role: ParticipantRoleSchema.meta({
-    title: "Participant Role",
-    description: "Role of the participant in the supply chain"
-  }),
-  reward_percentage: PercentageSchema.meta({
-    title: "Reward Percentage",
-    description: "Reward percentage allocated to the participant"
-  }),
-  large_business_discount_applied: zod.z.boolean().optional().meta({
-    title: "Large Business Discount Applied",
-    description: "Whether the large business discount was applied"
-  }),
-  effective_percentage: PercentageSchema.meta({
-    title: "Effective Percentage",
-    description: "Effective percentage of the reward after discounts"
-  })
-}).meta({
-  title: "Reward Allocation",
-  description: "Reward allocation for a specific participant"
-});
-var DistributionNotesSchema = zod.z.strictObject({
-  large_business_discount_applied: NonEmptyStringSchema.optional().meta({
-    title: "Large Business Discount Applied",
-    description: "Description of the large business discount applied",
-    examples: [
-      "50% reduction applied to participants with >$4M annual revenue"
-    ]
-  }),
-  redirected_rewards: NonEmptyStringSchema.optional().meta({
-    title: "Redirected Rewards",
-    description: "Description of the redirected rewards",
-    examples: [
-      "Discounted rewards from large businesses redirected to accredited NGOs"
-    ]
-  })
-}).meta({
-  title: "Distribution Notes",
-  description: "Additional notes about the reward distribution"
-});
-var ParticipantRewardsSchema = zod.z.strictObject({
-  distribution_basis: NonEmptyStringSchema.max(200).meta({
-    title: "Distribution Basis",
-    description: "Basis for the rewards distribution"
-  }),
-  reward_allocations: zod.z.array(RewardAllocationSchema).min(1).meta({
-    title: "Reward Allocations",
-    description: "Rewards percentage allocated to each participant"
-  }),
-  distribution_notes: DistributionNotesSchema.optional().meta({
-    title: "Distribution Notes",
-    description: "Additional notes about the reward distribution"
-  })
-}).meta({
-  title: "Participant Rewards",
-  description: "Rewards distribution to participants"
-});
-var SchemaHashSchema = zod.z.union([
-  Keccak256HashSchema,
-  zod.z.string().regex(
-    /^0x[a-fA-F0-9]{64}$/,
-    "Must be a Keccak256 hash as 0x-prefixed hex string"
-  )
-]).meta({
-  title: "Schema Hash",
-  description: "Keccak256 hash of the JSON Schema this record was validated against",
-  examples: [
-    "ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f",
-    "0xac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f"
-  ]
-});
-var SchemaInfoSchema = zod.z.strictObject({
-  hash: SchemaHashSchema,
-  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"
+  title: "Schema Information",
+  description: "Information about the schema used to validate this record"
 });
 var RecordEnvironmentSchema = zod.z.strictObject({
   blockchain_network: zod.z.enum(["mainnet", "testnet"]).meta({
@@ -675,8 +319,8 @@ var RecordEnvironmentSchema = zod.z.strictObject({
     description: "Name of the data set for this record"
   })
 }).meta({
-  title: "Environment",
-  description: "Environment information"
+  title: "Record Environment",
+  description: "Environment information for the record"
 });
 var BaseIpfsSchema = zod.z.strictObject({
   $schema: zod.z.url("Must be a valid URI").meta({
@@ -686,17 +330,11 @@ var BaseIpfsSchema = zod.z.strictObject({
   }),
   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"
+    title: "Created At",
+    description: "ISO 8601 creation timestamp for this record"
   }),
+  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"
@@ -705,11 +343,6 @@ var BaseIpfsSchema = zod.z.strictObject({
     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",
@@ -719,6 +352,24 @@ var BaseIpfsSchema = zod.z.strictObject({
   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, {
+    message: errorMessage
+  });
+}
+function uniqueBy(schema, selector, errorMessage = "Items must be unique") {
+  return zod.z.array(schema).refine(
+    (items) => {
+      const values = items.map(selector);
+      return new Set(values).size === values.length;
+    },
+    {
+      message: errorMessage
+    }
+  );
+}
+
+// src/shared/schemas/core/nft.schema.ts
 var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   "MassID",
   "RecycledID",
@@ -730,31 +381,38 @@ var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   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"
-  }),
+  smart_contract_address: SmartContractAddressSchema,
+  chain_id: BlockchainChainIdSchema,
+  network_name: BlockchainNetworkNameSchema,
   token_id: TokenIdSchema.meta({
-    title: "Token ID",
     description: "NFT token ID"
   })
+}).superRefine((value, ctx) => {
+  const matchedNetwork = ALLOWED_BLOCKCHAIN_NETWORKS.find(
+    (network) => network.chain_id === value.chain_id && network.network_name === value.network_name
+  );
+  if (!matchedNetwork) {
+    ctx.addIssue({
+      code: "custom",
+      message: "chain_id and network_name must match a supported network: 137/Polygon (mainnet) or 80002/Amoy (testnet)",
+      path: ["chain_id"]
+    });
+    ctx.addIssue({
+      code: "custom",
+      message: "chain_id and network_name must match a supported network: 137/Polygon (mainnet) or 80002/Amoy (testnet)",
+      path: ["network_name"]
+    });
+  }
 }).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({
+  label: NonEmptyStringSchema.max(50).meta({
     title: "Link Label",
     description: "Display name for the external link"
   }),
-  url: zod.z.url("Must be a valid URI").meta({
+  url: ExternalUrlSchema.meta({
     title: "Link URL",
     description: "Direct URI to the linked resource"
   }),
@@ -767,7 +425,7 @@ var ExternalLinkSchema = zod.z.strictObject({
   description: "External link with label and description"
 });
 var NftAttributeSchema = zod.z.strictObject({
-  trait_type: zod.z.string().max(50).meta({
+  trait_type: NonEmptyStringSchema.max(50).meta({
     title: "Trait Type",
     description: "Name of the trait or attribute"
   }),
@@ -795,7 +453,7 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
     })
   }),
   blockchain: BlockchainReferenceSchema,
-  name: zod.z.string().min(1).max(100).meta({
+  name: NonEmptyStringSchema.max(100).meta({
     title: "NFT Name",
     description: "Full display name for this NFT, including extra context",
     examples: [
@@ -804,12 +462,12 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
       "GasID #789 \u2022 Methane \u2022 1000 m\xB3"
     ]
   }),
-  short_name: zod.z.string().min(1).max(50).meta({
+  short_name: NonEmptyStringSchema.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({
+  description: NonEmptyStringSchema.max(500).meta({
     title: "Description",
     description: "Human-readable summary of the NFT's role and context. Ideally, maximum 300 characters.",
     examples: [
@@ -829,31 +487,17 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
     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"
+      "ipfs://bafybeigdyrztvzl5cceubvaxob7iqh6f3f7s36c74ojav2xsz2uib2g3vm/mass-id-animation.mp4",
+      "ipfs://bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku/recycled-visualization.webm"
     ]
   }),
   external_links: uniqueBy(
     ExternalLinkSchema,
     (link) => link.url,
     "External link URLs must be unique"
-  ).max(10).optional().meta({
+  ).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"
-        }
-      ]
-    ]
+    description: "Optional list of public resource links with labels"
   }),
   attributes: uniqueBy(
     NftAttributeSchema,
@@ -861,48 +505,32 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
     "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"
-        }
-      ]
-    ]
+    description: "List of visual traits and filterable attributes compatible with NFT marketplaces"
   })
+}).superRefine((value, ctx) => {
+  const environmentNetwork = value.environment?.blockchain_network;
+  if (!environmentNetwork) {
+    return;
+  }
+  const config = BLOCKCHAIN_NETWORK_CONFIG[environmentNetwork];
+  if (value.blockchain.chain_id !== config.chain_id) {
+    ctx.addIssue({
+      code: "custom",
+      message: `blockchain.chain_id must be ${config.chain_id} when environment.blockchain_network is ${environmentNetwork}`,
+      path: ["blockchain", "chain_id"]
+    });
+  }
+  if (value.blockchain.network_name !== config.network_name) {
+    ctx.addIssue({
+      code: "custom",
+      message: `blockchain.network_name must be ${config.network_name} when environment.blockchain_network is ${environmentNetwork}`,
+      path: ["blockchain", "network_name"]
+    });
+  }
 }).meta({
   title: "NFT IPFS Record",
   description: "NFT-specific fields for Carrot IPFS records"
 });
-function getSchemaBaseUrl() {
-  return `https://raw.githubusercontent.com/carrot-foundation/schemas/refs/tags/${getSchemaVersionOrDefault()}/schemas/ipfs`;
-}
-function buildSchemaUrl(schemaPath) {
-  const cleanPath = schemaPath.startsWith("/") ? schemaPath.slice(1) : schemaPath;
-  return `${getSchemaBaseUrl()}/${cleanPath}`;
-}
-function getSchemaVersionOrDefault() {
-  return "0.1.40";
-}
 var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
   value: MethodologyNameSchema
@@ -965,121 +593,377 @@ var RecyclerAttributeSchema = NftAttributeSchema.safeExtend({
     example: "Eco Reciclagem"
   })
 }).meta({
-  title: "Recycler Attribute",
-  description: "Recycler attribute"
+  title: "Recycler Attribute",
+  description: "Recycler attribute"
+});
+var MassIDTokenIdAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("MassID"),
+  value: StringifiedTokenIdSchema.meta({
+    title: "MassID Token ID",
+    description: "Token ID of the source MassID NFT as #<token_id>"
+  })
+}).meta({
+  title: "MassID Token ID Attribute",
+  description: "MassID token ID attribute"
+});
+var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
+  max_value: true
+}).safeExtend({
+  trait_type: zod.z.literal("MassID Recycling Date"),
+  value: UnixTimestampSchema.meta({
+    title: "MassID Recycling Date",
+    description: "Unix timestamp in milliseconds when the source waste was recycled"
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "MassID Recycling Date Attribute",
+  description: "MassID recycling date attribute using Unix timestamp in milliseconds"
+});
+var MethodologyComplianceSchema = zod.z.enum(["PASSED", "FAILED"]).meta({
+  title: "Methodology Compliance",
+  description: "Result of methodology compliance check",
+  examples: ["PASSED", "FAILED"]
+});
+var AuditReferenceSchema = zod.z.strictObject({
+  date: IsoDateSchema.meta({
+    title: "Audit Date",
+    description: "Date when the audit was completed"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Audit External ID",
+    description: "Unique identifier for the audit"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Audit External URL",
+    description: "URL to view the audit on Carrot Explorer"
+  }),
+  methodology_compliance: MethodologyComplianceSchema.meta({
+    title: "Methodology Compliance",
+    description: "Result of methodology compliance check"
+  }),
+  rules_executed: NonNegativeIntegerSchema.meta({
+    title: "Rules Executed",
+    description: "Number of rules executed during the audit"
+  }),
+  report: IpfsUriSchema.meta({
+    title: "Audit Report",
+    description: "IPFS URI of the audit report"
+  })
+}).meta({
+  title: "Audit Reference",
+  description: "Reference to an audit record"
+});
+
+// src/shared/schemas/audit.schema.ts
+var AuditRuleDefinitionSchema = zod.z.strictObject({
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the audit rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  rule_name: NonEmptyStringSchema.max(100).meta({
+    title: "Rule Name",
+    description: "Human-readable name of the rule",
+    examples: ["Waste Mass is Unique", "No Conflicting GasID or Credit"]
+  }),
+  description: zod.z.string().min(10).max(500).meta({
+    title: "Rule Description",
+    description: "Detailed description of what the rule validates and why it is necessary",
+    examples: [
+      "Validates that each MassID is unique within the system to prevent duplicate entries"
+    ]
+  }),
+  source_code_url: zod.z.url().regex(/^https:\/\/github\.com\/.*$/, "Must be a GitHub URL").meta({
+    title: "Rule Source Code URL",
+    description: "GitHub URL pointing to the implementation source code for this rule",
+    examples: [
+      "https://github.com/carrot-foundation/methodologies/blob/main/bold-carbon/rules/waste-mass-unique.js"
+    ]
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule must be executed"
+  })
+}).meta({
+  title: "Audit Rule Definition",
+  description: "Definition of an audit rule that must be executed for methodology compliance"
+});
+var AuditRuleDefinitionsSchema = zod.z.array(AuditRuleDefinitionSchema).min(1).meta({
+  title: "Audit Rule Definitions",
+  description: "List of audit rules that must be executed to check methodology compliance"
+});
+var AuditRuleExecutionResultSchema = zod.z.strictObject({
+  rule_name: NonEmptyStringSchema.meta({
+    title: "Rule Name",
+    description: "Human-readable name of the audit rule"
+  }),
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule was executed"
+  }),
+  result: MethodologyComplianceSchema.meta({
+    title: "Rule Execution Result",
+    description: "Result of the rule execution"
+  }),
+  description: zod.z.string().min(1).max(2e3).meta({
+    title: "Rule Description",
+    description: "Detailed description of what this rule validates"
+  }),
+  rule_processor_checksum: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Processor Checksum",
+    description: "Checksum for rule processor integrity verification"
+  }),
+  rule_source_code_version: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Source Code Version",
+    description: "Version identifier for the rule source code"
+  })
+}).meta({
+  title: "Audit Rule Execution Result",
+  description: "Detailed result of an audit rule execution"
+});
+var AuditRuleExecutionResultsSchema = zod.z.array(AuditRuleExecutionResultSchema).meta({
+  title: "Audit Rule Execution Results",
+  description: "Detailed results of each audit rule execution"
+});
+var ParticipantSchema = zod.z.strictObject({
+  id_hash: Sha256HashSchema.meta({
+    title: "Participant ID Hash",
+    description: "Anonymized identifier for the participant"
+  }),
+  name: ParticipantNameSchema,
+  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"
+});
+var PrecisionLevelSchema = zod.z.enum(["city", "region", "country"]).meta({
+  title: "Coordinate Precision Level",
+  description: "Level of coordinate precision",
+  examples: ["city"]
+});
+var CoordinatesSchema = zod.z.strictObject({
+  latitude: LatitudeSchema,
+  longitude: LongitudeSchema,
+  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: MunicipalitySchema,
+  administrative_division: AdministrativeDivisionSchema,
+  administrative_division_code: IsoAdministrativeDivisionCodeSchema.optional(),
+  country: CountryNameSchema,
+  country_code: IsoCountryCodeSchema,
+  responsible_participant_id_hash: Sha256HashSchema.meta({
+    title: "Responsible Participant ID Hash",
+    description: "Anonymized ID of the participant responsible for this location"
+  }),
+  coordinates: CoordinatesSchema
+}).meta({
+  title: "Location",
+  description: "Geographic location with address and coordinate information"
+});
+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"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "GasID IPFS URI",
+    description: "IPFS URI of the GasID record"
+  })
+}).meta({
+  title: "GasID Reference",
+  description: "Reference to a GasID record"
 });
-var MassIDTokenIdAttributeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("MassID"),
-  value: StringifiedTokenIdSchema.meta({
+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: "Token ID of the source MassID NFT as #<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"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "MassID IPFS URI",
+    description: "IPFS URI of the MassID record"
   })
 }).meta({
-  title: "MassID Token ID Attribute",
-  description: "MassID token ID attribute"
+  title: "MassID Reference",
+  description: "Reference to a MassID record"
 });
-var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
-  max_value: true
-}).safeExtend({
-  trait_type: zod.z.literal("MassID Recycling Date"),
-  value: UnixTimestampSchema.meta({
-    title: "MassID Recycling Date",
-    description: "Unix timestamp in milliseconds when the source waste was recycled"
+var MethodologyReferenceSchema = zod.z.strictObject({
+  external_id: ExternalIdSchema.meta({
+    title: "Methodology External ID",
+    description: "Unique identifier for the methodology"
   }),
-  display_type: zod.z.literal("date")
+  name: NonEmptyStringSchema.min(5).max(150).meta({
+    title: "Methodology Name",
+    description: "Human-readable name of the methodology",
+    examples: ["BOLD Carbon (CH\u2084)", "BOLD Recycling"]
+  }),
+  version: SemanticVersionSchema.meta({
+    title: "Methodology Version",
+    description: "Version of the methodology"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Methodology External URL",
+    description: "URL to view the methodology on Carrot Explorer"
+  }),
+  uri: IpfsUriSchema.optional().meta({
+    title: "Methodology IPFS URI",
+    description: "IPFS URI to the methodology record"
+  })
 }).meta({
-  title: "MassID Recycling Date Attribute",
-  description: "MassID recycling date attribute using Unix timestamp in milliseconds"
+  title: "Methodology Reference",
+  description: "Reference to a methodology record"
 });
-var AuditRuleDefinitionSchema = zod.z.strictObject({
-  rule_id: UuidSchema.meta({
-    title: "Rule ID",
-    description: "Unique identifier for the audit rule"
+var WasteClassificationSchema = zod.z.strictObject({
+  primary_type: WasteTypeSchema.meta({
+    title: "Source Waste Primary Type",
+    description: "Primary type of the source waste"
   }),
-  rule_slug: SlugSchema.meta({
-    title: "Rule Slug",
-    description: "URL-friendly identifier for the rule"
+  subtype: WasteSubtypeSchema.meta({
+    title: "Source Waste Subtype",
+    description: "Subtype of the source waste"
   }),
-  rule_name: NonEmptyStringSchema.max(100).meta({
-    title: "Rule Name",
-    description: "Human-readable name of the rule",
-    examples: ["Waste Mass is Unique", "No Conflicting GasID or Credit"]
+  net_weight_kg: WeightKgSchema.meta({
+    title: "Source Waste Net Weight",
+    description: "Net weight of the source waste"
+  })
+}).meta({
+  title: "Waste Classification",
+  description: "Classification of the source waste (MassID)"
+});
+var AccreditedParticipantSchema = zod.z.strictObject({
+  participant_id: UuidSchema.meta({
+    title: "Participant ID",
+    description: "Unique identifier for the participant"
   }),
-  description: zod.z.string().min(10).max(500).meta({
-    title: "Rule Description",
-    description: "Detailed description of what the rule validates and why it is necessary",
-    examples: [
-      "Validates that each MassID is unique within the system to prevent duplicate entries"
-    ]
+  name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Name of the participant"
   }),
-  source_code_url: zod.z.url().regex(/^https:\/\/github\.com\/.*$/, "Must be a GitHub URL").meta({
-    title: "Rule Source Code URL",
-    description: "GitHub URL pointing to the implementation source code for this rule",
-    examples: [
-      "https://github.com/carrot-foundation/methodologies/blob/main/bold-carbon/rules/waste-mass-unique.js"
-    ]
+  role: ParticipantRoleSchema.meta({
+    title: "Participant Role",
+    description: "Role of the participant in the supply chain"
   }),
-  mandatory: zod.z.boolean().meta({
-    title: "Mandatory",
-    description: "Whether this rule is mandatory for methodology compliance"
+  accreditation_id: UuidSchema.meta({
+    title: "Accreditation ID",
+    description: "Unique identifier for the participant accreditation"
   }),
-  execution_order: PositiveIntegerSchema.meta({
-    title: "Rule Execution Order",
-    description: "Sequential order in which this rule must be executed"
+  external_url: ExternalUrlSchema.meta({
+    title: "Participant Accreditation External URL",
+    description: "URL to view the participant accreditation on Carrot Explorer"
   })
 }).meta({
-  title: "Audit Rule Definition",
-  description: "Definition of an audit rule that must be executed for methodology compliance"
+  title: "Accredited Participant",
+  description: "Participant with valid accreditation in the supply chain"
 });
-var AuditRuleDefinitionsSchema = zod.z.array(AuditRuleDefinitionSchema).min(1).meta({
-  title: "Audit Rule Definitions",
-  description: "List of audit rules that must be executed to check methodology compliance"
+var AccreditedParticipantsSchema = zod.z.array(AccreditedParticipantSchema).min(1).meta({
+  title: "Accredited Participants",
+  description: "List of participants with valid accreditations"
 });
-var AuditRuleExecutionResultSchema = zod.z.strictObject({
-  rule_name: NonEmptyStringSchema.meta({
-    title: "Rule Name",
-    description: "Human-readable name of the audit rule"
-  }),
-  rule_id: UuidSchema.meta({
-    title: "Rule ID",
-    description: "Unique identifier for the rule"
+var RewardAllocationSchema = zod.z.strictObject({
+  participant_id: UuidSchema.meta({
+    title: "Participant ID",
+    description: "Unique identifier for the participant receiving the reward"
   }),
-  rule_slug: SlugSchema.meta({
-    title: "Rule Slug",
-    description: "URL-friendly identifier for the rule"
+  participant_name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Name of the participant receiving the reward"
   }),
-  execution_order: PositiveIntegerSchema.meta({
-    title: "Rule Execution Order",
-    description: "Sequential order in which this rule was executed"
+  role: ParticipantRoleSchema.meta({
+    title: "Participant Role",
+    description: "Role of the participant in the supply chain"
   }),
-  result: MethodologyComplianceSchema.meta({
-    title: "Rule Execution Result",
-    description: "Result of the rule execution"
+  reward_percentage: PercentageSchema.meta({
+    title: "Reward Percentage",
+    description: "Reward percentage allocated to the participant"
   }),
-  description: zod.z.string().min(1).max(2e3).meta({
-    title: "Rule Description",
-    description: "Detailed description of what this rule validates"
+  large_business_discount_applied: zod.z.boolean().optional().meta({
+    title: "Large Business Discount Applied",
+    description: "Whether the large business discount was applied"
   }),
-  rule_processor_checksum: NonEmptyStringSchema.max(200).meta({
-    title: "Rule Processor Checksum",
-    description: "Checksum for rule processor integrity verification"
+  effective_percentage: PercentageSchema.meta({
+    title: "Effective Percentage",
+    description: "Effective percentage of the reward after discounts"
+  })
+}).meta({
+  title: "Reward Allocation",
+  description: "Reward allocation for a specific participant"
+});
+var DistributionNotesSchema = zod.z.strictObject({
+  large_business_discount_applied: NonEmptyStringSchema.optional().meta({
+    title: "Large Business Discount Applied",
+    description: "Description of the large business discount applied",
+    examples: [
+      "50% reduction applied to participants with >$4M annual revenue"
+    ]
   }),
-  rule_source_code_version: NonEmptyStringSchema.max(200).meta({
-    title: "Rule Source Code Version",
-    description: "Version identifier for the rule source code"
+  redirected_rewards: NonEmptyStringSchema.optional().meta({
+    title: "Redirected Rewards",
+    description: "Description of the redirected rewards",
+    examples: [
+      "Discounted rewards from large businesses redirected to accredited NGOs"
+    ]
   })
 }).meta({
-  title: "Audit Rule Execution Result",
-  description: "Detailed result of an audit rule execution"
+  title: "Distribution Notes",
+  description: "Additional notes about the reward distribution"
 });
-var AuditRuleExecutionResultsSchema = zod.z.array(AuditRuleExecutionResultSchema).meta({
-  title: "Audit Rule Execution Results",
-  description: "Detailed results of each audit rule execution"
+var ParticipantRewardsSchema = zod.z.strictObject({
+  distribution_basis: NonEmptyStringSchema.max(200).meta({
+    title: "Distribution Basis",
+    description: "Basis for the rewards distribution"
+  }),
+  reward_allocations: zod.z.array(RewardAllocationSchema).min(1).meta({
+    title: "Reward Allocations",
+    description: "Rewards percentage allocated to each participant"
+  }),
+  distribution_notes: DistributionNotesSchema.optional().meta({
+    title: "Distribution Notes",
+    description: "Additional notes about the reward distribution"
+  })
+}).meta({
+  title: "Participant Rewards",
+  description: "Rewards distribution to participants"
 });
-var EPSILON = 1e-9;
-function nearlyEqual(a, b, epsilon = EPSILON) {
-  return Math.abs(a - b) <= epsilon;
-}
 var SummaryBaseSchema = zod.z.strictObject({
   total_certificates: PositiveIntegerSchema.meta({
     title: "Total Certificates",
@@ -1251,8 +1135,22 @@ function createReceiptCertificateSchema(params) {
     ...params.additionalShape
   }).meta(params.meta);
 }
+function getSchemaBaseUrl() {
+  return `https://raw.githubusercontent.com/carrot-foundation/schemas/refs/tags/${getSchemaVersionOrDefault()}/schemas/ipfs`;
+}
+function buildSchemaUrl(schemaPath) {
+  const cleanPath = schemaPath.startsWith("/") ? schemaPath.slice(1) : schemaPath;
+  return `${getSchemaBaseUrl()}/${cleanPath}`;
+}
+function getSchemaVersionOrDefault() {
+  return "0.1.42";
+}
 
-// src/shared/receipt/receipt.validation.ts
+// src/shared/schema-validation.ts
+var EPSILON = 1e-9;
+function nearlyEqual(a, b, epsilon = EPSILON) {
+  return Math.abs(a - b) <= epsilon;
+}
 function buildMessage(message, value) {
   return typeof message === "function" ? message(value) : message;
 }
@@ -2171,8 +2069,17 @@ var GasIDIpfsSchema = NftIpfsSchema.safeExtend({
       description: "GasID NFT schema type"
     })
   }),
-  attributes: GasIDAttributesSchema,
   data: GasIDDataSchema
+}).superRefine((value, ctx) => {
+  const attributesResult = GasIDAttributesSchema.safeParse(value.attributes);
+  if (!attributesResult.success) {
+    attributesResult.error.issues.forEach((issue) => {
+      ctx.addIssue({
+        ...issue,
+        path: ["attributes", ...issue.path ?? []]
+      });
+    });
+  }
 }).meta(GasIDIpfsSchemaMeta);
 var RecycledIDAttributeMethodologySchema = MethodologyAttributeSchema;
 var RecycledIDAttributeRecycledMassWeightSchema = NftAttributeSchema.safeExtend({
@@ -2251,8 +2158,19 @@ var RecycledIDIpfsSchema = NftIpfsSchema.safeExtend({
       description: "RecycledID NFT schema type"
     })
   }),
-  attributes: RecycledIDAttributesSchema,
   data: RecycledIDDataSchema
+}).superRefine((value, ctx) => {
+  const attributesResult = RecycledIDAttributesSchema.safeParse(
+    value.attributes
+  );
+  if (!attributesResult.success) {
+    attributesResult.error.issues.forEach((issue) => {
+      ctx.addIssue({
+        ...issue,
+        path: ["attributes", ...issue.path ?? []]
+      });
+    });
+  }
 }).meta(RecycledIDIpfsSchemaMeta);
 var CreditPurchaseReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: TokenSymbolSchema.meta({
@@ -3343,7 +3261,9 @@ var CollectionSchema = BaseIpfsSchema.safeExtend({
   image: IpfsUriSchema.meta({
     title: "Collection Image",
     description: "IPFS URI pointing to the collection's visual representation",
-    examples: ["ipfs://QmCollectionImageHash/collection-icon.png"]
+    examples: [
+      "ipfs://bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku/collection-icon.png"
+    ]
   }),
   description: zod.z.string().min(50).max(1e3).meta({
     title: "Collection Description",
@@ -3385,7 +3305,9 @@ var CreditSchema = BaseIpfsSchema.safeExtend({
   image: IpfsUriSchema.meta({
     title: "Token Image",
     description: "IPFS URI pointing to the token's visual representation image",
-    examples: ["ipfs://QmTokenImageHash/credit-icon.png"]
+    examples: [
+      "ipfs://bafybeigdyrztvzl5cceubvaxob7iqh6f3f7s36c74ojav2xsz2uib2g3vm/credit-icon.png"
+    ]
   }),
   description: zod.z.string().min(50).max(1e3).meta({
     title: "Token Description",
@@ -3508,6 +3430,7 @@ var MassIDAuditSchema = BaseIpfsSchema.safeExtend({
   data: MassIDAuditDataSchema
 }).meta(MassIDAuditSchemaMeta);
 
+exports.ALLOWED_BLOCKCHAIN_NETWORKS = ALLOWED_BLOCKCHAIN_NETWORKS;
 exports.AccreditedParticipantSchema = AccreditedParticipantSchema;
 exports.AccreditedParticipantsSchema = AccreditedParticipantsSchema;
 exports.AdministrativeDivisionSchema = AdministrativeDivisionSchema;
@@ -3516,6 +3439,7 @@ exports.AuditRuleDefinitionSchema = AuditRuleDefinitionSchema;
 exports.AuditRuleDefinitionsSchema = AuditRuleDefinitionsSchema;
 exports.AuditRuleExecutionResultSchema = AuditRuleExecutionResultSchema;
 exports.AuditRuleExecutionResultsSchema = AuditRuleExecutionResultsSchema;
+exports.BLOCKCHAIN_NETWORK_CONFIG = BLOCKCHAIN_NETWORK_CONFIG;
 exports.BaseIpfsSchema = BaseIpfsSchema;
 exports.BlockchainChainIdSchema = BlockchainChainIdSchema;
 exports.BlockchainNetworkNameSchema = BlockchainNetworkNameSchema;
@@ -3553,14 +3477,12 @@ exports.GasIDIpfsSchema = GasIDIpfsSchema;
 exports.GasIDIpfsSchemaMeta = GasIDIpfsSchemaMeta;
 exports.GasIDReferenceSchema = GasIDReferenceSchema;
 exports.HexColorSchema = HexColorSchema;
-exports.HoursSchema = HoursSchema;
 exports.IbamaWasteClassificationSchema = IbamaWasteClassificationSchema;
 exports.IpfsUriSchema = IpfsUriSchema;
 exports.IsoAdministrativeDivisionCodeSchema = IsoAdministrativeDivisionCodeSchema;
 exports.IsoCountryCodeSchema = IsoCountryCodeSchema;
 exports.IsoDateSchema = IsoDateSchema;
 exports.IsoTimestampSchema = IsoTimestampSchema;
-exports.Keccak256HashSchema = Keccak256HashSchema;
 exports.LatitudeSchema = LatitudeSchema;
 exports.LocationSchema = LocationSchema;
 exports.LongitudeSchema = LongitudeSchema;
@@ -3582,7 +3504,6 @@ exports.MethodologyNameSchema = MethodologyNameSchema;
 exports.MethodologyReferenceSchema = MethodologyReferenceSchema;
 exports.MethodologySchema = MethodologySchema;
 exports.MethodologySchemaMeta = MethodologySchemaMeta;
-exports.MinutesSchema = MinutesSchema;
 exports.MunicipalitySchema = MunicipalitySchema;
 exports.NftAttributeSchema = NftAttributeSchema;
 exports.NftIpfsSchema = NftIpfsSchema;
@@ -3599,7 +3520,6 @@ exports.PercentageSchema = PercentageSchema;
 exports.PositiveIntegerSchema = PositiveIntegerSchema;
 exports.ReceiptIdentitySchema = ReceiptIdentitySchema;
 exports.RecordEnvironmentSchema = RecordEnvironmentSchema;
-exports.RecordRelationshipTypeSchema = RecordRelationshipTypeSchema;
 exports.RecordSchemaTypeSchema = RecordSchemaTypeSchema;
 exports.RecycledIDAttributesSchema = RecycledIDAttributesSchema;
 exports.RecycledIDDataSchema = RecycledIDDataSchema;