Proof-native
Layer 1

The present depends
on accumulated history.

Bitcoin, Ethereum, Solana, Zcash, TRON, and most blockchains derive their current state from accumulated history. Some replay it directly, others shorten bootstrap with snapshots or checkpoints. Either way, a new verifier must reconstruct or inherit the path to the current state.

Basis of validity

Accumulated chain history

New verifier

Replays history or bootstraps from a snapshot/checkpoint

The present
proves the past.

Parano1d separates state validity from historical replay. The live State holds value and commitments to programmable spending rights, authenticated by a recursive proof from genesis. Spent outputs release their slots, so storage follows live use rather than chain age.

State growth

Tracks live UTXOs, not lifetime transactions

Spent outputs

Slots clear and can be reused

Chain age

Adds no accumulated replay debt

Bootstrap from
proof.
Not from trust.

Peers provide data, not authority. A node receives the live UTXO state, its matching terminal proof, and the latest 18-block reorg suffix. It authenticates the state, verifies the suffix, and joins the network as an independent full node. The procedure is the same in year one and year ten.

Prove where the
information lives.

In Parano1d, each proof is built where the required information already exists. The network receives a verifiable result, not a computation to repeat.

State follows
live use.
Not chain age.

Spending clears a slot. The allocator reuses empty positions before expanding the state. A segment becomes virtual again when its last UTXO is spent.

Spend

Clear the indexed slot

Reuse

Assign a fresh creation_id to an empty position

Expand

Attach a canonical empty half at 75% occupancy without pause

A secret is enough.
No keypair. No
signature.

Parano1d begins with 256 bits of secret entropy, not a public-key pair. The wallet proves knowledge of that secret without revealing it, and every spend produces a fresh zero-knowledge proof bound to the complete transaction.

Protocol

256-bit secret · no public-key scheme

On the wire

No public key · no transaction signature

Ownership

Secret knowledge proved in zero knowledge

Any photo
can become
a master secret.

A Parano1d wallet can generate a new master secret, import an existing one, or derive one from a private image. Photo Key reads the image locally, never uploads it, and keeps no copy. The same decoded pixels recreate the same 256-bit secret and every address derived from it. Change the pixels, and you get a different wallet.

Up to 504 inputs.
One transaction.

Each Tx8x2 page holds eight inputs and two outputs. PagedSpend joins pages into one atomic transaction with one txid, fee, authorization capsule and receipt. V2 admits up to 504 inputs within the block budget: at most 63 pages in Small, or 128 pages for one logical transaction in Large.

History advances
as a fixed-size proof.

Each HistoryStep proves the new block and verifies the preceding terminal within the same relation. The terminal changes with every block, but its size and verification work do not grow with chain height.

Active node

Live state + terminal proof + latest 18 complete blocks

Chain age

Does not increase proof size or history verification work

Privacy
without secrecy.

Parano1d is transparent while transactions pass through consensus: values, owners, and transactions are public. But consensus does not retain a permanent transaction graph. Long-term address tracking requires an external observer to record the stream continuously and store it independently.

LIVE STATE

Public values · public owners

PAST GRAPH

Not retained by consensus

LONG-TERM TRACKING

Requires continuous external recording

History expires.
The receipt does not.

When a payment confirms, the sender's wallet saves an exportable Merkle receipt. It carries the complete public payment data and a fixed-depth inclusion path. Any node verifies it against the canonical header. The historical block body is not required.

Authenticates

txid · recipients · amounts · fee · block time

Merkle path

Eight Poseidon2b levels

Old block body

Not required

One arithmetic.
End to end.

Addresses, wallet authorization, transactions, state, recursive history and PoW share one binary proof stack. FROST-GKR folds repeated Poseidon2b structure into shared Boolean hypercubes; FRI-Binius closes the relation without a trusted setup.

Fields

Traces: GF(2^128) · Fiat Shamir challenges: GF(2^256)

Prover

10.50× faster in the 59-permutation comparison

Algebraic proof

51.67× smaller

Post-quantum.
Provable from genesis.

The v2 resource assessment covers wallet authorization, transactions, contract execution, exact State transitions, recursive ancestry and matrix retirement. Its composition and preprocessing premises are explicit in the security model.

Result

NIST PQC Category 1 · conditional

Half-success floor

2^173.3897612554174

Complete ideal bound

≈ 0.04937388373372754 < 1/2

Prove first.
Mine second.

PoW chooses the order of already-proven transitions. The miner completes the nonce-independent block proof, freezes an immutable template, then searches only the 128-bit nonce.

Block target

30-second mean · ASERT difficulty

Role of PoW

Canonical ordering of proven transitions

Proof boundary

Cannot forge ownership or validate an invalid state

One network.
Two block classes.

Small is the default. A producing server may enable Large with --v2-large-blocks when extra payment capacity is useful. Every node verifies both. Both classes share 504 live inputs and 63 contract calls; each call uses one page and one input. The block target is 30 seconds.

16 → 11.30 → 8 → 5.65 → 4 → 2.83 → 2 → 1.41 → 1 NOID. One step every 1,051,200 blocks from H210537; State occupancy still sets the slot-growth fee.

Live value.
Live rights.

A live output can commit to a program, spending authorities and persistent counters. An authorized call proves the rules and creates the next valid state. The shared block proof carries continuity, so future nodes can verify the present after old interactions have been pruned.

Live State

Value + commitment to current rights

Execution

Proved inside the recursive block relation

Participants keep

Current public terms + portable receipts

Your rules.
One shared core.

Refundable payments, vaults, delegated allowances, period budgets, recurring payments and gradual unlocks are ready to use. Build custom programs through the GUI, CLI or API. Every application uses the same proved interpreter and block matrices.

Integer core

16 instructions · 2 persistent u64 counters

Rules

Checked arithmetic · conditions · block height

Execution trigger

An authorized call, including scheduled payments