Wallets prove ownership. Miners prove exact state transitions. Every node verifies the result. No signatures. No trusted setup. No replay from genesis.
O(1) SYNCno history. no archive nodes
SIGNATURELESShash-only ownership · PQ-ready
POW ORDERSproofs authorize every transition
01 / The dependency
Conventional blockchains history from genesis.
Bitcoin, Ethereum and nearly every modern blockchain derive the present by executing history from genesis. More use creates more permanent bootstrap work for every future verifier.
Source of truth
The complete execution log
New full node
Downloads and re-executes the chain
Network age
Becomes an ever-growing hardware requirement
02 / The break with history
The present proves itself.
ParanO(1)d separates validity from historical replay. Consensus carries a provable live UTXO state: spent outputs release their slots, and old activity does not remain a permanent burden for future nodes.
State growth
Live UTXOs—not lifetime transactions
Spent outputs
Slots clear and return to the allocator
Chain age
Adds no lifetime history or genesis replay
03 / Independent bootstrap
Bootstrap from proof. Not from trust.
Peers provide data—not trust. A node receives the live UTXO state, its matching terminal and the latest 18 complete blocks. It authenticates the state, verifies the reorg window and becomes an independent full node. The procedure is the same in year one and year ten.
live state+πtip + 18 blocks→independent node ✓
04 / The paradigm shift
Prove where the information lives.
In ParanO(1)d, proofs are built by whoever has the required data. The network receives the finished result, not another job to repeat the same work.
WWalletProves private authorization without revealing the spending secret.
MMinerProves public transaction logic and the exact state transition.
NNetworkVerifies proofs, applies proven slot writes and checks PoW.
05 / A living UTXO state
State grows with use. Not with time.
Spending clears a slot. The allocator reuses empty positions before opening new state. Empty segments are virtual and disappear again when their last UTXO is spent.
Spend
Clear the indexed slot
Reuse
Issue a fresh creation_id in an empty position
Expand
Attach a canonical empty half at 75% occupancy — no pause
06 / Signatureless ownership
A secret is enough. No keypair. No signature.
ParanO(1)d needs 256 bits of secret entropy—not a public-key pair or a mnemonic format. The wallet proves knowledge of that secret without revealing it; every spend produces a fresh ZK proof bound to the complete transaction.
Protocol
256-bit secret · no mnemonic format
On the wire
No public key · no transaction signature
Consensus
Hash-only ownership · PQ-ready from genesis
07 / PagedSpend
Many UTXOs. One transaction.
Fixed proof pages are internal geometry. Up to 128 pages remain one indivisible user transaction with one txid, one fee, one capsule and one receipt.
→
1,020 inputs · 256 outputs ATOMIC PAGEDSPEND
08 / Recursive history
History becomes a fixed proof.
Every HistoryStep proves the current block and verifies the preceding terminal inside the same relation. Proof size and verification work do not increase with block height.
πh−1+blockh · stateh→πh
Active node
Live state + compact headers + latest 18 complete blocks
Chain age
Does not increase history verification
09 / Privacy by non-retention
Privacy without privacy.
The live state is public, and transactions are visible while consensus carries them. ParanO(1)d does not make every node preserve the permanent transaction graph. Following an address across years requires an external tracker that records the stream continuously—and pays to store all of it.
Live state
Public values · public owners
Past graph
Not retained by consensus
External tracking
Record every transaction in real time
10 / Portable proof of payment
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—without the historical block body.
Authenticates
txid · recipients · amounts · fee · block time
Merkle path
Eight Poseidon2b levels
Old block body
Not required
11 / One binary proof stack
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.
ownership + tx→FROST-GKR→state + history + PoW
Field
GF(2^128) · one binary arithmetic
Prover
10.50× faster in the 59-permutation comparison
Algebraic proof
51.67× smaller
12 / Proof-Native PoW
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
15-second mean · ASERT difficulty
Majority hashpower
May censor · reorder · reorg
Proof boundary
Cannot forge ownership or validate an invalid state
13 / Hardware-adaptive decentralization
The entire L1. On your laptop.
Your laptop can hold the complete live state and independently verify the entire L1. ParanO(1)d adapts block capacity to available proving power: stronger hardware raises TPS; weaker hardware lowers it. Throughput changes. The network does not stop.
Blockchains have a fundamental architectural flaw: to validate the present, you must replay the past. Bitcoin, Ethereum, and nearly every major network inherit this property. A new full node downloads the chain from genesis and re-executes every transaction because the current state does not prove itself. This is not a temporary limitation. It is baked into the model.
ParanO(1)d is designed to remove this requirement.
In ParanO(1)d, validity is established once, where the complete information already exists. Authorization is proved locally by the party with the private witness — the wallet owner. The miner proves the public transaction logic and the exact state transition. The network verifies those proofs instead of repeating the same execution.
Every accepted block carries a recursive HistoryStep that binds the block, its new UTXO root, and the validity of the preceding statechain. A new node can therefore authenticate the current state and verify the recent reorg suffix without executing the chain from genesis.
Once the present state carries its own proof, a different architecture becomes possible. Spent state can be deleted and reused. Ownership no longer needs a public key or digital signature. State growth can be priced directly. Proof of work can order transitions whose validity is already established. The result is an L1 whose age does not become a hardware requirement. Years later, an ordinary laptop can still hold the complete live state and independently verify the network without replaying the chain's lifetime.
The Fundamental Shift
Conventional blockchain
ParanO(1)d
Validation
Every full node re-executes
The witness holder proves; the network verifies
Bootstrap
Rebuild state from genesis
Authenticate current state and verify the recent suffix
Ownership
Public-key signature
Fresh ZK proof of a Poseidon2b preimage
State
Derived from accumulated history
Exact live UTXO state is a consensus object
Spent outputs
Remain part of required history
Slots are cleared and safely reused
Proof of work
Orders an execution log
Orders proof-valid state transitions
Post-quantum migration
Replace the ownership scheme
No elliptic-curve transaction scheme to replace
ParanO(1)d is transparent, not a privacy chain. Current values and owners are public, and transactions are visible when relayed. The protocol turns history into proof: every node carries an authenticated present instead of an ever-growing transaction graph. Anyone may build an external tracer, but it must record the entire transaction stream for itself; the network does not make every node carry that burden.
Privacy here comes from non-retention, not concealment. Zero knowledge protects the spending witness; proof-native validation removes redundant execution.
How It Works
Execution Is Local
When sending NOID, the wallet selects its UTXOs and creates one atomic PagedSpend. It then produces a freshly randomized, witness-hiding authorization for {logical_txid, input_owner}. The spending secret never leaves the wallet.
The authorization is stateless: it contains no UTXO Merkle path and is not tied to one state root. The miner has the public state witness and proves separately that every input exists, every output slot is empty, values balance, fees are correct, and the resulting state root is exact.
Private authorization is proved by the wallet. Public execution is proved by the miner. Neither task is repeated across the network.
The Network Verifies, Not Executes
The mempool verifies the complete transaction intent before relaying it. A miner selects available intents immediately.
The miner combines the selected transactions, exact state transition and preceding terminal into the next HistoryStep. It completes this proof before searching for a PoW nonce. Peers receive one atomic {block, HistoryStep terminal} bundle and accept it only after verifying both the proof and the nonce.
Peers then apply the proven slot writes to advance their local UTXO set, materializing the proof's result without re-executing transaction logic.
History Collapses Recursively
Each HistoryStep proves the current block relation and verifies the previous terminal inside the same relation. Proof size and verification work do not increase with block height.
An active node keeps the exact live state, compact headers for cumulative work, and the latest 18 complete blocks for competing miners and reorgs. A joining node authenticates a finalized current state with its matching terminal, then verifies that recent suffix normally.
ParanO(1)d is history-stateless, not state-free. State transfer scales with the live UTXO set. What no longer scales with chain age is the execution required to prove why that state is valid.
Architecture
A Living UTXO State
The state is an exact sparse vector of indexed UTXOs. Spending clears a slot; the allocator reuses empty positions before opening new state. Every new output has a fresh creation_id, so reusing the same index can never revive an old reference.
State is divided into 2^16-slot segments. Empty segments are virtual and a segment disappears again when its last UTXO is spent. The slot domain begins at 2^24 and expands automatically at 75% occupancy by attaching a canonical empty half to the existing root. No state copy, migration or network pause is required.
Fees distinguish ordinary I/O from net-new state. The state-growth component rises with occupancy and is burned; consolidation pays no growth burn. Block reward halves when the state domain actually expands, with a permanent 1 NOID floor.
Signatureless Ownership
An address is the Poseidon2b image of a 256-bit spending secret. The protocol needs secret entropy, not a keypair or a prescribed mnemonic format. Ownership is a zero-knowledge proof of knowledge of that preimage, bound to the complete logical transaction. There is no public key or transaction signature on the wire.
The capsule is independently randomized on every spend, including repeated use of the same address. Transaction consensus contains no elliptic curves. The Ed25519 key used by libp2p identifies a peer only and has no spending or consensus authority.
PagedSpend
The proof system uses fixed physical pages with eight input and two output positions. PagedSpend joins up to 128 pages into one user transaction with one txid, one fee, one ZK capsule and one receipt.
A single transaction may consume up to 1,020 UTXOs and create up to 256 outputs. Continuation pages are internal proof geometry: they remain one indivisible transaction in the wallet, mempool, relay, block, receipt and reorg paths.
Portable Payment Receipts
Consensus does not preserve old block bodies forever, so the sender's wallet preserves the evidence that matters. After confirmation it stores an exportable receipt containing the public payment data and an eight-level Poseidon2b Merkle path. Anyone can later verify that the canonical block contained the stated txid, input owners, recipients, amounts, fee and block time by checking the receipt against the retained block header. The old block body is not required.
One Binary Proof Stack
The protocol is built over the binary tower field GF(2^128). Poseidon2b is the common permutation for addresses, transactions, Merkle trees, state roots, transcripts, block identifiers and PoW.
For ParanO(1)d, we developed FROST-GKR — Frobenius Reduction Over Shifted Tables. It places complete Poseidon2b batches and Merkle paths in shared Boolean hypercubes, checks the active degree-seven S-box relation with one degree-nine sumcheck, and binds adjacent rounds with one degree-two shift sumcheck. In a like-for-like 59-permutation benchmark, this reduces median prover time by 10.50× and raw algebraic proof bytes by 51.67×. Batched sumchecks, zerocheck, lincheck and FRI-Binius close the GF(2) R1CS relation without a trusted setup. The two authenticated launch matrices — B64 at m=23 and B255 at m=24 — are embedded in the official binary and can be regenerated from source. The benchmark artifact pins the exact comparison revision and environment.
This common arithmetic is what lets wallet authorization, exact state and recursive chain verification compose as one protocol instead of independent proof systems glued together afterward.
Proof-Native PoW
PoW has one job: choose the order of valid transitions. Majority hash power may censor, reorder or reorg valid payments, but it cannot forge ownership or make an invalid HistoryStep acceptable.
The miner proves the nonce-independent block first, then searches a fixed Poseidon2b header with a 128-bit nonce. ASERT targets a 15-second mean interval, and cumulative work selects the chain. An external miner receives an immutable, single-use template and returns only a nonce; it cannot alter the transactions or state root.
Launch Profile
Parameter
Value
Mean block target
15 seconds
Default miner class
B64, m=23, up to 64 user pages
Large miner class
B255, m=24, up to 255 user pages
Maximum logical transactions per block
255
Maximum one-page throughput
17 TPS
Maximum inputs in one transaction
1,020
Maximum outputs in one transaction
256
Recent block / reorg suffix
18 blocks
State domain
2^24 to 2^32 slots
B64 is the laptop-class mining floor, not the protocol ceiling. On the reference 12-thread Intel Core i7-1365U, saturated B64 preparation measures 14.387 seconds at p95 and verification measures 0.720 seconds at p95. Faster hardware may qualify B255; every node verifies both classes. Full measurements are in the two-class benchmark.
Network
ParanO(1)d uses libp2p GossipSub for blocks and transaction intents, typed request-response protocols for synchronization, Kademlia and DNS seeds for discovery, and mDNS for local networks. Persistent peers, connection limits, and IPv4/IPv6 network-group diversity reduce simple eclipse and connection flood attacks without adding a consensus round.
Finalized state transfer is authenticated by HistoryStep; short gaps use ordinary recent-block sync. Finalized transaction bodies are not required by active consensus. Exportable Merkle receipts preserve proof of inclusion after a body leaves the recent suffix.
Running ParanO(1)d
The first node of a new network creates genesis and starts mining:
paranoid --miner --genesis
--genesis is only for the first node. Join an existing network as a node or miner:
Default ports are 9400 for P2P and 127.0.0.1:9401 for JSON-RPC. First start creates ~/.paranoid/paranoid.toml, the MDBX state and the built-in wallet under ~/.paranoid/data/.
The current wallet.key is not password-encrypted. It is created with owner-only permissions; back it up and protect it.
CLI
Addresses use bech32m and begin with o1. 1 NOID = 1,000,000 μNOID.
Run paranoid --help, noid-cli help or noid-extminer --help for the full interface.
Building from Source
The canonical release build supports Linux on x86-64 and AArch64. It requires Rust with rustfmt, a native C/C++ toolchain, pkg-config, libclang and OpenSSL development headers. Release proving requires AVX2, PCLMULQDQ and VPCLMULQDQ on x86-64, or AES/PMULL on AArch64.
git clone https://github.com/ignotusnemo/paranoid.git
cd paranoid
./scripts/build_release.sh
The build regenerates and authenticates both HistoryStep matrices, runs the release tests and produces paranoid, noid-cli and noid-extminer.
Designed and developed by Ignotus Nemo. Licensed under Apache-2.0.
В архитектуре блокчейнов есть фундаментальный изъян: чтобы проверить настоящее, приходится заново проиграть прошлое. Bitcoin, Ethereum и почти все крупные сети наследуют эту зависимость. Новая полная нода скачивает цепочку от генезиса и повторно исполняет каждую транзакцию, потому что текущее состояние не способно доказать собственную корректность. Это не временное ограничение, а свойство самой модели.
ParanO(1)d создан, чтобы убрать это требование.
В ParanO(1)d корректность доказывается один раз — там, где уже есть вся необходимая информация. Право расходования локально доказывает владелец закрытых данных, то есть кошелёк. Майнер доказывает публичную логику транзакций и точный переход состояния. Сеть проверяет эти доказательства вместо того, чтобы повторять то же исполнение.
Каждый принятый блок несёт рекурсивный HistoryStep, который связывает сам блок, новый корень UTXO и корректность предшествующей statechain. Поэтому новая нода может подтвердить текущее состояние и обычным способом проверить недавнее окно реорганизаций, не исполняя всю цепочку от генезиса.
Когда настоящее состояние несёт собственное доказательство, становится возможна другая архитектура. Потраченное состояние можно удалять и использовать повторно. Владение больше не требует публичного ключа или цифровой подписи. Рост состояния можно тарифицировать напрямую. Proof of work может упорядочивать переходы, корректность которых уже установлена. Возраст такого L1 не превращается в требование к железу: спустя годы обычный ноутбук по-прежнему сможет хранить всё текущее состояние и независимо проверять сеть, не повторяя всю её жизнь.
Главное изменение
Обычный блокчейн
ParanO(1)d
Проверка
Каждая полная нода исполняет всё заново
Владелец закрытых данных доказывает; сеть проверяет
Первичный запуск
Собрать состояние от генезиса
Подтвердить текущее состояние и проверить недавний суффикс
Владение
Подпись публичным ключом
Новое ZK-доказательство прообраза Poseidon2b
Состояние
Производная накопленной истории
Точное текущее состояние UTXO — объект консенсуса
Потраченные выходы
Остаются частью обязательной истории
Слоты очищаются и безопасно используются снова
Proof of work
Упорядочивает журнал исполнения
Упорядочивает уже доказанные переходы состояния
Постквантовая миграция
Заменить схему владения
Нет транзакционной схемы на эллиптических кривых, которую придётся менять
ParanO(1)d прозрачен и не является privacy-chain. Текущие суммы и владельцы публичны, а транзакции видны во время распространения. Протокол превращает историю в доказательство: каждая нода несёт подтверждённое настоящее, а не постоянно растущий граф транзакций. Любой может построить внешний трекер, но тогда ему придётся самостоятельно записывать весь поток транзакций; сеть не заставляет каждую ноду нести этот груз.
Приватность здесь возникает из отсутствия постоянного хранения, а не из сокрытия данных. Zero knowledge защищает секрет расходования; Proof-Native проверка устраняет повторное исполнение.
Как это работает
Исполнение остаётся локальным
Отправляя NOID, кошелёк выбирает свои UTXO и создаёт один атомарный PagedSpend. Затем он строит новое рандомизированное доказательство права расходования для {logical_txid, input_owner}, скрывающее закрытые данные. Секрет расходования никогда не покидает кошелёк.
Это доказательство stateless: в нём нет Merkle-пути UTXO, и оно не привязано к одному корню состояния. У майнера есть публичные данные состояния; отдельно он доказывает, что каждый вход существует, каждый выходной слот пуст, суммы сходятся, комиссии верны, а итоговый корень состояния точен.
Приватное право расходования доказывает кошелёк. Публичное исполнение доказывает майнер. Сеть не повторяет ни одну из этих задач.
Сеть проверяет, а не исполняет
Перед распространением mempool проверяет полный замысел транзакции. Майнер сразу выбирает доступные транзакции.
Выбранные транзакции, точный переход состояния и предыдущий terminal майнер объединяет в следующий HistoryStep. Это доказательство завершается до начала поиска PoW nonce. Пиры получают один атомарный пакет {block, HistoryStep terminal} и принимают его только после проверки и доказательства, и nonce.
Затем пиры применяют доказанные записи слотов и продвигают локальный набор UTXO. Так результат доказательства материализуется без повторного исполнения логики транзакций.
История сворачивается рекурсивно
Каждый HistoryStep доказывает relation текущего блока и внутри той же relation проверяет предыдущий terminal. Размер доказательства и работа верификатора не растут с высотой блока.
Активная нода хранит точное текущее состояние, компактные заголовки для накопленной работы и последние 18 полных блоков, необходимые для конкурирующих майнеров и реорганизаций. Подключающаяся нода подтверждает финализированное текущее состояние соответствующим terminal, а затем обычно проверяет недавний суффикс.
ParanO(1)d не зависит от истории, но не является системой без состояния. Объём передачи состояния растёт вместе с числом живых UTXO. От возраста цепочки больше не зависит объём исполнения, необходимый для доказательства корректности этого состояния.
Архитектура
Живое состояние UTXO
Состояние — точный разреженный вектор индексированных UTXO. Расходование очищает слот; аллокатор повторно использует свободные позиции прежде, чем открывать новое состояние. Каждый новый выход получает свежий creation_id, поэтому повторное использование того же индекса никогда не оживит старую ссылку.
Состояние разделено на сегменты по 2^16 слотов. Пустые сегменты существуют виртуально, а сегмент снова исчезает, когда потрачен его последний UTXO. Домен слотов начинается с 2^24 и автоматически расширяется при заполнении 75%: к существующему корню подключается каноническая пустая половина. Копирование состояния, миграция и остановка сети не нужны.
Комиссии различают обычный ввод-вывод и чистое увеличение состояния. Компонент роста дорожает по мере заполнения и сжигается; консолидация не платит за рост. Награда за блок уменьшается вдвое, когда домен состояния действительно расширяется, но никогда не опускается ниже 1 NOID.
Владение без подписей
Адрес — Poseidon2b-образ 256-битного секрета расходования. Протоколу нужна секретная энтропия, а не пара ключей или обязательный формат мнемоники. Владение выражено zero-knowledge доказательством знания этого прообраза, связанным со всей логической транзакцией. В сети нет ни публичного ключа, ни подписи транзакции.
Capsule независимо рандомизируется при каждом расходовании, в том числе при повторном использовании одного адреса. В транзакционном консенсусе нет эллиптических кривых. Ключ Ed25519, который использует libp2p, лишь идентифицирует пир и не даёт полномочий расходовать монеты или влиять на консенсус.
PagedSpend
Система доказательств использует физические страницы фиксированного размера: восемь позиций для входов и две для выходов. PagedSpend объединяет до 128 страниц в одну пользовательскую транзакцию с одним txid, одной комиссией, одной ZK capsule и одним чеком.
Одна транзакция может потратить до 1 020 UTXO и создать до 256 выходов. Страницы продолжения — лишь внутренняя геометрия доказательства: в кошельке, mempool, relay, блоке, чеке и при реорганизации они остаются одной неделимой транзакцией.
Переносимые чеки платежей
Консенсус не хранит старые тела блоков вечно, поэтому кошелёк отправителя сохраняет нужное доказательство. После подтверждения он записывает экспортируемый чек с публичными данными платежа и восьмиуровневым Merkle-путём Poseidon2b. Позже любой может сверить чек с сохранённым заголовком блока и подтвердить, что канонический блок содержал указанные txid, владельцев входов, получателей, суммы, комиссию и время. Старое тело блока для этого не требуется.
Единый бинарный стек доказательств
Протокол построен над бинарным башенным полем GF(2^128). Poseidon2b служит общей перестановкой для адресов, транзакций, деревьев Merkle, корней состояния, транскриптов, идентификаторов блоков и PoW.
Для ParanO(1)d мы разработали FROST-GKR — Frobenius Reduction Over Shifted Tables. Он размещает полные пакеты Poseidon2b и Merkle-пути в общих булевых гиперкубах, проверяет активное отношение S-box степени семь одним sumcheck степени девять и связывает соседние раунды одним shift-sumcheck степени два. В прямом сравнении на 59 перестановках медианное время prover уменьшается в 10,50 раза, а объём сырого алгебраического доказательства — в 51,67 раза. Пакетные sumcheck, zerocheck, lincheck и FRI-Binius замыкают GF(2) R1CS relation без trusted setup. Две аутентифицированные стартовые матрицы — B64 при m=23 и B255 при m=24 — встроены в официальный бинарник и могут быть воспроизведены из исходников. Артефакт бенчмарка фиксирует точную ревизию и окружение сравнения.
Общая арифметика позволяет авторизации кошелька, точному состоянию и рекурсивной проверке цепочки составлять один протокол, а не набор независимых proof-систем, склеенных после разработки.
Proof-Native PoW
У PoW одна задача: выбрать порядок корректных переходов. Большинство хешрейта может цензурировать, менять порядок и проводить реорганизации корректных платежей, но не может подделать владение или сделать недействительный HistoryStep приемлемым.
Сначала майнер доказывает не зависящую от nonce часть блока, затем ищет 128-битный nonce в фиксированном Poseidon2b-заголовке. ASERT нацелен на средний интервал 15 секунд, а цепочку выбирает накопленная работа. Внешний майнер получает неизменяемый одноразовый шаблон и возвращает только nonce; изменить транзакции или корень состояния он не может.
Стартовый профиль
Параметр
Значение
Средняя цель блока
15 секунд
Класс майнера по умолчанию
B64, m=23, до 64 пользовательских страниц
Класс мощного майнера
B255, m=24, до 255 пользовательских страниц
Максимум логических транзакций в блоке
255
Максимальная пропускная способность одностраничных транзакций
17 TPS
Максимум входов в одной транзакции
1 020
Максимум выходов в одной транзакции
256
Недавний суффикс блоков / окно реорганизаций
18 блоков
Домен состояния
от 2^24 до 2^32 слотов
B64 — нижняя граница майнинга на ноутбуке, а не предел протокола. На эталонном 12-поточном Intel Core i7-1365U подготовка полностью заполненного B64 занимает 14,387 секунды на p95, а проверка — 0,720 секунды на p95. Более быстрое железо может соответствовать B255; каждая нода проверяет оба класса. Полные измерения находятся в двухклассовом бенчмарке.
Сеть
ParanO(1)d использует libp2p GossipSub для блоков и замыслов транзакций, типизированные request-response протоколы для синхронизации, Kademlia и DNS seeds для обнаружения, а mDNS — для локальных сетей. Постоянные пиры, лимиты соединений и разнообразие сетевых групп IPv4/IPv6 снижают риск простых eclipse-атак и connection flood без дополнительного раунда консенсуса.
Передача финализированного состояния аутентифицируется через HistoryStep; короткие разрывы закрывает обычная синхронизация недавних блоков. Тела финализированных транзакций активному консенсусу не нужны. Экспортируемые Merkle-чеки сохраняют доказательство включения после того, как тело транзакции покинуло недавний суффикс.
Запуск ParanO(1)d
Первая нода новой сети создаёт genesis и начинает майнинг:
paranoid --miner --genesis
--genesis нужен только первой ноде. Подключение к существующей сети в роли ноды или майнера:
Порты по умолчанию: 9400 для P2P и 127.0.0.1:9401 для JSON-RPC. При первом запуске создаются ~/.paranoid/paranoid.toml, состояние MDBX и встроенный кошелёк в ~/.paranoid/data/.
Текущий wallet.key не зашифрован паролем. Файл создаётся с правами только для владельца; сделайте резервную копию и защитите её.
CLI
Адреса используют bech32m и начинаются с o1. 1 NOID = 1 000 000 μNOID.
Полный интерфейс доступен через paranoid --help, noid-cli help и noid-extminer --help.
Сборка из исходников
Каноническая release-сборка поддерживает Linux на x86-64 и AArch64. Нужны Rust с rustfmt, нативный C/C++ toolchain, pkg-config, libclang и заголовки OpenSSL для разработки. Построение release-доказательств требует AVX2, PCLMULQDQ и VPCLMULQDQ на x86-64 либо AES/PMULL на AArch64.
git clone https://github.com/ignotusnemo/paranoid.git
cd paranoid
./scripts/build_release.sh
Сборка заново создаёт и аутентифицирует обе матрицы HistoryStep, запускает release-тесты и выпускает paranoid, noid-cli и noid-extminer.
Автор и разработчик — Ignotus Nemo. Лицензия Apache-2.0.