efir369999/montana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Afgroup 2026-05-28 23:44:50 +03:00
parent 0b779fbd5c
commit 493b314b90
10 changed files with 635 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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()
{

109
Montana-Protocol/Manifesto/Manifesto EN.md
View File

@ -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."*
> — George Orwell, *1984*
> *"Who controls the past controls the future. Who controls the present controls the past."*
> — 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.
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.
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.
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.
1. **Canonical order** (`TimeChain`) — irreversible sequential computation. The base layer.
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`, 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`) — 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.
- **Asynchronous finality.** Transfers do not wait for blocks. They are cemented through a P2P quorum of signatures from active operators in approximately 300 milliseconds.
- **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.
- **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 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.
- **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.
- **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 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.
- **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 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.
- **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.
## 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_无_金元Ɉ*

109
Montana-Protocol/Manifesto/Manifesto RU.md
View File

@ -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`) — необратимое вычисление. Базовый слой физики. Каждый оператор тикает независимо; вместе они образуют единый глобальный осциллятор.
2. **Присутствие** (`NodeChain`) — доказательство того, что конкретный идентификатор сопровождал этот поток времени. Вес в сети измеряется доказанным временем присутствия, не капиталом. Капитал не покупает времени.
3. **Деньги** (`Account`, `TimeCoin`) — количественная производная от доказанного присутствия. Единица `Ɉ` — это не награда за решение бессмысленных задач, а запись прошедшей секунды в книге сети. Эмиссия в закрытой форме: `supply(W) = 13 × (W + 1) Ɉ`. Никакого премайна. Никакого пресейла. Никакой доли основателя.
4. **История** (`Anchor`) — привязка любого внешнего факта (документа, сообщения, транзакции) к этой защищённой временной линии. Хэш навсегда зафиксирован в TimeChain. Переписать его означает пересчитать каждую итерацию VDF от генезиса. Математически невозможно.
1. **Канонический порядок** (`TimeChain`) — необратимое последовательное вычисление. Базовый слой.
2. **Присутствие** (`NodeChain`) — длина цепочки узла, накапливающаяся по одному окну за раз по мере канонической фиксации узла в порядке. Вес в консенсусе — это присутствие, не капитал. Капитал не покупает ретроактивно прошлое участие.
3. **Деньги** (`Account`, валюта Монтана) — количественная производная от присутствия. Награда за окно — `EMISSION_moneta = 13 × 10⁹ moneta = 13 Ɉ`. Эмиссия в закрытой форме: `supply_moneta(W) = EMISSION_moneta × (W + 1)`. Никакого премайна, пресейла, доли основателя, халвинга, supply cap, дискреционной эмиссии.
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` ни в одной операции.
- **Асинхронная финальность.** Переводы не ждут блоков. Они закрепляются через P2P-кворум подписей активных операторов примерно за 300 миллисекунд.
- **Без плутократии.** Тот, у кого один миллиард `Ɉ`, не имеет в консенсусе больше власти, чем оператор Mac Mini. Эмиссия (хронометрическая) и консенсус (Proof of Time) математически разделены. Семя лотереи содержит `cemented_bundle_aggregate(W-2)` — значение, которое атакующий не может предвычислить без подделки подписей честных участников.
- **Никакого governance в состоянии.** Нет DAO, нет казны, нет права вето основателя. Совещательные советы могут существовать снаружи протокола; ни один из них не имеет обязывающей силы внутри. Автор удалён из протокола.
- **Никаких узлов генезиса.** Монтана запускается как peer-to-peer-сеть в стиле Биткоина. Любой участник присоединяется одной командой в терминале. Bootstrap-кворума под контролем основателя не существует.
- **67 % честной active_chain_length.** Безопасность сохраняется, пока честные операторы контролируют более двух третей `active_chain_length`. Капитал в этот порог не входит.
- **Нулевые комиссии.** В протоколе нет поля `fee` ни в одной операции. Семь центов проходят.
- **Асинхронная финальность.** Переводы не ждут блоков. Они закрепляются через P2P-кворум подписей активных операторов внутри одного окна канонического порядка (примерно одна минута wall-clock на генезис-калибровке; длительность окна — эмерджентное свойство, не часть consensus state). Продавец отпускает покупателя.
- **Константная монотонная эмиссия.** `13 Ɉ` за окно, зафиксировано Указом Генезиса, закрытая форма. Никакого халвинга, никакого supply cap, никакой дискреционной эмиссии. Supply предсказуем на десятилетия одной формулой. Единица денег — не спекулятивная, это запись закрытого окна.
- **Никакой плутократии по построению.** Тот, у кого миллиард `Ɉ`, не имеет в консенсусе больше власти, чем оператор Mac Mini. Вес узла — это длина его цепочки, история закреплённого присутствия. Семя лотереи содержит `cemented_bundle_aggregate(W-2)` — подписи честных операторов двумя окнами назад, что закрывает класс grinding-атак при асимметрии железа без опоры на рациональные cost-аргументы.
- **Две трети честной длины цепочки.** Безопасность сохраняется, пока честные операторы контролируют более двух третей `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_无_金元Ɉ*

107
Montana-Protocol/Manifesto/Manifesto ZH.md
View File

@ -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`）——不可逆的计算。物理学的基础层。每个运营者独立地嘀嗒，共同构成一个全球振荡器。
2. **在场**（`NodeChain`）——证明某个特定身份伴随了这一时间流。网络中的权重，由可证明的在场时间度量，而非由资本度量。资本不能购买时间。
3. **货币**（`Account` 与 `TimeCoin`）——可证在场的数量化衍生物。单位 `Ɉ` 不是解决无意义难题的奖励，而是网络账本中一秒钟的记录。发行量是封闭式的：`supply(W) = 13 × (W + 1) Ɉ`。没有预挖。没有预售。没有创始人份额。
4. **历史**（`Anchor`）——把任何外部事实（文档、消息、交易）绑定到这条受保护的时间线。其哈希被永久封存于 TimeChain 之中。改写它，意味着从创世起重新计算每一次 VDF 迭代。在数学上不可能。
1. **规范顺序**（`TimeChain`）——不可逆的顺序计算。基础层。
2. **在场**（`NodeChain`）——节点的链长，随节点被规范地固化进顺序，一次一个窗口地累积。共识中的权重是「在场」，而非「资本」。资本无法追溯购买过去的参与。
3. **货币**（`Account`，蒙塔纳货币）——可证在场的数量化衍生物。封存一个窗口的奖励为 `EMISSION_moneta = 13 × 10⁹ moneta = 13 Ɉ`。供应量为封闭式：`supply_moneta(W) = EMISSION_moneta × (W + 1)`。无预挖、无预售、无创始人份额、无减半、无总量上限、无任何裁量发行。
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` 字段。
- **异步终局。** 转账不等待区块，而是由活跃运营者的 P2P 法定签名在约 300 毫秒内固化。
- **不行金权政治。** 持有十亿 `Ɉ` 的人，在共识中并不比一台 Mac Mini 的运营者拥有更多权力。发行（按时间计量）与共识（时间证明）在数学上彼此分离。抽签种子包含 `cemented_bundle_aggregate(W-2)`——攻击者若不伪造诚实参与者的签名便无法预计算的值。
- **状态中无治理。** 没有 DAO，没有金库，没有创始人否决权。咨询委员会可在协议之外存在；它们在协议之内皆无约束力。作者将自己从协议中移除。
- **不设创世节点。** 蒙塔纳以比特币式的对等网络方式启动。任何参与者皆可通过终端中的一条命令加入。不存在由创始人掌控的引导法定人数。
- **诚实 `active_chain_length` 的三分之二。** 只要诚实运营者掌握 `active_chain_length` 的三分之二以上，安全性即得到保持。资本不进入这一门槛。
- **零手续费。** 协议中任何操作都没有 `fee` 字段。七分钱可以通过。
- **异步终局。** 转账不等待区块，而是由活跃运营者的 P2P 法定签名在规范顺序的单一窗口之内固化（在创世硬件校准下约一分钟外部时钟；窗口时长为衍生属性，不属于共识状态）。商家敢让顾客离开。
- **恒定单调发行。** 每窗口 `13 Ɉ`，由创世法令固定，封闭式。无减半、无总量上限、无裁量发行。供应量可由一条公式预测数十年。货币单位不是投机品，而是一次封窗的记录。
- **构造上即非金权政治。** 持有十亿 `Ɉ` 的人，在共识中并不比一台 Mac Mini 的运营者拥有更多权力。节点的权重是其链长——其被固化的在场历史。抽签种子包含 `cemented_bundle_aggregate(W-2)`，即两个窗口前诚实运营者的签名，这在不依赖任何成本理性论证的前提下，封堵了硬件不对称情境下的研磨攻击。
- **链长三分之二的诚实门槛。** 只要诚实运营者掌握 `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_无_金元Ɉ*

15
Montana-Protocol/Manifesto/README.md
View File

@ -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

158
Russian/Site/explorer/explorer-api.py Normal file
View File

@ -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()

125
Russian/Site/explorer/index.html Normal file
View File

@ -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>

17
Russian/Site/explorer/montana-explorer.service Normal file
View File

@ -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

13
Russian/Site/explorer/nginx-snippet.conf Normal file
View File

@ -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;
}

74
_internal-private/Metzdowd-letter.txt Normal file
View File

@ -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