From 04e7d307ceb796f163f57be0174b9a9c421d89b3 Mon Sep 17 00:00:00 2001 From: Quentin Le Sceller Date: Tue, 19 Nov 2019 05:49:32 -0500 Subject: [PATCH] Replace MimbleWimble by Mimblewimble (#3118) * Replace MimbleWimble by Mimblewimble * MimbleWimble->Mimblewimble --- CONTRIBUTING.md | 2 +- Cargo.toml | 2 +- README.md | 10 +++---- api/Cargo.toml | 2 +- chain/Cargo.toml | 2 +- config/Cargo.toml | 2 +- core/Cargo.toml | 2 +- core/src/core/block.rs | 2 +- core/src/lib.rs | 2 +- doc/chain/chain_sync.md | 4 +-- doc/chain/chain_sync_KR.md | 4 +-- doc/contract_ideas.md | 2 +- doc/grin4bitcoiners.md | 8 +++--- doc/grin4bitcoiners_KR.md | 8 +++--- doc/grin4bitcoiners_ZH-CN.md | 8 +++--- doc/intro.md | 52 ++++++++++++++++++------------------ doc/intro_DE.md | 48 ++++++++++++++++----------------- doc/intro_ES.md | 52 ++++++++++++++++++------------------ doc/intro_KR.md | 40 +++++++++++++-------------- doc/intro_NL.md | 52 ++++++++++++++++++------------------ doc/intro_PT-BR.md | 48 ++++++++++++++++----------------- doc/intro_SE.md | 52 ++++++++++++++++++------------------ doc/intro_ZH-CN.md | 52 ++++++++++++++++++------------------ doc/merkle.md | 4 +-- doc/merkle_KR.md | 4 +-- doc/pruning.md | 6 ++--- doc/pruning_KR.md | 6 ++--- doc/switch_commitment.md | 4 +-- doc/toc.md | 2 +- keychain/Cargo.toml | 2 +- p2p/Cargo.toml | 2 +- pool/Cargo.toml | 2 +- servers/Cargo.toml | 2 +- src/bin/grin.yml | 2 +- store/Cargo.toml | 2 +- util/Cargo.toml | 2 +- 36 files changed, 248 insertions(+), 248 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 014fc5af7..00f9ec694 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -34,7 +34,7 @@ In case of problems with trying out grin, before starting to contribute, there's * And [see the developers chat](https://gitter.im/grin_community/dev) if you have questions about source code files. If you explain what you're looking at and what you want to do, we'll try to help you along the way. * Also see `docs/*.md` and the folder structure explanations, and [the wiki](https://github.com/mimblewimble/docs/wiki). -* Further information and discussions are in the [Forum](https://www.grin-forum.org/), the [website](https://grin-tech.org), the [mailing list](https://lists.launchpad.net/mimblewimble/) and news channels like the [@grincouncil](https://twitter.com/grincouncil) and a (mostly unfiltered!) Twitter bot that collects headlines, mailing list posts, and reddit posts related to MimbleWimble/Grin: [@grinmw](https://twitter.com/grinmw) +* Further information and discussions are in the [Forum](https://www.grin-forum.org/), the [website](https://grin-tech.org), the [mailing list](https://lists.launchpad.net/mimblewimble/) and news channels like the [@grincouncil](https://twitter.com/grincouncil) and a (mostly unfiltered!) Twitter bot that collects headlines, mailing list posts, and reddit posts related to Mimblewimble/Grin: [@grinmw](https://twitter.com/grinmw) ## Testing diff --git a/Cargo.toml b/Cargo.toml index 68551fcbc..79e807745 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ name = "grin" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/README.md b/README.md index 560d9482e..11556f8eb 100644 --- a/README.md +++ b/README.md @@ -8,17 +8,17 @@ # Grin -Grin is an in-progress implementation of the MimbleWimble protocol. Many characteristics are still undefined but the following constitutes a first set of choices: +Grin is an in-progress implementation of the Mimblewimble protocol. Many characteristics are still undefined but the following constitutes a first set of choices: * Clean and minimal implementation, and aiming to stay as such. - * Follows the MimbleWimble protocol, which provides great anonymity and scaling characteristics. + * Follows the Mimblewimble protocol, which provides great anonymity and scaling characteristics. * Cuckoo Cycle proof of work in two variants named Cuckaroo (ASIC-resistant) and Cuckatoo (ASIC-targeted). * Relatively fast block time: one minute. * Fixed block reward over time with a decreasing dilution. * Transaction fees are based on the number of Outputs created/destroyed and total transaction size. * Smooth curve for difficulty adjustments. -To learn more, read our [introduction to MimbleWimble and Grin](doc/intro.md). +To learn more, read our [introduction to Mimblewimble and Grin](doc/intro.md). ## Status @@ -31,7 +31,7 @@ To get involved, read our [contributing docs](CONTRIBUTING.md). Find us: * Chat: [Gitter](https://gitter.im/grin_community/Lobby). -* Mailing list: join the [~MimbleWimble team](https://launchpad.net/~mimblewimble) and subscribe on Launchpad. +* Mailing list: join the [~Mimblewimble team](https://launchpad.net/~mimblewimble) and subscribe on Launchpad. * Twitter for the Grin council: [@grincouncil](https://twitter.com/grincouncil) ## Getting Started @@ -48,7 +48,7 @@ We believe in pull requests, data and scientific research. We do not believe in ## Credits -Tom Elvis Jedusor for the first formulation of MimbleWimble. +Tom Elvis Jedusor for the first formulation of Mimblewimble. Andrew Poelstra for his related work and improvements. diff --git a/api/Cargo.toml b/api/Cargo.toml index 3d0155903..8b004c952 100644 --- a/api/Cargo.toml +++ b/api/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_api" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "APIs for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "APIs for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/chain/Cargo.toml b/chain/Cargo.toml index 07eaa79b5..ff7ee396d 100644 --- a/chain/Cargo.toml +++ b/chain/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_chain" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/config/Cargo.toml b/config/Cargo.toml index df71c2fb7..69636504e 100644 --- a/config/Cargo.toml +++ b/config/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_config" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Configuration for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Configuration for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/core/Cargo.toml b/core/Cargo.toml index d4342e1f7..2a215cef3 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_core" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/core/src/core/block.rs b/core/src/core/block.rs index b222280b9..b83a90026 100644 --- a/core/src/core/block.rs +++ b/core/src/core/block.rs @@ -451,7 +451,7 @@ impl Readable for UntrustedBlockHeader { } } -/// A block as expressed in the MimbleWimble protocol. The reward is +/// A block as expressed in the Mimblewimble protocol. The reward is /// non-explicit, assumed to be deducible from block height (similar to /// bitcoin's schedule) and expressed as a global transaction fee (added v.H), /// additive to the total of fees ever collected. diff --git a/core/src/lib.rs b/core/src/lib.rs index 19de40937..2e3e41c94 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -//! Implementation of the MimbleWimble paper. +//! Implementation of the Mimblewimble paper. //! https://download.wpsoftware.net/bitcoin/wizardry/mimblewimble.txt #![deny(non_upper_case_globals)] diff --git a/doc/chain/chain_sync.md b/doc/chain/chain_sync.md index 5ca400f27..ef556f6b8 100644 --- a/doc/chain/chain_sync.md +++ b/doc/chain/chain_sync.md @@ -4,7 +4,7 @@ We describe here the different methods used by a new node when joining the network to catch up with the latest chain state. We start with reminding the reader of the -following assumptions, which are all characteristics of Grin or MimbleWimble: +following assumptions, which are all characteristics of Grin or Mimblewimble: * All block headers include the root hash of all unspent outputs in the chain at the time of that block. @@ -27,7 +27,7 @@ its peers. The security model here is similar to bitcoin. We're able to verify the whole chain, the total work, the validity of each block, their full content, etc. -In addition, with MimbleWimble and full UTXO set commitments, even more integrity +In addition, with Mimblewimble and full UTXO set commitments, even more integrity validation can be performed. We do not try to do any space or bandwidth optimization in this mode (for example, diff --git a/doc/chain/chain_sync_KR.md b/doc/chain/chain_sync_KR.md index c5d25b4c5..67e993415 100644 --- a/doc/chain/chain_sync_KR.md +++ b/doc/chain/chain_sync_KR.md @@ -1,7 +1,7 @@ # 블록체인의 동기화 최신 노드 상태를 따라 가기 위해 네트워크에 참여할 때 새 노드가 사용하는 여러 가지 방법을 설명합니다. -먼저, 독자에게 다음과 같은 Grin 또는 MimbleWimble의 특성을 먼저 전제 하고 설명하겠습니다. +먼저, 독자에게 다음과 같은 Grin 또는 Mimblewimble의 특성을 먼저 전제 하고 설명하겠습니다. * 해당 블록 안의 모든 블록 헤더는 체인 안에 사용하지 않는 출력값의 모든 루트해시를 가지고 있습니다. * 입력 또는 출력은 전체 블록 상태를 무효화하지 않고선 변조되거나 위조 될 수 없습니다 @@ -14,7 +14,7 @@ 이 모델은 대부분의 메이저 퍼블릭 블록체인 에서 "풀 노드"가 사용하는 모델입니다. 새로운 노드는 제네시스 블록에 대한 사전 정보를 가지고 있습니다. 노드는 네트워크의 다른 피어와 연결되어 피어에게 알려진 최신 블록(호라이즌 블록)에 도달 할 때까지 블록을 요청하기 시작합니다. -보안 모델은 비트 코인과 비슷합니다. 전체 체인, 총 작업, 각 블록의 유효성, 전체 내용 등을 검증 할 수 있습니다. 또한 MimbleWimble 및 전체 UTXO 세트 실행들을 통해 훨씬 더 무결성 검증이 잘 수행될 수 있습니다. +보안 모델은 비트 코인과 비슷합니다. 전체 체인, 총 작업, 각 블록의 유효성, 전체 내용 등을 검증 할 수 있습니다. 또한 Mimblewimble 및 전체 UTXO 세트 실행들을 통해 훨씬 더 무결성 검증이 잘 수행될 수 있습니다. 이 모드에서는 저장공간 최적화 또는 대역폭 최적화를 시도하지 않습니다 (예를 들자면 유효성 검증 후 Range proof 가 삭제 될 수 있습니다). 여기서 중요한 것은 기록 아카이브를 제공하고 나중에 확인 및 증명을 하게 하는 것입니다. diff --git a/doc/contract_ideas.md b/doc/contract_ideas.md index a6d0d13ac..25157647a 100644 --- a/doc/contract_ideas.md +++ b/doc/contract_ideas.md @@ -248,7 +248,7 @@ changes (as does the nonce). Because it depends on the other party's nonce, this might require an additional round of interaction per channel update. Note also that nothing I've said depends at all on what's being signed. This -means this works just as well for MimbleWimble as it would for Bitcoin+Schnorr +means this works just as well for Mimblewimble as it would for Bitcoin+Schnorr as it would for Monero (with a multisig ring-CT construction) as it would for Ethereum+Schnorr. Further, it can link transactions across chains." - Andrew Poelstra - https://lists.launchpad.net/mimblewimble/msg00086.html diff --git a/doc/grin4bitcoiners.md b/doc/grin4bitcoiners.md index fbf4a52d9..7ee996fbb 100644 --- a/doc/grin4bitcoiners.md +++ b/doc/grin4bitcoiners.md @@ -1,4 +1,4 @@ -# Grin/MimbleWimble for Bitcoiners +# Grin/Mimblewimble for Bitcoiners *Read this in other languages:[Korean](grin4bitcoiners_KR.md) @@ -16,7 +16,7 @@ Moreover, there are no more transactions in a block. A Grin block looks just lik ## Scalability -As explained in the previous section, thanks to the MimbleWimble transaction and block format we can merge transactions when an output is directly spent by the input of another. It's as if when Alice gives money to Bob, and then Bob gives it all to Carol, Bob was never involved and his transaction is actually never even seen on the blockchain. +As explained in the previous section, thanks to the Mimblewimble transaction and block format we can merge transactions when an output is directly spent by the input of another. It's as if when Alice gives money to Bob, and then Bob gives it all to Carol, Bob was never involved and his transaction is actually never even seen on the blockchain. Pushing that further, between blocks, most outputs end up being spent sooner or later by another input. So *all spent outputs can be safely removed*. And the whole blockchain can be stored, downloaded and fully verified in just a few gigabytes or less (assuming a number of transactions similar to bitcoin). @@ -24,7 +24,7 @@ This means that the Grin blockchain scales with the number of users (unspent out ## Scripting -Maybe you've heard that MimbleWimble doesn't support scripts. And in some way, that's true. But thanks to cryptographic trickery, many contracts that in Bitcoin would require a script can be achieved with Grin using properties of Elliptic Curve Cryptography. So far, we know how to do: +Maybe you've heard that Mimblewimble doesn't support scripts. And in some way, that's true. But thanks to cryptographic trickery, many contracts that in Bitcoin would require a script can be achieved with Grin using properties of Elliptic Curve Cryptography. So far, we know how to do: * Multi-signature transactions. * Atomic swaps. @@ -43,7 +43,7 @@ Nope, no address. All outputs in Grin are unique and have no common data with an ### If transaction information gets removed, can I just cheat and create money? -No, and this is where MimbleWimble and Grin shine. Confidential transactions are a form of [homomorphic encryption](https://en.wikipedia.org/wiki/Homomorphic_encryption). Without revealing any amount, Grin can verify that the sum of all transaction inputs equal the sum of transaction outputs, plus the fee. Going even further, comparing the sum of all money created by mining with the total sum of money that's being held, Grin nodes can check the correctness of the total money supply. +No, and this is where Mimblewimble and Grin shine. Confidential transactions are a form of [homomorphic encryption](https://en.wikipedia.org/wiki/Homomorphic_encryption). Without revealing any amount, Grin can verify that the sum of all transaction inputs equal the sum of transaction outputs, plus the fee. Going even further, comparing the sum of all money created by mining with the total sum of money that's being held, Grin nodes can check the correctness of the total money supply. ### If I listen to transaction relay, can't I just figure out who they belong to before being cut-through? diff --git a/doc/grin4bitcoiners_KR.md b/doc/grin4bitcoiners_KR.md index 214bbb6d1..1feb18a02 100644 --- a/doc/grin4bitcoiners_KR.md +++ b/doc/grin4bitcoiners_KR.md @@ -1,4 +1,4 @@ -# Bitcoiner를 위한 Grin/MimbleWimble +# Bitcoiner를 위한 Grin/Mimblewimble ## 프라이버시와 대체가능성(Fungibility) @@ -14,7 +14,7 @@ Grin 트랜잭션에는 트랜잭션을 프라이빗하게 만드는 3 가지 ## 확장성(Scalability) -이전 섹션에서 설명한 것처럼 MimbleWimble 트랜잭션과 블록 포맷 때문에 출력이 다른 트랜잭션의 입력에 의해 직접 소비(spent) 될 때 트랜잭션을 합칠 수 있습니다. (예를 들어 - 문맥의 부드러움을 위해 첨가함, 역자 주 )앨리스가 밥에게 돈을 주고 밥이 캐럴에게 돈을 주면 밥은 결코 연관되지 않은것처럼 보이고 실제로 밥의 트랜잭션은 블록체인에서 보이지 않습니다. +이전 섹션에서 설명한 것처럼 Mimblewimble 트랜잭션과 블록 포맷 때문에 출력이 다른 트랜잭션의 입력에 의해 직접 소비(spent) 될 때 트랜잭션을 합칠 수 있습니다. (예를 들어 - 문맥의 부드러움을 위해 첨가함, 역자 주 )앨리스가 밥에게 돈을 주고 밥이 캐럴에게 돈을 주면 밥은 결코 연관되지 않은것처럼 보이고 실제로 밥의 트랜잭션은 블록체인에서 보이지 않습니다. 더 많은 트랜잭션들을 블록에 밀어 넣으면 대부분의 출력이 다른 입력에 의해 조만간 소비됩니다. 따라서 *모든 소비 출력값을(spent outputs) 안전하게 제거 할 수 있습니다*. 그리고 (bitcoin과 유사한 트랜잭션의 수를 가정 한다면)몇 GB 이하로 전체 블록 체인을 저장하고, 다운로드하고, 완벽하게 검증 할 수 있습니다. @@ -22,7 +22,7 @@ Grin 트랜잭션에는 트랜잭션을 프라이빗하게 만드는 3 가지 ## 스크립팅(Scripting) -아마도 MimbleWimble은 스크립트(Script)를 지원하지 않는다는 말을 들었을 겁니다. 어떤면에서 이 말은 사실입니다. 그러나 암호화 기법 덕분에 Bitcoin에서 스크립트를 필요로 하는 많은 계약은 Elliptic Curve Cryptography의 속성을 사용하여 Grin으로 작성 할 수 있습니다. 지금까지 아래와 같은 구현을 어떻게 하는지 하는지 알고 있습니다. : +아마도 Mimblewimble은 스크립트(Script)를 지원하지 않는다는 말을 들었을 겁니다. 어떤면에서 이 말은 사실입니다. 그러나 암호화 기법 덕분에 Bitcoin에서 스크립트를 필요로 하는 많은 계약은 Elliptic Curve Cryptography의 속성을 사용하여 Grin으로 작성 할 수 있습니다. 지금까지 아래와 같은 구현을 어떻게 하는지 하는지 알고 있습니다. : * Multi-signature transactions. * 아토믹 스왑 (Atomic swap). @@ -41,7 +41,7 @@ Grin 트랜잭션에는 트랜잭션을 프라이빗하게 만드는 3 가지 ### 트랜잭션 정보가 제거된다면 사기는 치거나 코인을 만들어 낼수 있지 않나요? -아니요, MimbleWimble과 Grin의 장점이 돋보이는것이 바로 이런 점 입니다. Confidential transaction은 [동형(homomorphic)암호](https://en.wikipedia.org/wiki/Homomophic_encryption)의 한 형태입니다. 금액을 드러내지 않고 Grin은 모든 거래의 입력값의 합계가 거래의 출력값의 합계 + 수수료를 합한 것과 일치하는지 확인이 가능합니다. 더해서 마이닝으로 만들어진 모든 코인의 합계와 보유하고 있는 총 금액과 비교하여, Grin노드는 코인의 모두 얼마나 공급 되었는지 그 정확성을 확인할 수 있습니다. +아니요, Mimblewimble과 Grin의 장점이 돋보이는것이 바로 이런 점 입니다. Confidential transaction은 [동형(homomorphic)암호](https://en.wikipedia.org/wiki/Homomophic_encryption)의 한 형태입니다. 금액을 드러내지 않고 Grin은 모든 거래의 입력값의 합계가 거래의 출력값의 합계 + 수수료를 합한 것과 일치하는지 확인이 가능합니다. 더해서 마이닝으로 만들어진 모든 코인의 합계와 보유하고 있는 총 금액과 비교하여, Grin노드는 코인의 모두 얼마나 공급 되었는지 그 정확성을 확인할 수 있습니다. ### 만약 트랜잭션 릴레이를 받는다면 컷 쓰루 전에는(cut-through) 누구에게 트랜잭션이 속하는지 알 수 없지 않나요? diff --git a/doc/grin4bitcoiners_ZH-CN.md b/doc/grin4bitcoiners_ZH-CN.md index 1692c1212..0af934321 100644 --- a/doc/grin4bitcoiners_ZH-CN.md +++ b/doc/grin4bitcoiners_ZH-CN.md @@ -1,4 +1,4 @@ -# Grin/MimbleWimble 致比特币持有者 +# Grin/Mimblewimble 致比特币持有者 * 阅读其他语言版本:[Korean](grin4bitcoiners_KR.md)、 [English](grin4bitcoiners.md) @@ -16,7 +16,7 @@ Grin 链上交易有三个隐私特性: ## 扩展性 -如上所述,由于 MimbleWimble 交易和区块格式,交易可以合并,一笔输出可以从另一笔的输入直接花费。例如,甲给乙转账,乙之后转账给丙。这一系列交易中可以去除乙的数据,乙的交易数据绝对不会在链上显示。 +如上所述,由于 Mimblewimble 交易和区块格式,交易可以合并,一笔输出可以从另一笔的输入直接花费。例如,甲给乙转账,乙之后转账给丙。这一系列交易中可以去除乙的数据,乙的交易数据绝对不会在链上显示。 详细来说,区块间多数交易输出迟早都会变成另笔交易的输入。因此,*所有输出花费都可以安全删除*。而且假设 Grin 交易量与比特币相当,仅需几个 GB 或更少容量即可存储、下载和验证完整区块。 @@ -24,7 +24,7 @@ Grin 链上交易有三个隐私特性: ## 脚本 -或许你听说过 MimbleWimble 协议不支持脚本 (Script)。某种程度上这是事实。但利用密码学方法,许多需要脚本的比特币合约在 Grin 上可以使用椭圆曲线密码学 (Elliptic Curve Cryptography) 实现。迄今为止已知的方法有: +或许你听说过 Mimblewimble 协议不支持脚本 (Script)。某种程度上这是事实。但利用密码学方法,许多需要脚本的比特币合约在 Grin 上可以使用椭圆曲线密码学 (Elliptic Curve Cryptography) 实现。迄今为止已知的方法有: * 多签交易 * 原子交换 @@ -43,7 +43,7 @@ Grin 链上交易有三个隐私特性: ### 如果删除交易信息,是不是就能欺骗并造新币? -不可以,这就是 MimbleWimble 协议和 Grin 的出众之处。机密交易是一种[同态加密](https://en.wikipedia.org/wiki/Homomorphic_encryption)形式。Grin 不用公开交易金额,即可验证交易输入总额等于交易输出与交易费总和。也就是说,比较挖矿产生的货币总量与现有货币总量,Grin 节点来检查货币总量是否准确。 +不可以,这就是 Mimblewimble 协议和 Grin 的出众之处。机密交易是一种[同态加密](https://en.wikipedia.org/wiki/Homomorphic_encryption)形式。Grin 不用公开交易金额,即可验证交易输入总额等于交易输出与交易费总和。也就是说,比较挖矿产生的货币总量与现有货币总量,Grin 节点来检查货币总量是否准确。 ### 如果监听交易中继,我是不是就能在交易核销前分析出持币人信息? diff --git a/doc/intro.md b/doc/intro.md index 04b190933..e21a1755a 100644 --- a/doc/intro.md +++ b/doc/intro.md @@ -1,13 +1,13 @@ -# Introduction to MimbleWimble and Grin +# Introduction to Mimblewimble and Grin *Read this in other languages: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -MimbleWimble is a blockchain format and protocol that provides +Mimblewimble is a blockchain format and protocol that provides extremely good scalability, privacy and fungibility by relying on strong cryptographic primitives. It addresses gaps existing in almost all current blockchain implementations. -Grin is an open source software project that implements a MimbleWimble +Grin is an open source software project that implements a Mimblewimble blockchain and fills the gaps required for a full blockchain and cryptocurrency deployment. @@ -18,7 +18,7 @@ The main goal and characteristics of the Grin project are: * Scales mostly with the number of users and minimally with the number of transactions (<100 byte `kernel`), resulting in a large space saving compared to other blockchains. -* Strong and proven cryptography. MimbleWimble only relies on Elliptic Curve +* Strong and proven cryptography. Mimblewimble only relies on Elliptic Curve Cryptography which has been tried and tested for decades. * Design simplicity that makes it easy to audit and maintain over time. * Community driven, encouraging mining decentralization. @@ -29,20 +29,20 @@ A detailed post on the step-by-step of how Grin transactions work (with graphics This document is targeted at readers with a good understanding of blockchains and basic cryptography. With that in mind, we attempt -to explain the technical buildup of MimbleWimble and how it's applied in Grin. We hope +to explain the technical buildup of Mimblewimble and how it's applied in Grin. We hope this document is understandable to most technically-minded readers. Our objective is to encourage you to get interested in Grin and contribute in any way possible. To achieve this objective, we will introduce the main concepts required for a good -understanding of Grin as a MimbleWimble implementation. We will start with a brief +understanding of Grin as a Mimblewimble implementation. We will start with a brief description of some relevant properties of Elliptic Curve Cryptography (ECC) to lay the foundation on which Grin is based and then describe all the key elements of a -MimbleWimble blockchain's transactions and blocks. +Mimblewimble blockchain's transactions and blocks. ### Tiny Bits of Elliptic Curves We start with a brief primer on Elliptic Curve Cryptography, reviewing just the -properties necessary to understand how MimbleWimble works and without +properties necessary to understand how Mimblewimble works and without delving too much into the intricacies of ECC. For readers who would want to dive deeper into those assumptions, there are other opportunities to [learn more](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). @@ -67,15 +67,15 @@ The previous formula `(k+j)*H = k*H + j*H`, with _k_ and _j_ both private keys, demonstrates that a public key obtained from the addition of two private keys (`(k+j)*H`) is identical to the addition of the public keys for each of those two private keys (`k*H + j*H`). In the Bitcoin blockchain, Hierarchical -Deterministic wallets heavily rely on this principle. MimbleWimble and the Grin +Deterministic wallets heavily rely on this principle. Mimblewimble and the Grin implementation do as well. -### Transacting with MimbleWimble +### Transacting with Mimblewimble -The structure of transactions demonstrates a crucial tenet of MimbleWimble: +The structure of transactions demonstrates a crucial tenet of Mimblewimble: strong privacy and confidentiality guarantees. -The validation of MimbleWimble transactions relies on two basic properties: +The validation of Mimblewimble transactions relies on two basic properties: * **Verification of zero sums.** The sum of outputs minus inputs always equals zero, proving that the transaction did not create new funds, _without revealing the actual amounts_. @@ -142,7 +142,7 @@ Which as a consequence requires that: ri1 + ri2 = ro3 -This is the first pillar of MimbleWimble: the arithmetic required to validate a +This is the first pillar of Mimblewimble: the arithmetic required to validate a transaction can be done without knowing any of the values. As a final note, this idea is actually derived from Greg Maxwell's @@ -154,7 +154,7 @@ applied to Bitcoin. #### Ownership In the previous section we introduced a private key as a blinding factor to obscure the -transaction's values. The second insight of MimbleWimble is that this private +transaction's values. The second insight of Mimblewimble is that this private key can be leveraged to prove ownership of the value. Alice sends you 3 coins and to obscure that amount, you chose 28 as your @@ -219,7 +219,7 @@ fees), is called a _transaction kernel_ and is checked by all validators. This section elaborates on the building of transactions by discussing how change is introduced and the requirement for range proofs so all values are proven to be -non-negative. Neither of these are absolutely required to understand MimbleWimble and +non-negative. Neither of these are absolutely required to understand Mimblewimble and Grin, so if you're in a hurry, feel free to jump straight to [Putting It All Together](#putting-it-all-together). @@ -249,7 +249,7 @@ and -3 and still obtain a well-balanced transaction, following the definition in the previous sections. This can't be easily detected because even if _x_ is negative, the corresponding point `x*H` on the curve looks like any other. -To solve this problem, MimbleWimble leverages another cryptographic concept (also +To solve this problem, Mimblewimble leverages another cryptographic concept (also coming from Confidential Transactions) called range proofs: a proof that a number falls within a given range, without revealing the number. We won't elaborate on the range proof, but you just need to know @@ -267,7 +267,7 @@ which can be signed by the attacker since Carols private key of 113 cancels due #### Putting It All Together -A MimbleWimble transaction includes the following: +A Mimblewimble transaction includes the following: * A set of inputs, that reference and spend a set of previous outputs. * A set of new outputs that include: @@ -280,13 +280,13 @@ A MimbleWimble transaction includes the following: ### Blocks and Chain State -We've explained above how MimbleWimble transactions can provide +We've explained above how Mimblewimble transactions can provide strong anonymity guarantees while maintaining the properties required for a valid blockchain, i.e., a transaction does not create money and proof of ownership is established through private keys. -The MimbleWimble block format builds on this by introducing one additional -concept: _cut-through_. With this addition, a MimbleWimble chain gains: +The Mimblewimble block format builds on this by introducing one additional +concept: _cut-through_. With this addition, a Mimblewimble chain gains: * Extremely good scalability, as the great majority of transaction data can be eliminated over time, without compromising security. @@ -318,11 +318,11 @@ The same holds true for blocks themselves once we realize a block is simply a se sum(outputs) - sum(inputs) = sum(kernel_excess) -Simplifying slightly, (again ignoring transaction fees) we can say that MimbleWimble blocks can be treated exactly as MimbleWimble transactions. +Simplifying slightly, (again ignoring transaction fees) we can say that Mimblewimble blocks can be treated exactly as Mimblewimble transactions. ##### Kernel Offsets -There is a subtle problem with MimbleWimble blocks and transactions as described above. It is possible (and in some cases trivial) to reconstruct the constituent transactions in a block. This is clearly bad for privacy. This is the "subset" problem - given a set of inputs, outputs and transaction kernels a subset of these will recombine to reconstruct a valid transaction. +There is a subtle problem with Mimblewimble blocks and transactions as described above. It is possible (and in some cases trivial) to reconstruct the constituent transactions in a block. This is clearly bad for privacy. This is the "subset" problem - given a set of inputs, outputs and transaction kernels a subset of these will recombine to reconstruct a valid transaction. For example, given the following two transactions - @@ -401,7 +401,7 @@ A block is simply built from: * The signatures generated using the excess value. * The mining fee. -When structured this way, a MimbleWimble block offers extremely good privacy +When structured this way, a Mimblewimble block offers extremely good privacy guarantees: * Intermediate (cut-through) transactions will be represented only by their transaction kernels. @@ -431,10 +431,10 @@ The first piece of information can be deduced just using the block height (its distance from the genesis block). And both the unspent outputs and the transaction kernels are extremely compact. This has 2 important consequences: -* The state a given node in a MimbleWimble blockchain needs to maintain is very +* The state a given node in a Mimblewimble blockchain needs to maintain is very small (on the order of a few gigabytes for a bitcoin-sized blockchain, and potentially optimizable to a few hundreds of megabytes). -* When a new node joins a network building up a MimbleWimble chain, the amount of +* When a new node joins a network building up a Mimblewimble chain, the amount of information that needs to be transferred is also very small. In addition, the complete set of unspent outputs cannot be tampered with, even @@ -444,7 +444,7 @@ factors in the outputs. ### Conclusion -In this document we covered the basic principles that underlie a MimbleWimble +In this document we covered the basic principles that underlie a Mimblewimble blockchain. By using the addition properties of Elliptic Curve Cryptography, we're able to build transactions that are completely opaque but can still be properly validated. And by generalizing those properties to blocks, we can eliminate a large diff --git a/doc/intro_DE.md b/doc/intro_DE.md index d670f0ee9..30ebacabd 100644 --- a/doc/intro_DE.md +++ b/doc/intro_DE.md @@ -1,28 +1,28 @@ -# Einführung in MimbleWimble und Grin +# Einführung in Mimblewimble und Grin *In anderen Sprachen lesen: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md)* -MimbleWimble ist ein Blockchain-Format und Protokoll, welches auf starke kryptographische Primitiven setzt und dadurch äußerst gute Skalierbarkeit, Privatsphäre und Fungibilität bietet. Es befasst sich mit Lücken, die in fast allen gegenwärtigen Blockchainimplementierungen existieren. +Mimblewimble ist ein Blockchain-Format und Protokoll, welches auf starke kryptographische Primitiven setzt und dadurch äußerst gute Skalierbarkeit, Privatsphäre und Fungibilität bietet. Es befasst sich mit Lücken, die in fast allen gegenwärtigen Blockchainimplementierungen existieren. -Grin ist ein Open-Source-Softwareprojekt, dass eine MimbleWimble-Blockchain implementiert und die für den Einsatz einer vollständigen Blockchain und Kryptowährung nötigen Lücken schließt. +Grin ist ein Open-Source-Softwareprojekt, dass eine Mimblewimble-Blockchain implementiert und die für den Einsatz einer vollständigen Blockchain und Kryptowährung nötigen Lücken schließt. Das Hauptziel und die Charakteristika des Grin-Projekts sind wie folgt: * Standardmäßige Privatsphäre. Dies ermöglicht volle Fungibilität, ohne die Fähigkeit auszuschließen, Informationen nach Bedarf selektiv preisgeben zu können. * Skaliert hauptsächlich mit der Anzahl der Nutzer und minimal mit der Anzahl an Transaktionen (<100 byte `kernel`), was zu hoher Platzsparung im Vergleich zu anderen Blockchains führt. -* Starke und bewährte Kryptografie. MimbleWimble setzt nur auf seit Jahrzehnten erprobte Elliptische-Kurven-Kryptografie. +* Starke und bewährte Kryptografie. Mimblewimble setzt nur auf seit Jahrzehnten erprobte Elliptische-Kurven-Kryptografie. * Einfachheit des Designs, die das dauerhafte Auditieren und Aufrechterhalten leicht gestaltet. * Von der Gemeinschaft gelenkt, die Dezentralisierung des Minings fördernd. ## Tongue Tying für Jedermann -Dieses Dokument richtet sich an Leser, die ein gutes Verständnis von Blockchain und grundlegender Kryptografie haben. Vor diesem Hintergrund sind wir bestrebt, den technischen Aufbau von MimbleWimble, sowie dessen Einsatz in Grin zu erklären. Wir hoffen, dass dieses Dokument für die meisten technikbegeisterten Leser verständlich ist. Unser Ziel ist es, dich für Grin zu begeistern und dein Interesse zu wecken, dich in jeder möglichen Weise einzubringen. +Dieses Dokument richtet sich an Leser, die ein gutes Verständnis von Blockchain und grundlegender Kryptografie haben. Vor diesem Hintergrund sind wir bestrebt, den technischen Aufbau von Mimblewimble, sowie dessen Einsatz in Grin zu erklären. Wir hoffen, dass dieses Dokument für die meisten technikbegeisterten Leser verständlich ist. Unser Ziel ist es, dich für Grin zu begeistern und dein Interesse zu wecken, dich in jeder möglichen Weise einzubringen. -Um dieses Ziel zu erreichen, führen wir die für ein gutes Verständnis von Grin als MimbleWimble-Umsetzung nötigen Hauptkonzepte ein. Wir beginnen mit einer kurzen Erläutering einiger relevanter Eigenschaften der Elliptischen-Kurven-Kryptografie (ECC), um die Grundlagen für Grin zu legen und anschließend die Kernelemente von Transaktionen und Blocks im MimbleWimble-Blockchain zu beschreiben. +Um dieses Ziel zu erreichen, führen wir die für ein gutes Verständnis von Grin als Mimblewimble-Umsetzung nötigen Hauptkonzepte ein. Wir beginnen mit einer kurzen Erläutering einiger relevanter Eigenschaften der Elliptischen-Kurven-Kryptografie (ECC), um die Grundlagen für Grin zu legen und anschließend die Kernelemente von Transaktionen und Blocks im Mimblewimble-Blockchain zu beschreiben. ### Tiny Bits of Elliptic Curves -Wir beginnen mit einer kurzen Einführung in Elliptische-Kurven-Kryptografie, wobei wir nur die Eigenschaften betrachten, die für das Verständnis von MimbleWimbles Funktionsweise nötig sind, ohne die Feinheiten von ECC eingehend zu vertiefen. Für Leser, die tiefer in diese Vorraussetzungen einzutauchen wünschen, gibt es weitere Möglichkeiten [mehr zu lernen](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). +Wir beginnen mit einer kurzen Einführung in Elliptische-Kurven-Kryptografie, wobei wir nur die Eigenschaften betrachten, die für das Verständnis von Mimblewimbles Funktionsweise nötig sind, ohne die Feinheiten von ECC eingehend zu vertiefen. Für Leser, die tiefer in diese Vorraussetzungen einzutauchen wünschen, gibt es weitere Möglichkeiten [mehr zu lernen](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). Eine elliptische Kurve zum Zwecke der Kryptografie ist ein großes Set an Punkten, die wir _C_ nennen. Diese Punkte können von Integern (auch Skalare genannt) addiert, substrahiert, oder multipliziert werden. Mit einem Integer _k_ und mittels einer Operation der skalaren Multiplikation können wir `k*H` errechnen, was auch einen Punkt auf der Kurve _C_ darstellt. Mit einem weiteren Integer _j_ können wir ferner `(k+j)*H` errechnen, was `k*H + j*H` gleicht. Diese Addition- und Skalarmultiplikationsoperationen auf einer elliptischen Kurve behalten die kommutativen und assoziativen Eigenschaften der Addition und Multiplikation bei: @@ -30,13 +30,13 @@ Eine elliptische Kurve zum Zwecke der Kryptografie ist ein großes Set an Punkte Wenn wir in ECC eine sehr große Zahl _k_ als privaten Schlüssel wählen, gilt `k*H` als der korrespondierende öffentliche Schlüssel. Selbst wenn der Wert des öffentlichen Schlüssels `k*H` bekannt ist, ist die Ableitung von _k_ nahezu unmöglich (oder anders ausgedrückt, während die Multiplikation trivial ist, ist die "Division" durch Kurvenpunkte extrem schwierig). -Die vorherige Formel `(k+j)*H = k*H + j*H`, mit jeweils _k_ und _j_ als privaten Schlüsseln, demonstriert, dass ein aus der Addition zweier privater Schlüssel (`(k+j)*H`) erhaltener öffentlicher Schlüssel identisch mit der Addition der öffentlichen Schlüssel für jeden der zwei privaten Schlüssel (`k*H + j*H`) ist. In der Bitcoin-Blockchain stützen sich Hierarchical Deterministic Wallets stark auf dieses Prinzip. Gleiches gilt auch für MimbleWimble und die Grin-Implementierung. +Die vorherige Formel `(k+j)*H = k*H + j*H`, mit jeweils _k_ und _j_ als privaten Schlüsseln, demonstriert, dass ein aus der Addition zweier privater Schlüssel (`(k+j)*H`) erhaltener öffentlicher Schlüssel identisch mit der Addition der öffentlichen Schlüssel für jeden der zwei privaten Schlüssel (`k*H + j*H`) ist. In der Bitcoin-Blockchain stützen sich Hierarchical Deterministic Wallets stark auf dieses Prinzip. Gleiches gilt auch für Mimblewimble und die Grin-Implementierung. -### Transaktionen mit MimbleWimble +### Transaktionen mit Mimblewimble -Die Struktur von Transaktionen veranschaulicht einen wesentlichen Grundsatz von MimbleWimble: starke Privatsphäre und Garantie der Vertraulichkeit. +Die Struktur von Transaktionen veranschaulicht einen wesentlichen Grundsatz von Mimblewimble: starke Privatsphäre und Garantie der Vertraulichkeit. -Die Validierung von MimbleWimble-Transaktionen hängt von zwei grundlegenden Eigenschaften ab: +Die Validierung von Mimblewimble-Transaktionen hängt von zwei grundlegenden Eigenschaften ab: * **Verifizierung von Zero Sums.** Die Summe der Outputs minus Inputs ergibt immer Null, was beweist, dass die Transaktion keine neuen Gelder erschaffen hat, _ohne dabei die tatsächlichen Beträge zu enthüllen._ * **Besitz von privaten Schlüsseln.** Wie bei den meisten anderen Kryptowährungen ist das Eigentum der Transtaktionsoutputs durch den Besitz der ECC-Privatschlüssel garantiert. Jedoch wird der Beweis, dass eine Entität jene privaten Schlüssel besitzt, nicht durch das direkte Signieren der Transaktion erreicht. @@ -81,13 +81,13 @@ Was als Konsequenz vorraussetzt, dass: ri1 + ri2 = ro3 -Dies ist der erste Grundpfeiler von MimbleWimble: die für die Validierung einer Transaktion erforderliche Arithmetik kann durchgeführt werden, ohne Kenntnis über die Werte zu haben. +Dies ist der erste Grundpfeiler von Mimblewimble: die für die Validierung einer Transaktion erforderliche Arithmetik kann durchgeführt werden, ohne Kenntnis über die Werte zu haben. Zum Schluss sei erwähnt, dass diese Idee von Greg Maxwells [Confidential Transactions](https://elementsproject.org/features/confidential-transactions/investigation) abgeleitet wurde, und jene wiederum von Adam Backs Vorschlag für an Bitcoin angepasste homomorphe Werte. #### Besitz -In den vorherigen Abschnitten haben wir private Schlüssel als Blinding Factor, um die Transaktionswerte zu verbergen, eingeführt. Die zweite Erkenntnis von MimbleWimble ist, dass private Schlüssel zum Einsatz kommen können, um den privaten Besitz des Wertes zu beweisen. +In den vorherigen Abschnitten haben wir private Schlüssel als Blinding Factor, um die Transaktionswerte zu verbergen, eingeführt. Die zweite Erkenntnis von Mimblewimble ist, dass private Schlüssel zum Einsatz kommen können, um den privaten Besitz des Wertes zu beweisen. Alice schickt dir 3 Coins. Um diesen Betrag zu verbergen, wählst du 28 als Blinding Factor (es sei angemerkt, dass der Blinding Factor als privater Schlüssel in der Praxis eine sehr große Zahl darstellt). Irgendwo auf der Blockchain erscheint der folgende Output, der nur von dir ausgebbar sein sollte: @@ -122,7 +122,7 @@ Diese Signatur, die jeder Transaktion zusammen mit weiteren Daten (wie Mininggeb #### Einige Feinheiten -Dieser Abschnitt führt die Erstellung von Transaktionen weiter aus und erörtert wie Wechselgeld eingeführt wird, sowie ferner die Voraussetzung von Range Proofs, sodass alle Werte nachweislich nicht negativ sind. Keines der beiden ist für das Verständnis von MimbleWimble und Grin absolut von Nöten, falls du es also eilig hast, spring einfach gleich zur [Zusammenfassung](#zusammenfassung). +Dieser Abschnitt führt die Erstellung von Transaktionen weiter aus und erörtert wie Wechselgeld eingeführt wird, sowie ferner die Voraussetzung von Range Proofs, sodass alle Werte nachweislich nicht negativ sind. Keines der beiden ist für das Verständnis von Mimblewimble und Grin absolut von Nöten, falls du es also eilig hast, spring einfach gleich zur [Zusammenfassung](#zusammenfassung). #### Wechselgeld @@ -141,13 +141,13 @@ In allen obigen Berechnungen stützen wir uns darauf, dass die Transaktionswerte Zum Beispiel könnten Transaktionen mit einem Input von 2 und Outputs von 5 und -3 erstellt werden, die trotzdem ausgeglichen sind, folgend der Definition in den vorherigen Abschnitten. Dies ist nicht einfach festzustellen, da sogar wenn _x_ Negativ ist, der korrespondierende Punkt `x.H` auf der Kurve so aussieht wie jeder andere. -Um dieses Problem zu lösen, setzt MimbleWimble ein anderes kryptographisches Konzept (ebenso stammend von Confidential Transactions) namens Range Proofs ein. Wir werden Range Proofs nicht ausführlich behandeln, du solltest nur wissen, dass wir für jedes `r.G + v.H` einen Beweis erstellen können, der zeigt, dass _v_ größer als Null ist und nicht zu Overflow führt. +Um dieses Problem zu lösen, setzt Mimblewimble ein anderes kryptographisches Konzept (ebenso stammend von Confidential Transactions) namens Range Proofs ein. Wir werden Range Proofs nicht ausführlich behandeln, du solltest nur wissen, dass wir für jedes `r.G + v.H` einen Beweis erstellen können, der zeigt, dass _v_ größer als Null ist und nicht zu Overflow führt. Es ist auch wichtig anzumerken, dass um einen gültigen Range Proof der obigen Beispiele zu erstellen, die beiden Werte 113 und 28, die für die Erstellung und Signierung des Wertüberschusses genutzt werden, bekannt sein müssen. Der Grund dafür, sowie eine genauere Beschreibung von Range Proofs, wird im [Range Proof Paper](https://eprint.iacr.org/2017/1066.pdf) behandelt. #### Zusammenfassung - Eine MimbleWimble-Transaktion beinhaltet wie folgt: + Eine Mimblewimble-Transaktion beinhaltet wie folgt: * Eine Reihe von Inputs, die referenzieren, sowie eine Reihe an vorherigen Outputs ausgeben. * Eine Reihe an neuen Outputs, die Folgendes umfassen: @@ -158,9 +158,9 @@ Es ist auch wichtig anzumerken, dass um einen gültigen Range Proof der obigen B ### Blocks und Chainstate -Wir haben oben beschrieben, wie MimbleWimble-Transaktionen starke Anonymität gewährleisten können, während die Eigenschaften für eine gültigen Blockchain beibehalten werden, das heißt, dass eine Transaktion kein Geld erstellt und der Eigentumsnachweis über private Schlüssel erfolgt. +Wir haben oben beschrieben, wie Mimblewimble-Transaktionen starke Anonymität gewährleisten können, während die Eigenschaften für eine gültigen Blockchain beibehalten werden, das heißt, dass eine Transaktion kein Geld erstellt und der Eigentumsnachweis über private Schlüssel erfolgt. -Das MimbleWimble-Blockformat baut darauf auf, indem es ein weiteres Konzept einführt: _cut-through_. Mit dieser Erweiterung erlangt eine MimbleWimble-Blockchain: +Das Mimblewimble-Blockformat baut darauf auf, indem es ein weiteres Konzept einführt: _cut-through_. Mit dieser Erweiterung erlangt eine Mimblewimble-Blockchain: * äußerst gute Skalierbarkeit, da die große Mehrzahl der Transaktionsdaten über Zeit entfernt werden können, ohne dabei Sicherheit zu beeinträchtigen. * Weitergehende Anonymität durch das Vermischen und Löschen von Transaktionsdaten. @@ -190,11 +190,11 @@ Das gleiche gilt auch für Blocks, sobald wir realisieren, dass ein Block ledigl sum(outputs) - sum(inputs) = sum(kernel_excess) -Leicht vereinfacht (weiterhin Transaktionsgebühren ignorierend) können wir sagen, dass MimbleWimble-Blocks genau wie MimbleWimble-Transaktionen behandelt werden können. +Leicht vereinfacht (weiterhin Transaktionsgebühren ignorierend) können wir sagen, dass Mimblewimble-Blocks genau wie Mimblewimble-Transaktionen behandelt werden können. ##### Kernel-Offsets -In den wie oben beschriebenen MimbleWimble-Blocks und Transaktionen gibt es ein subtiles Problem. Es ist möglich (und in manchen Fällen trivial) die konstituierende Transaktion in einem Block zu rekonstruieren. Dies ist eindeutig schlecht für die Privatsphäre. Es handelt sich um ein "subset"-Problem - bei einer gegebenen Reihe an Inputs, Outputs, und Transaktionskerneln, wird ein Subset dieser Reihe eine gültige Transaktion rekombinieren. +In den wie oben beschriebenen Mimblewimble-Blocks und Transaktionen gibt es ein subtiles Problem. Es ist möglich (und in manchen Fällen trivial) die konstituierende Transaktion in einem Block zu rekonstruieren. Dies ist eindeutig schlecht für die Privatsphäre. Es handelt sich um ein "subset"-Problem - bei einer gegebenen Reihe an Inputs, Outputs, und Transaktionskerneln, wird ein Subset dieser Reihe eine gültige Transaktion rekombinieren. Beispielsweise seien die folgenden beiden Transaktionen gegeben - @@ -260,7 +260,7 @@ Ein Block ist einfach ausgebaut aus: * Die Signaturen die durch die excess value generiert werden. * Die Mininggebühr. -Sofern so strukturiert, bietet ein MimbleWimble-Block äußerst gute Garantie der Vertraulichkeit: +Sofern so strukturiert, bietet ein Mimblewimble-Block äußerst gute Garantie der Vertraulichkeit: * Intermediäre (cut-through) Transaktionen werden nur von ihren Transaktionskerneln repräsentiert. * Alle Outputs sehen gleich aus: nur sehr große Zahlen, die unmöglich voneinander differenzierbar sind. Um einige Outputs auszuschließen, müssten alle ausgeschlossen werden. @@ -280,11 +280,11 @@ Verallgemeinernd können wir schlussfolgern, dass der Chainstate (ausgenommen He Das erste Informationsstück kann nur mittels der Blockhöhe (seiner Distanz zum Genesisblock), abgeleitet werden. Beide nicht verwendeten Outputs und die Transaktionskernel sind höchst kompakt. Dies hat 2 wichtige Konsequenzen: -* Der Zustand, den eine gegebene Node in einer MimbleWimble-Blockchain aufrechterhalten muss, ist sehr klein (von etwa einigen Gigabytes für eine Blockchain in der Größe von Bitcoin, und potentiall optimierbar auf wenige hundert Megabytes). -* Wenn eine neue Node einem neuen Netzwerk beitritt, dass eine MimbleWimble-Chain aufbaut, ist die Menge an Informationen, die transferiert werden müssen, ebenfalls sehr klein. +* Der Zustand, den eine gegebene Node in einer Mimblewimble-Blockchain aufrechterhalten muss, ist sehr klein (von etwa einigen Gigabytes für eine Blockchain in der Größe von Bitcoin, und potentiall optimierbar auf wenige hundert Megabytes). +* Wenn eine neue Node einem neuen Netzwerk beitritt, dass eine Mimblewimble-Chain aufbaut, ist die Menge an Informationen, die transferiert werden müssen, ebenfalls sehr klein. Darüber hinaus kann das vollständige Set an nicht verwendeten Outputs nicht manipuliert werden, selbst nicht durch das Hinzufügen oder Entfernen eines Outputs. Würde dies getan werden, führe es dazu, dass die Summierung aller Blinding Factors in den Transaktionskerneln von der Summierung der Blinding Factors in den Outputs abweichen würde. ### Fazit -In diesem Dokument haben wir die grundlegenden Prinzipien abgedeckt, die einer MimbleWimble-Blockchain unterliegen. Durch die Nutzung von Additionseigenschaften der Elliptischen-Kurven-Kryptografie können wir Transaktionen erstellen, die völlig undurchsichtig sind, aber dennoch korrekt validiert werden können. Durch die Verallgemeinerung dieser Eigenschaften auf Blocks, können wir große Mengen an Blockchaindaten entfernen, was hohe Skalierbarkeit und schnelle Synchronisierung neuer Peers erlaubt. +In diesem Dokument haben wir die grundlegenden Prinzipien abgedeckt, die einer Mimblewimble-Blockchain unterliegen. Durch die Nutzung von Additionseigenschaften der Elliptischen-Kurven-Kryptografie können wir Transaktionen erstellen, die völlig undurchsichtig sind, aber dennoch korrekt validiert werden können. Durch die Verallgemeinerung dieser Eigenschaften auf Blocks, können wir große Mengen an Blockchaindaten entfernen, was hohe Skalierbarkeit und schnelle Synchronisierung neuer Peers erlaubt. diff --git a/doc/intro_ES.md b/doc/intro_ES.md index 7022d7f41..8bc185dec 100644 --- a/doc/intro_ES.md +++ b/doc/intro_ES.md @@ -1,12 +1,12 @@ -# Introducción a MimbleWimble y Grin +# Introducción a Mimblewimble y Grin *Lea esto en otros idiomas: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -MimbleWimble es un formato y un protocolo de cadena de bloques que proporciona una escalabilidad, privacidad y funcionalidad +Mimblewimble es un formato y un protocolo de cadena de bloques que proporciona una escalabilidad, privacidad y funcionalidad extremadamente buenas al basarse en fuertes algoritmos criptográficos. Aborda los vacíos existentes en casi todas las implementaciones actuales de cadenas de bloques. -Grin es un proyecto de software de código abierto que implementa una cadena de bloques MimbleWimble y rellena los espacios +Grin es un proyecto de software de código abierto que implementa una cadena de bloques Mimblewimble y rellena los espacios necesarios para una implementación completa de la cadena de bloques y moneda criptográfica. El objetivo principal y las características del proyecto Grin son: @@ -15,7 +15,7 @@ El objetivo principal y las características del proyecto Grin son: selectiva cuando sea necesario. * Se escala principalmente con el número de usuarios y mínimamente con el número de transacciones (`<100 bytes kernel`), lo que resulta en un gran ahorro de espacio en comparación con otras cadenas de bloques. -* Criptografía robusta y probada. MimbleWimble sólo se basa en la criptografía de curvas elípticas que ha sido probada y +* Criptografía robusta y probada. Mimblewimble sólo se basa en la criptografía de curvas elípticas que ha sido probada y comprobada durante décadas. * Simplicidad de diseño que facilita la auditoría y el mantenimiento a lo largo del tiempo. * Dirigido por la comunidad, utilizando un algoritmo de minería resistente a la ASICs (Cuckoo Cycle) que fomenta la @@ -24,19 +24,19 @@ El objetivo principal y las características del proyecto Grin son: ## Tongue Tying para todos Este documento está dirigido a lectores con un buen conocimiento de cadenas de bloques y de la criptografía básica. Con -esto en mente, tratamos de explicar el desarrollo técnico de MimbleWimble y cómo se aplica en Grin. Esperamos que este +esto en mente, tratamos de explicar el desarrollo técnico de Mimblewimble y cómo se aplica en Grin. Esperamos que este documento sea comprensible para la mayoría de los lectores con visión técnica. Nuestro objetivo es animarles a interesarse en Grin y contribuir de cualquier manera posible. Para lograr este objetivo, presentaremos los principales conceptos necesarios para una buena comprensión de Grin como -implementación de MimbleWimble. Comenzaremos con una breve descripción de algunas propiedades relevantes de la Criptografía +implementación de Mimblewimble. Comenzaremos con una breve descripción de algunas propiedades relevantes de la Criptografía de Curva Elíptica (ECC) para sentar las bases sobre las que se basa Grin y luego describir todos los elementos clave de las -transacciones y bloques de una cadena de bloques MimbleWimble. +transacciones y bloques de una cadena de bloques Mimblewimble. ### Pequeños Bits de Curvas Elípticas Comenzamos con una breve introducción a la Criptografía de Curva Elíptica, revisando sólo las propiedades necesarias para -entender cómo funciona MimbleWimbleWimble y sin profundizar demasiado en las complejidades de ECC. Para los lectores que +entender cómo funciona MimblewimbleWimble y sin profundizar demasiado en las complejidades de ECC. Para los lectores que deseen profundizar en estos supuestos, existen otras opciones para [aprender más](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). Una curva elíptica con el objetivo de criptografía es simplemente un gran conjunto de puntos que llamaremos _C_. Estos puntos @@ -54,14 +54,14 @@ la multiplicación es trivial, la "división" por puntos de curva es extremadame La fórmula anterior `(k+j)*H = k*H + j*H`, con _k_ y _j_ ambas claves privadas, demuestra que una clave pública obtenida de la adición de dos claves privadas (`(k+j)*H`) es idéntica a la adición de las claves públicas para cada una de esas dos claves privadas (`k*H + j*H`). En la cadena de bloques Bitcoin, las carteras jerárquicas deterministas se basan en gran -medida en este principio. MimbleWimble y la implementación de Grin también lo hacen. +medida en este principio. Mimblewimble y la implementación de Grin también lo hacen. -### Transacciones con MimbleWimble +### Transacciones con Mimblewimble -La estructura de las transacciones demuestra un principio crucial de MimbleWimble: +La estructura de las transacciones demuestra un principio crucial de Mimblewimble: fuertes garantías de privacidad y confidencialidad. -La validación de las transacciones de MimbleWimbleWimble se basa en dos propiedades básicas: +La validación de las transacciones de MimblewimbleWimble se basa en dos propiedades básicas: * **Verificación de importes nulos.** La suma de las salidas menos las entradas siempre es igual a cero, lo que demuestra que la transacción no creó nuevos fondos, _sin revelar los importes reales_. @@ -118,7 +118,7 @@ Lo cual, requiere como consecuencia que: ri1 + ri2 = ro3 -Este es el primer pilar de MimbleWimble: la aritmética necesaria para validar una transacción se puede hacer sin conocer +Este es el primer pilar de Mimblewimble: la aritmética necesaria para validar una transacción se puede hacer sin conocer ninguno de los valores. Como nota final, esta idea se deriva en realidad de Greg Maxwell's @@ -128,7 +128,7 @@ que a su vez se deriva de una propuesta de Adam Back para valores homomórficos #### Propiedad En la sección anterior introducimos una clave privada como factor de ocultación para cubrir los valores de la transacción. La -segunda idea de MimbleWimble es que esta clave privada puede ser utilizada para probar la propiedad del valor. +segunda idea de Mimblewimble es que esta clave privada puede ser utilizada para probar la propiedad del valor. Alice te envía 3 monedas y para ocultar esa cantidad, elegiste 28 como tu factor de ocultación (nota que en la práctica, siendo el factor de ocultación una llave privada, es un número extremadamente grande). En algún lugar de la cadena de @@ -177,7 +177,7 @@ denomina _transacción de kernel_ y es comprobada por todos los validadores. #### Algunos puntos más precisos -Esta sección explica con más detalle la creación de transacciones discutiendo cómo se introduce el cambio y el requisito de pruebas de rango para que se demuestre que todos los valores no son negativos. Ninguno de los dos es absolutamente necesario para entender MimbleWimbleWimble y Grin, así que si tienes prisa, no dudes en ir directamente a +Esta sección explica con más detalle la creación de transacciones discutiendo cómo se introduce el cambio y el requisito de pruebas de rango para que se demuestre que todos los valores no son negativos. Ninguno de los dos es absolutamente necesario para entender MimblewimbleWimble y Grin, así que si tienes prisa, no dudes en ir directamente a [Poniendo todo junto](https://github.com/wimel/grin/blob/master/doc/intro.md#putting-it-all-together). ##### Cambio @@ -203,7 +203,7 @@ Por ejemplo, se podría crear una transacción con una entrada de 2 y salidas de equilibrada, siguiendo la definición de las secciones anteriores. Esto no puede ser fácilmente detectado porque incluso si _x_ es negativo, el punto correspondiente `x.H` en la curva se ve como cualquier otro. -Para resolver este problema, MimbleWimble utiliza otro concepto criptográfico (también procedente de Transacciones +Para resolver este problema, Mimblewimble utiliza otro concepto criptográfico (también procedente de Transacciones Confidenciales) llamado pruebas de rango: una prueba de que un número está dentro de un rango dado, sin revelar el número. No daremos más detalles sobre la prueba de rango, pero sólo necesitas saber que para cualquier `r.G + v.H` podemos construir una prueba que demuestre que _v_ es mayor que cero y no se sobrecarga. @@ -214,7 +214,7 @@ descripción más detallada de las pruebas de rango, se detallan en la sección #### Poniendo todo junto -Una transacción MimbleWimble incluye lo siguiente: +Una transacción Mimblewimble incluye lo siguiente: * Un conjunto de entradas, que hacen referencia y consumen un conjunto de salidas anteriores. * Un conjunto de nuevos resultados que incluyen: @@ -227,11 +227,11 @@ Una transacción MimbleWimble incluye lo siguiente: ### Bloques y estado de la cadena -Hemos explicado anteriormente cómo las transacciones de MimbleWimble pueden proporcionar fuertes garantías de anonimato a la +Hemos explicado anteriormente cómo las transacciones de Mimblewimble pueden proporcionar fuertes garantías de anonimato a la vez que mantienen las propiedades requeridas para una cadena de bloques válida, es decir, una transacción no crea dinero y la prueba de la propiedad se establece a través de claves privadas. -El formato de bloques MimbleWimble se basa en esto introduciendo un concepto adicional: _cut-through_. Con esta incorporación, una cadena MimbleWimble gana: +El formato de bloques Mimblewimble se basa en esto introduciendo un concepto adicional: _cut-through_. Con esta incorporación, una cadena Mimblewimble gana: * Extremadamente buena escalabilidad, ya que la gran mayoría de los datos de las transacciones pueden ser eliminados con el tiempo, sin comprometer la seguridad. @@ -264,12 +264,12 @@ compromiso resultante de Pedersen con la suma de los excesos del núcleo. - sum(outputs) - sum(inputs) = sum(kernel_excess) -Simplificando un poco, (de nuevo ignorando las tarifas de transacción) podemos decir que los bloques MimbleWimble pueden ser -tratados exactamente como transacciones MimbleWimble. +Simplificando un poco, (de nuevo ignorando las tarifas de transacción) podemos decir que los bloques Mimblewimble pueden ser +tratados exactamente como transacciones Mimblewimble. #### Kernel Offsets -Hay un problema leve con los bloques y las transacciones de MimbleWimble como se describe anteriormente. Es posible (y en +Hay un problema leve con los bloques y las transacciones de Mimblewimble como se describe anteriormente. Es posible (y en algunos casos trivial) reconstruir las transacciones constituyentes en un bloque. Esto es claramente malo para la privacidad. Este es el problema del "subconjunto" - dado un conjunto de entradas, salidas y núcleos de transacción, un subconjunto de estos se recombinará para reconstruir una transacción válida. @@ -354,7 +354,7 @@ Un bloque se contruye simplemente a partir de: * Las firmas creadas utilizando el exceso de valor. * La tasa minera. -Con esta estructura, un bloque MimbleWimble ofrece unas garantías de privacidad muy buenas: +Con esta estructura, un bloque Mimblewimble ofrece unas garantías de privacidad muy buenas: * Las transacciones intermedias (cut-through) estarán representadas únicamente por sus núcleos de transacciones. * Todas las salidas se ven iguales: sólo números muy grandes que son imposibles de diferenciar entre sí. Si uno quisiera @@ -381,9 +381,9 @@ La primera información se puede deducir simplemente usando la altura del bloque las salidas no utilizadas como los núcleos de transacción son extremadamente compactos. Esto tiene dos consecuencias importantes: -* El estado que un nodo dado en una cadena de bloques MimbleWimble necesita mantener es muy pequeño (del orden de unos pocos +* El estado que un nodo dado en una cadena de bloques Mimblewimble necesita mantener es muy pequeño (del orden de unos pocos gigabytes para una cadena del tamaño de Bitcoin, y potencialmente configurable a unos pocos centenares de megabytes). -* Cuando un nuevo nodo se une a una red formando una cadena MimbleWimble, la cantidad de información que necesita ser +* Cuando un nuevo nodo se une a una red formando una cadena Mimblewimble, la cantidad de información que necesita ser transferida es también muy pequeña.. Además, el conjunto completo de resultados no utilizados no puede ser alterado, ni siquiera añadiendo o quitando un @@ -392,7 +392,7 @@ suma de la ocultación, factores que influyen en los resultados. ### Conclusión -En este documento tratamos los principios básicos que subyacen a una cadena de bloques MimbleWimble. Utilizando las +En este documento tratamos los principios básicos que subyacen a una cadena de bloques Mimblewimble. Utilizando las propiedades de suma de la Criptografía de Curva Elíptica, somos capaces de construir transacciones que son completamente opacas pero que todavía pueden ser validadas adecuadamente. Y al generalizar esas propiedades a bloques, podemos eliminar una gran cantidad de datos de la cadena de bloques, lo que permite una gran escalabilidad y una sincronización rápida de nuevos diff --git a/doc/intro_KR.md b/doc/intro_KR.md index f03e9b39a..298ebfa86 100644 --- a/doc/intro_KR.md +++ b/doc/intro_KR.md @@ -1,9 +1,9 @@ -# MimbleWimble 과 Grin 에 대한 소개 +# Mimblewimble 과 Grin 에 대한 소개 *다른 언어로 Intro를 읽으시려면: [English](intro.md), [简体中文](intro.zh-cn.md), [Español](intro_ES.md), [Русский](intro.ru.md), [日本語](intro.jp.md).* MimbleWimlbe은 블록체인 포맷이면서 프로토콜 입니다. -MimbleWimble은 암호학적 기반에 의해서 극대화된 좋은 확장성, 프라이버시, 그리고 대체가능성을 제공합니다. 이러한 특성은 지금 현존하는 모든 블록체인 구현체에 존재하는 문제점들을 처리합니다. +Mimblewimble은 암호학적 기반에 의해서 극대화된 좋은 확장성, 프라이버시, 그리고 대체가능성을 제공합니다. 이러한 특성은 지금 현존하는 모든 블록체인 구현체에 존재하는 문제점들을 처리합니다. Grin 은 Mimble Wimble 블록체인을 구현한 오픈소스 프로젝트 입니다. 또한 완전한 블록체인와 크립토 커런시의 배포에 필요한 갭을 채워줍니다. Grin 프로젝트의 주요 목적과 특성들은 아래 설명을 참고하십시오. @@ -15,11 +15,11 @@ Grin 프로젝트의 주요 목적과 특성들은 아래 설명을 참고하십 * 커뮤니티가 주도하며, 채굴 탈중앙화가 권장됩니다. ## 모두의 혀를 묶자. -이 문서는 블록체인에 대해 어느정도 이해가 있고 암호학에 대한 기본적인 이해가 있는 독자들을 대상으로 합니다. 이것을 염두에 두고 우리는 MimbleWimble의 기술적인 발전과 어떻게 Grin에 적용되었는지 관해 설명 할 것입니다. +이 문서는 블록체인에 대해 어느정도 이해가 있고 암호학에 대한 기본적인 이해가 있는 독자들을 대상으로 합니다. 이것을 염두에 두고 우리는 Mimblewimble의 기술적인 발전과 어떻게 Grin에 적용되었는지 관해 설명 할 것입니다. 저희는 이 문서가 대부분의 기술적인 성격을 가진 독자들을 이해시킬 수 있길 바랍니다. 우리의 목적은 독자가 Grin에 대해 흥미를 느끼게 하고 어떤 방식으로든 Grin에 기여할 수 있게 이끄는 것입니다. -이러한 목적을 이루기 위해, 우리는 MimbleWimble 의 구현체인 Grin을 이해하는데 필요한 주요 컨셉들에 대해서 소개할것입니다. +이러한 목적을 이루기 위해, 우리는 Mimblewimble 의 구현체인 Grin을 이해하는데 필요한 주요 컨셉들에 대해서 소개할것입니다. - 우선 Grin이 어디에서 부터 기초로 하고 있는지에 대해 이해하기 위해서 타원 곡선 암호 (ECC)의 몇몇 속성들에 대한 간단한 설명으로 시작하겠습니다. 그 다음, MimbleWimble 블록체인의 트랜잭션과 블록에 한 모든 요소들을 설명하겠습니다. + 우선 Grin이 어디에서 부터 기초로 하고 있는지에 대해 이해하기 위해서 타원 곡선 암호 (ECC)의 몇몇 속성들에 대한 간단한 설명으로 시작하겠습니다. 그 다음, Mimblewimble 블록체인의 트랜잭션과 블록에 한 모든 요소들을 설명하겠습니다. ### 타원곡선에 대한 조그마한 조각들 ECC의 너무 복잡한 사항을 캐지 않고 어떻게 mimble wimble 이 어떻게 작동하는지에 대해 이해하는데 필요한 요소들만 리뷰할 것입니다. 이런 가정들을 좀 더 알고싶은 독자들은 [이 링크](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/)를 참고하세요. @@ -36,12 +36,12 @@ ECC의 너무 복잡한 사항을 캐지 않고 어떻게 mimble wimble 이 어 ECC 안에서 우리가 매우 큰 숫자인 _k_ 를 프라이빗 키로 가정할 때 `k*H` 는 해당하는 퍼블릭 키로 해당되어 집니다. 누군가 공개키인 `k*H`의 값을 알더라도 _k_ 를 추론해 내는것은 불가능에 가깝습니다. ( 달리 얘기하자면, 곱셉은 쉬우나 곡선 좌표에 의한 "나눗셈"은 정말 어렵습니다. ) -_k_ 와 _j_ 둘다 비밀키인 이전 공식 `(k+j)*H = k*H + j*H` 는 두개의 비밀키를 더해서 얻은 한 개의 공개키 (`(k+j)*H`) 와 각각 두개의 비밀키에 공개키를 더한것과 같습니다. Bitcoin blockchain에서도 HD 지갑은 이 원칙에 의존하고 있습니다. MimbleWimble 과 Grin의 구현또한 마찬가지 입니다. +_k_ 와 _j_ 둘다 비밀키인 이전 공식 `(k+j)*H = k*H + j*H` 는 두개의 비밀키를 더해서 얻은 한 개의 공개키 (`(k+j)*H`) 와 각각 두개의 비밀키에 공개키를 더한것과 같습니다. Bitcoin blockchain에서도 HD 지갑은 이 원칙에 의존하고 있습니다. Mimblewimble 과 Grin의 구현또한 마찬가지 입니다. -### MimbleWimble 함께 거래하기 -트랜잭션의 구조는 MimbleWimble의 강력한 프라이버시와 비밀이 유지된다라고 하는 중요한 규칙을 나타냅니다. +### Mimblewimble 함께 거래하기 +트랜잭션의 구조는 Mimblewimble의 강력한 프라이버시와 비밀이 유지된다라고 하는 중요한 규칙을 나타냅니다. -MimbleWimble 트랜잭션의 확인은 두가지 기본적인 성격을 전제로 합니다. +Mimblewimble 트랜잭션의 확인은 두가지 기본적인 성격을 전제로 합니다. * **제로섬의 검증:** 결과값에서 입력값을 뺸 합은 항상 0과 같습니다. 이것은 실제 전송되는 코인의 양을 드러내지 않고도 트랜잭션ㅇ이 새로운 코인을 만들지 않았다는 것을 증명합니다. * **비밀키의 소유:** 다른 많은 크립토 커런시 들처럼 , 트랜잭션의 소유권은 ECC 비밀키에 의해 보장됩니다. 그러나 어떤 실체가 이런 비밀키들을 소유하고 있다고 증명하는것이 직접적으로 트랜잭션에 사인한다고해서 얻어지는 것은 아닙니다. @@ -89,13 +89,13 @@ MimbleWimble 트랜잭션의 확인은 두가지 기본적인 성격을 전제 ri1 + ri2 = ro3 -이것이 MimbleWimble의 첫번째 특징입니다. 트랜잭션을 검증하는 산술적인 연산은 아무런 값을 알지 못해도 가능합니다. +이것이 Mimblewimble의 첫번째 특징입니다. 트랜잭션을 검증하는 산술적인 연산은 아무런 값을 알지 못해도 가능합니다. 이 아이디어는 Greg Maxwell 의 [Confidential Transactions](https://elementsproject.org/features/confidential-transactions/investigation) 에서 유래했습니다. Confidential transaction은 Adam back의 비트코인에 동형암호를 적용하자는 제안에서 비롯되었습니다. #### 소유권 -이전의 섹션에서 트랜잭션의 값을 보기 어렵게 하는 Blinding factor로서 비밀키를 소개했습니다. MimbleWimble 의 두번째 통찰은 비밀키가 어떤 값의 소유권을 증명하는데 사용할 수 있다는 것입니다. +이전의 섹션에서 트랜잭션의 값을 보기 어렵게 하는 Blinding factor로서 비밀키를 소개했습니다. Mimblewimble 의 두번째 통찰은 비밀키가 어떤 값의 소유권을 증명하는데 사용할 수 있다는 것입니다. Alice는 당신에게 3 코인을 보내면서 그 양을 가렸고, 당신은 28을 당신의 blinding factor로 선택했습니다. ( 실제로 blinding factor는 비밀키로 정말 무진장 큰 숫자 입니다.) @@ -140,7 +140,7 @@ _X_ 는 덧셈의 결과이면서 모두에게 다 보여집니다. 3은 당신 #### 몇몇 더 좋은 점들 -이 섹션은 트랜잭션을 만들때 잔돈이 어떻게 보여지고 범위 증명(range proofs)의 요구사항에 대해서 모든 값이 음수가 아닌지에 대해서 좀 더 자세하게 설명하려고 합니다. 이러한 개념들 역시 MimbleWimble 과 Grin 에 대한 이해가 당연히 필요합니다. 만약 당신이 조급하다면 [이 링크를 참고하세요.](#putting-it-all-together). +이 섹션은 트랜잭션을 만들때 잔돈이 어떻게 보여지고 범위 증명(range proofs)의 요구사항에 대해서 모든 값이 음수가 아닌지에 대해서 좀 더 자세하게 설명하려고 합니다. 이러한 개념들 역시 Mimblewimble 과 Grin 에 대한 이해가 당연히 필요합니다. 만약 당신이 조급하다면 [이 링크를 참고하세요.](#putting-it-all-together). ##### 잔돈에 대해서 @@ -159,7 +159,7 @@ _X_ 는 덧셈의 결과이면서 모두에게 다 보여집니다. 3은 당신 예를 들어 입력값이 3이고 출력값이 5과 -3인 트랜잭션을 만들수 있으며 이것은 이전 섹션의 정의에 따라 잘 구성된 트랜잭션입니다. 적절한 좌표 `x.H`가 다른 좌표처럼 곡선위에 있어서 _x_가 음수이더라도 찾기가 쉽지 않습니다. -이 문제점을 해결하기 위해서, MimbleWimble 은 Range proofs 라는 다른 암호학 개념을 사용합니다. ( 이 또한 Confidential Transaction 에서 유래했습니다.) +이 문제점을 해결하기 위해서, Mimblewimble 은 Range proofs 라는 다른 암호학 개념을 사용합니다. ( 이 또한 Confidential Transaction 에서 유래했습니다.) Range proof 란 숫자를 밝히지 않고 어떤 숫자가 주어진 범위안에 있는지 증명하는 것입니다. Range proof 에 대해서 자세히 설명하지 않을것이지만은, 그래도 어떤 `r.G + v.H` 의 결과가 _v_ 가 0보다 크고 오버플로우가 일어나지 않는다는 것을 증명할 수 있습니다. 또한 위의 예에서 유효한 Range proof 를 만들기 위해서 트랜잭션을 만들고 Signing 할때 사용된 초과값인 113과 28 두 값이 알려지는것은 중요합니다. 그 이유에 대해선 [range proof paper](https://eprint.iacr.org/2017/1066.pdf) 안에 Range proof에 대해 좀더 자세한 설명이 있습니다. @@ -176,9 +176,9 @@ MimbleWimlbe 트랜잭션은 다음을 포함합니다. ### 블록들과 체인 state에 대해서 -위에서 MimbleWimble 트랜잭션이 유요한 블록체인에 필요한 속성을 유지하면서 어떻게 강한 익명성을 보장하는지 설명했습니다.예를 들면 트랜잭션이 더이상 코인을 만들지 않으면서 비밀키를 통해 소유권을 증명하지 않는 방법들 같은것 말이죠. +위에서 Mimblewimble 트랜잭션이 유요한 블록체인에 필요한 속성을 유지하면서 어떻게 강한 익명성을 보장하는지 설명했습니다.예를 들면 트랜잭션이 더이상 코인을 만들지 않으면서 비밀키를 통해 소유권을 증명하지 않는 방법들 같은것 말이죠. -추가적으로 _cut-through_ 라는 개념이 MimbleWimble 블록 포멧에 사용 됩니다. 이로 인해 MimbleWimble 체인은 아래와 같은 장점을 얻습니다. +추가적으로 _cut-through_ 라는 개념이 Mimblewimble 블록 포멧에 사용 됩니다. 이로 인해 Mimblewimble 체인은 아래와 같은 장점을 얻습니다. * 대부분의 트랜잭션 데이터는 보안을 희생하지 않고서도 시간이 지나면 없어 질 수 있으므로 엄청나게 좋은 확장성을 얻게 됩니다. * 트랜잭션 데이터를 섞고 없애서 익명성을 추가로 획득합니다. @@ -207,11 +207,11 @@ Signature 공개키로서 트랜잭션의 합이 0임을 증명하는 _kernel ex 출력값의 합 - 입력값의 합 = kernel_excess의 합 -약간 단순화 시켜서 ( 트랜잭션 수수료를 무시하고) 우리는 MimbleWimbl block 이 MimbleWimble 트랜잭션들로 다뤄진다고 말 할 수 있습니다. +약간 단순화 시켜서 ( 트랜잭션 수수료를 무시하고) 우리는 MimbleWimbl block 이 Mimblewimble 트랜잭션들로 다뤄진다고 말 할 수 있습니다. ##### Kernel 오프셋들 -위에 설명했던겉 처럼 MimbleWimble 블록과 트랜잭션에 조그마한 문제가 있습니다. 그것은 블록에 있는 구성 트랜잭션을 재구성하는것이 가능합다는 겁니다.(그리고 어떤 사소한 경우에도요). +위에 설명했던겉 처럼 Mimblewimble 블록과 트랜잭션에 조그마한 문제가 있습니다. 그것은 블록에 있는 구성 트랜잭션을 재구성하는것이 가능합다는 겁니다.(그리고 어떤 사소한 경우에도요). 이것은 분명히 프라이버시에는 좋지 않습니다. 이걸 "subset" 문제 라고 합니다. "Subset" 문제란 주어진 입력값들, 출력값들과 트랜잭션 kernel들의 Subset 들이 재조합되어서 유효한 트랜잭션을 다시 만든다는 것입니다. @@ -307,12 +307,12 @@ Signature 공개키로서 트랜잭션의 합이 0임을 증명하는 _kernel ex 첫번째 정보는 Genesis 블록으로부터의 거리인 블록 높이를 가지고 유추 될 수 있습니다. 그리고 쓰지 않는 출력값과 트랜잭션 kernel은 매우 작습니다. 이것에는 아래와 같이 2가지 중요한 결과를 가지고 있습니다. -* MimbleWimble 블록체인에 있는 노드가 유지해야 되는 스테이트가 매우 작습니다.(비트코인 사이즈의 Blockchain의 경우 수 기가 바이트이고 잠재젹으로 수백 메가바이트까지 최적화 될 수 있습니다.) -* 새로운 노드가 MimbleWimble 체인에 가입히면, 전달해야 하는 정보의 양이 매우 적습니다. +* Mimblewimble 블록체인에 있는 노드가 유지해야 되는 스테이트가 매우 작습니다.(비트코인 사이즈의 Blockchain의 경우 수 기가 바이트이고 잠재젹으로 수백 메가바이트까지 최적화 될 수 있습니다.) +* 새로운 노드가 Mimblewimble 체인에 가입히면, 전달해야 하는 정보의 양이 매우 적습니다. 덧붙여서 출력값을 더하거나 제거하더라도 쓰지 않는 출력값의 모든 세트를 조작할 순 없습니다. 그렇게 하면 트랜잭션 kernel 내의 모든 blinding factor의 합과 출력값 내의 blinding factor의 합이 달라집니다. ### 결론 내리기 -이 문서에서는 MimbleWimble 블록체인 안의 기본적인 원리에 대해서 다루었습니다. +이 문서에서는 Mimblewimble 블록체인 안의 기본적인 원리에 대해서 다루었습니다. 타원 곡선 암호의 다른 성질을 사용해서 알아보기 어려우나 적절하게 입증될 수 있는 트랜잭션을 만들수 있습니다. 블록에 이러한 성질들을 일반화 시키면 큰 용량의 블록체인 데이터를 없앨 수 있고 새로운 피어들에게 높은 확장성과 빠른 동기화를 가능하게 할 수 있습니다. diff --git a/doc/intro_NL.md b/doc/intro_NL.md index ce97a653a..3f461df46 100644 --- a/doc/intro_NL.md +++ b/doc/intro_NL.md @@ -1,10 +1,10 @@ -# Inleiding tot MimbleWimble en Grin +# Inleiding tot Mimblewimble en Grin *Lees dit in andere talen: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -MimbleWimble is een blockchain formaat en protocol die extreem goede schaalbaarheid, privacy en fungibiliteit biedt door zich te berusten op sterke cryptografische primiteven. Het adresseert de lacunes die in bijna alle huidige blockchain-implementaties bestaan. +Mimblewimble is een blockchain formaat en protocol die extreem goede schaalbaarheid, privacy en fungibiliteit biedt door zich te berusten op sterke cryptografische primiteven. Het adresseert de lacunes die in bijna alle huidige blockchain-implementaties bestaan. -Grin is een open source softwareproject dat een MimbleWimble blockchain +Grin is een open source softwareproject dat een Mimblewimble blockchain implementeert en de lacunes vult die nodig zijn voor een volledige blockchain en cryptovaluta inzet @@ -16,7 +16,7 @@ Het belangrijkste doel en eigenschappen van het Grin project zijn: * Schaalt meestal met het aantal gebruikers en minimaal met het aantal transacties (<100 byte `kernel), wat resulteert in een grotere ruimtebesparing vergeleken met andere blockchains. -* Sterk en bewezen cryptografie. MimbleWimble rust enkel op Elliptic Curve +* Sterk en bewezen cryptografie. Mimblewimble rust enkel op Elliptic Curve Cryptografie die al decennia beproefd en getest wordt. * Eenvoud van het ontwerp die het makkelijk maakt om na verloop van tijd te controleren en onderhouden. @@ -27,22 +27,22 @@ Het belangrijkste doel en eigenschappen van het Grin project zijn: Dit document is bedoeld voor lezers met een sterke achtergrond van blockchains en elementaire cryptografie. Met dat in ons achterhoofd, proberen we -de technische opbouw van MimbleWimble en hoe het in Grin is toegepast uit te leggen. +de technische opbouw van Mimblewimble en hoe het in Grin is toegepast uit te leggen. We hopen dat dit document verstaanbaar is voor de meeste technische lezers Ons doel is om u aan te moedigen geïnteresseerd te raken in Grin en op welke manier mogelijk dan ook bij te dragen. Om dit doel te bereiken, zullen we de belangrijkste concepten introduceren die vereist -zijn voor een goed begrip van Grin als een MimbleWimble-implementatie. We beginnen met een beknopte beschrijving +zijn voor een goed begrip van Grin als een Mimblewimble-implementatie. We beginnen met een beknopte beschrijving van enkele relevante eigenschappen van Elliptic Curve Cryptografie (ECC) om de basis waarop Grin gebaseerd is en vervolgens alle belangrijke elementen van -MimbleWimble blockchain's transacties en -blokken te beschrijven. +Mimblewimble blockchain's transacties en -blokken te beschrijven. ### Minuscule Databits van Elliptic Curves We beginnen met een korte inleiding van Elliptic Curve Cryptografie, waarbij we alleen de eigenschappen evalueren die nodig zijn om om te begrijpen hoe -MimbleWimble werkt zonder te diep op de complexiteit van ECC in te gaan. +Mimblewimble werkt zonder te diep op de complexiteit van ECC in te gaan. Voor lezer die dat wel zouden willen, zijn er andere mogelijkheden om [er meer over te weten te komen](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). @@ -67,14 +67,14 @@ demonstreert dat een openbare sleutel verkregen is door de toevoeging van twee privésleutels (`(k+j)*H`) zijn identiek aan de toevoeging van de openbare sleutels voor elk van die twee privésleutels (`k*H + j*H`). In de Bitcoin blockchain, zijn Hiërarchische Deterministische portefeuilles -sterk afhankelijk van dit principe. Alsook MimbleWimble en de Grin-implementatie. +sterk afhankelijk van dit principe. Alsook Mimblewimble en de Grin-implementatie. -### Transacties met MimbleWimble +### Transacties met Mimblewimble -De structuur van transacties toont een cruciaal principe van MimbleWimble: +De structuur van transacties toont een cruciaal principe van Mimblewimble: sterke privacy- en vertrouwelijkheidsgaranties. -De validatie van MimbleWimble transacties zijn gebaseerd op twee basiseigenschappen: +De validatie van Mimblewimble transacties zijn gebaseerd op twee basiseigenschappen: * **Verificatie van zero sums.** De som van de uitkomsten min de ingaven is altijd gelijk aan nul, welke bewijst dat de transactie geen nieuw geld gecreëerd heeft, _zonder de werkelijke bedragen te onthullen_. @@ -140,7 +140,7 @@ Wat als gevolg vereist dat: ri1 + ri2 = ro3 -Dit is de eerste pijler van MimbleWimble: de arithmetische vereist om een transactie te valideren gedaan kan worden +Dit is de eerste pijler van Mimblewimble: de arithmetische vereist om een transactie te valideren gedaan kan worden zonder dat één van de waarden gekend is. Tot slot, is dit idee eigenlijk afgeleid van Greg Maxwell's @@ -151,7 +151,7 @@ aan Bitcoin. #### Eigendom In het vorige gedeelte hebben we een privésleutel geïntroduceerd als een blinding factor om de transactiewaarden te verdoezelen. -Het tweede inzicht van MimbleWimble is dat deze privésleutel +Het tweede inzicht van Mimblewimble is dat deze privésleutel gebruikt kan worden om het eigendom van de waarde aan te tonen. Alice stuurt je 3 munten en om dat bedrag te verdoezelen, kies je 28 als jouw @@ -205,7 +205,7 @@ mining fees), wordt een _transaction kernel_ genoemd en wordt gecontroleerd door Dit gedeelte gaat in op het maken van transacties door te bespreken hoe verandering geïntroduceerd is en de vereiste voor range proofs zodat alle waarden bewezen zijn als niet-negatieve. -Geen van beide zijn absoluut vereist om MimbleWimble en +Geen van beide zijn absoluut vereist om Mimblewimble en Grin te begrijpen, dus als je gehaast bent, voel je virj om meteen over te gaan naar [Alles bij elkaar samenbrengen](#putting-it-all-together). @@ -234,7 +234,7 @@ Bijvoorbeeld, kan iemand een transactie creëren met een invoer van 2 en uitvoer en -3 en nog steeds een goed gebalanceerde transactie krijgen, volgens de definitie in de vorige secties. Dit kan niet makkelijk gedetecteerd worden, zelfs als _x_ negatief is, het overeenkomstige punt `x.H` op de curve lijkt op een ander. -Om dit te probleem te verhelpen, maakt MimbleWimble gebruik van een ander cryptografisch concept (ook afkomstig +Om dit te probleem te verhelpen, maakt Mimblewimble gebruik van een ander cryptografisch concept (ook afkomstig vanuit Confidential Transactions) genaamd range proofs: een bewijs dat een getal binnen een gegeven bereik valt, zonder het nummer te onthullen. We gaan niet uitweiden op de range proof, maar u moet gewoon weten @@ -245,7 +245,7 @@ Het is ook belangrijk om op te merken dat om een geldige range proof te maken ui #### Alles bij elkaar samenbrengen -Een MimbleWimble transactie omvat het volgende: +Een Mimblewimble transactie omvat het volgende: * Een reeks invoeren, die verwijzen naar en een vorige reeks aan uitvoeren spendeert. * Een reeks van nieuwe uitvoeren met: @@ -257,11 +257,11 @@ Een MimbleWimble transactie omvat het volgende: ### Blocks en Chain State -We hebben hierboven uitgelegd hoe MimbleWimble transacties sterke anonimiteit kunnen garanderen terwijl de eigenschappen die vereist zijn voor een geldige blockchain handhaaft, +We hebben hierboven uitgelegd hoe Mimblewimble transacties sterke anonimiteit kunnen garanderen terwijl de eigenschappen die vereist zijn voor een geldige blockchain handhaaft, d.w.z. een transactie creëert geen geld en een bewijs van eigendom wordt vastgelegd met privésleutels. -Het MimbleWimble blockformaat bouwt hierop voort door een aanvullend concept te introduceren: _cut-through_. -Met deze aanvulling, verkrijgt een MimbleWimble chain: +Het Mimblewimble blockformaat bouwt hierop voort door een aanvullend concept te introduceren: _cut-through_. +Met deze aanvulling, verkrijgt een Mimblewimble chain: * Zeer goede schaalbaarheid, zoals de grote meerderheid van transactiegegevens geëlimineerd kunnen worden met de tijd, zonder de beveiliging in gevaar te brengen. @@ -292,11 +292,11 @@ Hetzelfde geldt voor blokken zelf als we eenmaal realiseren dat een blok eenvoud som(uitvoeren) - som(invoeren) = sum(kernel_excess) -Enigszins vereenvoudigd, (wederom negeren we de transactiekosten) kunnen we zeggen dat MimbleWimble-blokken behandeld kunnen worden als MimbleWimble-transacties. +Enigszins vereenvoudigd, (wederom negeren we de transactiekosten) kunnen we zeggen dat Mimblewimble-blokken behandeld kunnen worden als Mimblewimble-transacties. ##### Kernel Offsets -Er is een subtiel probleem met MimbleWimble-blokken en transacties zoals hierboven beschreven. Het is mogelijk (en in sommige gevallen triviaal) om de constituerende transacties in een blok te reconstrueren. Dit is duidelijk slecht voor privacy. Dit is een "subset" probleem - gegeven een verzameling van invoeren, uitvoeren en transactiekernels zal een subnet van dit formaat recombineren om een geldige transactie te reconstrueren. +Er is een subtiel probleem met Mimblewimble-blokken en transacties zoals hierboven beschreven. Het is mogelijk (en in sommige gevallen triviaal) om de constituerende transacties in een blok te reconstrueren. Dit is duidelijk slecht voor privacy. Dit is een "subset" probleem - gegeven een verzameling van invoeren, uitvoeren en transactiekernels zal een subnet van dit formaat recombineren om een geldige transactie te reconstrueren. Bijvoorbeeld, gegeven zijn de volgende twee transacties - @@ -370,7 +370,7 @@ Een blok is eenvoudigweg opgebouwd uit: * De handtekeningen gegenereerd door middel van de overtollige waarde. * De miningkost. -Wanneer het op deze manier geconstructureerd wordt, biedt een MimbleWimble-blok buitengewoon goede privacygaranties: +Wanneer het op deze manier geconstructureerd wordt, biedt een Mimblewimble-blok buitengewoon goede privacygaranties: * Intermediaire (cut-through) transacties worden alleen weergegeven door hun transactiekernels. * Alle uitvoeren zien er hetzelfde uit: gewoon hele grote getallen die onmogelijk van elkaar te differentiëren zijn. @@ -397,10 +397,10 @@ Het eerste stuk informatie kan afgeleid worden door alleen de blokhoogte (de afstand tot het genesisblok) te gebruiken. En zowel de niet-bestede uitgaven als de transactiekernels zijn ontzettend compact. Dit heeft 2 belangrijke gevolgen: -* De stand die een bepaalde node in een MimbleWimble blockchain moet behouden blijven is zeer klein +* De stand die een bepaalde node in een Mimblewimble blockchain moet behouden blijven is zeer klein (in de volgorde van enkele gigabytes voor een bitcoin-sized blockchain en potentieel optimaliseerbaar tot enkele honderden megabytes). -* Wanneer een nieuwe node zich aansluit bij een netwerk ter bijdrage aan de MimbleWimble chain, is het aantal informatie die overdragen moet worden ook enorm klein. +* Wanneer een nieuwe node zich aansluit bij een netwerk ter bijdrage aan de Mimblewimble chain, is het aantal informatie die overdragen moet worden ook enorm klein. Bovendien kan er niet met de gehele verzameling aan ongebruikte uitgaven gesjoemeld worden, zelfs niet door een uitgave toe te voegen of te verwijderen. Daarmee zou de sommatie van alle @@ -409,7 +409,7 @@ factors in de uitgaven. ### Conclusie -In dit document hebben we de basisprincipes behandeld die ten grondslag liggen van een MimbleWimble +In dit document hebben we de basisprincipes behandeld die ten grondslag liggen van een Mimblewimble blockchain. Door de aanvullende eigenschappen te gebruiken van Elliptic Curve Cryptografie, zijn we in staat om transacties te bouwen die geheel ondoorzichtig zijn maar nog steeds goed gevalideerd kunnen worden. En door deze eigenschappen te generaliseren naar blokken, kunnen we een grote hoeveelheid aan blockchaingegevens elimineren, diff --git a/doc/intro_PT-BR.md b/doc/intro_PT-BR.md index 9d0df8d97..3cf0cbc5a 100644 --- a/doc/intro_PT-BR.md +++ b/doc/intro_PT-BR.md @@ -1,28 +1,28 @@ -# Introdução ao MimbleWimble e ao Grin +# Introdução ao Mimblewimble e ao Grin *Leia isto em outros idiomas: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -O MimbleWimble é um formato e protocolo blockchain que fornece ótima escalabilidade, privacidade e fungibilidade, para isso contando com primitivas criptográficas fortes. Ele aborda as lacunas existentes em quase todos as implementações blockchain atuais. +O Mimblewimble é um formato e protocolo blockchain que fornece ótima escalabilidade, privacidade e fungibilidade, para isso contando com primitivas criptográficas fortes. Ele aborda as lacunas existentes em quase todos as implementações blockchain atuais. -O Grin é um projeto de software de código aberto que implementa um blockchain MimbleWimble e preenche os vãos necessários para se construir um blockchain e uma criptomoeda completos. +O Grin é um projeto de software de código aberto que implementa um blockchain Mimblewimble e preenche os vãos necessários para se construir um blockchain e uma criptomoeda completos. O principal objetivo e as características do projeto Grin são: * Privacidade por padrão. Isto permite fungibilidade completa sem impedir a capacidade de divulgação seletiva de informações quando necessário. * Escalabilidade, sobretudo quanto ao número de usuários e minimamente com relação ao número de transações (<100 byte `núcleo`), resultando em uma grande economia de espaço quando comparado a outros blockchains. -* Criptografia forte e comprovada. O MimbleWimble se baseia apenas em Criptografia de Curva Elíptica testada e experimentada há décadas. +* Criptografia forte e comprovada. O Mimblewimble se baseia apenas em Criptografia de Curva Elíptica testada e experimentada há décadas. * Simplicidade no design o que facilita a auditoria e manutenção com o tempo. * Direcionado pela comunidade, incentivando a descentralização da mineração. ## Amarra-Língua para Todos -Este documento destina-se a leitores com uma boa compreensão de blockchains e criptografia básica. Tendo isto em mente, tentamos explicar o desenvolvimento técnico do MimbleWimble e como ele é aplicado no Grin. Acreditamos que este documento seja compreensível para a maioria dos leitores tecnicamente conscientes. Nosso objetivo é incentivá-los a se interessar pelo Grin e contribuir da maneira que for possível. +Este documento destina-se a leitores com uma boa compreensão de blockchains e criptografia básica. Tendo isto em mente, tentamos explicar o desenvolvimento técnico do Mimblewimble e como ele é aplicado no Grin. Acreditamos que este documento seja compreensível para a maioria dos leitores tecnicamente conscientes. Nosso objetivo é incentivá-los a se interessar pelo Grin e contribuir da maneira que for possível. -Para alcançar este objetivo, apresentaremos os principais conceitos necessários para uma boa compreensão do Grin, sendo esta uma implementação do MimbleWimble. Vamos começar com uma breve descrição de algumas propriedades relevantes da Criptografia de Curva Elíptica (CCE) de forma a sedimentar a fundação em que o Grin é baseado e, em seguida, descrever todos os elementos-chave de transações e blocos do blockchain MimbleWimble. +Para alcançar este objetivo, apresentaremos os principais conceitos necessários para uma boa compreensão do Grin, sendo esta uma implementação do Mimblewimble. Vamos começar com uma breve descrição de algumas propriedades relevantes da Criptografia de Curva Elíptica (CCE) de forma a sedimentar a fundação em que o Grin é baseado e, em seguida, descrever todos os elementos-chave de transações e blocos do blockchain Mimblewimble. ### Um Pouquinho sobre Curvas Elípticas -Começamos com uma breve cartilha sobre Criptografia de Curva Elíptica, revisando apenas propriedades necessárias para entender como o MimbleWimble funciona e sem se aprofundar muito nos meandros da CCE. Para os leitores que gostariam de mergulhar mais fundo nesses pressupostos, existem outras oportunidades para [aprender mais](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). +Começamos com uma breve cartilha sobre Criptografia de Curva Elíptica, revisando apenas propriedades necessárias para entender como o Mimblewimble funciona e sem se aprofundar muito nos meandros da CCE. Para os leitores que gostariam de mergulhar mais fundo nesses pressupostos, existem outras oportunidades para [aprender mais](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). Uma Curva Elíptica para fins de criptografia é simplesmente um grande conjunto de pontos que nós chamaremos de _C_. Estes pontos podem ser adicionados, subtraídos ou multiplicados por inteiros (também chamados de escalares). Dado um inteiro _k_ e usando a operação de multiplicação escalar, podemos calcular `k*H`, que também é um ponto da curva _C_. Dado outro inteiro _j_ também podemos calcular `(k+j)*H`, que é igual a `k*H + j*H`. As operações de adição e multiplicação escalar em uma curva elíptica mantem as propriedades comutativa e associativa da adição e multiplicação: @@ -30,13 +30,13 @@ Uma Curva Elíptica para fins de criptografia é simplesmente um grande conjunto Em CCE, se escolhermos um número muito grande _k_ como uma chave privada, `k*H` é considerada a chave pública correspondente. Mesmo tendo conhecimento do valor da chave pública `k*H`, deduzir _k_ é quase impossível (ou em outras palavras, enquanto a multiplicação é trivial, a "divisão" por pontos da curva é extremamente difícil). -A fórmula anterior `(k+j)*H = k*H + j*H`, com _k_ e _j_ ambos sendo chaves privadas, demonstra que uma chave pública obtida a partir da adição de duas chaves privadas (`(k+j)*H`) é idêntica à adição das chaves públicas para cada uma dessas duas chaves privadas (`k*H + j*H`). No blockchain do Bitcoin, as carteiras Hierárquicas Determinísticas dependem fortemente desse princípio. O MimbleWimble e a implementação do Grin dependem também. +A fórmula anterior `(k+j)*H = k*H + j*H`, com _k_ e _j_ ambos sendo chaves privadas, demonstra que uma chave pública obtida a partir da adição de duas chaves privadas (`(k+j)*H`) é idêntica à adição das chaves públicas para cada uma dessas duas chaves privadas (`k*H + j*H`). No blockchain do Bitcoin, as carteiras Hierárquicas Determinísticas dependem fortemente desse princípio. O Mimblewimble e a implementação do Grin dependem também. -### Transacionando com o MimbleWimble +### Transacionando com o Mimblewimble -A estrutura das transações demonstra um princípio crucial do MimbleWimble: a garantia forte de privacidade e confidencialidade. +A estrutura das transações demonstra um princípio crucial do Mimblewimble: a garantia forte de privacidade e confidencialidade. -A validação das transações do MimbleWimble depende de duas propriedades básicas: +A validação das transações do Mimblewimble depende de duas propriedades básicas: * **Verificação de somas zero.** A soma das saídas menos as entradas é sempre igual a zero, provando que a transação não criou novos fundos, _sem revelar os montantes reais_. * **Posse de chaves privadas.** Como na maioria das outras criptomoedas, a propriedade sobre as saídas das transações é garantida pela posse de chaves privadas CCE. Contudo, a prova de que uma entidade possui essas chaves privadas não é obtida através da assinatura direta da transação. @@ -81,13 +81,13 @@ Que, como consequência, requer: re1 + re2 = rs3 -Este é o primeiro pilar do MimbleWimble: a aritmética necessária para validar uma transação pode ser feita sem conhecer nenhum dos montantes. +Este é o primeiro pilar do Mimblewimble: a aritmética necessária para validar uma transação pode ser feita sem conhecer nenhum dos montantes. Como nota final, esta ideia é, na verdade, derivada das [Transações Confidenciais](https://elementsproject.org/features/confidential-transactions/investigation) de Greg Maxwell, que por si derivou de uma proposta de Adam Back para montantes homomórficos aplicados ao Bitcoin. #### Propriedade -Na seção anterior, introduzimos uma chave privada como um fator de cegueira para obscurecer os montantes da transação. A segunda perspicácia do MimbleWimble é que esta chave privada pode ser aproveitada para provar a propriedade do montante. +Na seção anterior, introduzimos uma chave privada como um fator de cegueira para obscurecer os montantes da transação. A segunda perspicácia do Mimblewimble é que esta chave privada pode ser aproveitada para provar a propriedade do montante. Alice lhe envia 3 moedas e, para obscurecer essa quantia, você escolheu 28 como seu fator de cegueira (note que, na prática, o fator de cegueira sendo uma chave privada, é um número extremamente grande). Em algum lugar no blockchain, a seguinte saída aparece e só pode ser gasta por você: @@ -122,7 +122,7 @@ Esta assinatura, anexada a todas as transações, juntamente com alguns dados ad #### Alguns Pontos Refinados -Esta seção detalha a construção de transações discutindo como o troco deve ser introduzido e a exigência de provas de intervalo para que todos os montantes sejam comprovadamente não-negativos. Nenhum destes pontos é absolutamente necessário para entender o MimbleWimble e o Grin, por isso, se estiver com pressa, sinta-se à vontade para pular direto para [Juntando Tudo] (#juntando-tudo). +Esta seção detalha a construção de transações discutindo como o troco deve ser introduzido e a exigência de provas de intervalo para que todos os montantes sejam comprovadamente não-negativos. Nenhum destes pontos é absolutamente necessário para entender o Mimblewimble e o Grin, por isso, se estiver com pressa, sinta-se à vontade para pular direto para [Juntando Tudo] (#juntando-tudo). ##### Troco @@ -141,13 +141,13 @@ Em todos os cálculos acima, trabalhamos com montantes de transação sempre pos Por exemplo, pode-se criar uma transação com uma entrada de montante 2 e saídas de montantes 5 e -3 obtendo uma transação devidamente estruturada, de acordo com a definição das seções anteriores. Isso não pode ser detectado facilmente, porque mesmo sendo _x_ negativo, o ponto correspondente `x.H` na curva se assemelha a qualquer outro. -Para resolver este problema, o MimbleWimble utiliza outro conceito criptográfico (também proveniente de transações confidenciais) chamado prova de intervalo: uma prova que um número se enquadra dentro de um determinado intervalo, sem revelar este número. Nós não iremos elaborar sobre a prova de intervalo, basta saber que para qualquer `r.G + v.H` podemos construir uma prova que mostrará que _v_ é maior que zero e não sofre estouro numérico. +Para resolver este problema, o Mimblewimble utiliza outro conceito criptográfico (também proveniente de transações confidenciais) chamado prova de intervalo: uma prova que um número se enquadra dentro de um determinado intervalo, sem revelar este número. Nós não iremos elaborar sobre a prova de intervalo, basta saber que para qualquer `r.G + v.H` podemos construir uma prova que mostrará que _v_ é maior que zero e não sofre estouro numérico. Também é importante notar que, para criar uma prova de intervalo válida a partir do exemplo acima, ambos os montantes 113 e 28 usados na criação e assinatura do montante excedente devem ser conhecidos. A razão disto, assim como uma descrição aprofundada da prova de intervalo, estão mais detalhadas no [artigo sobre provas de intervalo] (https://eprint.iacr.org/2017/1066.pdf). #### Juntando Tudo -Uma transação MimbleWimble inclui o seguinte: +Uma transação Mimblewimble inclui o seguinte: * Um conjunto de entradas, que referencia e gasta um conjunto de saídas anteriores. * Um conjunto de novas saídas que incluem: @@ -158,9 +158,9 @@ Uma transação MimbleWimble inclui o seguinte: ### Blocos e Estado da Cadeia -Nós explicamos acima como as transações do MimbleWimble podem fornecer forte garantia de anonimato, mantendo as propriedades necessárias de um blockchain válido, ou seja, uma transação não cria dinheiro e a prova de propriedade é estabelecida através de chaves privadas. +Nós explicamos acima como as transações do Mimblewimble podem fornecer forte garantia de anonimato, mantendo as propriedades necessárias de um blockchain válido, ou seja, uma transação não cria dinheiro e a prova de propriedade é estabelecida através de chaves privadas. -O formato de bloco MimbleWimble se baseia nisso, introduzindo um conceito: _corte-completo_ (cut-through). Com esta adição, uma cadeia MimbleWimble ganha: +O formato de bloco Mimblewimble se baseia nisso, introduzindo um conceito: _corte-completo_ (cut-through). Com esta adição, uma cadeia Mimblewimble ganha: * Ótima escalabilidade, já que a grande maioria dos dados de transações podem ser eliminados com o tempo, sem comprometer a segurança. * Mais anonimato, misturando e removendo dados de transações. @@ -190,11 +190,11 @@ O mesmo vale para os próprios blocos, uma vez que percebemos que um bloco é si soma(saídas) - soma(entradas) = soma(excedente do núcleo) -Simplificando um pouco (ignorando novamente as taxas de transação), podemos dizer que os blocos MimbleWimble podem ser tratados exatamente como transações MimbleWimble. +Simplificando um pouco (ignorando novamente as taxas de transação), podemos dizer que os blocos Mimblewimble podem ser tratados exatamente como transações Mimblewimble. ##### Deslocamentos do Núcleo -Há um problema sutil nos blocos e transações do MimbleWimble, conforme descrito acima. É possível (e em alguns casos, é trivial) reconstruir as transações constituintes de um bloco. Isso é claramente ruim para a privacidade. Este é o problema do "subconjunto" - dado um conjunto de entradas, saídas e núcleos de transação, um subconjunto destes recombinará para reconstruir uma transação válida. +Há um problema sutil nos blocos e transações do Mimblewimble, conforme descrito acima. É possível (e em alguns casos, é trivial) reconstruir as transações constituintes de um bloco. Isso é claramente ruim para a privacidade. Este é o problema do "subconjunto" - dado um conjunto de entradas, saídas e núcleos de transação, um subconjunto destes recombinará para reconstruir uma transação válida. Por exemplo, dadas as duas transações a seguir - @@ -260,7 +260,7 @@ Um bloco é simplesmente constituído de:   * As assinaturas geradas usando o montante excedente.   * A taxa de mineração. -Quando estruturado dessa maneira, um bloco MimbleWimble oferece garantias extremamente boas de privacidade: +Quando estruturado dessa maneira, um bloco Mimblewimble oferece garantias extremamente boas de privacidade: * Transações intermediárias (corte-completo) serão representadas apenas por seus núcleos de transação. * Todas as saídas se assemelham: apenas números muito grandes que são impossíveis de distinguir um do outro. Se alguém quisesse excluir algumas saídas, este teria que excluir todas. @@ -280,12 +280,12 @@ Generalizando, concluímos que o estado da cadeia (excluindo cabeçalhos) a qual A primeira informação pode ser deduzida usando apenas a altura do bloco (sua distância do bloco de gênese). E tanto as saídas não gastas quanto os núcleos de transação são extremamente compactos. Isso tem 2 consequências importantes: -* O estado que um determinado nó do blockchain MimbleWimble precisa manter é muito pequeno (na ordem de alguns gigabytes para um blockchain do tamanho do bitcoin, e potencialmente otimizável para algumas centenas de megabytes). -* Quando um novo nó se une à rede que constrói uma cadeia MimbleWimble, a quantidade de informação que precisa ser transferida também é muito pequena. +* O estado que um determinado nó do blockchain Mimblewimble precisa manter é muito pequeno (na ordem de alguns gigabytes para um blockchain do tamanho do bitcoin, e potencialmente otimizável para algumas centenas de megabytes). +* Quando um novo nó se une à rede que constrói uma cadeia Mimblewimble, a quantidade de informação que precisa ser transferida também é muito pequena. Além disso, o conjunto completo de saídas não gastas não pode ser adulterado, mesmo somente adicionando ou removendo uma saída. Isso faria com que a soma de todos os fatores de cegueira nos núcleos de transação diferissem da soma dos fatores de cegueira nas saídas. ### Conclusão -Neste documento, cobrimos os princípios básicos subjacentes a um blockchain MimbleWimble. Usando as propriedades de adição da Criptografia de Curva Elíptica, construímos transações completamente opacas, mas que ainda assim podem ser corretamente validadas. E ao generalizar essas propriedades em blocos, podemos eliminar uma grande quantidade de dados do blockchain, permitindo uma grande escalabilidade bem como a rápida sincronização de novos pares. +Neste documento, cobrimos os princípios básicos subjacentes a um blockchain Mimblewimble. Usando as propriedades de adição da Criptografia de Curva Elíptica, construímos transações completamente opacas, mas que ainda assim podem ser corretamente validadas. E ao generalizar essas propriedades em blocos, podemos eliminar uma grande quantidade de dados do blockchain, permitindo uma grande escalabilidade bem como a rápida sincronização de novos pares. diff --git a/doc/intro_SE.md b/doc/intro_SE.md index 2d6d5deeb..db91fc14f 100644 --- a/doc/intro_SE.md +++ b/doc/intro_SE.md @@ -1,12 +1,12 @@ -# Introduktion till MimbleWimble och Grin +# Introduktion till Mimblewimble och Grin *Läs detta på andra språk: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -MimbleWimble är ett blockkedjeformat och protokoll som erbjuder extremt bra +Mimblewimble är ett blockkedjeformat och protokoll som erbjuder extremt bra skalbarhet, integritet, och fungibilitet genom starka kryptografiska primitiver. Den angriper brister som existerar i nästan alla nuvarande blockkedjeimplementationer. -Grin är ett mjukvaruprojekt med öppen källkod som implementerar en MimbleWimble-blockkedja +Grin är ett mjukvaruprojekt med öppen källkod som implementerar en Mimblewimble-blockkedja och fyller igen luckorna för att skapa en fullständig blockkedja och kryptovaluta. Grin-projektets huvudsakliga mål och kännetecken är: @@ -15,7 +15,7 @@ Grin-projektets huvudsakliga mål och kännetecken är: förhindra förmågan att selektivt uppdaga information efter behov. * Växer mestadels med antal användare och minimalt med antal transaktioner (< 100 bytes transaktionskärna), vilket resulterar i stora utrymmesbesparingar i jämförelse med andra blockkedjor. -* Stark och bevisad kryptografi. MimbleWimble förlitar sig endast på kryptografi med +* Stark och bevisad kryptografi. Mimblewimble förlitar sig endast på kryptografi med elliptiska kurvor (ECC) vilket har beprövats i decennier. * Simplistik design som gör det enkelt att granska och underhålla på lång sikt. * Gemenskapsdriven, uppmuntrar mining och decentralisering. @@ -23,20 +23,20 @@ elliptiska kurvor (ECC) vilket har beprövats i decennier. ## Tungknytande för alla Detta dokument är riktat mot läsare med en bra förståelse för blockkedjor och grundläggande kryptografi. -Med det i åtanke försöker vi förklara den tekniska uppbyggnaden av MimbleWimble och hur det appliceras i Grin. +Med det i åtanke försöker vi förklara den tekniska uppbyggnaden av Mimblewimble och hur det appliceras i Grin. Vi hoppas att detta dokument är föreståeligt för de flesta tekniskt inriktade läsare. Vårt mål är att uppmuntra er att bli intresserade i Grin och bidra på något möjligt sätt. För att uppnå detta mål kommer vi att introducera de huvudsakliga begrepp som krävs för en -bra förståelse för Grin som en MimbleWimble-implementation. Vi kommer att börja med en kort +bra förståelse för Grin som en Mimblewimble-implementation. Vi kommer att börja med en kort beskrivning av några av elliptiska kurvornas relevanta egenskaper för att lägga grunden som Grin -är baserat på och därefter beskriva alla viktiga element i en MimbleWimble-blockkedjas +är baserat på och därefter beskriva alla viktiga element i en Mimblewimble-blockkedjas transaktioner och block. ### Småbitar av elliptiska kurvor Vi börjar med en kort undervisning i kryptografi med elliptiska kurvor (ECC) där vi endast -går igenom de nödvändiga egenskaper för att förstå hur MimbleWimble fungerar utan att +går igenom de nödvändiga egenskaper för att förstå hur Mimblewimble fungerar utan att gå djupt in på dess krångligheter. För läsare som vill fördjupa sig i detta finns andra möjligheter att [lära sig mer](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). @@ -55,14 +55,14 @@ multiplikation med kurvpunkter är trivialt är "division" extremt svårt). Den föregående formeln `(k+j)*H = k*H + j*H`, med _k_ och _j_ båda som privata nycklar, demonstrerar att en publik nyckel erhållen av att ha adderat de två privata nycklarna är identisk med de två privata nycklarnas respektive publika nycklar adderade (`k*H + j*H`). I Bitcoin-blockkedjan använder hierarkiska deterministiska plånböcker (HD wallets) -sig flitigt av denna princip. MimbleWimble och Grin-implementationer gör det också. +sig flitigt av denna princip. Mimblewimble och Grin-implementationer gör det också. -### Transaktioner med MimbleWimble +### Transaktioner med Mimblewimble -Transaktionernas struktur demonstrerar en av MimbleWimbles kritiska grundsatser: +Transaktionernas struktur demonstrerar en av Mimblewimbles kritiska grundsatser: starka garantier av integritet och konfidentialitet. -Valideringen av MimbleWimble-transaktioner använder sig av två grundläggande egenskaper: +Valideringen av Mimblewimble-transaktioner använder sig av två grundläggande egenskaper: * **Kontroll av nollsummor.** Summan av outputs minus inputs är alltid lika med noll, vilket bevisar—utan att avslöja beloppen—att transaktionen inte skapade nya pengar. @@ -120,7 +120,7 @@ Vilket som följd kräver att: ri1 + ri2 = ro3 -Detta är MimbleWimbles första pelare: de beräkningar som är nödvändiga för att validera en transaktion +Detta är Mimblewimbles första pelare: de beräkningar som är nödvändiga för att validera en transaktion kan göras utan att veta några belopp. Denna idé härstammar faktiskt från Greg Maxwells @@ -130,7 +130,7 @@ som i sin tur härstammar från ett förslag av Adam Back för homomorfiska belo #### Ägande I föregående stycke introducerade vi en privat nyckel som en förblindningsfaktor för att dölja transaktionens belopp. -MimbleWimbles andra insikt är att denna privata nyckel kan användas för att bevisa ägande av beloppet. +Mimblewimbles andra insikt är att denna privata nyckel kan användas för att bevisa ägande av beloppet. Alice skickar 3 mynt till dig och för att dölja beloppet väljer du 28 som din förblindningsfaktor (notera att förblindningsfaktorn i praktiken är ett extremt stort tal). Någonstans i blockkedjan dyker följande output upp och ska endast kunna spenderas av dig: @@ -178,7 +178,7 @@ för _transaktionskärna_ och kontrolleras av alla validerare. #### Några finare punkter Detta stycke detaljerar byggandet av transaktioner genom att diskutera hur växel införs och kravet för "range proofs" -så att alla belopp är bevisade att vara icke-negativa. Inget av detta är absolut nödvändigt för att förstå MimbleWimble +så att alla belopp är bevisade att vara icke-negativa. Inget av detta är absolut nödvändigt för att förstå Mimblewimble och Grin, så om du har bråttom känn dig fri att hoppa direkt till [Sammanställningen av allt](#sammanställningen-av-allt). #### Växel @@ -204,7 +204,7 @@ Till exempel skulle man kunna skapa en transaktion med input-belopp 2 och output ha en balanserad transaktion. Detta kan inte upptäcklas enkelt eftersom punkten `x*H` ser ut som vilken annan punkt som helst på kurvan även om _x_ är negativt. -För att lösa detta problem använder MimbleWimble sig av ett kryptografiskt koncept som kallas "range proofs" (som också härstammar +För att lösa detta problem använder Mimblewimble sig av ett kryptografiskt koncept som kallas "range proofs" (som också härstammar från Confidential Transactions): ett bevis på att ett tal befinner sig inom ett visst intervall utan att avsölja talet. Vi kommer inte att förklara range proofs; du behöver endast veta att vi för varje `r*G + v*H` kan skapa ett bevis som visar att _v_ är större än noll och inte orsakar overflow. @@ -223,7 +223,7 @@ Denna output (`(113 + 99)*G + 2*H`) kräver att både talen 113 och 99 är känd #### Sammanställningen av allt -En MimbleWimble-transaktion inkluderar följande: +En Mimblewimble-transaktion inkluderar följande: * En mängd inputs som refererar till och spenderar en mängd föregående outputs. * En mängd nya outputs som inkluderar: @@ -236,12 +236,12 @@ avgiften minus inputs). ### Block och kedjetillstånd -Vi förklarade ovan hur MimbleWimble-transaktioner kan erbjuda starka anonymitetsgarantier samtidigt som de +Vi förklarade ovan hur Mimblewimble-transaktioner kan erbjuda starka anonymitetsgarantier samtidigt som de upprätthåller egenskaperna för en giltig blockkedja, d v s att en transaktion inte skapar pengar och att ägandebevis fastställs med privata nycklar. -MimbleWimble-blockformatet bygger på detta genom att introducera ett till koncept: _cut-through_. Med detta -får en MimbleWimble-kedja: +Mimblewimble-blockformatet bygger på detta genom att introducera ett till koncept: _cut-through_. Med detta +får en Mimblewimble-kedja: * Extremt bra skalbarhet då den stora majoriteten av transaktionsinformation kan elimineras på lång sikt utan att kompromissa säkerhet. @@ -273,12 +273,12 @@ transaktionskärnor. Vi kan summera alla outputs, subtrahera det med summan av a (summan av outputs) - (summan av inputs) = (summan av kärnöverskott) -Något förenklat (återigen utan hänsyn till transaktionsavgifter) kan vi säga att MimbleWimble-block kan betraktas precis som -MimbleWimble-transaktioner. +Något förenklat (återigen utan hänsyn till transaktionsavgifter) kan vi säga att Mimblewimble-block kan betraktas precis som +Mimblewimble-transaktioner. ##### Kärn-offset -Det finns ett subtilt problem med MimbleWimble-block och transaktioner som beskrivet ovan. Det är möjligt (och i vissa fall +Det finns ett subtilt problem med Mimblewimble-block och transaktioner som beskrivet ovan. Det är möjligt (och i vissa fall trivialt) att rekonstruera de konstituerande transaktionerna i ett block. Detta är naturligtvis dåligt för integriteten. Detta kallas för "delmängdsproblemet": givet en mängd inputs, outputs, och transaktionskärnor kommer någon delmängd av detta kunna kombineras för att rekonstruera en giltig transaktion. @@ -351,7 +351,7 @@ Ett block består av: * Signaturen genererad av överskottsbeloppet. * Mining-avgiften -Med denna struktur erbjuder ett MimbleWimble-block extremt bra integritetsgarantier: +Med denna struktur erbjuder ett Mimblewimble-block extremt bra integritetsgarantier: * Mellanliggande (genomskurna) transaktioner är endast representerade av sina transaktionskärnor. * Alla outputs ser likadana ut: väldigt stora tal som inte går att skilja åt på något meningsfullt sätt. @@ -376,14 +376,14 @@ Det första kan härledas genom att endast observera blockhöjden. Både mängden av UTXOs och transaktionskärnorna är extremt kompakta. Detta har två följder: -* En nod i en MimbleWimble-blockkedja får en väldigt liten kedja att behöva ta vara på. +* En nod i en Mimblewimble-blockkedja får en väldigt liten kedja att behöva ta vara på. * När en ny nod ansluter sig till nätverket krävs det väldigt lite information för att den ska bygga kedjan. Dessutom kan man inte manipulera mängden av UTXOs. Tar man bort ett element ändras summan av transaktionerna och är längre inte lika med noll. ### Slutsats -I detta dokument gick vi igenom de grundläggande principerna för en MimbleWimble-blockkedja. Genom att använda egenskaperna +I detta dokument gick vi igenom de grundläggande principerna för en Mimblewimble-blockkedja. Genom att använda egenskaperna för addition i kryptografi med elliptiska kurvor kan vi skapa fullständigt förmörkade transaktioner som ändå kan valideras. Genom att generalisera dessa egenskaper till block kan vi eliminera en stor mängd blockkedjeinformation vilket medför väldigt bra skalbarhet. diff --git a/doc/intro_ZH-CN.md b/doc/intro_ZH-CN.md index 76316abb7..e74f1a5b1 100644 --- a/doc/intro_ZH-CN.md +++ b/doc/intro_ZH-CN.md @@ -1,32 +1,32 @@ -MimbleWimble 和 Grin 简介 +Mimblewimble 和 Grin 简介 ===================================== *阅读其它语言版本: [English](intro.md), [简体中文](intro_ZH-CN.md), [Español](intro_ES.md), [Nederlands](intro_NL.md), [Русский](intro_RU.md), [日本語](intro_JP.md), [Deutsch](intro_DE.md), [Portuguese](intro_PT-BR.md), [Korean](intro_KR.md).* -MimbleWimble是一个区块链格式和协议,依托于健壮的加密原语,提供非常好的可扩展性、隐私和可替代性。它解决了当前几乎所有实现的区块链(与现实需求之间)差距。MimbleWimble 的白皮书在[本项目的WiKi](https://github.com/mimblewimble/docs/wiki/A-Brief-History-of-MinbleWimble-White-Paper)中可以找到,WiKi是开放的。 +Mimblewimble是一个区块链格式和协议,依托于健壮的加密原语,提供非常好的可扩展性、隐私和可替代性。它解决了当前几乎所有实现的区块链(与现实需求之间)差距。Mimblewimble 的白皮书在[本项目的WiKi](https://github.com/mimblewimble/docs/wiki/A-Brief-History-of-MinbleWimble-White-Paper)中可以找到,WiKi是开放的。 -Grin是一个实现MimbleWimble区块链的开源软件项目,并填补了(MimbleWimble协议所缺失的)实现一个完整的区块链和加密货币必需的一些东西。 +Grin是一个实现Mimblewimble区块链的开源软件项目,并填补了(Mimblewimble协议所缺失的)实现一个完整的区块链和加密货币必需的一些东西。 Grin 项目的主要目的和特性如下: * 隐私保护的缺省特性。 这使它具备了完全可替代性,且保留了按需选择性披露信息的能力。 * 区块大小与交易量相适配,历史交易仅保留约100字节的交易核(_transaction kernel_), 相比其它区块链节省了大量空间。 -* 强大且经过验证的密码学。 MimbleWimble只采用椭圆曲线密码,该密码技术已经过了数十年的试用和测试。 +* 强大且经过验证的密码学。 Mimblewimble只采用椭圆曲线密码,该密码技术已经过了数十年的试用和测试。 * 简单的设计使得日后的代码审查和维护变得容易。 * 社区驱动。采用一种抗拒ASIC的挖矿算法(Cuckoo Cycle算法),借此来鼓励去中心化的挖矿。 # Tongue Tying for Everyone -**备注**:MimbleWimble 出自《哈利波特》中的一句咒语,详见:[Tongue-Tying Curse](http://harrypotter.wikia.com/wiki/Tongue-Tying_Curse),这个标题的涵义应该是希望所有读到这篇介绍的人都可以来为这个开放社区做点贡献,真心希望如此。 +**备注**:Mimblewimble 出自《哈利波特》中的一句咒语,详见:[Tongue-Tying Curse](http://harrypotter.wikia.com/wiki/Tongue-Tying_Curse),这个标题的涵义应该是希望所有读到这篇介绍的人都可以来为这个开放社区做点贡献,真心希望如此。 -本文针对的读者是已经了解过区块链并了解一些基本的密码学知识的人群。我们尝试解释MimbleWimble的技术构建,以及它如何应用于Grin。我们希望这篇介绍能够浅显易懂,我们的目的是鼓励您对Grin产生兴趣,并加入Grin的开放社区,以任何您可能的方式对其做出贡献。 +本文针对的读者是已经了解过区块链并了解一些基本的密码学知识的人群。我们尝试解释Mimblewimble的技术构建,以及它如何应用于Grin。我们希望这篇介绍能够浅显易懂,我们的目的是鼓励您对Grin产生兴趣,并加入Grin的开放社区,以任何您可能的方式对其做出贡献。 -为了实现这个目标,我们将介绍一个主要概念:Grin是一个MimbleWimble实现。我们将从椭圆曲线密码(ECC)的简短描述开始,这是Grin的重要基础。然后描述MimbleWimble区块链交易和区块的所有关键要素。 +为了实现这个目标,我们将介绍一个主要概念:Grin是一个Mimblewimble实现。我们将从椭圆曲线密码(ECC)的简短描述开始,这是Grin的重要基础。然后描述Mimblewimble区块链交易和区块的所有关键要素。 ## 椭圆曲线简介 -我们首先简要介绍一下椭圆曲线密码学(后面简称为:ECC),只是简单说明一下理解MimbleWimble如何工作所必需了解的ECC属性,这里并不深入研究和讨论ECC。对于想要更多一点了解ECC的读者,可以参考这个介绍: +我们首先简要介绍一下椭圆曲线密码学(后面简称为:ECC),只是简单说明一下理解Mimblewimble如何工作所必需了解的ECC属性,这里并不深入研究和讨论ECC。对于想要更多一点了解ECC的读者,可以参考这个介绍: [了解更多](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/). 用于密码学目的的椭圆曲线只是一大组我们称之为 _C_ 的点。这些点可以被加、减或乘以整数(也称为标量)。 给定一个整数 _k_ 并使用标量乘法运算,我们可以计算`k * H`,这也是曲线 _C_ 上的一个点。 @@ -36,16 +36,16 @@ Grin 项目的主要目的和特性如下: 在ECC中,如果我们选择一个非常大的数字 _k_ 作为私钥,则`k * H`被作为相应的公钥。 即使人们知道公钥`k * H`的值,推导 _k_ 几乎不可能(或者换句话说,椭圆曲线点的乘法计算是微不足道的,然而曲线点的“除法”计算却极其困难。参见:[椭圆曲线密码学](https://zh.wikipedia.org/wiki/椭圆曲线密码学)。 -先前的公式`(k + j)* H = k * H + j * H`中, _k_ 和 _j_ 都是私钥,演示了从两个私钥的加和获取公钥`(k + j)* H`,等价于每个私钥的对应公钥加和(`k * H + j * H`)。在比特币区块链中,[分层确定性钱包(HD Wallets/BIP32)](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)严重依赖于这个原则。 MimbleWimble和Grin也是如此。 +先前的公式`(k + j)* H = k * H + j * H`中, _k_ 和 _j_ 都是私钥,演示了从两个私钥的加和获取公钥`(k + j)* H`,等价于每个私钥的对应公钥加和(`k * H + j * H`)。在比特币区块链中,[分层确定性钱包(HD Wallets/BIP32)](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)严重依赖于这个原则。 Mimblewimble和Grin也是如此。 -## MimbleWimble 交易 +## Mimblewimble 交易 -交易结构的设计显示了MimbleWimble的一个关键原则:强大的隐私性和保密性。 +交易结构的设计显示了Mimblewimble的一个关键原则:强大的隐私性和保密性。 -MimbleWimble的交易确认依赖于两个基本属性: +Mimblewimble的交易确认依赖于两个基本属性: * **0和验证。** 输出总和减去输入总是等于零,证明交易没有凭空创造新的资金,而且**不会显示实际金额**。 -* **拥有私钥即拥有交易输出的所有权。** 像大多数其他加密货币一样,交易输出通过拥有ECC私钥来保证其所有权。 然而,在MimbleWimble中,证明一个所有者拥有这些私钥并不是通过直接签署交易来实现的。 +* **拥有私钥即拥有交易输出的所有权。** 像大多数其他加密货币一样,交易输出通过拥有ECC私钥来保证其所有权。 然而,在Mimblewimble中,证明一个所有者拥有这些私钥并不是通过直接签署交易来实现的。 下面介绍账户余额、所有权、变更和证明,并借此说明上面的这两个基本属性是如何得以实现的。 @@ -88,13 +88,13 @@ MimbleWimble的交易确认依赖于两个基本属性: ri1 + ri2 = ro3 -这是MimbleWimble的第一个支柱:验证交易的算术运算可以在完全不知道任何实际交易值的情况下完成。 +这是Mimblewimble的第一个支柱:验证交易的算术运算可以在完全不知道任何实际交易值的情况下完成。 补充最后一点说明,这个想法实际上派生自Greg Maxwell的[机密交易](https://elementsproject.org/features/confidential-transactions/investigation),机密交易本身是从Adam Back提出的用于比特币的同态值提议中发展而来。 ### 所有权 -在前面的章节中,我们介绍了一个私钥作为致盲因子来掩盖实际交易值。MimbleWimble的第二个见解就是这个私钥可以用来证明值的所有权。 +在前面的章节中,我们介绍了一个私钥作为致盲因子来掩盖实际交易值。Mimblewimble的第二个见解就是这个私钥可以用来证明值的所有权。 Alice 给你发了3个币并且隐藏了这个数字,你选择了28作为你的致盲因子(请注意,在实践中,致盲因子是一个私钥,是一个非常大的数字)。 区块链上的某处显示以下交易输出,并只能由你来用(做交易输入): @@ -133,7 +133,7 @@ _X_, 上述加法的输出值,是对所有人可见的。 但是值3只有你 ### 一些更深入的细节 -本节阐述创建交易,通过讨论交易的找零机制和范围证明的要求以便所有值都被证明为非负。 这些都不是了解MimbleWimble和Grin的必需内容,所以如果你想快速了解,随时可以直接跳过本节内容,直接到[Putting It All Together](#transaction-conclusion). +本节阐述创建交易,通过讨论交易的找零机制和范围证明的要求以便所有值都被证明为非负。 这些都不是了解Mimblewimble和Grin的必需内容,所以如果你想快速了解,随时可以直接跳过本节内容,直接到[Putting It All Together](#transaction-conclusion). #### 找零 @@ -155,7 +155,7 @@ _X_, 上述加法的输出值,是对所有人可见的。 但是值3只有你 例如,可以创建一个输入为2并且输出为5和-3的交易,并且依照前面章节中的定义仍然可以获得平衡的事务。 这是不容易被检测到的,因为即使x是负数,ECDSA曲线上的对应点x.H看起来也是任何值。 -为了解决这个问题,MimbleWimble利用了另一个加密概念(也来自机密交易),称为范围证明:一个数字落在给定范围内的证明,而不会泄露数字。 +为了解决这个问题,Mimblewimble利用了另一个加密概念(也来自机密交易),称为范围证明:一个数字落在给定范围内的证明,而不会泄露数字。 我们不会详细说明范围证明,您只需要知道,对于任何`r.G + v.H`,我们都可以创建一个证明,证明 _v_ 大于零且不会溢出。 同样重要的是要注意,为了从上面的示例中创建有效的范围证明,必须知道在创建和签署excess value时使用的值113和28。 其原因以及范围证明的更详细描述在[range proof paper](https://eprint.iacr.org/2017/1066.pdf)中进一步详述。 @@ -163,7 +163,7 @@ _X_, 上述加法的输出值,是对所有人可见的。 但是值3只有你 ### 小结 -MimbleWimble交易包括以下内容: +Mimblewimble交易包括以下内容: * 一组输入,参考和花费一组以前的输出。 * 一组新的输出包括: @@ -174,9 +174,9 @@ MimbleWimble交易包括以下内容: ## 区块状态和链状态 -我们已经在上面解释了MimbleWimble交易如何在保持有效区块链所需的属性的同时提供强大的匿名性保证,即交易不会凭空捏造出货币,并且通过私钥建立所有权证明。 +我们已经在上面解释了Mimblewimble交易如何在保持有效区块链所需的属性的同时提供强大的匿名性保证,即交易不会凭空捏造出货币,并且通过私钥建立所有权证明。 -MimbleWimble区块格式通过引入一个附加概念来构建:核销(_cut-through_)。 有了这个补充,一个MimbleWimble链可获得: +Mimblewimble区块格式通过引入一个附加概念来构建:核销(_cut-through_)。 有了这个补充,一个Mimblewimble链可获得: * 极大的可扩展性,因为绝大部分交易数据主体可以随时间消除,而不会影响安全性。 * 通过混合和删除交易数据进一步匿名。 @@ -206,11 +206,11 @@ MimbleWimble区块格式通过引入一个附加概念来构建:核销(_cut- sum(outputs) - sum(inputs) = sum(kernel_excess) -简单来说,(依然忽略交易费部分)我们可以认为,对MimbleWimble区块的处理方法和对MimbleWimble交易的处理方法是严格一致的。 +简单来说,(依然忽略交易费部分)我们可以认为,对Mimblewimble区块的处理方法和对Mimblewimble交易的处理方法是严格一致的。 #### 交易核偏移因子(Kernel Offsets) -上面描述的MimbleWimble区块和交易设计有一个小问题,有可能从一个区块中的数据来重建交易(即找出一笔或几笔完整的交易,分辨哪一笔交易输入对应哪一笔交易输出)。这个对于隐私而言当然是不好的事情。这个问题也被称为子集问题("subset" problem) - 给定一系列交易输入、交易输出和交易核,有可能能够从中分辨出一个子集来重新拼出对应的完整的交易(很像拼图游戏)。 +上面描述的Mimblewimble区块和交易设计有一个小问题,有可能从一个区块中的数据来重建交易(即找出一笔或几笔完整的交易,分辨哪一笔交易输入对应哪一笔交易输出)。这个对于隐私而言当然是不好的事情。这个问题也被称为子集问题("subset" problem) - 给定一系列交易输入、交易输出和交易核,有可能能够从中分辨出一个子集来重新拼出对应的完整的交易(很像拼图游戏)。 例如,假如有下面的两笔交易: @@ -277,7 +277,7 @@ MimbleWimble区块格式通过引入一个附加概念来构建:核销(_cut- * 使用excess value生成的签名。 * 挖矿费用 (fee)。 -当区块以这种方式构建时,MimbleWimble区块提供了非常好的隐私保证: +当区块以这种方式构建时,Mimblewimble区块提供了非常好的隐私保证: * 更多的交易可能已经完成,但不会显式出现(在区块中)。 * 所有的输出看起来都是一样的:只是一些非常大的数字,不可能相互区分。 如果有人想排除某些输出,他们将不得不排除所有输出。 @@ -297,12 +297,12 @@ MimbleWimble区块格式通过引入一个附加概念来构建:核销(_cut- 第一条信息可以使用块高度(与起始块的距离)推导出来。未使用的输出和交易内核都非常紧凑。这有两个重要的后果: -* MimbleWimble区块链中给定的节点需要维护的状态非常小(对于比特币大小的区块链,几个G字节大小的数量级,可能优化到几百兆字节)。 -* 当新节点加入构建MimbleWimble链的网络时,需要传输的信息量也非常小。 +* Mimblewimble区块链中给定的节点需要维护的状态非常小(对于比特币大小的区块链,几个G字节大小的数量级,可能优化到几百兆字节)。 +* 当新节点加入构建Mimblewimble链的网络时,需要传输的信息量也非常小。 另外,未使用的交易输出(即UTXO)组成的完整集是不可篡改的,即使只是想去添加或删除一些交易输出。这样做会导致交易内核中所有致盲因因子的总和与输出中致盲因素的总和不同。 ## 结论 -在本文中,我们介绍了基于MimbleWimble区块链的基本原则。 通过使用椭圆曲线密码的附加属性,我们能够构建完全不透明但仍可以正确验证的交易。 +在本文中,我们介绍了基于Mimblewimble区块链的基本原则。 通过使用椭圆曲线密码的附加属性,我们能够构建完全不透明但仍可以正确验证的交易。 通过应用这些属性,我们可以消除大量区块链数据,从而实现新对等点的大规模部署和快速同步。 diff --git a/doc/merkle.md b/doc/merkle.md index 7cd2316a1..a65f89acb 100644 --- a/doc/merkle.md +++ b/doc/merkle.md @@ -2,7 +2,7 @@ *Read this in other languages:[Korean](merkle_KR.md)* -MimbleWimble is designed for users to verify the state of the system given +Mimblewimble is designed for users to verify the state of the system given only pruned data. To achieve this goal, all transaction data is committed to the blockchain by means of Merkle trees which should support efficient updates and serialization even when pruned. @@ -12,7 +12,7 @@ proofs) have the ability to be summed in some way, so it makes sense to treat Merkle sum trees as the default option, and address the sums here. A design goal of Grin is that all structures be as easy to implement and -as simple as possible. MimbleWimble introduces a lot of new cryptography +as simple as possible. Mimblewimble introduces a lot of new cryptography so it should be made as easy to understand as possible. Its validation rules are simple to specify (no scripts) and Grin is written in a language with very explicit semantics, so simplicity is also good to achieve well-understood diff --git a/doc/merkle_KR.md b/doc/merkle_KR.md index 69a960940..13576a4f7 100644 --- a/doc/merkle_KR.md +++ b/doc/merkle_KR.md @@ -1,11 +1,11 @@ # 머클의 구조 -MimbleWimble은 Pruning 데이터만 있는 시스템의 상태를 사용자가 증명하도록 설계되었습니다. 이러한 목표를 달성하기 위해 모든 트랜잭션 데이터는 pruning 된 경우라도 효율적인 업데이트와 serialization을 지원하는 Merkle 트리를 사용하여 블록 체인에 커밋됩니다. +Mimblewimble은 Pruning 데이터만 있는 시스템의 상태를 사용자가 증명하도록 설계되었습니다. 이러한 목표를 달성하기 위해 모든 트랜잭션 데이터는 pruning 된 경우라도 효율적인 업데이트와 serialization을 지원하는 Merkle 트리를 사용하여 블록 체인에 커밋됩니다. 또한 거의 모든 거래 데이터 (입력, 출력, Excess 및 Excess proof)는 어떤 방식으로 합산 될 수 있으므로 Merkle sum 트리를 기본 옵션으로 처리하고 여기에서 합계를 처리하는 것이 좋습니다. Grin의 디자인 목표는 모든 구조를 구현하기 쉽고 가능한 한 간단하게 만드는 것입니다. -MimbleWimble은 많은 새로운 암호화 방식을 내 놓았고 이러한 방식을 가능한 한 쉽게 이해할 수 있도록 만들어야합니다. +Mimblewimble은 많은 새로운 암호화 방식을 내 놓았고 이러한 방식을 가능한 한 쉽게 이해할 수 있도록 만들어야합니다. 새로운 암호화 방식의 입증 규칙은 스크립트가 없이도 구체화 하기 쉽고 Grin은 매우 명확한 의미론을 가진 프로그래밍 언어로 작성되기 때문에 단순함은 잘 알려진 컨센서스 룰을 달성하는 것에도 좋습니다. ## Merkle Trees diff --git a/doc/pruning.md b/doc/pruning.md index bc05f35bb..7f609cad7 100644 --- a/doc/pruning.md +++ b/doc/pruning.md @@ -2,12 +2,12 @@ *Read this in other languages: [Korean](pruning_KR.md).* -One of the principal attractions of MimbleWimble is its theoretical space +One of the principal attractions of Mimblewimble is its theoretical space efficiency. Indeed, a trusted or pre-validated full blockchain state only requires unspent transaction outputs, which could be tiny. The grin blockchain includes the following types of data (we assume prior -understanding of the MimbleWimble protocol): +understanding of the Mimblewimble protocol): 1. Transaction outputs, which include for each output: 1. A Pedersen commitment (33 bytes). @@ -47,7 +47,7 @@ There may be several contexts in which data can be pruned: ## Validation of Fully Pruned State Pruning needs to remove as much data as possible while keeping all the -guarantees of a full MimbleWimble-style validation. This is necessary to keep +guarantees of a full Mimblewimble-style validation. This is necessary to keep a pruning node state's sane, but also on first fast sync, where only the minimum amount of data is sent to a new node. diff --git a/doc/pruning_KR.md b/doc/pruning_KR.md index 6c26cc1e3..8e8307111 100644 --- a/doc/pruning_KR.md +++ b/doc/pruning_KR.md @@ -1,8 +1,8 @@ # 블록체인 데이터 프루닝(가지치기)에 대해 -MimbleWimble의 주된 매력 중 하나는 이론적인 공간효율성 입니다. 실제로 신뢰 할수 있거나 또는 사전에 입증된 전체 블록체인 스테이트는 아주 작을수도 있는 UTXO(unspent transaction outputs)만 나타냅니다. +Mimblewimble의 주된 매력 중 하나는 이론적인 공간효율성 입니다. 실제로 신뢰 할수 있거나 또는 사전에 입증된 전체 블록체인 스테이트는 아주 작을수도 있는 UTXO(unspent transaction outputs)만 나타냅니다. -Grin의 블록체인에는 다음 유형의 데이터가 포함됩니다 (MimbleWimble 프로토콜에 대한 사전 지식이 있다고 가정합니다). +Grin의 블록체인에는 다음 유형의 데이터가 포함됩니다 (Mimblewimble 프로토콜에 대한 사전 지식이 있다고 가정합니다). 1. 아래를 포함하는 트랜잭션 출력값 1. Pedersen commitment (33 bytes). @@ -36,7 +36,7 @@ Grin의 블록체인에는 다음 유형의 데이터가 포함됩니다 (Mimble ## 완전히 정리된 스테이트(Fully Pruned State)의 입증에 대해서 -(데이터)Pruning은 가능한 한 많은 양의 데이터를 제거하면서 MimbleWimble 스타일의 검증을 보장하는 것이 필요합니다. +(데이터)Pruning은 가능한 한 많은 양의 데이터를 제거하면서 Mimblewimble 스타일의 검증을 보장하는 것이 필요합니다. 이는 pruning 노드 상태를 정상적으로 유지하는 데 필요할 뿐만 아니라 최소한의 양의 데이터만 새 노드로 전송할 첫번째 고속 동기화에서도 필요합니다. 체인 스테이트의 완전한 입증을 위해 아래와 같은 사항들이 필요합니다. diff --git a/doc/switch_commitment.md b/doc/switch_commitment.md index a5199e361..723cfa420 100644 --- a/doc/switch_commitment.md +++ b/doc/switch_commitment.md @@ -38,7 +38,7 @@ did not change the secret number during the game. ### Pedersen Commitment -Other, more advanced commitment schemes can have additional properties. For example MimbleWimble +Other, more advanced commitment schemes can have additional properties. For example Mimblewimble and Confidential Transactions (CT) make heavy use of _[Pedersen Commitments](https://link.springer.com/content/pdf/10.1007/3-540-46766-1_9.pdf)_, which are _homomorphic_ commitments. Homomorphic in this context means that (speaking in the @@ -51,7 +51,7 @@ from _box1_ and _box2_. While this "box" metaphor no longer seems to be reasonable in the real-world this is perfectly possible using the properties of operations on elliptic curves. -Look into [Introduction to MimbleWimble](intro.md) for further details on Pedersen Commitments +Look into [Introduction to Mimblewimble](intro.md) for further details on Pedersen Commitments and how they are used in Grin. diff --git a/doc/toc.md b/doc/toc.md index 21ebeb09f..337ba01d5 100644 --- a/doc/toc.md +++ b/doc/toc.md @@ -6,7 +6,7 @@ This should get progressively filled up, until we're ready to advertize it more widely. * What is Grin? -* [Introduction to MimbleWimble](intro.md) +* [Introduction to Mimblewimble](intro.md) * Cryptographic Primitives * Pedersen Commitments * Aggregate (Schnorr) Signatures diff --git a/keychain/Cargo.toml b/keychain/Cargo.toml index 7f2c432bb..7795552c1 100644 --- a/keychain/Cargo.toml +++ b/keychain/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_keychain" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/p2p/Cargo.toml b/p2p/Cargo.toml index 4dfc80aa5..1f23a5b37 100644 --- a/p2p/Cargo.toml +++ b/p2p/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_p2p" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/pool/Cargo.toml b/pool/Cargo.toml index 0fc9f5655..5e1ba865c 100644 --- a/pool/Cargo.toml +++ b/pool/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_pool" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Chain implementation for grin, a simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/servers/Cargo.toml b/servers/Cargo.toml index d68715e3e..06b53b5a7 100644 --- a/servers/Cargo.toml +++ b/servers/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_servers" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/src/bin/grin.yml b/src/bin/grin.yml index bf953cd3c..13cdeeeac 100644 --- a/src/bin/grin.yml +++ b/src/bin/grin.yml @@ -1,5 +1,5 @@ name: grin -about: Lightweight implementation of the MimbleWimble protocol. +about: Lightweight implementation of the Mimblewimble protocol. author: The Grin Team args: diff --git a/store/Cargo.toml b/store/Cargo.toml index 4e0a91216..e1b9f2552 100644 --- a/store/Cargo.toml +++ b/store/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_store" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ] diff --git a/util/Cargo.toml b/util/Cargo.toml index e7846d4ab..762782729 100644 --- a/util/Cargo.toml +++ b/util/Cargo.toml @@ -2,7 +2,7 @@ name = "grin_util" version = "3.0.0-alpha.1" authors = ["Grin Developers "] -description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." +description = "Simple, private and scalable cryptocurrency implementation based on the Mimblewimble chain format." license = "Apache-2.0" repository = "https://github.com/mimblewimble/grin" keywords = [ "crypto", "grin", "mimblewimble" ]