CarbonProof

The problem

Carbon credits are a promise: one credit = one tonne of CO₂e reduced or removed, counted once. That promise is routinely broken. The same tonne can be claimed by the project developer, a broker, and the end buyer; credit histories sit in closed databases, spreadsheets, and PDFs; and verifying a credit's provenance means trusting intermediaries. When double counting surfaces, the credibility of the entire market — and the climate finance flowing through it — suffers.

The solution — CarbonProof

CarbonProof is a working prototype registry built on one rule: history can only grow, never change.

• Hash-chained ledger. Every registry event (issue, transfer, retire) is a block containing the SHA-256 hash of the previous block. Alter any historical record and chain verification fails — tampering is detectable by anyone, in one command.
• Lifecycle state machine. Credits move ISSUE → TRANSFER → RETIRE under strict rules: a serial number can be issued at most once; only the current owner can transfer or retire a credit; retirement is permanent and one-time — a retired credit can never be transferred or retired again. Double-counting isn't flagged after the fact; it's refused at the moment it's attempted.
• State by replay. There is no separate mutable database. Credit state is derived by replaying the verified chain, and loading a tampered registry file is rejected outright.
• Emissions calculator. Activity data (electricity, petrol, diesel, LPG, natural gas, flights) is converted to tCO₂e with published emission factors (India's Central Electricity Authority grid factor; UK DEFRA/BEIS conversion factors), so users can compute a footprint and retire matching credits against it.
• Two interfaces, zero dependencies. A full CLI (plus a scripted end-to-end demo that attempts four frauds live — all blocked) and a local web UI showing the registry, any credit's complete provenance, and chain verification status. Python standard library only: free, offline, runs anywhere Python runs. The seeded demo registry tells a complete story: two issuers (a reforestation alliance and a mangrove trust), two Indian climate projects, 10 credits of 10 tCO₂e each, a company buying credits, passing one to its subsidiary, and retiring credits against real calculated footprints.

Target users

• Companies making offset claims that must withstand scrutiny.
• Project developers and issuers who want provable credit provenance.
• Auditors and regulators verifying registry history without sampling PDFs.
• Small registries, cooperatives, and communities that need transparent credit tracking without expensive infrastructure.

Scalability & adoption

The ledger core is transport-agnostic: the same state machine can run behind a multi-node network where independent issuers countersign blocks (the hash chain already gives every participant identical tamper-evidence), with a public read API for auditors. Because the registry format is open JSON and verification is a single command, existing registries could also publish hash-chain mirrors of their histories as a transparency layer without replacing their systems. The prototype runs today on a laptop, fully offline, at zero cost.

Honest limitations

A single local chain provides tamper-evidence and lifecycle enforcement, but a lone operator could discard the whole file and start a new chain — production deployment needs multi-party signing / public anchoring of chain heads, which the design anticipates but this build does not implement. Issuer identity in the prototype is a name, not a verified credential; real markets also need accredited project verification (MRV) before issuance. Emission factors are documented defaults for prototyping and education, not an audited GHG inventory. Credit splitting/merging is not implemented.

How it's built

A Python package (carbonproof/) with five focused modules: ledger.py (SHA-256 hash chain + lifecycle state machine + JSON persistence with verify-on-load replay), calculator.py (emission factors with cited sources), seed.py (deterministic demo data — identical chain hashes on any machine), cli.py (argparse CLI + scripted demo), and web.py (local UI on http.server). 23 unittest tests cover the happy-path lifecycle, every double-counting attack (double issue, double retire, transfer-after-retirement, non-owner actions), and tamper detection (record mutation, hash mutation, block reordering, forged file on load) — all passing. License: MIT, Copyright (c) 2026 Swarnnim Agnihotri.

Track alignment

Track: Carbon Markets & Emissions Transparency. CarbonProof addresses the Carbon Markets & Emissions Transparency challenge head-on: lack of transparency, double counting, and complex verification undermine carbon-market credibility. It implements a blockchain-style verification registry for carbon credits — a SHA-256 hash-chained ledger with unique credit serials and a lifecycle state machine (ISSUE → TRANSFER → RETIRE) that makes double issuance and double retirement impossible by construction, plus one-command independent verification of the complete registry history by any buyer, auditor, or regulator.

Try it out

Clone the repo and run python3 -m carbonproof.cli demo (no installation, Python 3.10+ standard library only). Web UI: python3 -m carbonproof.cli serve then open http://127.0.0.1:8000/

Built with AI coding assistance, all code reviewed and tested by the entrant. Built during this hackathon period. Country: India.

Built With

• blockchain
• carbon-credits
• cli
• climate-tech
• hash-chain
• http-server
• json
• open-source
• python
• sha-256
• stdlib-only
• transparency
• unittest