From de74ea57b09fdc6b06512003dd4bad0c042d01e8 Mon Sep 17 00:00:00 2001 From: dongwon Date: Thu, 4 Dec 2025 15:02:56 +0900 Subject: [PATCH 1/6] wip: initial structure --- WHITEPAPER.md | 213 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 213 insertions(+) create mode 100644 WHITEPAPER.md diff --git a/WHITEPAPER.md b/WHITEPAPER.md new file mode 100644 index 0000000..a83e9b3 --- /dev/null +++ b/WHITEPAPER.md @@ -0,0 +1,213 @@ +# **Gno: A Deterministic Multi-Realm Computing Platform for Decentralized Applications** + +**TODO: Add Authors** + +Draft v0.1 +December 2025 + +The current spec is on github.com/gnolang/gno + +--- + +## **Abstract** + +> *At first, there was Bitcoin, out of entropy soup of the greater All.* +> *Then, there was Ethereum, which was created in the likeness of Bitcoin, but made Turing complete.* +> *Among these were Tendermint and Cosmos to engineer robust PoS and IBC.* +> *Then came Gno upon Cosmos and there spring forth Gnoland,* +> *simulated by the Gnomes of the Greater Resistance.* + +We stand at an inflection point in the evolution of decentralized systems. The infrastructure that governs our digital lives—social networks, financial systems, public discourse, and collective knowledge—remains captured by centralized authorities that decide what we see, what we say, and what we own. Blockchains promised liberation, yet their programming models remain opaque, their governance plutocratic, and their developer experience hostile. + +**Gno.land is the missing piece: a platform for timeless code that stores truth in plain sight.** + +Gno—the deterministic, Go-compatible programming environment powering the Gno.land platform—provides a model where smart contracts exist as human-readable source code: permanently on-chain, directly auditable, and inherently forkable. Gno.land then builds on this foundation by introducing governance driven not by token accumulation but by demonstrable contribution. Together, they form the basis of the **Logoverse**: a persistent, composable, censorship-resistant substrate for decentralized knowledge and coordination. + +### **Technical Summary** + +**Problem.** Current smart contract platforms exhibit: (1) bytecode opacity preventing practical auditability, (2) manual state serialization causing developer friction and storage-related vulnerabilities, (3) stake-weighted governance conflating capital ownership with technical competence, and (4) domain-specific languages fragmenting the developer ecosystem. + +**Solution.** We introduce Gno, a deterministic Go-compatible language executed by GnoVM, an AST-based interpreter providing automatic object persistence, capability-based realm isolation, and source-level transparency. Governance authority derives from Proof of Contribution (PoC), a Sybil-resistant reputation mechanism assigning voting power based on verified contributions rather than token holdings. + +**Result.** Gno.land achieves: (1) source-level transparency with direct auditability, (2) automatic state persistence eliminating serialization overhead, (3) contribution-weighted governance resistant to plutocratic capture, and (4) immediate developer accessibility for Go's established developer base. + +--- + +# **1. Introduction** + +## **1.1 Background** + +Bitcoin demonstrated decentralized value transfer without intermediaries [1]. Ethereum extended this to general computation through smart contracts [2]. Tendermint and Cosmos established practical Byzantine fault-tolerant consensus and inter-blockchain communication [3, 4]. + +Despite these advances, structural limitations persist: + +- **Opacity**: Deployed contracts exist as bytecode, requiring specialized tools to interpret +- **Complexity**: Developers must learn domain-specific languages and manage state serialization manually +- **Plutocracy**: Governance power correlates with token holdings rather than expertise +- **Fragmentation**: Each ecosystem demands distinct languages, tooling, and mental models + +## **1.2 Contributions** + +This whitepaper presents: + +1. **Gno Language** (§4): Deterministic Go variant (~99% compatible) with source-level on-chain storage +2. **GnoVM** (§5): AST-based interpreter with automatic persistent object memory +3. **Realm Model** (§6): Capability-based isolation with explicit cross-realm semantics +4. **Proof of Contribution** (§9): Reputation-based consensus mechanism separating voting power from token ownership +5. **Tendermint2** (§10): Minimal consensus engine where implementation serves as specification + +--- + +# **2. System Model** + +// TODO: +// - Formal Foundations +// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, Deterministic Execution, Cross-Realm Call semantics + +--- + +# **3. Comparison with Existing Platforms** + +// TODO: +// - Why Gno Wins +// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) + Solidity vs Gno code examples, e.g., State management +// - Add more + +## **The Bytecode Problem** + +Ethereum stores compiled bytecode: + +``` +Deployed: 0x608060405234801561001057600080fd5b50... +``` + +Interpreting this requires decompilation or external source verification. + +Gno stores source code directly: + +```go +func Transfer(to std.Address, amount int64) { + caller := std.PreviousRealm().Address() + balances[caller] -= amount + balances[to] += amount +} +``` + +Auditing requires only the ability to read Go. + +## **Virtual Machine Comparison** + +| Feature | EVM | WASM | MoveVM | **GnoVM** | +|---------|-----|------|--------|-----------| +| On-chain representation | Bytecode | Bytecode | Bytecode | **Source (AST)** | +| Auditability | Decompiler required | Decompiler required | Decompiler required | **Direct** | +| State model | Manual slots | Manual memory | Linear types | **Auto-persistent objects** | +| Safety model | Manual | Sandbox | Resource types | **Realm isolation + Go types** | +| Determinism | Partial | Partial | Strong | **Strong** | +| Language familiarity | New (Solidity) | Complex (Rust) | New (Move) | **Established (Go)** | + +--- + +# **4. Gno Language** + +// TODO: +// - Language Specification +// - ~99% Go compatible + Deterministic constraints + std package + Render convention +// - Interrealm specification + +# **5. GnoVM Architecture** + +// TODO: +// - VM Architecture +// - AST-based interpreter (not bytecode) + Persistent Object Memory (automatic state) + Execution lifecycle + +--- + +# **6. Realm Execution Model** + +// TODO: +// - Execution Semantics +// - OS Analogy Table (Process=Realm, Kernel=GnoVM) + Package hierarchy (/p/, /r/, /e/) + Isolation Theorem + +--- + +# **7. State Commitment** + +// TODO: +// - Data Integrity +// - Merkle Tree structure + Amino encoding (deterministic serialization) + +--- + +# **8. Economics** + +// TODO: +// - Token & Incentive Design +// - GNOT Token + Gas model + Storage Deposit (lock/unlock) + Fee distribution → Validators + Contributors + +--- + +# **9. Proof of Contribution** + +// TODO: +// - Governance Innovation +// - PoS limitations (capital ≠ competence) → Contributio based + Tier structure + DAOs +// - Maybe we should have another session for GovDAO? ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 + +--- + +# **10. Tendermint2** + +// TODO: +// - Consensus Layer +// - Implementation = Specification + ~15K LOC + BFT rounds (Propose→Prevote→Precommit) + PoC integration +// - Differences from the original Tendermint? + +--- + +# **11. Safety and Liveness** + +// TODO: +// - Security Proofs +// - Assumptions: network eventually delivers, <1/3 malicious, crypto works +// - Theorems: all nodes compute same result, contracts can't hack each other, no forks, chain never halts, no censorship + +--- + +# **12. The Logoverse** + +// TODO: +// - Long-term Vision +// - Permanence + Composability + Transparency + Core applications (boards, users, govdao, gnodev, etc.) + +--- + +# **13. Conclusion** + +// TODO: +// - Summary & Recap +// - Go-compatible + AST transparency + auto-persistence + PoC governance + minimal consensus + +--- + +# **Appendix** + +// TODO: Add + +--- + +# **References** + +// TODO: Add more + +[1] S. Nakamoto, "Bitcoin: A peer-to-peer electronic cash system," 2008. + +[2] V. Buterin, "Ethereum: A next-generation smart contract and decentralized application platform," 2014. + +[3] J. Kwon, "Tendermint: Consensus without mining," 2014. + +[4] J. Kwon, E. Buchman, "Cosmos: A network of distributed ledgers," 2016. + +--- + +## **Changelog** From c3b515da8282e56db1f3a92b682cf489baef42c7 Mon Sep 17 00:00:00 2001 From: dongwon Date: Thu, 4 Dec 2025 15:17:37 +0900 Subject: [PATCH 2/6] fix --- WHITEPAPER.md | 86 ++++++++++++++++++++++++++------------------------- 1 file changed, 44 insertions(+), 42 deletions(-) diff --git a/WHITEPAPER.md b/WHITEPAPER.md index a83e9b3..00014ee 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -1,11 +1,11 @@ # **Gno: A Deterministic Multi-Realm Computing Platform for Decentralized Applications** -**TODO: Add Authors** +**TODO: Add authors** Draft v0.1 December 2025 -The current spec is on github.com/gnolang/gno +The current spec is on [github.com/gnolang/gno](https://github.com/gnolang/gno) --- @@ -60,20 +60,20 @@ This whitepaper presents: # **2. System Model** -// TODO: -// - Formal Foundations -// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, Deterministic Execution, Cross-Realm Call semantics +// TODO: +// - Formal Foundations +// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, Deterministic Execution, Cross-Realm Call semantics --- # **3. Comparison with Existing Platforms** -// TODO: -// - Why Gno Wins -// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) + Solidity vs Gno code examples, e.g., State management +// TODO: +// - Why Gno Wins +// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) + Solidity vs Gno code examples, e.g., State management // - Add more -## **The Bytecode Problem** +## **3.1 The Bytecode Problem** Ethereum stores compiled bytecode: @@ -95,7 +95,7 @@ func Transfer(to std.Address, amount int64) { Auditing requires only the ability to read Go. -## **Virtual Machine Comparison** +## **3.2 Virtual Machine Comparison** | Feature | EVM | WASM | MoveVM | **GnoVM** | |---------|-----|------|--------|-----------| @@ -110,83 +110,85 @@ Auditing requires only the ability to read Go. # **4. Gno Language** -// TODO: -// - Language Specification -// - ~99% Go compatible + Deterministic constraints + std package + Render convention -// - Interrealm specification +// TODO: +// - Language Specification +// - ~99% Go compatible + Deterministic constraints + std package + Render convention +// - Interrealm specification # **5. GnoVM Architecture** -// TODO: -// - VM Architecture +// TODO: +// - VM Architecture // - AST-based interpreter (not bytecode) + Persistent Object Memory (automatic state) + Execution lifecycle --- # **6. Realm Execution Model** -// TODO: -// - Execution Semantics +// TODO: +// - Execution Semantics // - OS Analogy Table (Process=Realm, Kernel=GnoVM) + Package hierarchy (/p/, /r/, /e/) + Isolation Theorem --- # **7. State Commitment** -// TODO: -// - Data Integrity -// - Merkle Tree structure + Amino encoding (deterministic serialization) +// TODO: +// - Data Integrity +// - Merkle Tree structure + Amino encoding (deterministic serialization) --- # **8. Economics** -// TODO: -// - Token & Incentive Design -// - GNOT Token + Gas model + Storage Deposit (lock/unlock) + Fee distribution → Validators + Contributors +// TODO: +// - Token & Incentive Design +// - GNOT Token + Gas model + Storage Deposit (lock/unlock) + Fee distribution → Validators + Contributors +// - ref: https://gist.github.com/jaekwon/4d1c81ee3b82a0fc29f67d50e7f8664c. --- # **9. Proof of Contribution** -// TODO: -// - Governance Innovation -// - PoS limitations (capital ≠ competence) → Contributio based + Tier structure + DAOs -// - Maybe we should have another session for GovDAO? ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 +// TODO: +// - Governance Innovation +// - PoS limitations (capital ≠ competence) → Contributio based + Tier structure + DAOs +// - Maybe we should have another session for GovDAO? ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 --- # **10. Tendermint2** -// TODO: -// - Consensus Layer -// - Implementation = Specification + ~15K LOC + BFT rounds (Propose→Prevote→Precommit) + PoC integration -// - Differences from the original Tendermint? +// TODO: +// - Consensus Layer +// - Implementation = Specification + ~15K LOC + BFT rounds (Propose→Prevote→Precommit) + PoC integration +// - Differences from the original Tendermint? --- # **11. Safety and Liveness** -// TODO: -// - Security Proofs -// - Assumptions: network eventually delivers, <1/3 malicious, crypto works -// - Theorems: all nodes compute same result, contracts can't hack each other, no forks, chain never halts, no censorship +// TODO: +// - Security Proofs +// - Assumptions: network eventually delivers, <1/3 malicious, crypto works +// - Theorems: all nodes compute same result, contracts can't hack each other, no forks, chain never halts, no censorship --- # **12. The Logoverse** -// TODO: -// - Long-term Vision -// - Permanence + Composability + Transparency + Core applications (boards, users, govdao, gnodev, etc.) +// TODO: +// - Long-term Vision +// - Permanence + Composability + Transparency + Core applications (boards, users, govdao, gnodev, etc.) +// - ref: https://gno.land/r/gnoland/blog:p/gnoland-the-first-logoverse --- # **13. Conclusion** -// TODO: -// - Summary & Recap -// - Go-compatible + AST transparency + auto-persistence + PoC governance + minimal consensus +// TODO: +// - Summary & Recap +// - Go-compatible + AST transparency + auto-persistence + PoC governance + minimal consensus --- From 6e8913315b279922a574db6875426d290930dadc Mon Sep 17 00:00:00 2001 From: moul <94029+moul@users.noreply.github.com> Date: Tue, 16 Dec 2025 16:26:42 +0000 Subject: [PATCH 3/6] chore: 80cols Signed-off-by: moul <94029+moul@users.noreply.github.com> --- WHITEPAPER.md | 348 +++++++++++++++++++++++++++----------------------- 1 file changed, 185 insertions(+), 163 deletions(-) diff --git a/WHITEPAPER.md b/WHITEPAPER.md index 00014ee..0d7ac45 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -1,79 +1,109 @@ -# **Gno: A Deterministic Multi-Realm Computing Platform for Decentralized Applications** +# Gno: A Deterministic Multi-Realm Computing Platform -**TODO: Add authors** +TODO: Add authors -Draft v0.1 -December 2025 +Draft v0.1, December 2025 The current spec is on [github.com/gnolang/gno](https://github.com/gnolang/gno) ---- - -## **Abstract** - -> *At first, there was Bitcoin, out of entropy soup of the greater All.* -> *Then, there was Ethereum, which was created in the likeness of Bitcoin, but made Turing complete.* -> *Among these were Tendermint and Cosmos to engineer robust PoS and IBC.* -> *Then came Gno upon Cosmos and there spring forth Gnoland,* -> *simulated by the Gnomes of the Greater Resistance.* - -We stand at an inflection point in the evolution of decentralized systems. The infrastructure that governs our digital lives—social networks, financial systems, public discourse, and collective knowledge—remains captured by centralized authorities that decide what we see, what we say, and what we own. Blockchains promised liberation, yet their programming models remain opaque, their governance plutocratic, and their developer experience hostile. - -**Gno.land is the missing piece: a platform for timeless code that stores truth in plain sight.** - -Gno—the deterministic, Go-compatible programming environment powering the Gno.land platform—provides a model where smart contracts exist as human-readable source code: permanently on-chain, directly auditable, and inherently forkable. Gno.land then builds on this foundation by introducing governance driven not by token accumulation but by demonstrable contribution. Together, they form the basis of the **Logoverse**: a persistent, composable, censorship-resistant substrate for decentralized knowledge and coordination. - -### **Technical Summary** - -**Problem.** Current smart contract platforms exhibit: (1) bytecode opacity preventing practical auditability, (2) manual state serialization causing developer friction and storage-related vulnerabilities, (3) stake-weighted governance conflating capital ownership with technical competence, and (4) domain-specific languages fragmenting the developer ecosystem. - -**Solution.** We introduce Gno, a deterministic Go-compatible language executed by GnoVM, an AST-based interpreter providing automatic object persistence, capability-based realm isolation, and source-level transparency. Governance authority derives from Proof of Contribution (PoC), a Sybil-resistant reputation mechanism assigning voting power based on verified contributions rather than token holdings. - -**Result.** Gno.land achieves: (1) source-level transparency with direct auditability, (2) automatic state persistence eliminating serialization overhead, (3) contribution-weighted governance resistant to plutocratic capture, and (4) immediate developer accessibility for Go's established developer base. - ---- - -# **1. Introduction** - -## **1.1 Background** - -Bitcoin demonstrated decentralized value transfer without intermediaries [1]. Ethereum extended this to general computation through smart contracts [2]. Tendermint and Cosmos established practical Byzantine fault-tolerant consensus and inter-blockchain communication [3, 4]. +## Abstract + +> At first, there was Bitcoin, out of entropy soup of the greater All. +> Then, there was Ethereum, which was created in the likeness of Bitcoin, +> but made Turing complete. +> Among these were Tendermint and Cosmos to engineer robust PoS and IBC. +> Then came Gno upon Cosmos and there spring forth Gnoland, +> simulated by the Gnomes of the Greater Resistance. + +We stand at an inflection point in the evolution of decentralized systems. The +infrastructure that governs our digital lives, social networks, financial +systems, public discourse, and collective knowledge, remains captured by +centralized authorities that decide what we see, what we say, and what we own. +Blockchains promised liberation, yet their programming models remain opaque, +their governance plutocratic, and their developer experience hostile. + +Gno.land is the missing piece: a platform for timeless code that stores truth +in plain sight. + +Gno, the deterministic, Go-compatible programming environment powering the +Gno.land platform, provides a model where smart contracts exist as +human-readable source code: permanently on-chain, directly auditable, and +inherently forkable. Gno.land then builds on this foundation by introducing +governance driven not by token accumulation but by demonstrable contribution. +Together, they form the basis of the Logoverse: a persistent, composable, +censorship-resistant substrate for decentralized knowledge and coordination. + +### Technical Summary + +Problem: Current smart contract platforms exhibit: (1) bytecode opacity +preventing practical auditability, (2) manual state serialization causing +developer friction and storage-related vulnerabilities, (3) stake-weighted +governance conflating capital ownership with technical competence, and +(4) domain-specific languages fragmenting the developer ecosystem. + +Solution: We introduce Gno, a deterministic Go-compatible language executed +by GnoVM, an AST-based interpreter providing automatic object persistence, +capability-based realm isolation, and source-level transparency. Governance +authority derives from Proof of Contribution (PoC), a Sybil-resistant +reputation mechanism assigning voting power based on verified contributions +rather than token holdings. + +Result: Gno.land achieves: (1) source-level transparency with direct +auditability, (2) automatic state persistence eliminating serialization +overhead, (3) contribution-weighted governance resistant to plutocratic +capture, and (4) immediate developer accessibility for Go's established +developer base. + +# 1. Introduction + +## 1.1 Background + +Bitcoin demonstrated decentralized value transfer without intermediaries [1]. +Ethereum extended this to general computation through smart contracts [2]. +Tendermint and Cosmos established practical Byzantine fault-tolerant consensus +and inter-blockchain communication [3, 4]. Despite these advances, structural limitations persist: -- **Opacity**: Deployed contracts exist as bytecode, requiring specialized tools to interpret -- **Complexity**: Developers must learn domain-specific languages and manage state serialization manually -- **Plutocracy**: Governance power correlates with token holdings rather than expertise -- **Fragmentation**: Each ecosystem demands distinct languages, tooling, and mental models +- Opacity: Deployed contracts exist as bytecode, requiring specialized tools + to interpret +- Complexity: Developers must learn domain-specific languages and manage state + serialization manually +- Plutocracy: Governance power correlates with token holdings rather than + expertise +- Fragmentation: Each ecosystem demands distinct languages, tooling, and + mental models -## **1.2 Contributions** +## 1.2 Contributions This whitepaper presents: -1. **Gno Language** (§4): Deterministic Go variant (~99% compatible) with source-level on-chain storage -2. **GnoVM** (§5): AST-based interpreter with automatic persistent object memory -3. **Realm Model** (§6): Capability-based isolation with explicit cross-realm semantics -4. **Proof of Contribution** (§9): Reputation-based consensus mechanism separating voting power from token ownership -5. **Tendermint2** (§10): Minimal consensus engine where implementation serves as specification - ---- - -# **2. System Model** - -// TODO: -// - Formal Foundations -// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, Deterministic Execution, Cross-Realm Call semantics - ---- - -# **3. Comparison with Existing Platforms** - -// TODO: -// - Why Gno Wins -// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) + Solidity vs Gno code examples, e.g., State management +1. Gno Language (S4): Deterministic Go variant (~99% compatible) with + source-level on-chain storage +2. GnoVM (S5): AST-based interpreter with automatic persistent object memory +3. Realm Model (S6): Capability-based isolation with explicit cross-realm + semantics +4. Proof of Contribution (S9): Reputation-based consensus mechanism separating + voting power from token ownership +5. Tendermint2 (S10): Minimal consensus engine where implementation serves as + specification + +# 2. System Model + +// TODO: +// - Formal Foundations +// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, +// Deterministic Execution, Cross-Realm Call semantics + +# 3. Comparison with Existing Platforms + +// TODO: +// - Why Gno Wins +// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) +// - Solidity vs Gno code examples, e.g., State management // - Add more -## **3.1 The Bytecode Problem** +## 3.1 The Bytecode Problem Ethereum stores compiled bytecode: @@ -95,121 +125,113 @@ func Transfer(to std.Address, amount int64) { Auditing requires only the ability to read Go. -## **3.2 Virtual Machine Comparison** - -| Feature | EVM | WASM | MoveVM | **GnoVM** | -|---------|-----|------|--------|-----------| -| On-chain representation | Bytecode | Bytecode | Bytecode | **Source (AST)** | -| Auditability | Decompiler required | Decompiler required | Decompiler required | **Direct** | -| State model | Manual slots | Manual memory | Linear types | **Auto-persistent objects** | -| Safety model | Manual | Sandbox | Resource types | **Realm isolation + Go types** | -| Determinism | Partial | Partial | Strong | **Strong** | -| Language familiarity | New (Solidity) | Complex (Rust) | New (Move) | **Established (Go)** | - ---- - -# **4. Gno Language** - -// TODO: -// - Language Specification -// - ~99% Go compatible + Deterministic constraints + std package + Render convention -// - Interrealm specification - -# **5. GnoVM Architecture** - -// TODO: -// - VM Architecture -// - AST-based interpreter (not bytecode) + Persistent Object Memory (automatic state) + Execution lifecycle - ---- - -# **6. Realm Execution Model** - -// TODO: -// - Execution Semantics -// - OS Analogy Table (Process=Realm, Kernel=GnoVM) + Package hierarchy (/p/, /r/, /e/) + Isolation Theorem - ---- - -# **7. State Commitment** - -// TODO: -// - Data Integrity -// - Merkle Tree structure + Amino encoding (deterministic serialization) - ---- - -# **8. Economics** - -// TODO: -// - Token & Incentive Design -// - GNOT Token + Gas model + Storage Deposit (lock/unlock) + Fee distribution → Validators + Contributors -// - ref: https://gist.github.com/jaekwon/4d1c81ee3b82a0fc29f67d50e7f8664c. - ---- - -# **9. Proof of Contribution** - -// TODO: -// - Governance Innovation -// - PoS limitations (capital ≠ competence) → Contributio based + Tier structure + DAOs -// - Maybe we should have another session for GovDAO? ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 - ---- - -# **10. Tendermint2** - -// TODO: -// - Consensus Layer -// - Implementation = Specification + ~15K LOC + BFT rounds (Propose→Prevote→Precommit) + PoC integration -// - Differences from the original Tendermint? - ---- - -# **11. Safety and Liveness** - -// TODO: -// - Security Proofs -// - Assumptions: network eventually delivers, <1/3 malicious, crypto works -// - Theorems: all nodes compute same result, contracts can't hack each other, no forks, chain never halts, no censorship - ---- - -# **12. The Logoverse** - -// TODO: -// - Long-term Vision -// - Permanence + Composability + Transparency + Core applications (boards, users, govdao, gnodev, etc.) +## 3.2 Virtual Machine Comparison + +| Feature | EVM | WASM | MoveVM | GnoVM | +|---------------|------------|------------|------------|----------------| +| On-chain | Bytecode | Bytecode | Bytecode | Source (AST) | +| Auditability | Decompiler | Decompiler | Decompiler | Direct | +| State model | Manual | Manual | Linear | Auto-persistent| +| Safety model | Manual | Sandbox | Resources | Realm isolation| +| Determinism | Partial | Partial | Strong | Strong | +| Language | Solidity | Rust | Move | Go | + +# 4. Gno Language + +// TODO: +// - Language Specification +// - ~99% Go compatible + Deterministic constraints + std package +// - Render convention +// - Interrealm specification + +# 5. GnoVM Architecture + +// TODO: +// - VM Architecture +// - AST-based interpreter (not bytecode) +// - Persistent Object Memory (automatic state) +// - Execution lifecycle + +# 6. Realm Execution Model + +// TODO: +// - Execution Semantics +// - OS Analogy Table (Process=Realm, Kernel=GnoVM) +// - Package hierarchy (/p/, /r/, /e/) +// - Isolation Theorem + +# 7. State Commitment + +// TODO: +// - Data Integrity +// - Merkle Tree structure +// - Amino encoding (deterministic serialization) + +# 8. Economics + +// TODO: +// - Token & Incentive Design +// - GNOT Token + Gas model +// - Storage Deposit (lock/unlock) +// - Fee distribution: Validators + Contributors +// - ref: https://gist.github.com/jaekwon/4d1c81ee3b82a0fc29f67d50e7f8664c + +# 9. Proof of Contribution + +// TODO: +// - Governance Innovation +// - PoS limitations (capital != competence) +// - Contribution based + Tier structure + DAOs +// - Maybe separate section for GovDAO? +// - ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 + +# 10. Tendermint2 + +// TODO: +// - Consensus Layer +// - Implementation = Specification + ~15K LOC +// - BFT rounds (Propose -> Prevote -> Precommit) +// - PoC integration +// - Differences from the original Tendermint? + +# 11. Safety and Liveness + +// TODO: +// - Security Proofs +// - Assumptions: network eventually delivers, <1/3 malicious, crypto works +// - Theorems: all nodes compute same result, contracts can't hack each other, +// no forks, chain never halts, no censorship + +# 12. The Logoverse + +// TODO: +// - Long-term Vision +// - Permanence + Composability + Transparency +// - Core applications (boards, users, govdao, gnodev, etc.) // - ref: https://gno.land/r/gnoland/blog:p/gnoland-the-first-logoverse ---- - -# **13. Conclusion** +# 13. Conclusion -// TODO: -// - Summary & Recap -// - Go-compatible + AST transparency + auto-persistence + PoC governance + minimal consensus +// TODO: +// - Summary & Recap +// - Go-compatible + AST transparency + auto-persistence +// - PoC governance + minimal consensus ---- - -# **Appendix** +# Appendix // TODO: Add ---- - -# **References** +# References // TODO: Add more [1] S. Nakamoto, "Bitcoin: A peer-to-peer electronic cash system," 2008. -[2] V. Buterin, "Ethereum: A next-generation smart contract and decentralized application platform," 2014. +[2] V. Buterin, "Ethereum: A next-generation smart contract and decentralized + application platform," 2014. [3] J. Kwon, "Tendermint: Consensus without mining," 2014. [4] J. Kwon, E. Buchman, "Cosmos: A network of distributed ledgers," 2016. ---- - -## **Changelog** +## Changelog From 5157094a0a8ca3a7c1653693042a67bda530de10 Mon Sep 17 00:00:00 2001 From: moul <94029+moul@users.noreply.github.com> Date: Tue, 16 Dec 2025 16:32:58 +0000 Subject: [PATCH 4/6] wip Signed-off-by: moul <94029+moul@users.noreply.github.com> --- WHITEPAPER.md | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/WHITEPAPER.md b/WHITEPAPER.md index 0d7ac45..153bab5 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -162,10 +162,35 @@ Auditing requires only the ability to read Go. # 7. State Commitment +In most smart contract platforms, developers manually serialize and deserialize +state using explicit storage slots or key-value mappings. Gno eliminates this +friction: global variables are automatically persistent. + +```go +package counter + +var total int + +func Add(n int) { + total += n +} + +func Get() int { + return total +} +``` + +When `Add(5)` is called, `total` changes from 0 to 5. GnoVM detects this change +and commits it to the Merkle tree automatically. No `storage.set()`, no manual +encoding, no boilerplate. + +This works for any Go type: structs, slices, maps, pointers. The entire object +graph rooted at package-level variables is tracked and persisted. + // TODO: -// - Data Integrity -// - Merkle Tree structure +// - Merkle Tree structure details // - Amino encoding (deterministic serialization) +// - Gas costs for state changes # 8. Economics From 0b8a70cf9b3924d660df926a1a5c28ab772d728d Mon Sep 17 00:00:00 2001 From: moul <94029+moul@users.noreply.github.com> Date: Tue, 16 Dec 2025 16:35:19 +0000 Subject: [PATCH 5/6] wip: markdown todos Signed-off-by: moul <94029+moul@users.noreply.github.com> --- WHITEPAPER.md | 136 +++++++++++++++++++++++++++----------------------- 1 file changed, 74 insertions(+), 62 deletions(-) diff --git a/WHITEPAPER.md b/WHITEPAPER.md index 153bab5..919eaf6 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -90,18 +90,20 @@ This whitepaper presents: # 2. System Model -// TODO: -// - Formal Foundations -// - 4 Core Definitions: Realm tuple, Persistent Object Memory graph, -// Deterministic Execution, Cross-Realm Call semantics +TODO: + +- Formal Foundations +- 4 Core Definitions: Realm tuple, Persistent Object Memory graph, + Deterministic Execution, Cross-Realm Call semantics # 3. Comparison with Existing Platforms -// TODO: -// - Why Gno Wins -// - Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) -// - Solidity vs Gno code examples, e.g., State management -// - Add more +TODO: + +- Why Gno Wins +- Bytecode problem + VM Comparison Table (EVM/WASM/MoveVM vs GnoVM) +- Solidity vs Gno code examples, e.g., State management +- Add more ## 3.1 The Bytecode Problem @@ -138,27 +140,30 @@ Auditing requires only the ability to read Go. # 4. Gno Language -// TODO: -// - Language Specification -// - ~99% Go compatible + Deterministic constraints + std package -// - Render convention -// - Interrealm specification +TODO: + +- Language Specification +- ~99% Go compatible + Deterministic constraints + std package +- Render convention +- Interrealm specification # 5. GnoVM Architecture -// TODO: -// - VM Architecture -// - AST-based interpreter (not bytecode) -// - Persistent Object Memory (automatic state) -// - Execution lifecycle +TODO: + +- VM Architecture +- AST-based interpreter (not bytecode) +- Persistent Object Memory (automatic state) +- Execution lifecycle # 6. Realm Execution Model -// TODO: -// - Execution Semantics -// - OS Analogy Table (Process=Realm, Kernel=GnoVM) -// - Package hierarchy (/p/, /r/, /e/) -// - Isolation Theorem +TODO: + +- Execution Semantics +- OS Analogy Table (Process=Realm, Kernel=GnoVM) +- Package hierarchy (/p/, /r/, /e/) +- Isolation Theorem # 7. State Commitment @@ -187,68 +192,75 @@ encoding, no boilerplate. This works for any Go type: structs, slices, maps, pointers. The entire object graph rooted at package-level variables is tracked and persisted. -// TODO: -// - Merkle Tree structure details -// - Amino encoding (deterministic serialization) -// - Gas costs for state changes +TODO: + +- Merkle Tree structure details +- Amino encoding (deterministic serialization) +- Gas costs for state changes # 8. Economics -// TODO: -// - Token & Incentive Design -// - GNOT Token + Gas model -// - Storage Deposit (lock/unlock) -// - Fee distribution: Validators + Contributors -// - ref: https://gist.github.com/jaekwon/4d1c81ee3b82a0fc29f67d50e7f8664c +TODO: + +- Token & Incentive Design +- GNOT Token + Gas model +- Storage Deposit (lock/unlock) +- Fee distribution: Validators + Contributors +- ref: https://gist.github.com/jaekwon/4d1c81ee3b82a0fc29f67d50e7f8664c # 9. Proof of Contribution -// TODO: -// - Governance Innovation -// - PoS limitations (capital != competence) -// - Contribution based + Tier structure + DAOs -// - Maybe separate section for GovDAO? -// - ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 +TODO: + +- Governance Innovation +- PoS limitations (capital != competence) +- Contribution based + Tier structure + DAOs +- Maybe separate section for GovDAO? +- ref: https://gist.github.com/jaekwon/918ad325c4c8f7fb5d6e022e33cb7eb3 # 10. Tendermint2 -// TODO: -// - Consensus Layer -// - Implementation = Specification + ~15K LOC -// - BFT rounds (Propose -> Prevote -> Precommit) -// - PoC integration -// - Differences from the original Tendermint? +TODO: + +- Consensus Layer +- Implementation = Specification + ~15K LOC +- BFT rounds (Propose -> Prevote -> Precommit) +- PoC integration +- Differences from the original Tendermint? # 11. Safety and Liveness -// TODO: -// - Security Proofs -// - Assumptions: network eventually delivers, <1/3 malicious, crypto works -// - Theorems: all nodes compute same result, contracts can't hack each other, -// no forks, chain never halts, no censorship +TODO: + +- Security Proofs +- Assumptions: network eventually delivers, <1/3 malicious, crypto works +- Theorems: all nodes compute same result, contracts can't hack each other, + no forks, chain never halts, no censorship # 12. The Logoverse -// TODO: -// - Long-term Vision -// - Permanence + Composability + Transparency -// - Core applications (boards, users, govdao, gnodev, etc.) -// - ref: https://gno.land/r/gnoland/blog:p/gnoland-the-first-logoverse +TODO: + +- Long-term Vision +- Permanence + Composability + Transparency +- Core applications (boards, users, govdao, gnodev, etc.) +- ref: https://gno.land/r/gnoland/blog:p/gnoland-the-first-logoverse # 13. Conclusion -// TODO: -// - Summary & Recap -// - Go-compatible + AST transparency + auto-persistence -// - PoC governance + minimal consensus +TODO: + +- Summary & Recap +- Go-compatible + AST transparency + auto-persistence +- PoC governance + minimal consensus # Appendix -// TODO: Add +TODO: Add # References -// TODO: Add more +TODO: Add more [1] S. Nakamoto, "Bitcoin: A peer-to-peer electronic cash system," 2008. From eae651728174b7cdef83aa5a654b20ee3ac033d5 Mon Sep 17 00:00:00 2001 From: moul <94029+moul@users.noreply.github.com> Date: Tue, 16 Dec 2025 16:36:42 +0000 Subject: [PATCH 6/6] chore: fix footnote links Signed-off-by: moul <94029+moul@users.noreply.github.com> --- WHITEPAPER.md | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/WHITEPAPER.md b/WHITEPAPER.md index 919eaf6..bbe3d4d 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -58,10 +58,10 @@ developer base. ## 1.1 Background -Bitcoin demonstrated decentralized value transfer without intermediaries [1]. -Ethereum extended this to general computation through smart contracts [2]. +Bitcoin demonstrated decentralized value transfer without intermediaries[^1]. +Ethereum extended this to general computation through smart contracts[^2]. Tendermint and Cosmos established practical Byzantine fault-tolerant consensus -and inter-blockchain communication [3, 4]. +and inter-blockchain communication[^3][^4]. Despite these advances, structural limitations persist: @@ -262,13 +262,10 @@ TODO: Add TODO: Add more -[1] S. Nakamoto, "Bitcoin: A peer-to-peer electronic cash system," 2008. - -[2] V. Buterin, "Ethereum: A next-generation smart contract and decentralized - application platform," 2014. - -[3] J. Kwon, "Tendermint: Consensus without mining," 2014. - -[4] J. Kwon, E. Buchman, "Cosmos: A network of distributed ledgers," 2016. +[^1]: S. Nakamoto, "Bitcoin: A peer-to-peer electronic cash system," 2008. +[^2]: V. Buterin, "Ethereum: A next-generation smart contract and decentralized + application platform," 2014. +[^3]: J. Kwon, "Tendermint: Consensus without mining," 2014. +[^4]: J. Kwon, E. Buchman, "Cosmos: A network of distributed ledgers," 2016. ## Changelog