Skip to content
ZJ

Case study /11 · Delivered

Guardian Methodology Digitization

Blockchain · Carbon Markets · Digital MRV

Digitizing carbon methodologies — VM0048, VM0033 and MECD — into executable, auditable Guardian policies that mint verifiable credits.

Carbon methodologies live as long PDF documents written for human auditors. This work turned three of them — VM0048 (reducing emissions from deforestation), VM0033 (tidal wetland and seagrass restoration) and the MECD methodology — into executable Guardian policies: digital workflows where every monitoring value, calculation and approval becomes a verifiable, on-chain-anchored record.

  • Hedera Guardian
  • Hedera Hashgraph
  • TypeScript
  • Node.js
  • JSON Schema
  • W3C DID / VC
  • IPFS
  • Policy workflows
  • Digital MRV
  • Carbon accounting
Guardian methodology digitization flow: methodology analysis and schema design become a Guardian policy workflow, where DID-signed submissions feed unit-tested calculation modules, verification anchors to Hedera and verified reductions mint as credits.

Context

The carbon market's core problem is trust: buyers can't independently verify what a credit represents. Digital MRV (measurement, reporting and verification) attacks that by making the entire evidence chain — from field data to issued credit — machine-checkable. Hedera Guardian is the open-source platform for this: methodologies become policy workflow graphs, data becomes schema-validated verifiable credentials, and verified emission reductions mint as tokens.

Problem

Methodology digitization is a translation problem with zero tolerance for drift. The source documents mix prose, equations, eligibility rules and monitoring requirements designed for expert judgment. Encode them too loosely and the digital policy certifies things the methodology never allowed; too rigidly and legitimate projects can't pass. Every modeling decision had to be defensible against the original text.

Constraints

  • Methodology fidelity was absolute: the digital policy must implement the written methodology, not an interpretation of it.
  • Multi-role workflows — project proponent, validator/verifier (VVB), standard registry — each with distinct permissions and approval gates.
  • Every artifact needed cryptographic provenance: who submitted it, who approved it, against which schema version.
  • The Guardian platform itself evolves quickly; policies had to survive version upgrades.

Responsibilities

  • Methodology analysis: decomposing VM0048, VM0033 and MECD into data requirements, calculations, roles and decision points.
  • JSON Schema design for monitoring parameters, project descriptions and verification reports.
  • Policy workflow implementation in Guardian — block graphs wiring roles, forms, approvals and calculations.
  • Calculation modules for baselines, emission reductions and uncertainty deductions, tested against the methodologies' worked examples.
  • Verifiable-credential chains (W3C DID/VC) linking every step of the MRV trail.
  • Token mint integration so verified reductions issue as credits on Hedera.

Architecture

  • Each methodology compiles to a Guardian policy: a graph of workflow blocks where documents flow between roles through schema-validated forms and approval gates.
  • Monitoring data models are versioned JSON Schemas; submissions become verifiable credentials signed by the submitting role's DID.
  • Calculation blocks derive baselines and emission reductions from credentialed inputs, so every number traces to signed source data.
  • Artifacts and evidence anchor to Hedera topics (with large files referenced via IPFS), producing an immutable, independently checkable audit trail.
  • Final verification triggers token minting — issued credits carry the full credential chain that justified them.

Key decisions

  • Equations became isolated, unit-tested calculation modules validated against the methodologies' own worked examples — the only defensible proof of fidelity.
  • Where a methodology requires expert judgment, the policy models an explicit human approval gate rather than pretending the judgment can be automated.
  • Schema versioning from day one: monitoring requirements change, and in-flight projects must keep validating against the version they started under.
  • Ambiguities discovered during digitization were documented and resolved with methodology stakeholders, not silently interpreted in code.

Implementation

  • VM0048 policy flows cover project eligibility, deforestation baselines and leakage handling through role-gated submission and verification rounds.
  • VM0033 flows model wetland restoration monitoring across carbon pools and reporting intervals, with schema-enforced parameter completeness.
  • MECD flows digitize device deployment and usage monitoring with recurring monitoring-report cycles.
  • Policies were exercised end-to-end in dry-run mode — registration through mint — before any real project data entered the system.
  • Worked-example test suites pin calculation outputs so platform or policy upgrades can't silently change issued quantities.

Performance

  • Large evidence files stay off-chain behind IPFS references; Hedera anchors stay small and cheap.
  • Schema validation happens at submission time, so bad data fails fast at the edge instead of surfacing mid-verification.
  • Batched anchoring keeps policy execution responsive during heavy submission periods.

Outcomes

  • Three methodologies executable end-to-end: project registration through verified credit minting, with a complete credential chain behind every token.
  • Calculation modules reproduce the methodologies' worked examples exactly — fidelity is demonstrated, not asserted.
  • The digitized policies turn weeks of document-shuffling MRV into structured, auditable workflow.
  • [PLACEHOLDER — add issued-credit volumes and program details when publishable.]

Lessons

  • Methodology digitization is spec work: the methodology authors' intent is the spec, and every deviation must be visible.
  • Digitizing a document exposes its ambiguities — resolving them with stakeholders is half the value delivered.
  • In trust infrastructure, the audit trail is the product; the workflow is just how it gets built.

Software Architecture

Seven-stage flow from a written methodology to a credit with a verifiable evidence chain. 1. Methodology analysis: decompose VM0048, VM0033 and MECD into data requirements, calculations, roles and decision points, raising ambiguities rather than guessing. 2. Schema design: monitoring parameters become JSON Schema, versioned from day one with explicit completeness, so in-flight projects stay pinned to the version they started under. 3. Policy workflow: a Guardian block graph wires proponent, validator/verifier and standard registry through forms and approval gates, keeping expert judgment human. 4. Data submission: field data is signed by its submitter as a DID-backed credential, schema-validated at the edge so bad data fails fast. 5. Calculation modules: baselines and emission reductions derive from signed inputs through unit-tested equations, with the methodologies' worked examples pinning outputs so every number is traceable. 6. Verify and anchor: approval rounds are recorded immutably against Hedera topics, with IPFS holding large evidence, making the trail independently checkable. 7. Token mint: verified reductions issue as credits carrying the credential chain that justified them. A schema-version pinning loop protects in-flight projects when requirements change, and an MRV trail band records who submitted, who approved, against which schema version and which calculation produced the number.
Architecture diagram in four columns. Methodology inputs: source documents VM0048, VM0033 and MECD, equations for baselines and uncertainty, eligibility rules defining project criteria and scope, and worked examples serving as the fidelity test suite. Digitized policy: versioned JSON Schema parameter models, Guardian workflow blocks forming the policy graph, role gates for proponent, validator/verifier and registry, and isolated unit-tested calculation modules. Trust layer: DID identities one per workflow role, verifiable credentials for signed submissions, schema validation enforced at submission time, and approval records capturing who approved what and when. Anchoring and issuance: Hedera topics as immutable, cheap anchors, IPFS references keeping large evidence off-chain, token mint issuing verified reductions, and a credential chain that travels with the credit. A closing band covers upgrade safety: schema versioning, worked-example test suites, dry-run policy execution and issued quantities that cannot drift.