sync 2026-05-28T20:44:49Z

Montana-Protocol/Code/crates/montana-node/src/commands/start.rs

@@ -191,6 +191,10 @@ pub fn run(args: StartArgs) -> Result<(), NodeError> {
     let store = FsStore::open(&data_dir)
         .map_err(|e| NodeError::InvalidArguments(format!("FsStore::open: {e:?}")))?;
 
+    // DEV-012 T_r history: per-window T_r snapshot for BC endpoint validation
+    // when BCs arrive after current has advanced.
+    let mut t_r_history: BTreeMap<u64, Hash32> = BTreeMap::new();
+
     // DEV-012 multi-confirmer: per-window accumulator of BCs from Active peers.
     // Keyed by window then node_id so duplicates from same node deduplicate.
     let mut bc_accumulator: BTreeMap<u64, BTreeMap<mt_state::NodeId, BundledConfirmation>> =
@@ -571,7 +575,11 @@ pub fn run(args: StartArgs) -> Result<(), NodeError> {
                                 // current-window BCs this is timechain.t_r; for past windows
                                 // we'd need history. Simplification: validate against
                                 // current t_r only; older BCs may fail and be ignored.
-                                if mt_lottery::validate_bundle(&bc, &state.nodes, &timechain.t_r)
+                                let expected_t_r = t_r_history
+                                    .get(&bc.window_index)
+                                    .copied()
+                                    .unwrap_or(timechain.t_r);
+                                if mt_lottery::validate_bundle(&bc, &state.nodes, &expected_t_r)
                                     .is_ok()
                                 {
                                     let node_id = bc.node_id;
@@ -839,7 +847,14 @@ pub fn run(args: StartArgs) -> Result<(), NodeError> {
                     signature: Signature::from_array([0u8; SIGNATURE_SIZE]),
                 };
 
-                // DEV-012: insert own BC into accumulator first.
+                // DEV-012: record T_r for this window so late-arriving BCs validate
+                // against historical T_r (not Armenia's current after window advances).
+                t_r_history.insert(current, timechain.t_r);
+                while t_r_history.len() > 64 {
+                    let oldest = *t_r_history.keys().next().unwrap();
+                    t_r_history.remove(&oldest);
+                }
+                // Insert own BC into accumulator first.
                 bc_accumulator
                     .entry(current)
                     .or_default()
@@ -901,11 +916,15 @@ pub fn run(args: StartArgs) -> Result<(), NodeError> {
                                     if let Ok((rec_bc, _)) =
                                         BundledConfirmation::decode(&msg.payload)
                                     {
+                                        let exp_t_r = t_r_history
+                                            .get(&rec_bc.window_index)
+                                            .copied()
+                                            .unwrap_or(timechain.t_r);
                                         if rec_bc.window_index == current
                                             && mt_lottery::validate_bundle(
                                                 &rec_bc,
                                                 &state.nodes,
-                                                &timechain.t_r,
+                                                &exp_t_r,
                                             )
                                             .is_ok()
                                         {

Montana-Protocol/Manifesto/Manifesto EN.md

@@ -1,80 +1,115 @@
 # The Montana Manifesto
 
-**Version:** 1.0.0
+**Version:** 1.1.0
 **Date:** 2026-05-28
 **Author:** Alejandro Montana
 **Repository:** [github.com/efir369999/Montana](https://github.com/efir369999/Montana)
 
-> *"He who controls the past controls the future. He who controls the present controls the past."*
+> *"Who controls the past controls the future. Who controls the present controls the past."*
-> — George Orwell, *1984*
+> — Orwell, *1984*
 
-## I. The Question
+**The cash system Bitcoin promised. The economics of time the digital-money tradition has not yet built.**
 
-Bitcoin answered one question: **Whom do we trust with money?** *No one. Trust mathematics.*
+## I. The Cash System Bitcoin Did Not Build
 
-Bitcoin removed trust from money but left trust in time. Its difficulty adjusts to the wall-clocks of its miners; its block heights are measured against the watches of the world outside.
+Bitcoin's title was *A Peer-to-Peer Electronic Cash System*. Its cryptographic answer is famous: *whom do we trust with money?* — no one, trust mathematics. The cash-system answer never arrived.
 
-Montana answers a deeper question: **Whom do we trust with time?**
+A merchant at the corner cannot receive seven cents from the customer at the counter: the fee consumes the transaction. Settlement waits for block confirmation that is ten minutes at best and unbounded under congestion: the merchant cannot let the customer leave. Anti-spam is denominated in the very currency the system creates: under congestion the small user is priced out, under abundance the spammer re-enters at marginal cost — the mechanism oscillates with demand and does not converge.
 
-Money is a derivative of time, not the other way around. Today the infrastructure of time (NTP), of position (GPS), of communication (messaging servers) and of history (centralized databases) demands unconditional trust in a third party. One point of failure is one point of control. To control this infrastructure is to control the present. To control the databases is to rewrite the past.
+Bitcoin became **digital gold**. The medium-of-exchange property its title promised was never delivered.
 
-Montana makes *1984* technically impossible.
+Two things were missing.
 
-## II. Time as Computation
+- **A cash-system tokenomics.** Zero fees, so the seven-cent transaction settles. Asynchronous finality at window cementing — within a single window of the canonical order (approximately one minute of wall-clock at the genesis-hardware calibration), with no fee auction and no block queue ahead of the next operation. A non-speculative emission unit.
+- **An economics of time.** A non-monetary scarcity that replaces fees in anti-abuse, so the cash properties above are not undermined by the very mechanism that defends them — which is how Bitcoin lost its cash character in the first place.
 
-In Montana, a Verifiable Delay Function is not a clock that *displays* time. The VDF *is* time, written into the work of a sequential SHA-256 hash chain (FIPS 180-4). Each window is a sequential computation of `D ≈ 325 000 000` iterations on commodity x86_64 hardware. It cannot be parallelized; it cannot be faked; it cannot be hurried beyond the physics of the processor.
+The economics of time is a domain Bitcoin's framing did not see. The cash system is what Bitcoin's framing said but did not build. Montana takes both.
 
-Montana does not consume external time. Montana **produces** it. The output is an unbreakable cryptographic arrow of time — the **TimeChain**.
+Montana addresses, at the same level, three places where trust must still be removed:
 
-We chose a sequential SHA-256 delay function over the efficiently-verifiable constructions of Boneh, Bonneau, Bünz and Fisch [CRYPTO 2018], Pietrzak [ITCS 2019] and Wesolowski [EUROCRYPT 2019] deliberately. Verification cost equals computation cost. The minimal cryptographic surface is its own audit. SHA-256 is already required for hashing, addressing and Merkle commitments; no new assumption is added.
+- **Trust in time.** The protocol produces a canonical order of events with no external source.
+- **Trust in storage.** A user's data lives on the user's node, not in a corporation's database.
+- **Trust in communication.** Messages flow between users through their nodes, with no intermediary.
+
+The solution to the first problem is the foundation of the other two — and the carrier of the time-economics that makes the cash system viable.
+
+## II. Canonical Order, Not Wall-Clock Time
+
+Each Montana node performs a **sequential delay computation** — an iterated SHA-256 hash chain `T_W = SHA-256^D (T_{W-1})` with `D = 325 000 000` iterations per window. `D` is fixed in the Genesis Decree from a single quartz measurement on the genesis hardware (Apple iMac M1 2021, idle, single-thread); after Genesis the protocol consults no clock ([I-18]). The wall-clock duration of a window is an emergent property of each node's hardware and is not part of consensus state.
+
+This is **not** a verifiable delay function in the sense of Boneh-Bonneau-Bünz-Fisch [CRYPTO 2018], Pietrzak [ITCS 2019] or Wesolowski [EUROCRYPT 2019]. Those constructions provide succinct verification of order `O(log T)` or `O(1)`, but they operate over RSA groups or class groups of imaginary quadratic fields — assumptions broken by Shor's algorithm. A production-grade post-quantum succinct VDF does not yet exist. Montana takes the simpler primitive: an iterated SHA-256 chain. Verification cost equals computation cost; a verifier re-runs the same iterations the prover ran. SHA-256 is already required for addressing, hashing and Merkle commitments — no new assumption is added. The cryptographic surface is minimized to one primitive ([I-7]).
+
+The output is the **TimeChain**: a canonical, monotonic, unambiguous, independently verifiable sequence of windows. Montana does not measure physical duration. Mapping a window number to a calendar is the observer's task, not the protocol's.
 
 ## III. The Hierarchy of Truth
 
-Montana is built on a strict dependency. Every layer is impossible without the one below.
+Every layer is impossible without the one below.
 
-1. **Time** (`TimeChain`) — irreversible computation. The base layer of physics. Every operator ticks independently; together they form one global oscillator.
+1. **Canonical order** (`TimeChain`) — irreversible sequential computation. The base layer.
-2. **Presence** (`NodeChain`) — proof that a specific identity accompanied this stream of time. Weight in the network is measured by proven time of presence, not by capital. Capital does not buy more time.
+2. **Presence** (`NodeChain`) — a node's chain length, accumulated one window at a time as the node is canonically cemented into the order. Weight in consensus is presence, not capital. Capital cannot retroactively purchase past participation.
-3. **Money** (`Account`, `TimeCoin`) — the quantitative derivative of proven presence. The unit `Ɉ` is not a reward for solving meaningless puzzles; it is the recording of a passed second in the network's ledger. Emission is closed-form: `supply(W) = 13 × (W + 1) Ɉ`. No premine. No presale. No founder allocation.
+3. **Money** (`Account`, the Montana currency) — a quantitative derivative of presence. The reward for sealing a window is `EMISSION_moneta = 13 × 10⁹ moneta = 13 Ɉ`. Supply is closed-form: `supply_moneta(W) = EMISSION_moneta × (W + 1)`. No premine, no presale, no founder allocation, no halving, no supply cap, no discretionary issuance.
-4. **History** (`Anchor`) — the binding of any external fact (document, message, transaction) to this protected timeline. A hash is sealed in the TimeChain. To rewrite it is to recompute every iteration of the VDF from genesis. Mathematically impossible.
+4. **History** (`Anchor`) — a 32-byte hash bound to a window for the lifetime of the network. Rewriting it requires recomputing every iteration of the chain from the Genesis Decree. Mathematically impossible.
 
-*Money without proven presence is a phantom. Presence without verifiable time is a claim. Time without irreversible computation is trust.*
+`1 Ɉ = 10⁹ moneta`. The international ticker is `MONT`.
 
 ## IV. Post-Quantum from the First Day
 
-All consensus signatures are **ML-DSA-65** (FIPS 204). All transport key encapsulation is **ML-KEM-768** (FIPS 203). Hashing is **SHA-256** (FIPS 180-4). The transport handshake is **Noise_PQ XX**: ephemeral ML-KEM-768 on both sides, an ML-DSA-65 signature binding the full handshake transcript, and ChaCha20-Poly1305 AEAD framing on the established session (RFC 8439).
+- **Consensus signatures:** ML-DSA-65 (FIPS 204).
+- **Transport key encapsulation:** ML-KEM-768 (FIPS 203).
+- **Hashing:** SHA-256 (FIPS 180-4).
+- **Transport handshake:** Noise_PQ XX — ephemeral ML-KEM-768 on both sides, an ML-DSA-65 signature binding the full transcript, ChaCha20-Poly1305 AEAD framing (RFC 8439) on the established session.
+- **PeerId:** the SHA-256 multihash of each peer's ML-DSA-65 identity public key.
 
 No ECDSA. No EdDSA. No classical Diffie-Hellman. No assumption that Shor's algorithm will be late.
 
-PeerId is the SHA-256 multihash of each peer's ML-DSA-65 identity public key. Routing identity and consensus identity are bound to the same key material.
+## V. The Cash-System Tokenomics
 
-## V. Architecture Without Compromise
+The properties that make Montana a peer-to-peer electronic cash system are not features layered on a chain — they are the chain.
 
-- **Zero fees.** Anti-spam is operated by time, not by money: per-identity rate per window, `account_chain_length` thresholds, seniority gating. The protocol contains no `fee` field on any operation.
+- **Zero fees.** The protocol contains no `fee` field on any operation. The seven-cent transaction settles.
-- **Asynchronous finality.** Transfers do not wait for blocks. They are cemented through a P2P quorum of signatures from active operators in approximately 300 milliseconds.
+- **Asynchronous finality.** Transfers do not wait for blocks. They are cemented through a P2P quorum of signatures from active operators within a single window of the canonical order (approximately one minute of wall-clock at the genesis-hardware calibration; the wall-clock duration is emergent, not part of consensus state). The merchant lets the customer leave.
-- **No plutocracy.** Whoever holds one billion `Ɉ` has no more power in consensus than the operator of a Mac Mini. Emission (chronometric) and consensus (Proof of Time) are mathematically separated. The lottery seed incorporates `cemented_bundle_aggregate(W-2)` — a value an attacker cannot precompute without forging the signatures of honest participants.
+- **Constant monotonic emission.** `13 Ɉ` per window, fixed by the Genesis Decree, closed-form. No halving, no supply cap, no discretionary issuance. Supply is predictable for decades through one formula. The unit of money is not speculative; it is the record of a sealed window.
-- **No governance in state.** There is no DAO, no treasury, no founder veto. Advisory councils may exist outside the protocol; none of them have binding force inside it. The author is removed from the protocol.
+- **No plutocracy by construction.** Whoever holds a billion `Ɉ` has no more power in consensus than the operator of a Mac Mini. A node's weight is its chain length — its history of cemented presence. The lottery seed incorporates `cemented_bundle_aggregate(W-2)`, signatures from honest operators two windows back, which closes the grinding attack class under hardware asymmetry without depending on rational-cost arguments.
-- **No genesis nodes.** Montana launches as a peer-to-peer network in the style of Bitcoin. Any participant joins by running one command in a terminal. There is no founder-controlled bootstrap quorum.
+- **Two-thirds honest chain length.** Safety holds while honest operators control more than two-thirds of `active_chain_length`. Capital does not enter the threshold.
-- **67% honest active chain length.** Safety holds while honest operators control more than two-thirds of `active_chain_length`. Capital does not enter this threshold.
 
-## VI. The Scale Baseline
+## VI. The Economics of Time
 
-Every decision in Montana is calibrated for **at least one billion active users**. Mechanisms that do not scale to 10⁹ are discarded without discussion. AccountRecord is 2 059 bytes; state at 10⁹ accounts is approximately 2.06 TB, holdable on commodity disks. The pruning rule is canonical: state size is bounded by active population, not by chain age.
+Anti-abuse is done by time, not by money — three independent scarcities, each derived from time elapsed.
 
-## VII. Privacy as a Choice
+- **Per-identity rate per window.** One operation per account per window τ₁. An attacker with N Sybil identities gets at most N operations per window, but each identity has its own creation cost.
+- **`account_chain_length` thresholds.** Privileged operations require the operating account to have been active for at least `k` windows. The threshold cannot be purchased.
+- **Sequential entry barrier for node operators.** Node registration requires producing a sequential SHA-256 chain of length `vdf_chain_length × D` iterations — approximately fourteen days of wall-clock on a commodity x86_64 core. Sequential time is non-acquirable; an attacker with `M` parallel machines produces `M` identities at the same wall-clock cost, not faster.
 
-Balances, transfers and operator identities are public by default. Privacy is achieved through **Anchor** objects: a 32-byte hash is committed to the chain and the encrypted content is held off-chain by its owner. The protocol has no visibility into the contents. Privacy is what the user chooses to keep — not what the protocol imposes nor what the protocol forbids.
+Together these three close DoS without monetary barriers. Time as scarcity does not require a price feed, an oracle, or an exchange to measure. Its valuation is fixed by the protocol: one window is one window, regardless of `Ɉ` price.
 
-## VIII. What Montana Is Not
+## VII. The Ladder of Sovereignty
 
-Montana is not a faster Ethereum. Montana is not an L2. Montana is not a privacy mixer. Montana is not yield. Montana is not governance. Montana is not a brand.
+Two roles, one chain.
 
-Montana is the digital atomic clock for the internet. It is the standard of frequency from which money, presence and history derive.
+- **Account user.** A key in a smartphone or hardware wallet. Sends and receives Montana; commits 32-byte hashes via `Anchor`; runs applications on top of someone else's node. No protocol-layer earnings. Barrier: a first incoming Transfer (the AccountRecord is created atomically together with crediting the amount).
+- **Node operator.** Commodity hardware (one CPU core), 24/7 uptime, a network connection, and the sequential SHA-256 entry barrier at registration. Full participation in consensus. Earnings through the per-window node lottery.
+
+The seed phrase and the account chain belong to the user, not to the node. The user moves up the ladder when they choose to.
+
+## VIII. The Scale Baseline, Privacy, and Removal of the Author
+
+- **Scale.** Every decision is calibrated for at least one billion active users. Mechanisms that do not scale to 10⁹ are discarded without discussion. AccountRecord is 2 059 bytes; state at 10⁹ accounts is approximately 2.06 TB, holdable on commodity disks. Pruning is canonical: state size is bounded by active population, not by chain age.
+- **Privacy.** Balances and account graphs are public by default ([I-2]). Application-level privacy is achieved through `Anchor`: a 32-byte hash is committed to the chain; encrypted content is held off-chain by its owner. The protocol has no visibility into the contents. Privacy is what the user chooses to keep — not what the protocol imposes nor what the protocol forbids.
+- **No governance in state.** No DAO, no treasury, no founder veto. Advisory councils may exist outside the protocol; none of them have binding force inside it. The author is removed from the protocol by construction. Montana launches as a peer-to-peer network with no founder-controlled bootstrap quorum.
+
+## IX. What Montana Is
+
+Not a blockchain with a timestamping feature. Not a faster Ethereum. Not an L2. Not a privacy mixer. Not yield. Not governance. Not a brand. Not digital gold.
+
+Montana is **the peer-to-peer electronic cash system whose anti-abuse scarcity is time, not money** — the cash system Bitcoin's title promised and Bitcoin did not deliver, built on top of **the economics of time** the digital-money tradition has not yet built.
+
+A time frame of reference with a value-transfer feature. The standard of frequency from which money, presence and history derive.
 
 ---
 
-**Reference implementation:** Rust, Apache-2.0 / MIT. Twelve crates including `mt-timechain`, `mt-consensus`, `mt-lottery`, `mt-crypto`, `mt-net`, `mt-noise-pq`. Specification: [Whitepaper Montana.md](../Whitepaper%20Montana.md).
+**Reference implementation:** Rust, Apache-2.0 / MIT. Twenty-three crates including `mt-timechain`, `mt-consensus`, `mt-lottery`, `mt-crypto`, `mt-net`, `mt-noise-pq`. Specification: [Whitepaper Montana.md](../Whitepaper%20Montana.md) and [Montana Protocol v35.25.1](../Montana%20Protocol%20v35.25.1.md).
 
-**Symbol:** **Ɉ** — one second of Montana time.
+**Symbol:** **Ɉ** — Montana. `moneta` — the smallest unit (`1 Ɉ = 10⁹ moneta`). **Ticker:** `MONT`.
 
 Alejandro Montana
 *Ничто_Nothing_无_金元Ɉ*

Montana-Protocol/Manifesto/Manifesto RU.md

@@ -1,80 +1,115 @@
 # Манифест Монтаны
 
-**Версия:** 1.0.0
+**Версия:** 1.1.0
 **Дата:** 28 мая 2026
 **Автор:** Alejandro Montana
 **Репозиторий:** [github.com/efir369999/Montana](https://github.com/efir369999/Montana)
 
-> *«Тот, кто контролирует прошлое, контролирует будущее. Тот, кто контролирует настоящее, контролирует прошлое».*
+> *«Кто контролирует прошлое — контролирует будущее. Кто контролирует настоящее — контролирует прошлое».*
-> — Дж. Оруэлл, *1984*
+> — Оруэлл, *1984*
 
-## I. Вопрос
+**Кэш-система, которую обещал Биткоин. Экономика времени, которую традиция цифровых денег ещё не построила.**
 
-Биткоин ответил на один вопрос: **Кому доверять деньги?** *Никому. Доверяй математике.*
+## I. Кэш-система, которую Биткоин не построил
 
-Биткоин убрал доверие из денег, но оставил доверие во времени. Его сложность подстраивается под наручные часы майнеров; высота его блоков сверяется со временем мира снаружи.
+Название whitepaper Биткоина — *«A Peer-to-Peer Electronic Cash System»*. Его криптографический ответ известен: *кому доверять деньги?* — никому, доверяй математике. Системного ответа на «кэш-систему» так и не пришло.
 
-Монтана отвечает на более глубокий вопрос: **Кому доверять время?**
+Продавец на углу не может принять семь центов от покупателя у кассы: комиссия съедает перевод. Финальность ждёт подтверждения блока — десять минут в лучшем случае и неограниченное время при заторе: продавец не может отпустить покупателя. Анти-спам выражен в той же валюте, которую система создаёт: при заторе мелкий пользователь вытеснен ценой, при свободе спамер возвращается по предельной цене — механизм осциллирует со спросом и не сходится.
 
-Деньги — производная от времени, а не наоборот. Сегодня инфраструктура измерения времени (NTP), позиционирования (GPS), связи (серверы мессенджеров) и истории (централизованные базы данных) требует безусловного доверия к третьей стороне. Одна точка отказа — одна точка контроля. Контролировать эту инфраструктуру означает контролировать настоящее. Контролировать базы данных — переписывать прошлое.
+Биткоин стал **digital gold**. Медиум-обмена-функция, обещанная в заголовке, не была доставлена.
 
-Монтана делает *1984* технически невозможным.
+Не хватало двух вещей.
 
-## II. Время как вычисление
+- **Токеномики кэш-системы.** Нулевые комиссии, чтобы перевод на семь центов имел смысл. Асинхронная финальность на закрытии окна — внутри одного окна канонического порядка (примерно одна минута wall-clock на генезис-калибровке), без fee-аукциона и без очереди блоков перед следующей операцией. Неспекулятивная единица эмиссии.
+- **Экономики времени.** Неденежная нехватка, заменяющая комиссию в анти-абузе — иначе свойства кэш-системы будут подорваны тем же механизмом, который их защищает (это и есть способ, которым Биткоин потерял свой кэш-характер).
 
-В Монтане функция отложенной верификации (VDF) — это не часы, которые *показывают* время. VDF — это само время, *записанное в работе* последовательной цепочки хэшей SHA-256 (FIPS 180-4). Каждое окно — последовательное вычисление `D ≈ 325 000 000` итераций на обычном процессоре x86_64. Его невозможно распараллелить, нельзя подделать, нельзя ускорить за пределами физики самого процессора.
+Экономика времени — это домен, которого рамка Биткоина не увидела. Кэш-система — это то, что рамка Биткоина сказала, но не построила. Монтана берёт оба.
 
-Монтана не потребляет внешнее время. Монтана его **производит**. На выходе — нерушимая криптографическая стрела времени — **TimeChain**.
+Монтана адресует на одном уровне три места, где доверие нужно убрать:
 
-Мы намеренно выбрали последовательную SHA-256 функцию вместо эффективно-верифицируемых конструкций Бонеха-Бонно-Бюнца-Фиша [CRYPTO 2018], Петрчака [ITCS 2019] и Весоловского [EUROCRYPT 2019]. Стоимость проверки равна стоимости вычисления. Минимальная криптографическая поверхность — это и есть аудит. SHA-256 в любом случае нужен для хеширования, адресации и обязательств Меркла; новых предположений не добавляется.
+- **Доверие ко времени.** Протокол производит канонический порядок событий без внешнего источника.
+- **Доверие к хранению.** Данные пользователя живут на узле пользователя, а не в базе корпорации.
+- **Доверие к связи.** Сообщения текут между пользователями через их узлы без посредника.
+
+Решение первой задачи — фундамент двух остальных и носитель той экономики времени, которая делает кэш-систему жизнеспособной.
+
+## II. Канонический порядок, не наручное время
+
+Каждый узел Монтаны выполняет **последовательное вычисление с задержкой** — итерированную цепочку хэшей SHA-256 `T_W = SHA-256^D (T_{W-1})`, где `D = 325 000 000` итераций на окно. `D` зафиксирован в Указе Генезиса по единственному кварцевому замеру на генезис-железе (Apple iMac M1 2021, idle, single-thread); после Генезиса протокол не обращается к часам ([I-18]). Длительность окна в секундах внешнего мира — эмерджентное свойство железа узла, она не входит в consensus state.
+
+Это **не** verifiable delay function в смысле Бонех-Бонно-Бюнц-Фиш [CRYPTO 2018], Петрчака [ITCS 2019] или Весоловского [EUROCRYPT 2019]. Те конструкции дают сжатую верификацию `O(log T)` или `O(1)`, но работают над группами RSA или групп классов мнимо-квадратичных полей — предположения, ломаемые алгоритмом Шора. PQ-стойкого succinct VDF production-grade сегодня не существует. Монтана берёт более простой примитив: итерированную цепочку SHA-256. Стоимость проверки равна стоимости вычисления; верификатор повторяет те же итерации, что и вычислитель. SHA-256 в любом случае нужен для адресации, хеширования и обязательств Меркла — новых предположений не добавляется. Криптографическая поверхность сведена к одному примитиву ([I-7]).
+
+На выходе — **TimeChain**: канонический, монотонный, однозначный, независимо верифицируемый порядок окон. Монтана не измеряет физическую длительность. Сопоставление номера окна с календарём — задача наблюдателя, не протокола.
 
 ## III. Иерархия истины
 
-Архитектура Монтаны строится на строгой зависимости. Каждый последующий слой невозможен без предыдущего.
+Каждый последующий слой невозможен без предыдущего.
 
-1. **Время** (`TimeChain`) — необратимое вычисление. Базовый слой физики. Каждый оператор тикает независимо; вместе они образуют единый глобальный осциллятор.
+1. **Канонический порядок** (`TimeChain`) — необратимое последовательное вычисление. Базовый слой.
-2. **Присутствие** (`NodeChain`) — доказательство того, что конкретный идентификатор сопровождал этот поток времени. Вес в сети измеряется доказанным временем присутствия, не капиталом. Капитал не покупает времени.
+2. **Присутствие** (`NodeChain`) — длина цепочки узла, накапливающаяся по одному окну за раз по мере канонической фиксации узла в порядке. Вес в консенсусе — это присутствие, не капитал. Капитал не покупает ретроактивно прошлое участие.
-3. **Деньги** (`Account`, `TimeCoin`) — количественная производная от доказанного присутствия. Единица `Ɉ` — это не награда за решение бессмысленных задач, а запись прошедшей секунды в книге сети. Эмиссия в закрытой форме: `supply(W) = 13 × (W + 1) Ɉ`. Никакого премайна. Никакого пресейла. Никакой доли основателя.
+3. **Деньги** (`Account`, валюта Монтана) — количественная производная от присутствия. Награда за окно — `EMISSION_moneta = 13 × 10⁹ moneta = 13 Ɉ`. Эмиссия в закрытой форме: `supply_moneta(W) = EMISSION_moneta × (W + 1)`. Никакого премайна, пресейла, доли основателя, халвинга, supply cap, дискреционной эмиссии.
-4. **История** (`Anchor`) — привязка любого внешнего факта (документа, сообщения, транзакции) к этой защищённой временной линии. Хэш навсегда зафиксирован в TimeChain. Переписать его означает пересчитать каждую итерацию VDF от генезиса. Математически невозможно.
+4. **История** (`Anchor`) — 32-байтовый хэш, привязанный к окну на всю жизнь сети. Переписать его означает пересчитать каждую итерацию цепочки от Указа Генезиса. Математически невозможно.
 
-*Деньги без доказанного присутствия — фантомы. Присутствие без верифицируемого времени — заявление. Время без необратимых вычислений — доверие.*
+`1 Ɉ = 10⁹ moneta`. Международный тикер — `MONT`.
 
 ## IV. Постквантовая с первого дня
 
-Все консенсусные подписи — **ML-DSA-65** (FIPS 204). Все инкапсуляции ключей транспорта — **ML-KEM-768** (FIPS 203). Хеширование — **SHA-256** (FIPS 180-4). Транспортное рукопожатие — **Noise_PQ XX**: эфемерные ML-KEM-768 с обеих сторон, подпись ML-DSA-65 связывающая весь транскрипт рукопожатия, шифрование установленной сессии ChaCha20-Poly1305 AEAD (RFC 8439).
+- **Консенсусные подписи:** ML-DSA-65 (FIPS 204).
+- **Инкапсуляция ключей транспорта:** ML-KEM-768 (FIPS 203).
+- **Хеширование:** SHA-256 (FIPS 180-4).
+- **Транспортное рукопожатие:** Noise_PQ XX — эфемерные ML-KEM-768 с обеих сторон, ML-DSA-65 подпись связывающая весь транскрипт, шифрование сессии ChaCha20-Poly1305 AEAD (RFC 8439).
+- **PeerId:** SHA-256 multihash открытого ключа ML-DSA-65 каждого пира.
 
 Никакого ECDSA. Никакого EdDSA. Никакого классического Диффи-Хеллмана. Никаких надежд, что алгоритм Шора задержится.
 
-PeerId — это SHA-256 multihash открытого ключа ML-DSA-65 каждого пира. Маршрутизация и консенсус привязаны к одному и тому же ключевому материалу.
+## V. Токеномика кэш-системы
 
-## V. Архитектура без компромиссов
+Свойства, делающие Монтану peer-to-peer электронной кэш-системой, — это не «фичи поверх цепи». Это сама цепь.
 
-- **Без комиссий.** Защита от спама построена через время, не через деньги: одна операция на идентичность за окно, пороги по `account_chain_length`, приоритет по выслуге. В протоколе нет поля `fee` ни в одной операции.
+- **Нулевые комиссии.** В протоколе нет поля `fee` ни в одной операции. Семь центов проходят.
-- **Асинхронная финальность.** Переводы не ждут блоков. Они закрепляются через P2P-кворум подписей активных операторов примерно за 300 миллисекунд.
+- **Асинхронная финальность.** Переводы не ждут блоков. Они закрепляются через P2P-кворум подписей активных операторов внутри одного окна канонического порядка (примерно одна минута wall-clock на генезис-калибровке; длительность окна — эмерджентное свойство, не часть consensus state). Продавец отпускает покупателя.
-- **Без плутократии.** Тот, у кого один миллиард `Ɉ`, не имеет в консенсусе больше власти, чем оператор Mac Mini. Эмиссия (хронометрическая) и консенсус (Proof of Time) математически разделены. Семя лотереи содержит `cemented_bundle_aggregate(W-2)` — значение, которое атакующий не может предвычислить без подделки подписей честных участников.
+- **Константная монотонная эмиссия.** `13 Ɉ` за окно, зафиксировано Указом Генезиса, закрытая форма. Никакого халвинга, никакого supply cap, никакой дискреционной эмиссии. Supply предсказуем на десятилетия одной формулой. Единица денег — не спекулятивная, это запись закрытого окна.
-- **Никакого governance в состоянии.** Нет DAO, нет казны, нет права вето основателя. Совещательные советы могут существовать снаружи протокола; ни один из них не имеет обязывающей силы внутри. Автор удалён из протокола.
+- **Никакой плутократии по построению.** Тот, у кого миллиард `Ɉ`, не имеет в консенсусе больше власти, чем оператор Mac Mini. Вес узла — это длина его цепочки, история закреплённого присутствия. Семя лотереи содержит `cemented_bundle_aggregate(W-2)` — подписи честных операторов двумя окнами назад, что закрывает класс grinding-атак при асимметрии железа без опоры на рациональные cost-аргументы.
-- **Никаких узлов генезиса.** Монтана запускается как peer-to-peer-сеть в стиле Биткоина. Любой участник присоединяется одной командой в терминале. Bootstrap-кворума под контролем основателя не существует.
+- **Две трети честной длины цепочки.** Безопасность сохраняется, пока честные операторы контролируют более двух третей `active_chain_length`. Капитал в этот порог не входит.
-- **67 % честной active_chain_length.** Безопасность сохраняется, пока честные операторы контролируют более двух третей `active_chain_length`. Капитал в этот порог не входит.
 
-## VI. Базовый масштаб
+## VI. Экономика времени
 
-Каждое решение Монтаны рассчитывается под **не менее одного миллиарда активных пользователей**. Механизмы, не масштабирующиеся на 10⁹, отбрасываются без обсуждения. Запись аккаунта — 2 059 байт; состояние при 10⁹ аккаунтов — около 2,06 ТБ, помещается на обычных дисках. Правило очистки каноническое: размер состояния ограничен активным населением, не возрастом цепи.
+Анти-абуз построен через время, не через деньги — три независимые нехватки, каждая выводится из прошедшего времени.
 
-## VII. Приватность как выбор
+- **Темп на идентичность за окно.** Одна операция на аккаунт за окно τ₁. Атакующий с N Sybil-идентичностями получает не более N операций за окно, и у каждой идентичности своя стоимость создания.
+- **Пороги по `account_chain_length`.** Привилегированные операции требуют, чтобы аккаунт был активен не менее `k` окон. Порог нельзя купить.
+- **Последовательный SHA-256 барьер на регистрацию узла.** Регистрация требует последовательной цепочки SHA-256 длины `vdf_chain_length × D` итераций — примерно четырнадцать суток wall-clock на одном ядре commodity x86_64. Последовательное время неприобретаемо; атакующий с `M` параллельными машинами получает `M` идентичностей за то же wall-clock, не быстрее.
 
-Балансы, переводы и идентификаторы операторов открыты по умолчанию. Приватность реализуется через объекты **Anchor**: 32-байтный хэш записывается в цепь, а зашифрованное содержимое хранится у владельца вне цепи. Протокол не видит содержимого. Приватность — это то, что пользователь выбирает сохранить, а не то, что протокол навязывает или запрещает.
+Вместе три механизма закрывают DoS без денежных барьеров. Время как нехватка не требует прайс-фида, оракула или биржи. Его оценка зафиксирована протоколом: одно окно равно одному окну, независимо от цены `Ɉ`.
 
-## VIII. Чем Монтана не является
+## VII. Лестница суверенитета
 
-Монтана — не более быстрый Эфириум. Монтана — не L2. Монтана — не приватный миксер. Монтана — не доходность. Монтана — не governance. Монтана — не бренд.
+Две роли, одна цепочка.
 
-Монтана — это цифровые атомные часы интернета. Это эталон частоты, от которого выводятся деньги, присутствие и история.
+- **Пользователь аккаунта.** Ключ в смартфоне или аппаратном кошельке. Отправляет и получает Монтану; коммитит 32-байтовые хэши через `Anchor`; запускает приложения поверх чужого узла. Заработка на уровне протокола нет. Барьер входа — первый входящий перевод (запись аккаунта создаётся атомарно вместе с зачислением суммы).
+- **Оператор узла.** Обычное железо (одно ядро), 24/7 аптайм, сетевое соединение и последовательный SHA-256 барьер на регистрации. Полное участие в консенсусе. Заработок через лотерею окон.
+
+Сид-фраза и цепочка аккаунта принадлежат пользователю, а не узлу. По лестнице вверх — когда пользователь сам решит.
+
+## VIII. Базовый масштаб, приватность и удаление автора
+
+- **Масштаб.** Каждое решение калибруется под не менее одного миллиарда активных пользователей. Механизмы, не масштабирующиеся на 10⁹, отбрасываются без обсуждения. Запись аккаунта — 2 059 байт; состояние при 10⁹ аккаунтов — около 2,06 ТБ, помещается на обычных дисках. Очистка каноническая: размер состояния ограничен активным населением, не возрастом цепи.
+- **Приватность.** Балансы и графы аккаунтов открыты по умолчанию ([I-2]). Прикладная приватность реализуется через `Anchor`: 32-байтовый хэш записывается в цепь, а зашифрованное содержимое хранится у владельца вне цепи. Протокол не видит содержимого. Приватность — это то, что пользователь выбирает сохранить, а не то, что протокол навязывает или запрещает.
+- **Никакого governance в состоянии.** Нет DAO, казны, права вето основателя. Совещательные советы могут существовать снаружи протокола; внутри ни один не имеет обязывающей силы. Автор удалён из протокола по построению. Монтана запускается как peer-to-peer-сеть без bootstrap-кворума под контролем основателя.
+
+## IX. Чем Монтана является
+
+Не блокчейн с фичей timestamping. Не более быстрый Эфириум. Не L2. Не приватный миксер. Не доходность. Не governance. Не бренд. Не digital gold.
+
+Монтана — это **peer-to-peer электронная кэш-система, анти-абуз-нехватка которой — время, а не деньги**: кэш-система, которую обещал заголовок Биткоина и Биткоин не доставил, построенная поверх **экономики времени**, которую традиция цифровых денег ещё не построила.
+
+Система отсчёта времени с фичей передачи стоимости. Эталон частоты, от которого выводятся деньги, присутствие и история.
 
 ---
 
-**Эталонная реализация:** Rust, Apache-2.0 / MIT. Двенадцать крейтов, включая `mt-timechain`, `mt-consensus`, `mt-lottery`, `mt-crypto`, `mt-net`, `mt-noise-pq`. Спецификация: [Whitepaper Montana.md](../Whitepaper%20Montana.md).
+**Эталонная реализация:** Rust, Apache-2.0 / MIT. Двадцать три крейта, включая `mt-timechain`, `mt-consensus`, `mt-lottery`, `mt-crypto`, `mt-net`, `mt-noise-pq`. Спецификация: [Whitepaper Montana.md](../Whitepaper%20Montana.md) и [Montana Protocol v35.25.1](../Montana%20Protocol%20v35.25.1.md).
 
-**Символ:** **Ɉ** — одна секунда времени Монтаны.
+**Символ:** **Ɉ** — Монтана. `moneta` — наименьшая единица (`1 Ɉ = 10⁹ moneta`). **Тикер:** `MONT`.
 
 Alejandro Montana
 *Ничто_Nothing_无_金元Ɉ*

Montana-Protocol/Manifesto/Manifesto ZH.md

@@ -1,80 +1,115 @@
 # 蒙塔纳宣言
 
-**版本：** 1.0.0
+**版本：** 1.1.0
 **日期：** 2026 年 5 月 28 日
 **作者：** Alejandro Montana
 **仓库：** [github.com/efir369999/Montana](https://github.com/efir369999/Montana)
 
 > *「谁控制过去，谁就控制未来；谁控制现在，谁就控制过去。」*
-> ——乔治·奥威尔《1984》
+> ——奥威尔《1984》
 
-## 一、问题
+**比特币所承诺的现金系统。数字货币传统尚未建立的时间经济学。**
 
-比特币回答了一个问题：**谁来托管金钱？** *无人。请信任数学。*
+## 一、比特币未曾建造的现金系统
 
-比特币把信任从金钱中移除，却把信任留在了时间里。它的难度调整依赖于矿工的钟表，它的区块高度以外界的时钟为度量。
+比特币白皮书的标题是 *《A Peer-to-Peer Electronic Cash System》*。其密码学答案早已知名：*谁来托管金钱？*——无人，请信任数学。其现金系统的答案从未到来。
 
-蒙塔纳回答一个更深的问题：**谁来托管时间？**
+街角的商家无法收取顾客交出的七分钱：手续费吞掉了交易。终局等待区块确认——最佳情况下十分钟、拥堵时无上界：商家无法让顾客离开。反垃圾以系统所创造的同一货币计价：拥堵时小用户被价格挤出，闲置时垃圾以边际成本回流——机制随需求而振荡，不收敛。
 
-金钱是时间的衍生物，反之则不然。今天，测量时间的基础设施（NTP）、定位的基础设施（GPS）、通讯的基础设施（消息服务器）以及历史的基础设施（中心化数据库），都要求无条件信任第三方。一个故障点，就是一个控制点。控制这套基础设施，就是控制现在；控制这些数据库，就是改写过去。
+比特币成了 **数字黄金**。其标题所许诺的「交换媒介」属性从未兑现。
 
-蒙塔纳让《1984》在技术上不可能成立。
+缺了两样东西：
 
-## 二、时间即计算
+- **现金系统的代币经济学。** 零手续费，使七分钱的交易得以结清。窗口固化时的异步终局——发生于规范顺序的单一窗口之内（在创世硬件校准下约一分钟外部时钟），无手续费拍卖，下一笔操作前无区块队列。一个非投机性的发行单位。
+- **时间经济学。** 一种取代手续费在反滥用中位置的非货币性稀缺——否则上述现金属性，将被其自身的防御机制所拆毁（这正是比特币失去现金特性的方式）。
 
-在蒙塔纳中，可验证延迟函数（VDF）不是一个 *显示* 时间的时钟。VDF 本身 *就是* 时间，写在 SHA-256（FIPS 180-4）顺序哈希链的工作之中。每一个时间窗口是约 `D ≈ 325 000 000` 次顺序迭代的计算，运行于普通 x86_64 处理器之上。它无法并行，无法伪造，也无法在处理器物理极限之外加速。
+时间经济学，是比特币的语境从未看见的领域。现金系统，则是比特币的语境说过却未曾建造的东西。蒙塔纳两者皆取。
 
-蒙塔纳不消耗外部时间，而是 **生产** 时间。其输出，是一支不可摧毁的密码学时间之箭——**TimeChain**。
+蒙塔纳在同一层面上处理三个仍需移除信任的位置：
 
-我们刻意选用顺序 SHA-256 延迟函数，而非 Boneh-Bonneau-Bünz-Fisch [CRYPTO 2018]、Pietrzak [ITCS 2019]、Wesolowski [EUROCRYPT 2019] 的可高效验证型 VDF。验证成本等于计算成本。最小的密码学表面，本身就是审计。SHA-256 在哈希、寻址与默克尔承诺中本就必须存在，并未引入任何新的假设。
+- **时间之信任。** 协议在无外部时间源的情况下生成事件的规范顺序。
+- **存储之信任。** 用户数据存于用户自己的节点，而非企业数据库。
+- **通讯之信任。** 消息通过用户的节点在用户之间流动，无中介。
+
+第一个问题的解，是后两个问题的基础——也是承载那门让现金系统得以成立的时间经济学的载体。
+
+## 二、规范顺序，而非外部时钟时间
+
+蒙塔纳的每个节点都执行 **顺序延迟计算**——一条迭代式 SHA-256 哈希链 `T_W = SHA-256^D (T_{W-1})`，每个窗口包含 `D = 325 000 000` 次迭代。`D` 由创世法令固定，源自创世硬件上的单次石英测量（Apple iMac M1 2021，空闲，单线程）；创世之后协议不再查阅任何时钟（[I-18]）。窗口在外部世界中的实际持续时间，是节点硬件所体现出的衍生属性，并不属于共识状态。
+
+这 **不是** Boneh-Bonneau-Bünz-Fisch [CRYPTO 2018]、Pietrzak [ITCS 2019]、Wesolowski [EUROCRYPT 2019] 意义上的可验证延迟函数。那些构造提供 `O(log T)` 或 `O(1)` 的简洁验证，但它们建立于 RSA 群或虚二次域类群之上——这些假设会被 Shor 算法攻破。当今尚不存在生产级别的抗量子简洁 VDF。蒙塔纳采取更简单的原语：迭代式 SHA-256 链。验证成本等于计算成本；验证者重复运行与证明者相同的迭代。SHA-256 本就必须用于寻址、哈希与默克尔承诺，并未引入任何新的假设。密码学表面被压缩至单一原语（[I-7]）。
+
+其输出即 **TimeChain**：一个规范的、单调的、无歧义的、可独立验证的窗口序列。蒙塔纳并不测量物理持续时间。把窗口编号映射为日历时间，是观察者的任务，而非协议的任务。
 
 ## 三、真相的层级
 
-蒙塔纳的架构建立在严格的依赖之上，每一层都不可能脱离其下一层而成立。
+每一层皆不可能脱离其下一层而存在。
 
-1. **时间**（`TimeChain`）——不可逆的计算。物理学的基础层。每个运营者独立地嘀嗒，共同构成一个全球振荡器。
+1. **规范顺序**（`TimeChain`）——不可逆的顺序计算。基础层。
-2. **在场**（`NodeChain`）——证明某个特定身份伴随了这一时间流。网络中的权重，由可证明的在场时间度量，而非由资本度量。资本不能购买时间。
+2. **在场**（`NodeChain`）——节点的链长，随节点被规范地固化进顺序，一次一个窗口地累积。共识中的权重是「在场」，而非「资本」。资本无法追溯购买过去的参与。
-3. **货币**（`Account` 与 `TimeCoin`）——可证在场的数量化衍生物。单位 `Ɉ` 不是解决无意义难题的奖励，而是网络账本中一秒钟的记录。发行量是封闭式的：`supply(W) = 13 × (W + 1) Ɉ`。没有预挖。没有预售。没有创始人份额。
+3. **货币**（`Account`，蒙塔纳货币）——可证在场的数量化衍生物。封存一个窗口的奖励为 `EMISSION_moneta = 13 × 10⁹ moneta = 13 Ɉ`。供应量为封闭式：`supply_moneta(W) = EMISSION_moneta × (W + 1)`。无预挖、无预售、无创始人份额、无减半、无总量上限、无任何裁量发行。
-4. **历史**（`Anchor`）——把任何外部事实（文档、消息、交易）绑定到这条受保护的时间线。其哈希被永久封存于 TimeChain 之中。改写它，意味着从创世起重新计算每一次 VDF 迭代。在数学上不可能。
+4. **历史**（`Anchor`）——一个 32 字节哈希在网络的整个生命周期内被绑定到某一窗口。改写它意味着从创世法令开始重新计算链的每一次迭代。在数学上不可能。
 
-*没有可证在场的货币，是幻影；没有可验证时间的在场，是断言；没有不可逆计算的时间，是信任。*
+`1 Ɉ = 10⁹ moneta`。国际行情代码为 `MONT`。
 
 ## 四、自第一天起的抗量子
 
-所有共识签名采用 **ML-DSA-65**（FIPS 204）。所有传输层密钥封装采用 **ML-KEM-768**（FIPS 203）。哈希采用 **SHA-256**（FIPS 180-4）。传输握手为 **Noise_PQ XX**：双方各自的临时 ML-KEM-768、绑定到完整握手记录的 ML-DSA-65 签名、以及在已建立会话上的 ChaCha20-Poly1305 AEAD 帧加密（RFC 8439）。
+- **共识签名：** ML-DSA-65（FIPS 204）。
+- **传输层密钥封装：** ML-KEM-768（FIPS 203）。
+- **哈希：** SHA-256（FIPS 180-4）。
+- **传输握手：** Noise_PQ XX——双方各自的临时 ML-KEM-768、绑定整个握手记录的 ML-DSA-65 签名、已建立会话上的 ChaCha20-Poly1305 AEAD 加密（RFC 8439）。
+- **PeerId：** 每个节点 ML-DSA-65 身份公钥的 SHA-256 multihash。
 
 没有 ECDSA。没有 EdDSA。没有经典 Diffie-Hellman。不指望 Shor 算法会迟到。
 
-PeerId 是每个节点 ML-DSA-65 身份公钥的 SHA-256 multihash。路由身份与共识身份绑定在同一份密钥之上。
+## 五、现金系统的代币经济学
 
-## 五、不妥协的架构
+让蒙塔纳成为对等电子现金系统的那些属性，并非「附在链上的功能」，而是链本身。
 
-- **零手续费。** 防垃圾通过时间而非金钱实现：每身份每窗口一次操作、`account_chain_length` 阈值、资历门控。协议中任何操作都没有 `fee` 字段。
+- **零手续费。** 协议中任何操作都没有 `fee` 字段。七分钱可以通过。
-- **异步终局。** 转账不等待区块，而是由活跃运营者的 P2P 法定签名在约 300 毫秒内固化。
+- **异步终局。** 转账不等待区块，而是由活跃运营者的 P2P 法定签名在规范顺序的单一窗口之内固化（在创世硬件校准下约一分钟外部时钟；窗口时长为衍生属性，不属于共识状态）。商家敢让顾客离开。
-- **不行金权政治。** 持有十亿 `Ɉ` 的人，在共识中并不比一台 Mac Mini 的运营者拥有更多权力。发行（按时间计量）与共识（时间证明）在数学上彼此分离。抽签种子包含 `cemented_bundle_aggregate(W-2)`——攻击者若不伪造诚实参与者的签名便无法预计算的值。
+- **恒定单调发行。** 每窗口 `13 Ɉ`，由创世法令固定，封闭式。无减半、无总量上限、无裁量发行。供应量可由一条公式预测数十年。货币单位不是投机品，而是一次封窗的记录。
-- **状态中无治理。** 没有 DAO，没有金库，没有创始人否决权。咨询委员会可在协议之外存在；它们在协议之内皆无约束力。作者将自己从协议中移除。
+- **构造上即非金权政治。** 持有十亿 `Ɉ` 的人，在共识中并不比一台 Mac Mini 的运营者拥有更多权力。节点的权重是其链长——其被固化的在场历史。抽签种子包含 `cemented_bundle_aggregate(W-2)`，即两个窗口前诚实运营者的签名，这在不依赖任何成本理性论证的前提下，封堵了硬件不对称情境下的研磨攻击。
-- **不设创世节点。** 蒙塔纳以比特币式的对等网络方式启动。任何参与者皆可通过终端中的一条命令加入。不存在由创始人掌控的引导法定人数。
+- **链长三分之二的诚实门槛。** 只要诚实运营者掌握 `active_chain_length` 的三分之二以上，安全性即得到保持。资本不进入该门槛。
-- **诚实 `active_chain_length` 的三分之二。** 只要诚实运营者掌握 `active_chain_length` 的三分之二以上，安全性即得到保持。资本不进入这一门槛。
 
-## 六、规模基准
+## 六、时间经济学
 
-蒙塔纳的每一项决策都以 **至少十亿活跃用户** 为基准。无法扩展到 10⁹ 的机制不予讨论。账户记录为 2 059 字节；10⁹ 账户下的状态约 2.06 TB，普通磁盘即可承载。修剪规则是规范的：状态大小由活跃人口决定，而非由链龄决定。
+反滥用以时间而非金钱构造——三种独立的稀缺，每一种皆出自已逝时间。
 
-## 七、隐私即选择
+- **每身份每窗口的速率。** 每个账户每窗口 τ₁ 至多一次操作。攻击者拥有 N 个 Sybil 身份至多得到 N 次操作；每个身份都有自己的创建成本。
+- **`account_chain_length` 阈值。** 特权操作要求所操作账户已活跃至少 `k` 个窗口。这一门槛无法购买。
+- **节点运营者的顺序进入门槛。** 节点注册需生成一条长度为 `vdf_chain_length × D` 的顺序 SHA-256 链——约相当于普通 x86_64 单核外部时钟约十四天的工作量。顺序时间不可购买；攻击者用 `M` 台并行机器仅能在同一外部时钟内得到 `M` 个身份，并不更快。
 
-余额、转账与运营者身份默认公开。隐私通过 **Anchor** 对象实现：32 字节的哈希被提交到链上，加密内容由所有者保存在链外。协议看不见内容。隐私是用户选择保留的，而不是协议强加或禁止的。
+三者合力，在无金钱壁垒的前提下封堵 DoS。时间这种稀缺，不需要价格喂价、不需要预言机、也不需要交易所来度量。其估值由协议固定：一个窗口等于一个窗口，与 `Ɉ` 的价格无关。
 
-## 八、蒙塔纳不是什么
+## 七、主权阶梯
 
-蒙塔纳不是更快的以太坊。蒙塔纳不是 L2。蒙塔纳不是隐私混币。蒙塔纳不是收益率。蒙塔纳不是治理。蒙塔纳不是品牌。
+两种角色，一条链。
 
-蒙塔纳是互联网的数字原子钟。它是频率的基准，金钱、在场与历史皆由此衍生。
+- **账户用户。** 智能手机或硬件钱包中的一把钥匙。收发蒙塔纳；通过 `Anchor` 提交 32 字节哈希；在他人节点上运行应用。协议层无收益。进入门槛：第一笔进账（账户记录与入账金额原子地被同时创建）。
+- **节点运营者。** 普通硬件（一颗 CPU 核心）、24/7 在线、网络连接，以及注册时的顺序 SHA-256 进入门槛。完全参与共识。通过窗口抽签获得收益。
+
+种子短语与账户链属于用户，而非节点。用户何时沿阶梯而上，由用户自己决定。
+
+## 八、规模基准、隐私与作者的移除
+
+- **规模。** 每一项决策都以至少十亿活跃用户为基准。无法扩展到 10⁹ 的机制不予讨论。账户记录为 2 059 字节；10⁹ 账户下的状态约 2.06 TB，普通磁盘即可承载。修剪规则是规范的：状态大小由活跃人口决定，而非由链龄决定。
+- **隐私。** 余额与账户图谱默认公开（[I-2]）。应用层隐私通过 `Anchor` 实现：32 字节的哈希被提交到链上，加密内容由所有者保存在链外。协议看不见内容。隐私是用户选择保留的，而不是协议强加或禁止的。
+- **状态中无治理。** 没有 DAO，没有金库，没有创始人否决权。咨询委员会可在协议之外存在；在协议之内皆无约束力。作者按构造将自己从协议中移除。蒙塔纳以无创始人控制的引导法定人数启动，是比特币式的对等网络。
+
+## 九、蒙塔纳是什么
+
+不是带有时间戳功能的区块链。不是更快的以太坊。不是 L2。不是隐私混币。不是收益率。不是治理。不是品牌。不是数字黄金。
+
+蒙塔纳是 **一种反滥用稀缺为时间而非金钱的对等电子现金系统**——比特币的标题所承诺、但比特币未曾交付的那种现金系统；建立于 **数字货币传统尚未建立的时间经济学** 之上。
+
+一个带有价值转移功能的时间参考系。频率的基准，金钱、在场与历史皆由此衍生。
 
 ---
 
-**参考实现：** Rust，Apache-2.0 / MIT。十二个 crate，包括 `mt-timechain`、`mt-consensus`、`mt-lottery`、`mt-crypto`、`mt-net`、`mt-noise-pq`。规范：[Whitepaper Montana.md](../Whitepaper%20Montana.md)。
+**参考实现：** Rust，Apache-2.0 / MIT。二十三个 crate，包括 `mt-timechain`、`mt-consensus`、`mt-lottery`、`mt-crypto`、`mt-net`、`mt-noise-pq`。规范：[Whitepaper Montana.md](../Whitepaper%20Montana.md) 与 [Montana Protocol v35.25.1](../Montana%20Protocol%20v35.25.1.md)。
 
-**符号：** **Ɉ**——蒙塔纳时间的一秒。
+**符号：** **Ɉ**——蒙塔纳。`moneta`——最小单位（`1 Ɉ = 10⁹ moneta`）。**代码：** `MONT`。
 
 Alejandro Montana
 *Ничто_Nothing_无_金元Ɉ*

Montana-Protocol/Manifesto/README.md

@@ -1,20 +1,27 @@
 # Montana Manifesto
 
-**Version:** 1.0.0
+**Version:** 1.1.0
 **Date:** 2026-05-28
 **Author:** Alejandro Montana
 **Repository:** [github.com/efir369999/Montana](https://github.com/efir369999/Montana)
 
 A single declaration of what Montana is and refuses to be, published in three languages from one canonical version. The three texts say the same thing.
 
-- [English](Manifesto%20EN.md) — for the Metzdowd Cryptography mailing list and independent reviewers
+- [English](Manifesto%20EN.md) — for the Metzdowd cryptography list and independent reviewers
 - [Русский](Manifesto%20RU.md) — голос автора
 - [中文](Manifesto%20ZH.md) — 中文版本
 
-The English version is canonical for cryptographic claims; the Russian version is canonical for the author's voice. For the academic specification of the protocol, see [Whitepaper Montana.md](../Whitepaper%20Montana.md).
+The English version is canonical for cryptographic claims; the Russian version is canonical for the author's voice. For the academic specification of the protocol, see [Whitepaper Montana.md](../Whitepaper%20Montana.md) and [Montana Protocol v35.25.1](../Montana%20Protocol%20v35.25.1.md).
+
+**v1.1.0 (2026-05-28):**
+
+- *Terminology* aligned with Montana Protocol v35.25.1. The primitive is named «sequential delay computation» / «iterated SHA-256 hash chain», not VDF. Montana's chain is deliberately not a verifiable delay function in the Boneh-Pietrzak-Wesolowski sense (see §II for the rationale). Consensus is named Proof of Time. The smallest unit is `moneta`; `1 Ɉ = 10⁹ moneta`; the international ticker is `MONT`.
+- *Cash-system frame* foregrounded. §I makes explicit that Bitcoin's title — *A Peer-to-Peer Electronic Cash System* — was never delivered, and identifies the two missing pieces Montana takes on: a cash-system tokenomics (§V) and an economics of time (§VI). §IX names Montana as the cash system Bitcoin promised, built on top of the economics of time the digital-money tradition has not yet built.
+- *Finality claim corrected* against spec v35.25.1. Asynchronous finality is at window cementing — within a single window of the canonical order (approximately one minute of wall-clock at the genesis-hardware calibration), not the obsolete «~300 ms» claim carried from an early draft. The wall-clock duration of a window is an emergent property of the operating hardware, not part of consensus state.
+- *Reference-implementation count corrected.* Twenty-three crates in `Code/crates/`, not twelve.
 
 ---
 
-**Symbol:** **Ɉ** — one second of Montana time.
+**Symbol:** **Ɉ** — Montana.
 
 Alejandro Montana

Russian/Site/explorer/explorer-api.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Montana explorer JSON API — читает state files docker-volume montana-data."""
+import os, sys, json, struct, glob, time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import urlparse, parse_qs
+
+DATA_DIR = os.environ.get("MT_DATA_DIR", "/var/lib/docker/volumes/montana-data/_data")
+PROPOSALS = os.path.join(DATA_DIR, "proposals")
+ACCOUNTS_BIN = os.path.join(DATA_DIR, "accounts.bin")
+NODES_BIN = os.path.join(DATA_DIR, "nodes.bin")
+CANDIDATES_BIN = os.path.join(DATA_DIR, "candidates.bin")
+META_LAST = os.path.join(DATA_DIR, "meta_last_cemented.bin")
+CURRENT_WIN = os.path.join(DATA_DIR, "current_window.bin")
+
+ACCOUNT_SZ = 2059
+NODE_SZ = 2098
+CANDIDATE_SZ = 2082
+PROPOSAL_SZ = 3722  # header; cemented envelope may be larger
+
+def read_u64_le(path):
+    try:
+        with open(path, "rb") as f:
+            return struct.unpack("<Q", f.read(8))[0]
+    except Exception:
+        return None
+
+def parse_proposal_header(buf):
+    if len(buf) < PROPOSAL_SZ:
+        return None
+    return {
+        "prev_proposal_hash": buf[0:32].hex(),
+        "window_index": struct.unpack("<Q", buf[32:40])[0],
+        "protocol_version": struct.unpack("<I", buf[40:44])[0],
+        "control_root": buf[44:76].hex(),
+        "node_root": buf[76:108].hex(),
+        "candidate_root": buf[108:140].hex(),
+        "account_root": buf[140:172].hex(),
+        "state_root": buf[172:204].hex(),
+        "timechain_value": buf[204:236].hex(),
+        "included_bundles_root": buf[236:268].hex(),
+        "included_reveals_root": buf[268:300].hex(),
+        "winner_endpoint": buf[300:332].hex(),
+        "winner_id": buf[332:364].hex(),
+        "proposer_node_id": buf[364:396].hex(),
+        "target": int.from_bytes(buf[396:412], "little"),
+        "fallback_depth": buf[412],
+        "envelope_size": len(buf),
+        "bundle_count": (struct.unpack("<H", buf[3722:3724])[0] if len(buf) >= 3724 else 0),
+    }
+
+def parse_node_record(buf):
+    if len(buf) < NODE_SZ:
+        return None
+    return {
+        "node_id": buf[0:32].hex(),
+        "suite_id": struct.unpack("<H", buf[1984:1986])[0],
+        "operator_account_id": buf[1986:2018].hex(),
+        "start_window": struct.unpack("<Q", buf[2018:2026])[0],
+        "chain_length": struct.unpack("<Q", buf[2026:2034])[0],
+        "chain_length_snapshot": struct.unpack("<Q", buf[2034:2042])[0],
+        "last_confirmation_window": struct.unpack("<Q", buf[2090:2098])[0],
+    }
+
+def api_status():
+    last_cem = read_u64_le(META_LAST) or 0
+    cur_win = read_u64_le(CURRENT_WIN) or 0
+    n_acc = os.path.getsize(ACCOUNTS_BIN) // ACCOUNT_SZ if os.path.exists(ACCOUNTS_BIN) else 0
+    n_node = os.path.getsize(NODES_BIN) // NODE_SZ if os.path.exists(NODES_BIN) else 0
+    n_cand = os.path.getsize(CANDIDATES_BIN) // CANDIDATE_SZ if os.path.exists(CANDIDATES_BIN) else 0
+    props = sorted(glob.glob(os.path.join(PROPOSALS, "*.bin")))
+    return {
+        "current_window": cur_win,
+        "last_cemented_window": last_cem,
+        "accounts": n_acc,
+        "nodes": n_node,
+        "candidates": n_cand,
+        "proposals_archived": len(props),
+        "ts": int(time.time()),
+    }
+
+def api_nodes():
+    if not os.path.exists(NODES_BIN):
+        return {"nodes": []}
+    with open(NODES_BIN, "rb") as f:
+        data = f.read()
+    out = []
+    for i in range(0, len(data), NODE_SZ):
+        rec = parse_node_record(data[i:i + NODE_SZ])
+        if rec:
+            out.append(rec)
+    return {"nodes": out}
+
+def api_proposals(limit=30):
+    files = sorted(glob.glob(os.path.join(PROPOSALS, "*.bin")), reverse=True)[:limit]
+    out = []
+    for fp in files:
+        try:
+            with open(fp, "rb") as f:
+                buf = f.read()
+            hdr = parse_proposal_header(buf)
+            if hdr:
+                out.append({
+                    "window_index": hdr["window_index"],
+                    "proposer_node_id": hdr["proposer_node_id"],
+                    "winner_id": hdr["winner_id"],
+                    "state_root": hdr["state_root"],
+                    "envelope_size": hdr["envelope_size"],
+                    "bundle_count": hdr["bundle_count"],
+                })
+        except Exception:
+            continue
+    return {"proposals": out, "count": len(out)}
+
+def api_proposal(window):
+    fp = os.path.join(PROPOSALS, f"{window:020d}.bin")
+    if not os.path.exists(fp):
+        return {"error": "not found"}, 404
+    with open(fp, "rb") as f:
+        buf = f.read()
+    hdr = parse_proposal_header(buf)
+    if not hdr:
+        return {"error": "parse error"}, 500
+    return hdr
+
+class H(BaseHTTPRequestHandler):
+    def log_message(self, *a, **k): pass
+    def _send(self, body, code=200):
+        body_b = json.dumps(body, ensure_ascii=False, indent=2).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Content-Length", str(len(body_b)))
+        self.end_headers()
+        self.wfile.write(body_b)
+    def do_GET(self):
+        u = urlparse(self.path)
+        q = parse_qs(u.query)
+        try:
+            if u.path == "/api/status":
+                return self._send(api_status())
+            if u.path == "/api/nodes":
+                return self._send(api_nodes())
+            if u.path == "/api/proposals":
+                limit = min(int(q.get("limit", [30])[0]), 200)
+                return self._send(api_proposals(limit))
+            if u.path.startswith("/api/proposal/"):
+                w = int(u.path.split("/")[-1])
+                r = api_proposal(w)
+                if isinstance(r, tuple): return self._send(r[0], r[1])
+                return self._send(r)
+            self._send({"error": "unknown route", "path": u.path}, 404)
+        except Exception as e:
+            self._send({"error": str(e)}, 500)
+
+if __name__ == "__main__":
+    port = int(os.environ.get("MT_EXPLORER_PORT", "5010"))
+    print(f"montana-explorer listening on :{port} reading {DATA_DIR}", flush=True)
+    HTTPServer(("0.0.0.0", port), H).serve_forever()

Russian/Site/explorer/index.html

@@ -0,0 +1,125 @@
+<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8">
+<title>Montana Explorer</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<style>
+:root { --bg:#000; --fg:#e8e8e8; --acc:#d4af37; --dim:#666; --card:#0d0d0d; --hl:#1a1a1a; }
+* { box-sizing:border-box; }
+body { background:var(--bg); color:var(--fg); font:14px/1.5 -apple-system,system-ui,sans-serif; margin:0; padding:0; }
+header { padding:24px; border-bottom:1px solid var(--hl); display:flex; justify-content:space-between; align-items:center; flex-wrap:wrap; }
+h1 { margin:0; color:var(--acc); font-weight:300; font-size:24px; letter-spacing:1px; }
+h2 { color:var(--acc); font-weight:400; font-size:16px; margin:24px 0 8px; }
+.grid { display:grid; grid-template-columns:repeat(auto-fit,minmax(180px,1fr)); gap:12px; padding:24px; }
+.stat { background:var(--card); padding:16px; border-radius:4px; border:1px solid var(--hl); }
+.stat .label { color:var(--dim); font-size:11px; text-transform:uppercase; letter-spacing:1px; }
+.stat .value { color:var(--acc); font-size:28px; font-weight:300; margin-top:4px; font-variant-numeric:tabular-nums; }
+.section { padding:0 24px 24px; }
+table { width:100%; border-collapse:collapse; background:var(--card); border:1px solid var(--hl); border-radius:4px; overflow:hidden; }
+th, td { text-align:left; padding:10px 12px; border-bottom:1px solid var(--hl); font-variant-numeric:tabular-nums; }
+th { background:var(--hl); color:var(--acc); font-weight:500; font-size:11px; text-transform:uppercase; letter-spacing:1px; }
+td.mono { font-family:'SF Mono',Menlo,monospace; font-size:12px; color:var(--dim); }
+.hex { display:inline-block; max-width:120px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; vertical-align:bottom; }
+tr:hover td { background:var(--hl); }
+.online { color:#3a7; }
+.search { padding:8px 12px; background:var(--card); border:1px solid var(--hl); color:var(--fg); border-radius:4px; width:240px; }
+footer { color:var(--dim); padding:24px; text-align:center; font-size:11px; border-top:1px solid var(--hl); }
+a { color:var(--acc); text-decoration:none; }
+a:hover { text-decoration:underline; }
+#detail { display:none; }
+.tag { display:inline-block; padding:2px 8px; background:var(--hl); color:var(--acc); border-radius:3px; font-size:11px; }
+</style>
+</head>
+<body>
+<header>
+  <h1>Ɉ MONTANA EXPLORER</h1>
+  <input class="search" id="searchBox" placeholder="окно (window number)" type="number" min="0">
+</header>
+
+<div class="grid" id="stats"></div>
+
+<div class="section">
+  <h2>Узлы (NodeTable)</h2>
+  <table id="nodes-tbl">
+    <thead><tr><th>node_id</th><th>chain_length</th><th>start_window</th><th>last_conf</th></tr></thead>
+    <tbody></tbody>
+  </table>
+</div>
+
+<div class="section">
+  <h2>Последние Proposals</h2>
+  <table id="props-tbl">
+    <thead><tr><th>window</th><th>proposer</th><th>winner</th><th>state_root</th><th>envelope</th><th>bundles</th></tr></thead>
+    <tbody></tbody>
+  </table>
+</div>
+
+<div class="section" id="detail">
+  <h2>Детали окна <span id="detail-w"></span></h2>
+  <pre id="detail-body" style="background:var(--card);padding:16px;border-radius:4px;border:1px solid var(--hl);overflow-x:auto;font-size:11px;"></pre>
+</div>
+
+<footer>
+  Montana Reference Implementation · обновление каждые 5с · <span class="online" id="liveness">●</span> <span id="ts"></span>
+</footer>
+
+<script>
+const API = "/montana-api";
+const hex16 = h => h ? `<span class="hex" title="${h}">${h.slice(0,16)}…</span>` : "";
+const fmt = n => Number(n).toLocaleString("ru-RU");
+
+async function load() {
+  try {
+    const st = await (await fetch(`${API}/status`)).json();
+    document.getElementById("stats").innerHTML = `
+      <div class="stat"><div class="label">Текущее окно</div><div class="value">${fmt(st.current_window)}</div></div>
+      <div class="stat"><div class="label">Цементировано</div><div class="value">${fmt(st.last_cemented_window)}</div></div>
+      <div class="stat"><div class="label">Узлов в NodeTable</div><div class="value">${fmt(st.nodes)}</div></div>
+      <div class="stat"><div class="label">Кандидатов</div><div class="value">${fmt(st.candidates)}</div></div>
+      <div class="stat"><div class="label">Аккаунтов</div><div class="value">${fmt(st.accounts)}</div></div>
+      <div class="stat"><div class="label">Архив Proposals</div><div class="value">${fmt(st.proposals_archived)}</div></div>
+    `;
+    const ns = await (await fetch(`${API}/nodes`)).json();
+    document.querySelector("#nodes-tbl tbody").innerHTML = ns.nodes.map(n => `
+      <tr><td class="mono">${hex16(n.node_id)}</td><td>${fmt(n.chain_length)}</td><td>${fmt(n.start_window)}</td><td>${fmt(n.last_confirmation_window)}</td></tr>
+    `).join("");
+    const ps = await (await fetch(`${API}/proposals?limit=25`)).json();
+    document.querySelector("#props-tbl tbody").innerHTML = ps.proposals.map(p => `
+      <tr onclick="showDetail(${p.window_index})" style="cursor:pointer">
+        <td><a href="#w${p.window_index}">${fmt(p.window_index)}</a></td>
+        <td class="mono">${hex16(p.proposer_node_id)}</td>
+        <td class="mono">${hex16(p.winner_id)}</td>
+        <td class="mono">${hex16(p.state_root)}</td>
+        <td>${fmt(p.envelope_size)} B</td>
+        <td><span class="tag">${p.bundle_count}</span></td>
+      </tr>
+    `).join("");
+    document.getElementById("liveness").className = "online";
+    document.getElementById("ts").textContent = new Date(st.ts * 1000).toLocaleString("ru-RU");
+  } catch(e) {
+    document.getElementById("liveness").className = "";
+    document.getElementById("liveness").style.color = "#a33";
+    document.getElementById("ts").textContent = "offline: " + e.message;
+  }
+}
+
+async function showDetail(w) {
+  try {
+    const d = await (await fetch(`${API}/proposal/${w}`)).json();
+    document.getElementById("detail-w").textContent = w;
+    document.getElementById("detail-body").textContent = JSON.stringify(d, null, 2);
+    document.getElementById("detail").style.display = "block";
+  } catch(e) {
+    alert("ошибка: " + e.message);
+  }
+}
+
+document.getElementById("searchBox").addEventListener("keydown", e => {
+  if (e.key === "Enter") { const v = parseInt(e.target.value); if (!isNaN(v)) showDetail(v); }
+});
+
+load(); setInterval(load, 5000);
+</script>
+</body>
+</html>

Russian/Site/explorer/montana-explorer.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Montana Explorer JSON API
+After=docker.service network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=/usr/bin/python3 /opt/montana-explorer/explorer-api.py
+Restart=on-failure
+RestartSec=5
+Environment=MT_EXPLORER_PORT=5010
+Environment=MT_DATA_DIR=/var/lib/docker/volumes/montana-data/_data
+User=root
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target

Russian/Site/explorer/nginx-snippet.conf

@@ -0,0 +1,13 @@
+# /etc/nginx/sites-available/efir_org additions for Montana explorer
+location = /montana { return 301 /montana/; }
+location /montana/ {
+    alias /var/www/efir_org/montana/;
+    try_files $uri $uri/ /montana/index.html;
+}
+location /montana-api/ {
+    proxy_pass http://149.154.184.205:5010/api/;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_read_timeout 10s;
+    proxy_connect_timeout 5s;
+}

_internal-private/Metzdowd-letter.txt

@@ -0,0 +1,74 @@
+Subject: Montana — manifesto for review
+
+Dear list,
+
+This list discussed Bitcoin as a peer-to-peer electronic cash system
+before it discussed it as anything else. I would like to share for
+review a manifesto for a protocol I have been building since
+January 2026.
+
+The position the manifesto takes:
+
+Bitcoin's title was "A Peer-to-Peer Electronic Cash System". The
+cryptographic answer is famous; the cash-system answer was never
+delivered. Bitcoin's anti-spam is denominated in the same money the
+system creates; settlement waits for block confirmation that is ten
+minutes at best and unbounded under congestion; the seven-cent
+transaction is uneconomical because the fee consumes it. Bitcoin
+became digital gold.
+
+Montana takes the two pieces that an actual peer-to-peer electronic
+cash system needs and Bitcoin did not deliver:
+
+  1. A cash-system tokenomics: zero fees on every operation;
+     asynchronous finality at window cementing (within one window
+     of the canonical order, approximately one minute on commodity
+     x86_64); closed-form linear emission of 13 Ɉ per window — no
+     fees, no halving, no premine, no founder allocation, no
+     governance.
+
+  2. An economics of time: a non-monetary scarcity that replaces
+     fees in anti-abuse — per-identity rate per window, account
+     chain-length thresholds, and a sequential SHA-256 entry
+     barrier for node registration (~14 days of wall-clock on a
+     commodity core). Time-based scarcity does not require a price
+     feed, an oracle, or an exchange to measure. Anti-abuse cannot
+     undermine the cash properties because it is not denominated
+     in money.
+
+On the cryptographic primitives:
+
+The chain advances by an iterated sequential SHA-256 hash chain
+T_W = SHA-256^D (T_{W-1}) with D = 325 000 000 per window. This is
+deliberately not a verifiable delay function in the Boneh-Bonneau-
+Bünz-Fisch [CRYPTO 2018], Pietrzak [ITCS 2019] or Wesolowski
+[EUROCRYPT 2019] sense: production-grade post-quantum succinct
+VDFs do not yet exist, and verification cost equals computation
+cost (verifiers re-run the iterations). SHA-256 is already required
+for addressing, hashing and Merkle commitments, so the cryptographic
+surface stays at one primitive. Consensus signatures are ML-DSA-65
+(FIPS 204); transport key encapsulation is ML-KEM-768 (FIPS 203);
+the transport handshake is Noise_PQ XX over TCP/Yamux with
+ChaCha20-Poly1305 AEAD (RFC 8439). PeerId is the SHA-256 multihash
+of the ML-DSA-65 identity public key; routing identity and
+consensus identity are bound to the same key material.
+
+Quorum is 67% of active_chain_length, not headcount. Capital does
+not enter the threshold. The lottery seed incorporates
+cemented_bundle_aggregate(W-2), signatures from honest operators
+two windows back, which closes the hardware-asymmetry grinding
+attack class without rational-cost arguments.
+
+Manifesto (English, also Russian and Chinese):
+  https://github.com/efir369999/Montana/tree/main/Manifesto
+
+Whitepaper:
+  https://github.com/efir369999/Montana/blob/main/Whitepaper%20Montana.md
+
+I would value the list's reading — on the cryptographic choices,
+on the cash-system / time-economics framing, or on the relation
+between them.
+
+Best regards,
+Alejandro Montana
+github.com/efir369999/Montana