HELIXIUM (HLX) WHITEPAPER V1.1

A proof-lifecycle blockchain for verifiable data.

Helixium is a verification-first Layer-1 design built around a simple problem: blockchains can prove that a hash exists, but they rarely prove the full lifecycle that made the hash trustworthy. Helixium adds a runtime-enforced A/T/C/G proof lifecycle, portable proof bundles, validator liveness, peer proofs, and challenge-aware Guard verification.

Current public demo status: Substrate runtime spec 110, live wallet, faucet, public verifier API, proof #3 passing A/T/C/G 4/4, validator heartbeat, peer proof, and lifecycle worker. The current deployment is a single-node secured demo; the next public milestone is a 3-validator testnet that demonstrates distributed role assignment and failure behavior.

Core Problem Proof lifecycle

Helixium proves not only that data was anchored, but that it passed Authorization, Transfer, Certification, and Guard stages.

Network Target 3-validator public testnet

The next network runs multiple validators where every validator can perform A/T/C/G roles and roles are assigned dynamically.

Supply 46,000,000 HLX

HLX is the native coin target. One HLX equals 100,000,000 nucleo. Genesis policy is fixed-supply by design.

What Helixium Solves

From hash anchoring to verifiable lifecycle evidence.

A normal chain can say: this hash appeared in this block. Helixium's goal is to say: this proof was authorized, transferred, certified, guarded against fraud/challenge conditions, finalized as a proof lifecycle, and exported as a portable verification bundle.

Question	Classic Hash Anchor	Helixium Answer
Who authorized it?	Usually app-specific	A role: Authorization validator vote and event
Was it delivered or transferred?	Usually not explicit	T role: Transfer validator vote and event
Was it certified?	Often left to the explorer or backend	C role: Certification quorum and voter record
Was it challenge-checked?	Rarely standardized	G role: Guard stage, challenge window, fraud/invalidity path
Can others verify it?	Explorer URL or raw hash	Portable proof bundle plus public verifier endpoint

Nukleoid Architecture

A/T/C/G are Nukleoid roles, not fixed servers.

In Helixium v1.1, A/T/C/G are official Nukleoid roles. They are not permanently assigned to one machine. Every validator in the production model can participate in all four roles; the network assigns available validators dynamically per proof lifecycle.

Symbol	Role	Runtime Meaning
A	Authorization	Validates creator permission, identity context, and proof start conditions.
T	Transfer	Validates proof payload movement, delivery context, and transaction propagation evidence.
C	Certification	Certifies that the required validator attestations meet the active proof quorum.
G	Guard	Applies challenge-window, fraud-proof, invalidation, and tamper-evidence checks.

anchorProof
-> NukleoidRoleVerified(A)
-> NukleoidRoleVerified(T)
-> NukleoidRoleVerified(C)
-> Guard challenge window
-> NukleoidRoleVerified(G)
-> ProofLifecycleFinalized

`ProofLifecycleFinalized` finalizes the proof lifecycle only. It does not replace block consensus finality. Block consensus and proof certification are separate layers.

Finished Product Architecture

The 3-validator public network proves distributed role assignment.

The current server proves that the runtime, wallet, faucet, peer proof, verifier API, and lifecycle flow work. The next milestone is a 3-validator public testnet. The purpose is not just more servers; it is to prove that A/T/C/G roles are distributed dynamically and that the network behaves clearly when one validator is slow or offline.

Scenario	Expected Behavior	What Users See
3/3 validators online	Roles are distributed across available validators. One validator may perform A and G, another T, another C.	Stage voters, live quorum, peer proofs, and finalized proof lifecycle.
2/3 validators online	Adaptive testnet mode can continue proof lifecycles if configured. Production mode can require a safety floor.	Explorer displays nominal quorum, effective quorum, and which validators voted.
1/3 validators online	Private/dev mode may continue for liveness testing. Production mode should not finalize public proofs below the configured safety floor.	Explorer reports insufficient certification quorum unless adaptive mode is intentionally enabled.
Bad proof or dispute	Guard challenge opens, fraud evidence is recorded, proof can be rejected or invalidated, and stake/slash hooks are applied.	Challenge, fraud proof, challenger, resolution, and invalidation state are visible.

Validator 1: can vote A, T, C, or G
Validator 2: can vote A, T, C, or G
Validator 3: can vote A, T, C, or G

Example proof:
  V1 votes A + G
  V2 votes T
  V3 votes C
  -> A/T/C/G 4/4
  -> ProofLifecycleFinalized true

Current Deployed Evidence

The demo proves the lifecycle path before scaling the validator set.

Runtime	Substrate runtime spec 110
Wallet	Browser wallet connection, balance view, faucet, HLX transfer, proof anchor, proof read
Proof API	/proof/latest, /proof/:id/bundle, /proof/:id/verify, /proof/:id/audit, /validators, /challenges, /faucet
Reference proof	Proof #3, A/T/C/G 4/4, ProofLifecycleFinalized true
Validator evidence	Heartbeat active, peer proof active, stake bond configured in runtime
Security hardening	SSH key-only login, root login disabled, fail2ban, Caddy security headers, RPC behind reverse proxy

GET /proof-api/proof/latest GET /proof-api/proof/3/verify GET /proof-api/proof/3/audit GET /proof-api/validators POST /proof-api/faucet

Initial Markets

The first wedge is verifiable data, not generic Layer-1 repetition.

Market	Pain	Helixium Fit
AI provenance	AI output, prompts, model versions, and approvals are difficult to verify later.	Anchor prompt/output hashes, model metadata, approval attestations, and Guard checks.
RWA and regulated records	Documents are shared as PDFs or database rows without portable audit proof.	Proof bundle for document hash, authorization, certification, and challenge status.
Supply chain	QR pages often point to private databases controlled by one operator.	Each major event can be anchored and exported as a verifiable lifecycle proof.
Enterprise audit trails	Internal logs are hard to prove without exposing raw private data.	Hash-only anchors with lifecycle metadata and external verifier endpoints.

Portable Proof Bundles

The product output is a proof someone else can verify.

{
  "standard": "helixium.portable_proof_bundle.v2",
  "proof_id": 3,
  "runtime_spec": 110,
  "digest": "0x...",
  "nukleoid_roles": {
    "A": "Authorization",
    "T": "Transfer",
    "C": "Certification",
    "G": "Guard"
  },
  "verification": {
    "atcg_verified": "4/4",
    "pair_links_verified": true,
    "proof_lifecycle_finalized": true
  }
}

The long-term product is not an explorer screenshot. It is an exportable bundle plus verifier endpoint that lets another wallet, auditor, company, or partner system validate the proof without trusting Helixium's UI.

HLX Economics

HLX secures and pays for proof lifecycle work.

Maximum supply	46,000,000 HLX
Smallest unit	nucleo
Unit rule	1 HLX = 100,000,000 nucleo
Utility	Transaction fees, proof anchoring, validator staking, certification work, Guard/challenge work, and governance.
Economic security direction	Validator bond, reward for honest proof work, slash/invalidity path for provably bad attestations.

Roadmap

What must happen before public investor-grade testnet.

Done

Runtime lifecycle demo

Spec 110, proof anchor, A/T/C/G lifecycle, peer proof, verifier API, wallet, faucet, and security hardening.

3-validator public testnet

Run three validators, show dynamic role assignment, failure scenarios, live quorum, and stage voters.

Then

Benchmarks and audit path

Measure proof latency, block time, storage cost, verifier throughput, challenge handling, and recovery drills.

Later

Mainnet candidate

Freeze genesis, publish release checksums, formalize token economics, complete legal/security reviews, and onboard independent validators.

Boundaries

Helixium does not rely on a metaphor alone.

Helixium does not replace SHA-256. It packages digest, lifecycle, validator evidence, and verification metadata.

Helixium does not replace block consensus with A/T/C/G. A/T/C/G finalizes proof lifecycle, not block finality.

Helixium does not claim biological DNA storage. The nucleotide language is a digital proof grammar.

Helixium does not claim production decentralization from a single-node demo. The next proof point is the 3-validator public testnet.

Live Demo

Verify a proof or use the testnet wallet.

The demo currently exposes wallet connection, test HLX faucet, native transfers, proof anchoring, and public A/T/C/G verification.

Open Wallet