@carrot-foundation/schemas 0.1.41 → 0.1.43

package/dist/index.cjs

@@ -3,82 +3,14 @@
 var zod = require('zod');
 require('fs');
 require('path');
+var crypto = require('crypto');
+var canonicalize = require('canonicalize');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var canonicalize__default = /*#__PURE__*/_interopDefault(canonicalize);
 
 // src/mass-id/mass-id.attributes.ts
-var nativeDateParse = Date.parse.bind(Date);
-var ISO_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
-var UuidSchema = zod.z.uuidv4().meta({
-  title: "UUID V4",
-  description: "A universally unique identifier version 4",
-  examples: ["ad44dd3f-f176-4b98-bf78-5ee6e77d0530"]
-});
-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"]
-});
-var IsoTimestampSchema = zod.z.string().regex(
-  ISO_TIMESTAMP_REGEX,
-  "Must be a valid ISO 8601 timestamp with timezone information"
-).superRefine((value, ctx) => {
-  const parsed = nativeDateParse(value);
-  if (Number.isNaN(parsed)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Must be a valid ISO 8601 timestamp with timezone information"
-    });
-  }
-}).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 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 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)",
-  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 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 NonEmptyStringSchema = zod.z.string().min(1, "Cannot be empty").meta({
   title: "Non-Empty String",
   description: "A string that contains at least one character",
@@ -109,14 +41,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"
@@ -130,16 +54,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", "Domestic Sludge"]
-});
 var ParticipantRoleSchema = NonEmptyStringSchema.max(100).meta({
   title: "Participant Role",
   description: "Role that a participant plays in the waste management supply chain",
@@ -150,27 +64,38 @@ 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.union([zod.z.literal(137), zod.z.literal(80002)]).meta({
-  title: "Chain ID",
-  description: "Supported Polygon chain identifiers",
-  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 = zod.z.enum(["Polygon", "Amoy"]).meta({
-  title: "Blockchain Network Name",
-  description: "Supported Polygon network names",
-  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 = NonNegativeFloatSchema.max(100).meta({
   title: "Percentage",
@@ -187,43 +112,107 @@ var PositiveIntegerSchema = zod.z.number().int().min(1).meta({
   description: "Integer value that is greater than zero",
   examples: [1, 123, 456]
 });
-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 MinutesSchema = NonNegativeIntegerSchema.meta({
-  title: "Minutes",
-  description: "Time duration in minutes",
-  examples: [4350, 1440, 10110]
+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 IpfsUriSchema = NonEmptyStringSchema.regex(
-  /^ipfs:\/\/[a-zA-Z0-9]+(\/.*)?$/,
-  "Must be a valid IPFS URI with CID"
+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 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+$/,
@@ -233,16 +222,16 @@ var TokenIdSchema = NonEmptyStringSchema.regex(
   description: "Numeric identifier for blockchain tokens as string",
   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"]
+  title: "Token ID",
+  description: "Token ID represented as #<token_id>",
+  example: "#123"
 });
 var Sha256HashSchema = zod.z.hash("sha256", {
-  error: "Must be a SHA-256 hash as 32-byte hex string"
+  error: "Must be a SHA256 hash as 32-byte hex string"
 }).meta({
   format: void 0,
   title: "SHA-256 Hash",
@@ -251,18 +240,33 @@ var Sha256HashSchema = zod.z.hash("sha256", {
     "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489"
   ]
 });
-var ExternalIdSchema = UuidSchema.meta({
-  title: "External ID",
-  description: "UUID identifier for external system references"
-});
 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 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: [
-    "https://explore.carrot.eco/",
-    "https://https://whitepaper.carrot.eco/"
+    "ipfs://bafybeigdyrztvzl5cceubvaxob7iqh6f3f7s36c74ojav2xsz2uib2g3vm/mass-id-organic.png",
+    "ipfs://bafybeihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku"
   ]
 });
+
+// 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",
   "MassID Audit",
@@ -278,308 +282,26 @@ var RecordSchemaTypeSchema = zod.z.enum([
   description: "Type of schema in the Carrot ecosystem",
   examples: ["MassID", "RecycledID", "GasID"]
 });
-var TokenSymbolSchema = NonEmptyStringSchema.max(10).regex(
-  /^[A-Z0-9-]+$/,
-  "Must contain only uppercase letters, numbers, and hyphens"
-).meta({
-  title: "Token Symbol",
-  description: "Symbol representing a token or cryptocurrency",
-  examples: ["MASS", "REC", "GAS"]
-});
-var CreditTokenSymbolSchema = TokenSymbolSchema.meta({
-  title: "Credit Token Symbol",
-  description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
-  examples: ["C-CARB", "C-BIOW"]
-});
-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"
-  }),
-  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 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 TokenSymbolSchema = NonEmptyStringSchema.max(10).regex(
+  /^[A-Z0-9-]+$/,
+  "Must contain only uppercase letters, numbers, and hyphens"
+).meta({
+  title: "Token Symbol",
+  description: "Symbol representing a token or cryptocurrency",
+  examples: ["MASS", "REC", "GAS"]
 });
-var SchemaHashSchema = Sha256HashSchema.meta({
-  title: "Schema Hash",
-  description: "SHA-256 hash of the JSON Schema this record was validated against"
+var CreditTokenSymbolSchema = TokenSymbolSchema.meta({
+  title: "Credit Token Symbol",
+  description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
+  examples: ["C-CARB", "C-BIOW"]
 });
+
+// src/shared/schemas/core/base.schema.ts
 var SchemaInfoSchema = zod.z.strictObject({
-  hash: SchemaHashSchema,
+  hash: Sha256HashSchema.meta({
+    title: "Schema Hash",
+    description: "SHA-256 hash of the JSON Schema this record was validated against"
+  }),
   type: RecordSchemaTypeSchema,
   version: SemanticVersionSchema.meta({
     title: "Schema Version",
@@ -636,11 +358,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"
 });
-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);
+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",
@@ -652,16 +387,10 @@ 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"
-  }),
+  smart_contract_address: SmartContractAddressSchema,
+  chain_id: BlockchainChainIdSchema,
   network_name: BlockchainNetworkNameSchema,
   token_id: TokenIdSchema.meta({
-    title: "Token ID",
     description: "NFT token ID"
   })
 }).superRefine((value, ctx) => {
@@ -685,11 +414,11 @@ var BlockchainReferenceSchema = zod.z.strictObject({
   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"
   }),
@@ -702,7 +431,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"
   }),
@@ -730,7 +459,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: [
@@ -739,12 +468,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: [
@@ -764,31 +493,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,
@@ -796,33 +511,7 @@ 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;
@@ -848,16 +537,6 @@ var NftIpfsSchema = BaseIpfsSchema.safeExtend({
   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.41";
-}
 var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
   value: MethodologyNameSchema
@@ -920,117 +599,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"
   }),
-  execution_order: PositiveIntegerSchema.meta({
-    title: "Rule Execution Order",
-    description: "Sequential order in which this rule must be executed"
+  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: "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",
@@ -1202,8 +1141,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.43";
+}
 
-// 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;
 }
@@ -1352,6 +1305,20 @@ function validateAttributesForItems(params) {
     }
   });
 }
+function canonicalizeForHash(value) {
+  const canonical = canonicalize__default.default(value);
+  if (canonical === void 0) {
+    throw new TypeError("Value is not serializable to canonical JSON");
+  }
+  return canonical;
+}
+function hashCanonicalJson(canonicalJson) {
+  return crypto.createHash("sha256").update(canonicalJson, "utf8").digest("hex");
+}
+function hashObject(value) {
+  const canonical = canonicalizeForHash(value);
+  return hashCanonicalJson(canonical);
+}
 var IbamaWasteClassificationSchema = zod.z.string().regex(/^\d{2} \d{2} \d{2}\*?$/, "Invalid Ibama code format").meta({
   title: "Ibama Classification Code",
   description: "Ibama waste classification code in the format NN NN NN with required spaces and optional trailing *",
@@ -2122,8 +2089,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({
@@ -2202,8 +2178,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({
@@ -3294,7 +3281,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",
@@ -3336,7 +3325,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",
@@ -3459,6 +3450,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;
@@ -3467,6 +3459,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;
@@ -3504,7 +3497,6 @@ exports.GasIDIpfsSchema = GasIDIpfsSchema;
 exports.GasIDIpfsSchemaMeta = GasIDIpfsSchemaMeta;
 exports.GasIDReferenceSchema = GasIDReferenceSchema;
 exports.HexColorSchema = HexColorSchema;
-exports.HoursSchema = HoursSchema;
 exports.IbamaWasteClassificationSchema = IbamaWasteClassificationSchema;
 exports.IpfsUriSchema = IpfsUriSchema;
 exports.IsoAdministrativeDivisionCodeSchema = IsoAdministrativeDivisionCodeSchema;
@@ -3532,7 +3524,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;
@@ -3573,12 +3564,15 @@ exports.WasteSubtypeSchema = WasteSubtypeSchema;
 exports.WasteTypeSchema = WasteTypeSchema;
 exports.WeightKgSchema = WeightKgSchema;
 exports.buildSchemaUrl = buildSchemaUrl;
+exports.canonicalizeForHash = canonicalizeForHash;
 exports.createAttributeMap = createAttributeMap;
 exports.createReceiptCertificateSchema = createReceiptCertificateSchema;
 exports.createReceiptCollectionSchema = createReceiptCollectionSchema;
 exports.createReceiptCreditSchema = createReceiptCreditSchema;
 exports.getSchemaBaseUrl = getSchemaBaseUrl;
 exports.getSchemaVersionOrDefault = getSchemaVersionOrDefault;
+exports.hashCanonicalJson = hashCanonicalJson;
+exports.hashObject = hashObject;
 exports.nearlyEqual = nearlyEqual;
 exports.uniqueArrayItems = uniqueArrayItems;
 exports.uniqueBy = uniqueBy;