VERDET

A solar meter that signs its own readings, proves clean energy on Hedera, and turns every verified kWh into tokens people can trade with neighbours or redeem for airtime.

Comment

Inspiration

In Nigeria, the sound of the evening is a generator. The grid can't keep up, so homes and small businesses burn petrol and diesel just to keep the lights on. Nigeria has the largest population without electricity in the world, and the combined capacity of its generators is estimated at about eight times that of the national grid.

Solar is the obvious way out, and panels are spreading fast. But we noticed a gap: the clean energy a panel produces is invisible. Nobody measures it in a way anyone else can trust, so nobody can reward it, trade it or count it toward climate goals.

Our inspiration was GreenAfrica, Nigeria-first smart bins that reward recyclers with airtime or data. Its pattern was simple: a physical device captures something real, verification rejects fakes, Hedera records the proof, the person gets a tangible reward, and a public dashboard shows the impact. We wanted to apply that pattern to solar energy and go one step further, so the proof starts inside the meter itself.

What it does

VERDET (VERifiable Decentralized Energy Trading) is a Track 2 project: Renewable Energy & Energy Trading.

  1. Sign up with email and password. You instantly get a Hedera account, and that account ID is your VERDET App ID. No wallet app is needed.
  2. Register your meter with its public key. The registration is recorded on Hedera.
  3. The meter signs every reading. Every 60 seconds, the meter totals the energy it measured and signs that window with its own Ed25519 key.
  4. VERDET verifies each reading through four checks: registered meter → valid signature → new sequence number (blocks replays and double claims) → physically possible (output can't exceed the panel's rating).
  5. Every decision, accepted or rejected, is written to a public Hedera Consensus Service topic.
  6. Accepted energy mints VKWH, a Hedera token where 1 VKWH = 1 verified kWh.
  7. Trade or redeem. Sell VKWH to neighbours for HBAR in a single atomic transaction, or redeem it for airtime and data. Redeemed tokens are burned.
  8. A public impact page shows total verified energy and estimated diesel and CO₂ avoided, with links to the proof on HashScan.

Demo User

A demo account is available for judges and reviewers.

Email: [email protected]
Password: Demo-va8S9BtIwcHS

Who it's for: solar homes and small businesses first. The same verified records are useful to mini-grid operators, clean-energy funders paying incentives, and policymakers who today only have estimates.

How we built it

The meter. An Arduino Mega 2560 reads current from an ACS712-20A sensor and voltage through a 47 kΩ / 10 kΩ divider. It samples at 1 kHz on a timer interrupt, averages each second, and adds up the energy over each 60-second window:

$$P_i = V_i \cdot I_i \qquad E_{\text{window}} = \sum_{i=1}^{60} P_i \,\Delta t, \quad \Delta t = 1\,\text{s}$$

The meter then builds one exact line of text, signs it with Ed25519 (the rweather Crypto library), and sends it over USB:

VERDET|v1|{meterId}|{seq}|{tStartMs}|{tEndMs}|{mWh}|{peakMw}|{avgMv}|{avgMa}

Every value is a whole number (mWh, mW, mV, mA), so the board and the server can rebuild the signed text byte for byte. The private key and the sequence number live in the board's EEPROM, so they survive a restart. The key never leaves the board.

The gateway. A small Python script forwards the signed lines from the serial port to the app unchanged. It never holds the key, so it can drop a reading but can't forge one. This is our answer to the oracle problem.

The app. It is one Python service: FastAPI, SQLModel (Postgres in production), and server-rendered pages with HTMX and Tailwind, installable as a PWA. All Hedera calls go through the official Hiero Python SDK, in one module.

On Hedera (testnet):

  • HCS: four topics (registry, readings, trades, redemptions) form a public, time-stamped audit trail.
  • HTS: the VKWH token has 6 decimals, so the smallest unit is exactly 1 mWh:

$$1\ \text{VKWH} = 1\ \text{kWh} = 10^{6}\ \text{mWh}$$

  • Atomic swaps: a marketplace purchase is one TransferTransaction. VKWH moves seller → buyer and HBAR moves buyer → seller, both signed in the same transaction, so either both legs happen or neither does.
  • Burn on redeem: redeemed VKWH goes back to the treasury and is burned, so supply always matches energy that hasn't been spent.

Impact maths is shown openly on the public page, with cited, configurable factors:

$$\text{Diesel avoided (L)} = E_{\text{verified}} \times f_{\text{L/kWh}} \qquad \text{CO}2\ \text{avoided (kg)} = \text{Diesel avoided} \times f{\text{kg/L}}$$

Testnet IDs: VKWH token [0.0.______] · readings topic [0.0.______] · trades topic [0.0.______]

Challenges we ran into

  • The oracle problem. A blockchain can prove what it was told, never that the physical world matched. We can't fully solve that, so we don't claim to. VERDET is trust-minimized and auditable, not "trustless". Signing at the device, sequence numbers, physics limits and an on-chain record of every rejection each close off a specific attack. What remains (someone tampering with the hardware itself) is stated openly, along with how production would handle it: a secure key chip, a tamper-evident enclosure and installer checks.
  • A young SDK. The Python Hedera SDK is newer than the JavaScript one, and we weren't sure it could do a two-signature atomic swap. We tested that on day one, before writing any app code. It worked.
  • Dropping the AI check. We planned an AI layer that compares each reading with a clear-sky solar model for the meter's location, to catch fakes that pass the basic rules. With the deadline close, we cut it and kept verification to four checks we could fully test. It is first on our roadmap.
  • Parts that never came. The parts for a calibrated build didn't arrive in time. We built a mock-up with the parts on hand, so the readings are real and signed but uncalibrated, and we label them that way.

Accomplishments that we're proud of

  • A real device signing real readings, end to end. On October 19, a signed reading from the physical meter went through the gateway, passed every check, and landed on Hedera with its proof.
  • Rejections you can see on-chain. Unregistered meters, tampered signatures, replayed windows and duplicate claims are all caught, and each rejection is recorded publicly, not hidden in a log.
  • A true atomic swap. Peer-to-peer energy trading settles in one Hedera transaction, visible on HashScan with both legs together.
  • Onboarding with no wallet. Users sign up with an email and get a working Hedera account in seconds.
  • No smart contracts needed. Logging, minting, trading and burning all run on Hedera's native services.
  • Honest claims throughout. Every limit of the prototype is stated in the app, the docs and this story.

What we learned

  • Trust has to start at the source. On-chain records are only as good as the data going in, and a signature at the device moves trust much closer to the physical world.
  • Hedera's native services go a long way. HCS and HTS covered logging, minting, atomic swaps and burning without a single smart contract.
  • Building a Python backend from scratch. We built it with FastAPI, from authentication and encrypted key storage to tests that never touch the network.
  • De-risk first. Testing the riskiest parts on day one (the swap on the SDK, signing on the board) saved the project when hardware slipped.
  • Design for missing hardware. Building against a simulator with the exact signed format meant late parts never blocked the software.

What's next for VERDET

  • Connected meters: Wi-Fi or GSM meters, so no PC gateway is needed
  • Hardware security: a secure key chip (ATECC608) and a tamper-evident enclosure
  • AI verification: anomaly checks against a clear-sky solar model to catch plausible fakes
  • Accuracy: calibrated, then certified AC metering for real inverter systems
  • Real rewards: airtime and data delivered through a provider API (the current vouchers are testnet demos)
  • Scale: batching many meters' readings into one Hedera message, to support thousands of meters cheaply
  • Pilots: a first pilot with solar homes, small businesses and a mini-grid operator in Nigeria

VERDET is a prototype on Hedera testnet. User keys are custodial (encrypted at rest), the meter mock-up is uncalibrated, and VKWH is a verified-energy reward token, not a carbon credit. Trading moves the verified green-energy attribute, not the electrons themselves.

Built With

Share this project:

Updates

Submission history