Planetary Entropy Mining PEM · v0.1.0

Entropy provenance · 13 stages

Planetary
Entropy
Mining

A certificate is grounded in a window of environmental noise that nobody could have precomputed, and a proof that the measurement was taken when it says it was. The proof does not reveal where the sensor sits, so a verifier can check the origin of a certificate without learning the location of the node that produced it.

How the chain works Source
Captured window · 216 samples · 8-bit ADC thermal / RF / seismic · seeded simulator
min-entropy gate sample 0 sample 65535
The trace is a seeded simulator, not a recording. Gate: max bin count × 2 T ≤ samples

The idea

01 · Provenance

The problem

Emission and offset certificates are issued by registries, so their audit trail is paperwork held by the issuer. A buyer has to trust the registry instead of checking the measurement.

Physical measurement offers a way out. A window of environmental noise is unique, cannot be precomputed and cannot be produced on demand by a party that was not there.

How it works

A node captures that window, reduces it to a histogram and estimates its min-entropy with the NIST SP 800-90B estimators. A zero-knowledge circuit proves the histogram clears a min-entropy threshold and that the node holds the matching GF(256) hardening polynomial and nullifier.

The certificate then travels as erasure-coded shards across an intermittent mesh, matches in a blind dark pool, and settles once per nullifier so the same measurement cannot be claimed twice.

The pipeline

02 · Eleven modules, thirteen stages
  1. 01

    Capture & measure

    • dsp/capture.pyseeded noise, known truth
    • dsp/nist800_90b.pymin-entropy estimate
    • dsp/validation.pyordering verified
  2. 02

    Harden & prove

    • hardening/polynomial.pyGF(256) commitment
    • circuits/entropy_audit_poly.circomthe gate, compiled
  3. 03

    Certify & bind

    • identity/nullifier.pyonce per window
    • identity/certificate.pysigned, versioned
  4. 04

    Frame & shard

    • net/sphinx.pyonion layers
    • erasure/reedsolomon.pyk-of-n shards
  5. 05

    Carry & settle

    • net/dtn.pyintermittent mesh
    • net/darkpool.pyblind crossing
    • contracts/EntropySettlement.solpay once per nullifier
Capture & measure a window of noise becomes a number

Thermal, RF and seismic noise is captured as a window, reduced to a 256-bin histogram, and estimated with the NIST SP 800-90B estimators. The estimator ordering is checked against closed-form truth rather than assumed.

The run walks the five acts once every twenty seconds. Point at an act to hold it. Motion follows your system, and the switch above overrides it.

Limits

04 · What is simulated
  • The physical sources are seeded simulators. Real piezo and SDR capture sits outside this repository, and the estimators are validated against modelled truth rather than against hardware.
  • The settlement ledger runs in memory. The Solidity contract is the specification; the chain is not exercised.
  • The Solidity verifier checks the public layout. Pairing maths is not verified, and swapping in the snarkjs-exported verifier is a documented one-file change.
  • Foundry was not runnable on the build machine, so the Python twin of the settlement suite is the one that is green.

Run it

05 · On a laptop

Python 3.11 or newer. The zero-knowledge stage needs Node for circom and snarkjs.

git clone https://github.com/KELLERBABG/Planetary-Entropy-Mining
cd Planetary-Entropy-Mining
py -m pip install -e ".[dev]"

py -m pytest -q                 # fast suite
py -m pytest -m ""              # adds the slow 1M-bit NIST tier
py -m cli.validate              # entropy report into docs/
py -m cli.demo --quick          # end-to-end chain, Python only

node circuits/scripts/entropy_poly_prove.mjs --assert

The reference implementation runs every stage as a deterministic simulation, so the protocol can be specified, tested and audited without hardware. The cryptographic core — GF(256) field arithmetic, X25519 and AES-GCM onion layers, Shamir secret sharing — is real.

Read the whitepaper ↗