上图为通过0xTracker跟踪的0x协议的天交易。从图中数据来看，最近一个月最高的天交易量约为160万美元左右。接下来，我们来对比看看中心化交易所的天交易量。

上图数据来自CoinMarketcap，排在第一的交易所DigiFinex，24小时的交易量居然达到了18亿。去中心化交易所的交易量相比来说，简直不值一提。

去中心化的交易所到底出了什么问题？

去中心化交易所的问题，不如从2018年的Hydro 分叉0x说起。事情简单来说就是，基于0x上建立的DDEX交易所，因为底层的0x不够好用，于是进行了“分叉”，并启用自己的Hydro协议引擎。所指出来的0x痛点是：

• 0x使用链下撮合的方式不够完美。如果多人选择了同一个单成交，最终只会有一个人成交时。在交易量很大时，这种情况会非常突出。效率不高。会导致量大的交易所都活不下去。
• 另外，部分人可以利用工具优势，如矿工，或通过提高手续费，优先打包。优先执行自己的订单。普通小白用户就处于劣势了。

所以hydro的解决方案就是，自己把撮合匹配也做为一种解决方案进行了提供，最近还开放了自己的sdk。

总的来说，去中心化的底层协议还在成熟的过程中，还有不少的问题。

新加入的选手 - Uniswap

最近在以太坊上，有个新的去中心化交易所Uniswap，自从上线，就成为了讨论的焦点。虽然2018年11月才上线，交易量已经超过创建于2017年的去中心化交易协议Bancor。

这个项目有个神奇的地方，没有代币，没有中心化的组织，甚至对于开发者来说，不会收到任何收益，纯粹是个非赢利的项目。它的发展，只是由以太坊基金会，捐赠了10万美元。

相比通常的交易所，它的解决方案简单得多。去掉了交易所的订单撮合的概念，而是提供一个资金池。类似bancor通过算法，根据想买代币的数量，动态匹配对应的代币数量，完成交易。整个过程都在链上，而且资金池保证，永远都可以进行兑换。

资金池由做市商提供代币，每笔交易总额的千分之三为手续费。做市商可以按自己在整个资金池的比例获得相应手续费。但因为Uniswap自己的机制，做市商可能因为自己投入的代币价格波动，造成直接损失。所以上面这个手续费是笔风险收益金。

细研Uniswap的机制，你会发现，它还有不少小问题。比如，对于大额交易来说，它的机制不友好，会导致买的代币数量变少，也就是买的量越大，价格越贵。但对于小额交易来说，它的优点比较突出，gas占用少，没有复杂的下单过程，下单保证能交易，简单且快。

在研究的过程中，我还发现了它的另一个优点。因为它是资金池的模式，随着使用的用户增多，资金池越大，交易量越大，手续费越多，会吸引越来越多的人加入这个网络，形成网络效应。这个相比0x这种按订单撮合的解决方案是一种本质的不同。

去中心化交易所的需求真的存在吗？

从去中心化的上线数据来看，交易数据实在惨不忍睹，那是不是去中心化的交易需求压根不存在呢。也许并不一定。

去中心化的交易所的适用场景，主要还是在DApp间的实时代币转换，现在以太坊上火热讨论的DeFi经济来说，不可或缺。当前未有效起量，还是因为DApp的落地仍在探索中，如果未来出现大量的超级应用，代币间的转换也会益发频繁，去中心化的交易就会慢慢凸显它的价值了。

让我们拭目以待吧。

coinbase的托管

早在2017年11月的文章中中，coinbase宣布了进军托管领域。随即在2018年就上线了托管平台，可谓动作相当之快。

这个托管平台的用户是谁呢？仅面向机构投资者，而且门槛不是很低。启动的手续费要10万美元，每月还要收10个点的托管手续费。所以，散户不适合玩。

手续费不低，那coinbase靠什么让这些机构乖乖掏这个钱呢。主要是声称基于自己的经验，在安全存储，访问控制审计方面提供了工业级的合规解决方案。除了这个明面上的原因，我猜想，一个潜在的原因是，机构的量一般非常大，常规交易所买卖走量波动极大，通过这个平台可以做做大宗交易。另一个潜在的原因是，部分传统的资金管理平台，想配一定比例的数字货币对冲风险。前提肯定得找家合规的，那么coinbase，就成为了一个不二之选。

合规，加上大资产的流动性，还是很对机构用户的胃口的。据其自己透露的消息，当前已有60个客户，及超过4亿美元的规模。看起来不错，一切都很完美。

coinbase的staking生意

回过头来说，托管对资产方来说，始终是个烧钱的事。放那就意味着不断的折损，能不能有些资产增值的好处呢？那就得先从pos说起了。

pos（proof of stake），简单来说，就是区块链的一种挖矿机制。之前用算力，大家都觉得太耗资源，而且还慢。有没有又快，又不必要浪费这么多能源的方式呢。最后，就提出了，通过经济驱动挖矿的想法。参与者把币押在某个区块上，声明自己保证它没有问题。如果最终真的没有问题，声明的这个人获得分红，如果被发现有作弊，直接没收押的钱。如果不出问题，效果类似，把钱押那里，能有些固定收益，抵抗通胀，还是不错的。

当然，上面只是简化说明。实际要参与pos的押注过程，需要进行很多复杂的操作，而且有一定的风险（操作的过程需要使用到私钥签名）。所以对于机构投资者来说，当然不愿意，为了这点小钱，去担这个风险了。

好了。coinbase的解决方案就来了。你把资产放我这里，我帮你安全的搞定相关的所有事。你能做所有你直接拿着这些钱，能做的所有的事。比如，分点红，拿点被动收入，事情是个好事情呀。

coinbase怎么安全的做到这一切呢？

这里先得说下，第一个上的支持被动分红的币了，Tezos。coinbase在文章中说，Tezos这个币的架构考虑比较全面，支持在冷钱包存储的状态下（资产是离线的状态，保证安全），还能参与网络的押注过程，本身就比较安全。另一方面，coinbase自己对此，还买了保险，资产出问题了，可以赔偿。第三方面，押注验证的过程，coinbase自己来做节点服务，进行验证，帮助客户拿到分红。可谓帮人帮到底。

这么辛苦的做这些事，根本是想在托管之上提供增值服务，留住客户。coinbase，打得一手好牌呀。

staking的市场

coinbase的行动很快，根本瞄准的还是押注（staking）市场。这个市场很有潜力。

简单来说说，因为刚才说的那个分红机制，潜在会鼓励大家把钱放在自己手上，自己参与网络过程挣点钱。那么钱就会从交易所拿出来。但如果后面交易所通过coinbase支持了这个服务，或者说，交易所自己也做这个押注服务了呢。那么，这个行业就精彩了。

从上面这个角度接着讲，对每一个pos网络来说，未来也许会出现这些头部的机构，通过押注，来挖矿，保证网络的运行。这些头部的押注方，也肯定会对整个网络有一定的话语权，不知道算不算是个好事。

当然，最最重要的是，如果coinbase的理想实现了。作为一个入口，把机构投资者带进了加密币的世界，那么对整个加密生态，肯定是件好事了。

原文翻译自：https://blog.oceanprotocol.com/the-web3-data-economy-b6fd8ecac4c4 。文中观点不代表网站观点，如有侵权不当，请联系删除，谢谢。

影子数据经济

2017年5月的“经济学人”杂志的封面文章将数据定位为“世界上最有价值的资源”。在数据的背后，Google、Facebook和一小部分的其它公司，已经创造一个市值超过千亿美元的市场。对于他们来说，数据就是钱：更多的数据意味着更好的AI模型，更精准的广告，更多的广告点击，更多的利润。追寻金钱的轨迹，在其背后是数据。

我们现在在一个数据经济的时代。但它是影子数据经济。它是不透明的：Google和它类似的这些公司，因为竞争的原因（数据孤岛），独自持有这些数据。同时，权力是中心化的，比如Zuckerberg和它20亿人的领地。

我们是否能推动数据经济到一个开放，无需信任的时代？这也正是Ocean Protocol正在做的。幸运的是，我们有灵感。

钱的经济

2005年，一个年收入1.5万美元的草莓采摘者拿到了72万的购房贷款。他永远不可能能还清。但这事为什么会发生呢？正如数据一样，我们跟随钱的流向。借款人从费用中赚了很多钱。他们想出了如何通过信用违约掉期等技巧，将劣质贷款评为优质贷款。猪嘴唇上的口红。

2008年，纸牌屋倒了。千亿资产蒸发。所有的纳税者支付了账单。银行家们收起了它们的奖金，闭上了它们的嘴。

这就是政府和银行家的影子钱经济。它是不透明的，而且权力集中在少数人手中。

进行到比特币的时代。Satoshi明确的指出了它创建比特币的原因正是经济危机。比特币点亮了区块链运动。其中，代币经济开启了透明和无需信任的钱的时代。

代币经济正是数据经济的灵感来源。正如通过区块链运动，我们开启了钱的时代一样，让我们也同时开启数据的时代。

问题是，我们怎么做到这一切？最终会是什么样的？也许令人惊讶，但这一切也许会开始于AI（人工智能）。

一个开放的数据经济

从数据之中，大家可以得到价值。从一个数据源到另一个数据源的关键是AI模型。数据越多，模型将越精确，以及更多的收益。AI是关键。

在财富500强、NGO、以及政府部门里，实际上有数以亿计的数据。虽然他们有数据，但他们并没有AI专家。它们艰难的吸引AI研究者。为什么这么难呢？因为AI专家都在组建它他们自己的企业来从AI中赚到第一桶金。

而这些新创企业需要的也正是数据。

其中仅有一小部分的公司既有数据又有AI专家：Google、Facebook以及其它的一小部分。这一小部分的公司正在积累所有价值。

如果我们能把AI与有数据的人们联系起来的话（译者注：解决更多的人或公司，获取数据的可能性，比如中小型公司。）？

为了做到这一切，想像一下，我们可以创建一个基础层，来连接大家。一个发挥AI和数据价值的基础层。

我们在下图进行详细的说明。在最上面是主要的用户：问题拥有者，问题解决者。最下一层是用于连接的基础层。介于两者之间的是连接不同组织的中间层：基于AI的交换市场，以及数据科学家的工具包。

问题拥有者，政府通常需要通过授权才能开放它们的数据。这包括市级，一直到省级，最后到国家级。联合国组织和其它非政府组织正在努力使用数据，与大多数企业没有什么不同。如上面所述，AI专家很难深入到企业中，同样的挑战，存在于政府及非政府组织中。

对数据来说，需求方是很简单的。AI需要数据。具体来说，数据科学家知道AI模型可以最大化的发挥提供数据的价值。

所以，关键是推动供给方。为了做到这一切，我们使用价格的阴阳，以及免费的数据。假设我们有数10个或数100个数据市场，买卖不同行业和垂直行业的数据-汽车、医药等等-以及一些公用数据。与收费数据一起的，是免费数据，用来激励大家提供更多免费的数据。如果我们将问题定义也放入公共池，通过激励解决这个问题，我们就将得到AI公共池（译者注：问题解决方案是与AI打包在一起的）。

数据经济

这部分会讨论一个开放的，无需信任的Web3数据经济的驱动力；来自金钱经济的灵感；我们说明一下基于数据为基础的经济会是怎么样的；以及其相关的应用。但它真的会看起来像一个经济吗？

灵感

让我们再次从金钱经济中来找灵感。让我们来解构下一个开放的，无需信任的代币经济的相关元素（一个简化模型，然而有一定的意义）。

上图中的最底一行是代币经济的基础层。有作为储备货币意义的或者说价值存储的：比特币。也有应用平台，交换单元，比如以太坊。以及应用的集资平台，以太坊。

在中间的行中，是应用层的最后一公里。它们是dApps。

最上面一行，是经济层的最后一公里。它们有保管人/钱包，比如Coinbase或Metamask。以及交易所，比如GDAX等。最后，以及矿工，比如比特大陆。

假设数据经济与代币经济看起来是一样的呢？（至少是近似的）。让我们来设想一下，详见下图：

同样的，我们有储备货币，交易单元，数据或资产融资平台，以及应用和经济的最后一公里。

Web3数据经济的元素

接下来，如何启动数据经济呢？我们要向上图中的蓝色框中填入对应的项。让我们基于当前的Ocean Procotol的设计，看看我们可以怎么来达成（注意，这一切有可能会有调整）。

用户可以押注在数据资产上，参照Curation Markets的概念（Curation Markets），基于一个债券曲线（Bonding curves，缩写BC）。债券曲线可以作为某个数据集X的相关性或质量的指标。在X上大家的下注越多，那么将被认为更有价值，并且数据集在提供服务时，押注越多的人会获得更多的块奖励。

债券曲线（Bonding curve，缩写BC）是一个自动做市商，一个可以随时以某个价格，买卖代币的智能合约。对于数据资产X，BC开始销售称为DX的代币，通过X来交换Ocean的代币O（译者注：对于数据资产X进行初始发行，数据的价值在于持续更新，谁来做这个持续更新的事呢？再一个数据的单价怎么定合适呢？由谁决定，代币持有者？)。一开始时，只有0DX。但一旦有人因为DX便宜而开始购买，BC将发行更多DX代币。DX会随着买的人越多，而变得越来越值钱。如果你卖掉了DX，它将会销毁。DX将会循环发行或销毁的过程。

基础层：数据资产融资平台。每次你发布一个数据资产，并启动一个代币，你实际上在进行一个迷你艾西欧。人们可以购买代币，每个代币都有权从收入中获得区块奖励。一开始，没有任何代币。但一旦有人开始押注在它上面，那么它就会发布那些数据资产的令牌。

基础层：储备货币。券线（Bonding curves）有一个内置的储备货币的意义。曲线下方的一片区域实际就是当前的储备，占用流动性。这个代币被人押注得越多，那么储备货币量就越大（译者注：储备货币，使用稳定币是不是好一些，Ocean做的事太大，感觉上，做不了这么多呀）。

基础层：交易单元。交易单元由买卖数据，存储服务，计算服务等等组成。Web3的基础层已经有相应的工具来做到这一切。

总的来说，Web3的数据基础层，由储备货币/价值存储，交易单元，融资平台组成。

在基础层之上的是经济层和应用层的最后“一公里”，如下所示。还有大量的工作要做；让我们一起来解构一下。

经济层的最后一公里：保管人/钱包。代币要以由传统的加密工具，比如，Metamask或者Balance来管理（译者注：数据类的发币平台，以数据做为价值来发行代币，每个项目都有数据，再发一个数据币？）。或者新的专为数据经济设计的新钱包。我们认为代币经济有长尾效应。在数据经济中，我们将有更多的代币。我们将有1万个数据集，或者100万个数据集（译者注：突然发现艾西欧其实就是最成功的激励模式），每一个都有它自己的代币。这些如何能被管理起来是一个有趣的问题。这是一个钱包层要解决的问题（译者注：这不是一个钱包层，是一个数据市场？）

经济最后一公里：数据交互。现存的中心化的、去中心的数据交换场所，也许会发现，通过Web3的数据基础层，价值会显著的增加数据的供应。加密代币交易所会想办法增加其价值。

经济层的最后一公里：服务网络。在Web3的数据经济中，“矿工”变成了数据提供者，存储及计算层。它们有三个潜在收益：一个新（潜在的非常大的）的客户获取渠道；为客户提供新功能（如，预处理后）；通过块奖励为他们/他们的用户带来新的收入。

应用层的最后一公里。这是数据科学家的新的力量：更多的数据，来源，以及新的收入机会。因此，做数据相关的工具的也许能发现通过发挥Web3基础层的来更好的服务数据类的用户，将会得到不少收益。我们也非常期望能看到应用层和经济层的工具的有趣结合。比如个人电脑中内置钱包，可以用于买卖数据。

简单来说，Web3的基础层与代币经济将非常相似。

结尾

数据是钱。让我们在第三代互联网中开启这一切。我们已经从影子钱的经济转移到了代币经济。让我们在数据上也同样的进行一遍。从影子数据经济转向到一个透明的无需信任的数据经济时代。一个第三代互联网的数据经济时代。

区块链的核心动力在于激励设计。Curation Market是典型的激励设计方案。未来可能应用到区块链激励设计的各个环节（未来的产品经理是做激励设计的？）。

基本概念

Curation Market（CMs）是一个模型，在共同的目标下，让群体提高合作效率和他们共建价值的收益。每个主题/meme/想法/目标都有一个与之对应的，代表其价值的代币，用来促使其所含信息的价值最大化。

CMs通过一个数学上的曲线来实现上面所说的信息价值最大化，具体来说，是通过信息所关联代币价格与其供应量之间的曲线来体现。

下面是一个二元曲线的例子，其中 \(currentPrice = tokenSupply^2\)。

当一个用户想买10个代币时，合约将增发10个新代币，并根据曲线计算对应的购买价格。

工作原理：概述

上述价格曲线的基本假设如下：

1. 通过智能合约，你可以通过，比如ETH，购买新代币（某个项目的代币）。此时ETH将存入智能合约。它不属于任何一个特定的人或者团队。
2. 购买价格由当前代币的供给量所决定。购买价格依据某个算法曲线硬编码进合约。
3. 任何时候，大家都可以将他们的代币卖回公共池，并获得由卖出曲线设定的适当奖励。

这个机制意味着代币将根据所需形成或消亡。如果所有人都离开了，其中的资金将会全部取出，代币已没有存在的必要了。如果尽早购买，同样的价格将得到更多的代币，越往后购买，则得到的将越少。而到供给量越来越高时售卖，单个代币也将返还更多的资金。

上述设计所带来的意义是，它奖励的是早期的参与者。如果在后期将代币卖回公共池，将获得不少收益。不同项目设置独立代币的原因是，更能体现对应项目的价值。当且仅当价值与代币价值匹配时，这个货币经济的正向循环才能支撑这个系统稳定的运行。

主要参考

• Tokens 2.0: Curved Token Bonding in Curation Markets - @simondlr Nov 2017
• Introducing Curation Markets: Trade Popularity of Memes & Information (with code)! - @simondlr May 2017

原文：http://tokenengineering.net/curation-markets

文中内容不代表本网站观点，内容仅供参考。

翻译自：https://jessewalden.com/4-eras-of-blockchain-computing-degrees-of-composability/

如有侵权请联系我进行删除，谢谢。

在a16z crypto，我们认为加密网络与城市结构类似，因为两者都受益于基于共享基础设施之上的，由下至上的不断的成长。

传统的商业通常选址于居民区，公共设施健全，法律，安全，以及充满经济活力的地方。类似的，开发者基于共享资源，如良好的用户基础，数据，安全，以及稳定的运行的环境来获得好处。

这其中的核心是可组合性。如果现存的资源可以作为构建块，被整合到更高层的应用中，我们就认为平台是可组合的。可组合性非常重要的，因为它可以让开发者以更少的资源做更多的事情，最终，会带来更快，复合的创新。

区块链天然无需信任的特质打开了可组合性的大门。因为它允许开发者不用担心底层依赖，而在共享的基础设施之上进行开发。区块链既是无权限的（开源），同时又是有状态的（类似API）。

在研究区块链计算的演变时，我将勾勒出四个不同阶段的核心模型，每个阶段都有其各自的架构，并以可组合性来进行分层：

1. 计算器 era - 特定于某个应用的，组合性有限
2. 大型机 era - 图灵完备，高可组合性
3. 服务器 era - 特定于某个应用的，兼容可组合性
4. 云 era - 图灵完备，可扩展的组合性

接下来会根据上面的分类，一一阐述其各自的优势与劣势。事先需要说明的是，这个领域仍有许多待解决的，开放研究中的问题，我们并不清楚事情将会如何发展。每一个阶段都是值得尝试的实验。

计算器 era

比特币是区块链计算的先驱。它是一个特定问题的全栈式解决方案，即电子黄金。除了简单的支持查看余额及转账外，比特币提供了一个脚本语言，可用来构建更复杂的功能。

有一定数量的项目使用了比特币的脚本语言来构建更高层级的应用。比如，Proof of Existence使用OP_RETURN的数据项创建了一个证明，证明某人在某个给定的时间有某个电子文件。而其它项目，如Colored Coins和Counterparty则基于比特币的安全网络中创建了自己的代币。但其它一些进一步扩展比特币功能，代币功能的尝试，受限于比特币潜在的脚本语言的限制。

许多人辩解到，去中心化的货币系统最重要的特性是安全，而不是可编程性，由此有限的脚本语言能力是一种特性，而不是一个bug。从这个角度，我们可以更多的把比特币视作一个计算器，而不是一个电脑（这是一个肯定的评价）。它是根据一定目的构建的，在其自身的任务上完成得很好，只是对于渴望提供更多功能及创建新应用的开发者来说，需要向新架构演进。

大型机 era

基于比特币开创的先进理念，以太坊通过包含一个图灵完备的虚拟机，泛化了区块链计算机。使开发者可以透过一个去中心化的机器网络，部署和运行任何程序。

其中，为了确定性，网络中的每个节点都必须执行每个程序的函数。这使得整个网络缓慢且成本高，但以太坊在一个方面是无与伦比的：它的计算是无需信任的。可以期望每个程序能被确定的执行（可验证）和输出，甚至状态都是所有人可见的。以太坊平台为开发者提供了与应用与关的，中立的构建块，用以组合为更高层级的应用。我们看到了下面这一切的发生：

Marble支持闪贷，实现去中心化交易所间的对冲：“交易者可以从Marble的智能合约银行借款，从一个DEX上购买代币，再在另一个DEX以更高的价钱卖掉代币，还款给智能合约银行，获得其中的对冲收益。所有的上述一切，可以在一个原子交易中完成。”Marble通过以太坊的全局唯一的虚拟机执行不同项目中的一系列功能，并最终得到了一个大家都可以使用的简单功能。

Primotif是一个金融的衍生品，跟踪指数，就像标准普尔指数一样。它使用Augur来跟踪指数价格，使用dYdX做空代币来对冲ETH的波动，而dYdX的底层使用Maker的Dai这种稳定币。

通过组合而产生的网络效应（Network effects）不是一个新出现的现象。下面是Biz Stone，Twitter的创始人，在2007年关于他们的API的可组合性的说明（AVC）：

“API是最重要的，或者无可争议的，是我们做Twitter时最最重要的一件事。它允许我们，首先，让服务非常简单，而简单的API能让开发者基于我们为基础设施进行开发，并随之带来更好的创意，构建了类似Twitterrific，这样一种美妙优雅的使用的Twitter的方式，一种我们在如此小的团队的情况下，所不要能达到的。API非常容易达到比网站大10倍的流量，这些对我们来说真的非常重要。”

遗憾的是，组合性并没有持续的出现在Web2.0的场景中。其中一个问题是我们没有办法通过API传输价值，而且没有有效且公平的方式来管理平台规则，比如，广告展示。这导致了平台与开发者之间的激励错位，最终回到数据的中心化上，从而也丧失了第三方所带来的创新。

我的合作伙伴Chris已经写了一篇关于加密代币可以如何可持续的，构建开放的网络更好的引导激励的文章。

这就是区块链的大型机 era。存在着由于组合所带来的无可争议的早期的网络效应-安全性，用户基础，数据，运行环境-但随着更多的应用，开始达到大型机的资源限制，最终让边际效应递减。反过来，增加了每个用户和开发人员的成本。通过下图大家可以看一下：

由于资源限制，每个用户的成本逐渐提升，并最终超过组合（共享资源和开发者的网络效应）所带来的好处

服务器 era

为了寻求可扩展性，一些开发者越过了可组合性和共享所带来的网络效应，而是回归到特定应用的架构。Polkadot和Cosmos的项目愿景是这些尝试中的一部分，异构链-每一个都需进行个性化的调整来接入网络从而代表其自身。Polkadot的Substrate和Cosmos的SDK都是模块化的区块链构建包来创建你自己的全栈“xx链”。

基于一个底层包来全栈开发一个应用的工作量，比基于现有的网络资源开发大得多。对于开发者来说，这意味着从状态机到应用接口都需要开发，搭建一个在这个网络上的最小安全（Minimun viable Security）网络，从而实现与网络中的其它人互操作。

从历史上来说，全栈的策略已经证明在推动未来并将早期技术推向市场方面取得了成功。Wang Technologies在PC应用来临前的早期，提供了集成软硬件的文字处理解决方案。此后，AOL捆绑了ISP，一个内容分发系统，邮件以及即时消息-在网络建设的早期提供了良好的用户体验。RIM则将移动设备，操作系统和早期应用程序（如BBM和推送电子邮件）捆绑在一起，以促进智能手机的采用。

全栈平台，推动未来

在网络时代的早期，每个网站都有一个自建的服务器。为了保证端到端的体验，开发者也需要掌控基础设施。在区块链的下一阶段，也许会类似。这就是我所称为的服务器 era。

服务器 era的区块链牺牲组合性来换取控制。控制体现在两个方面：对终端的用户体验的控制，以及更多的对网络资源成本的精细化控制。服务器 era架构的一个前提假设是，网络资源，比如实现安全，存储，及计算是受限的。也就是说，随着应用被更多人采用，网络可以扩容。这与大型机 era形成对比，其资源成本随着网络中其它流量的变化而变化(译者注：比如加密猫让以太坊网络崩溃)。理论上来说，全栈的服务器 era架构可以减轻大型机 era的风险。

服务器 era区块链与其前辈不同的是，它仍然是区块链。前面所提到的Wang，AOL以及RIM都是封闭的平台，服务器 era的区块链可验证，公开的数据结构，可对激励编程。这些特质允许它们可以组合进hub（这正是Cosmos和Polkadot正在做的）。一个区块链可以是另一个区块链的轻客户端，开发者可以构建一个原子交换（Atomic swap）或者扩展其功能。

这意味着，即使是服务器 era的区块链仍旧是可组合的，但与大型机 era不同，是从一个完全不同的层面。这些区块链计算机需要一种全新的交互标准协议，以允许跨应用的相互组合，没法采用大型机 era由于大家都在同一个虚拟机上，所实现的方式。这些交互接口正是当前研究中和标准化的内容，无疑在组合性方面，会增加开发的复杂性。但除了这个缺点外，捆绑的好处可能会成为新一波区块链架构的催化剂，我认为在最近，我们会看到更多的项目开始讨论这种全栈的方式。

云 era

云 era意味着采用一种可扩展的，通用的无需信任的计算（trustless computation）的基础层。这是理想的未来，可组合性仅受限于创造性，没有扩容与交互的复杂性，创意间可以组合而不会带来边际收益的下降。

如何实现这一切正在研究中。服务器 era架构的支持者认为，通过将异构区块链的链内通信抽象并标准化，最终能达到云 era的体验。其它的，比如以太坊2.0（Serenity）和Dfinity正在对同质的，图灵完备的链融合为支持分片的版本。你可以把它想像为许多的大型机，它们共享安全，但在许多同质的虚拟机上分离状态和计算。还有一些其它的正在研究全新的架构，以将计算移到链下进行。

基于这个领域的研究者的数量，以及解决方案所获得的潜在奖励，如果“云 era”区块链计算在所谓的“服务器 era”的尾巴上炙手可热，我也不会感到惊讶。我们已经部好线缆和数据中心-云 era区块链计算更多的是软件层面的创新。当我们实现时，很明显，无需信任的组合将会成为开发者的超级力量，一旦开发者可以通过简单的工作来达成更大的事时，我们将会受益于更容易的合作，创造性，以及互联网上的选择性。计算器 era

正如我们前面介绍过的，Plasma的核心是构建一个方法来实现可扩展的计算，我们需要应对围绕区块扣留攻击的相关问题生成欺诈证明，同时也包括区块空间可用性。在Plasma中的区块扣留攻击的解决方案是构建一个系统，它能在发生链停止或者Plasma区块扣留时，大家可以进行批量退出（mass exit）。

然而，链上的批量退出（mass exit）成本高昂，特别是当UTXO集合非常大时，位图必须发布到链上。额外的，也许我们只期望发布单个退出（single exit）。批量取款（mass withdrawal）交易需要一个复杂的涉及许多参与者的交互游戏。它只应该被用来做最后的保障。

取而代之的是，我们成立了一个等级参差的法院体系，在这些体系中存在某个特定的场所能证明某个状态。大家可以把根链视为最高法院，所有下级法院从这里得到权力。根链的法律允许所有下级法院获得司法权。这将允许管辖地的扩展，当且仅当下层法院的状态被质疑或暂停了，那么向高一级的法院申请更具代表性的管辖权。广播级别更高的法院的证明总是可行的，但也意味着成本更高昂。

所有的状态都将梅克尔化，并提交到根链。在最乐观的情况下，区块头会直接发布在父链上，父链也会发布到它的父链上，如此往复直到根链。区块头内信息是对在父链中看到过这个区块的一个梅克尔化的承诺。

交易可以提交到Plasma链，或者任何父Plasma链，也包括根链（root blockchain）。这样的目的是为了保证可互换性和防止中心化。具体而言，当发生停止或不披露区块状态时，人们仍可以提取资金。

当对一个区块的承诺提交后，要完成通过，需要等待主链可见的一定数量的确认。在这个时间，欺诈证明可以提交到根链或者任何的中间Plasma链（他们最终通过区块头提交到根链）。

每一个独立Plasma链都会运行一个状态机，会将承诺打包进Plasma区块。独立的Plasma也许会或者不会深入到子Plasma链的详情中。相反，他们会运行一个确认，确认Plasma链价值的余额。当子Plasma链更新了状态，他们会提交他的Plasma区块头的哈希串给他的父Plasma链或者根链。

这也意味着，某个特定的区块状态可以提交到多个父链。当发生重复时，这也许不是错误（但也会根据具体应用的某些特定共识而受到惩罚）。另一方面，如果存在不一致的状态，比如，提交到父链1和父链2的状态不同，那么父链中的押金会被没收。

一个新的子链状态更新可以使用下述字段，并包括在他们的状态更新消息中：要支付的费用（和面额），提交到的根链区块哈希，前一个区块哈希，提交到的父链的区块哈希，存款证明，取款证明。

无论向哪个父链提交，我们都假设子链已校验他提交到点前的所有数据，包括递归的校验所有的父节点。这将提交一个证明，证明不是不一致的数据或者双花的交易（因此如果发生不一致，将会没收押金）。

当发生不一致时，父链的状态始终优先考虑。我们创建了激励，激励任何方都可以披露不一致。

存款和取款可以在父链和根链上进行。

取款也可以在Plasma链间进行，以提供充足的流动性，来让其它方可将资金带到任何其它的地方。这将通过跨链的原子交换（crosschain atomic swap）来实现。

如果某人希望通过主链来进行清算，可以通过在链间构建HTLC来实现，这有点类似链上的闪电支付。

所有的欺诈证明必须提供一个链承诺的梅克尔证明。证明为错误时，将会惩罚特定的Plasma链，因为他们对错误的块负有责任。

主要的设计负责复杂度来自，为保证去中心化，实现交易状态向多个父链广播时，交易状态如何表达的问题。早期的版本假设状态转换/交易仅能在某个Plasma链中执行，与其它链的交互仅仅是提交信息到父链/子链来存取款。这种情况下，复杂度就主要是存取款相关的证明。

数据的提交作为证明的一部分被包含进来。

6.1 链内接收资金

在这个链中链的分层框架中，当一个人从其它人那里接收资金时，流程如下。比如，Alice想给Bob，在一个三级深的Plasma链中发送资金。

1. Alice与Bob协商一致，她想向Bob发送资金。Alice向Bob公开，公开Bob将要接收资金的Plasma链。Bob决定什么时候接受支付，具体来说，Bob需要保证，在根链上的智能合约是他将接收支付的那条链（智能合约代码/机制，也包括可接受的共识退出（exit）延迟等）。
2. 如果当前的支付是为了购买某种商品，可以预签名一个声明来定义支付的条件，在很多情况下，如果足够成熟，可以实现为包含在区块中的支付证明，然而在某些环境下，也可以实现为一个合约支付哈希（pay-to-contract-hash）。这不是链上的操作，仅仅是附加解决问题的条款以向其它人证明。
3. Alice在Plasma链中进行支付。这个区块被验证人签名，并且对区块头的承诺发布到他的父区块中。对子Plasma的梅克尔化的承诺被包含进了它的每一个父链中（译者注：多级的父链都包括），最终被包含进根链。
4. Bob完整同步根链，然后校验要接收资金的链，以及这个链相关的父链。Bob没有必要校验与当前资金无关的链。Bob可以在最差情况下，比较成熟的保证在Plasma链中能校验Alice是否进行了支付。然而，如果期望得到快速的确定（finality）性。Alice可以提前签名会在新块完成支付（详见前面在Plasma链中接收支付的说明）。如果Alice将要对支付签名（sign off），同时Bob接受了（如果他能证明取款（withdraw）），那么我们将假设达到了确定性。Bob可以从Plasma链中取款了。

这个设计的关键点在于，其中的参与者需要对子区块链的校验负责。如果Bob没有能力校验Plasma链和链对应的所有父节点（最终周期性提交到根链的也被验证了），那么这一切将不能认为已完成。与闪电网络中的构建方式类似，Bob可以不关心在其它Plasma链中发生的事情。他仅仅关注与他有关的链就好了。当他能使用币时，那么他就确信能花掉他们了。

6.2 从父链中接收资金

从父链中接收资金与从父链中取款类似，区别在于，接收者需要校验所有的父Plasma链（而不是仅仅校验Plasma链）。向子Plasma链中速度非常快。

6.3 从一个树到网

因为上面的描述的是单一的父链，Plasma链可以监听多个根链。这将允许大家更新子链的余额。必须要小心的是，某一个父链的失败可能不会马上被所有链识别，可以通过时延和减少跨链流动性的假设，来减轻级联系统失败。合适的构建方式当前正在讨论中。

6.4 减轻区块扣留的问题

通过构建某人可以广播单个取款交易到多个场所（venues），将会存在要从多个暂停或发生区块扣留的链退出的场景。如果子链失败，于是可以在主链上执行一个简单的退出，即便交易在主链上较为昂贵。

这使得人们持有Plasma的输出也能具有一定的可信度，前提是他们能确定至少一个父Plasma链运行正常。目标是解决这其中的主要问题，同时减少级联失败的影响。

如果某人持有非常大的输出余额，如果对时间没有很强的要求，不用做特别的承保，然而，如果某人有单一的低价值的输出（当支付交易费变得越来越贵时），它需要有某种方式的确保其中的一个父链是可用的。如果某人希望一个更大的保证，它可以运行一个嵌入链，深度的与许多独立的在不同层级的Plasma链结合。尽管如此，其中仍有一些权衡，比如其中某个Plasma链出现Byzantine问题，那么每个链都需要向新链批量取款（mass-withdraw）。如果其中有一个父链不是byzantine的，当然，如果父链拒绝执行Byzantine链的提交，那么也可能继续运行并快速向另一条链转移。

也可能出现一些服务，仅仅在发生子链失败时运行。服务的运行者不需要做任何事，除非子链失败（服务本身可以极为被动，我们甚至可以在故障发生时才开启服务，服务会自动跳过在这个被动服务的上一层链中广播的区块）。

我们期望父链中的取款尽量是简单取款而不是批量取款（mass withdraw），因为父链可能有非常高的交易量（区块大小/gas限制）。

6.5 退出

父链或根链的批量退出（mass exit）是可能的。如果子链出现Byzantine，我们可以假设所有的状态都将是不可用的，与一个没有嵌套父链的Plasma链类似。同样的，批量退出（mass exit）是一种快速的从一个Byzantine父链中退出的方式。可以跳过父链（或子链本身）到它的父链或直接根链。

也许看起来设计中有一定的复杂性，假设如果有任何链出现Byzantine问题，其所有子链必须有所行动。存在一种优化方式通过心跳让退出在不需要协调一致的情况下进行（退出是默认没有签名情况下，而在用户的一方撤销它，并且Plasma链本身作出它已经接收到的承诺，但可能是不成熟的优化）。

构建基本上与简单退出或者批量退出一样，然而有一些小的在设计上的改变来支持嵌套链。退出允许重复，但父链中的退出有优先权。如果父链出现Byzantine问题，退出也可以提交到父链。（被认为发生Byzantine的Plasma链）的责任来反映并更新其父/根链中的重复退出的状态，并撤销自身链中的重复退出。然而，如果它不能这样做，用户的资金将在根链中可用。

如果父链发生Byzantine问题，但子链中持有的资金工作正常，可能能避免进行一个复杂的批量退出交易。参与者找一个新的接收资金的链来进行一个简单退出，其中流动性服务商在子链中接收资金，然后其它用户在新链中接收资金（不需要Byzantine父链的参与）。子链区块的提交被广播到了父链或更高一级的父链中（从而避免了Byzantine的节点）。用户将很快在新链中获得资金，流动性提供者则从根链或更高一级父链中退出资金。这一切的目的是新资金可以快速的分配到新链，且可以进行快速退出。

6.6 可扩展性

这将允许UTXO位图的可扩展性，当位图（bitmap）变得越来越大时，人们可以将位图（bitmap）拆分到多个子链。对于子链，假设它们通过区块高度的随机数（候选链提示）来表示账户余额来替代一般的输出。类似的，对于倾向使用账户而不是UTXO的情况下，也可以提供只支持简单取款做为一个折衷。

最后的结果是用户获得了最大程度的可扩展性。他们只需要关注他们资金所在Plasma链（以及其父链）。有效地将数据集分解为影响自身的验证。

7 Plasma Pos

我们提议了一个简单的Pos构建。这不太会成为可选的pos构建，然而可以来说明在Plasma链中可能是什么样的。

直到当前，我们假设Plasma链的运营者是单个实体，职责是签名区块。如果创建了一个无效的区块，任何其它有区块数据的都可以生成一个欺诈证明，回滚区块并惩罚运行者。证明是可能的，因为运营者通过签名者签名了这个区块。在根链中发布Plasma区块的梅克尔提交（因为最高的父Plasma区块包含了子链状态更新的提交），由此状态更新是有序的，且绑定到正确的状态行为中。

然而，在许多情况下，构建一个Pos链而不是单参与方的POA链，多方参与是更期望的情况。这将减少关于区块扣留的风险（通过将一个链条嵌入一个单一方的POA以及开放的多方的POS链，可以实现两全其美）。一个代币化Pos链也将激励代币持有者来保证链的正常运行，因为代币的价值与Byzantine的行为有关。更加详细的关于代币化的价值在后面的章节中会介绍。

在Plasma中构建Pos相对比较容易，因为他依赖于底层的根链的健壮性。关于区块扣留，确定性以及其它的关键点都被推向了根链。Plasma在最佳情况下与根链的安全性一致。如果根链是基于工作量证明机制的，那么将会是一个基于POW的POS（在根链的上的POS）。如果根链是POS的，那么就将构建一个基于POS的POS。然而Plasma链上的POS机制将比根链上的POS简单，或者不太一样。

7.1 Nakamoto共识激励

我们尝试复制Nakamoto共识（工作量证明机制）的主要激励机制。其中最重要要复制的激励是，鼓励从一个矿工到其它矿工的区块传播。

许多现存的POS提案依赖于主节点的选取，t0我们选择了某个为主节点，并在t1，这个主节点有权限来生成区块。这并没能复制Nakmoto的围绕区块传播的共识。Nakamoto共识确实也做了主节点的选取，但是它是做的一个概率性的主节点选取。如果一方发现了一个区块，它相信它也许会成为主节点，但是他仍不太确信。其它人也有可能在同时也挖出了这个区块。最好的提升成为领导节点的可能性是，尽快广播这个区块，越快，越远越好，来让其它人基于这个区块构建。这创建了信息可用性（infomation availability）的激励。

Plasma的POS构建需要做一些类似的事。

我们希望鼓励每个人尽可能远，尽可能广的传播区块，并从中取得平衡。这其中也许有其它的构建方式（具体来说，构建依赖于随机选择和概率性的主节点选择，通过为每个分支随机分配分数，并最终取最高分值的分支）。

7.2 简单的POS模型的例子

因为这是一个简单的构建POS模型的提案，它看起来在各方面都不及预期。目标是构建一个简单的，Plasma可以使用的东西。与创建强制执行的机制不同，这里的办法是简单的创建对正确协作和正确行为的激励（目的是实现区块传播）。

奖励（译者注：原文为fee）由根合约分配，如果一切如常的话，并周期性的分派出去，这个会计工作在链自身内完成。

作为权益（staking）合约的一部分，权益所有者（stakers）的资金分配并指向一个代理的权益者（staker）。代理者有责任代表用户，如果出现错误，也将代为受罚。权益（staking）被承诺为某个特定的时间（如，3个月）。每个staker的最低限额是所有代币的百分之一，最高限额为5%。如果某人想分配超过5%，那么他可以使用多个权益身份（目的是为了最大化数据的分发并减少低于51%cartels的效率）。

资金的分派取决于过去100个Plasma区块能否代表所有参与者。如果某人占3%的权益，那么那他应该占100个块中的3%。如果高于这个量，这个权益者将不会因为发布额外的区块来得到更多的奖励。如果在过去的100个块中，它的块数低于3%，那么当前的区块创建者也将得到更少的奖励。在根链上每个区块只能分派一个Plasma区块。

这将鼓励所有参与者平等的协调并包含每个人的区块。假定人们不再需要建立强制执行机制，参与者将会协调并使用某些类型的模式（比如，轮询）来保证最大程度的奖励。

如果他们因为不恰当的区块数量而没有得到最大化的交易费，资金会进行一个池中，以对未来的区块进行支付。

结果将是一种经济激励，每个人必须尽量包含其它参与者。

然而，还没有完成，因为前面我们只鼓励了权益者间的准确参与。在每一个区块中都是来自过去100个块的随机部分数据的梅克尔化的承诺。这将强制权益者拥有完整的区块数据并强制性的让区块创建者向其它权益者传播区块。

链的头是由最大的奖励来决定的，如果有平行的分支，那么从协调中获得了最大的奖励费的将会是最终的获胜者（译者注：这里就是在做激励的协调，也许游戏是一个设计得最好的激励系统）。

这个构建不是设计来阻止51%攻击，而是来鼓励区块传播（因为如果某人提交到扣留区块，给所有人带来的威胁都是一样的）。另外，这个构建依赖于主链上包含块的信息可用性和公正性；在主链上构建这样的Pos是不太可能的，因为这一切都基于数据可用性和中心化的激励。

8 经济激励

在POS的验证模型里，可以构建与合约条款中约定的正确行为相一致的激励。尽管信用押金保证了链的精确性，我们需要创建后续关于数据可用性，阻止区块链停止的激励。通过仅允许使用每个Plasma链特定的代币，可能保证能激励人们持续运行这个链，因为代币的价值来源于所有未来收益的净现值贴现。因此，网络故障将减少所持有代币的价值，同时其中的个人有很大的动机为网络的持续运营带来最佳利益。

Plasma链的运行者通过广播交易到链上而获得手续费（fees）。计算可能根据不同的操作收取不同的费用，费用可能会一级级向下收取，特别是对于复杂操作时。因为存在激励让更多的交易在尽可能深的子链中执行，可以在子链中创建资金已发送的承诺，或者计算，并将一步步向上传播。并将允许父链对子链中进行的计算收费，如果存在一个不正确的承诺，区块数据将不可用且不可达。这并不是必须的，在许多的情况下，人们更希望在子链中进行更多的计算，而不一定需要将费用分配到根链。

对于系统升级，可以通过创建另一个接收同样代币的合约，并公告一个过渡期（或在分布式社区共同来决定）来解决。

这也许会创建一个自行运行的系统。相比于大家需要在云计算中通过网站做存储和计算，来实现支付和运行服务，现在可能通过构建一系列的智能合约（与欺诈证明一起），一个代币，有足够的参与者来支付费用，那么这个系统，可以由一小部分权益所有者通过持续的运行网络和计算等基础设施，而推动其自我运行，从而真正意义上的实现了云上的计算。

8.1 代币 vs. 币和经济安全

根链上的欺诈证明和最终持有的押金可以是原生代币，比如，以太坊网的ether（ETH），或者也可以是其它的维持底层区块链共识的代币。

使用根区块链的原生代币（例如ETH）表面上看起来最为简单，但是有一些有趣的经济安全影响。

如果我们的目标是阻止链停止和错误的行为，因为依赖于区块链的应用，如果只使用ETH，我们也许不会有足够的激励来阻止错误的行为。如果链停止或发生Byzantine，代币的价值将会下降。另外，代币价值应该接近于未来交易费的净现值贴现，这才应该是代币的价值体现。如果一个人以ETH做为权益押金，那么他就是在赌押金对应的时间价值（time-value）与收到的费用。应该来说，押金的价值应该远远低于代币的净折现值。另外，链停止和区块扣留证明起来比较困难，如果某人使用ETH做为押金，在过了押金期间后，取回了ETH，这将没有足够的驱动来应对Byzantine行为，因为代币应该因为Byzantine行为，价值应该下降。

9 区块链的MapReduce

几乎所有在MapReduce中可计算的都可以在区块链上计算。这需要我们重构我们在区块链上实现计算和编程的思考方式。一个有欺诈证明（fraud proof）的MapReduce。每一个节点代表一个区块链。这与在之前章节中介绍的Plasma链的树形结构高度匹配。

比如，如果想进行一个标准的词数统计，你可以创建一个运行reduce函数的区块链的梅克尔树。如果此时出现了欺诈证明，那犯错的节点将被惩罚。如果你能产生一个求和的reduce函数，你也可以产生一个平均值函数。例如，平均价格等等。Map函数则将计算发送到各个链，然后提交结果。显然，在数据吞吐量方面仍然存在限制，这也是reduce的欺诈证明存在的必要性。任意类型的任意计算是不可能的，但可以解决许多特定类型的问题；通常来说内存受限的问题集，可以通过一开始运行一个排序算法来解决，这也是Plasma的链内流量较大的折衷方案。

如果节点不能生产实际的区块来证明计算，那么他们的结果将被丢弃和回滚（译者注：因为区块必有欺诈证明，假计算真区块将受惩罚）。需要注意的是，这并不能保证MapReduce所实现的计算扩容（由于，你需要观察链来维持共识），然而，它确实让活动强制执行且扩展了actors的能力。因此，主要的限制是围绕这样一个现实，受某个计算影响的各方应该关注这个计算集合。如果只需要关注一小部分，那么也很好，但如果需要关注所有的计算，那么它没有提供扩展的好处（仅在可扩展性的保证方面带来了一些好处）。也就是说，许多问题，可以这样解决，比如，去中心化的交易所（如果所有其它人的交易是正常的，你并不用关心他们的细节，只关心映射的集合中自己的交易）等。

区块的格式必须与TrueBit构建的可计算数据相兼容。有对状态的承诺（可以构建UTXO/状态前缀树，来允许对包含/未包含的状态转换的证明），账户前缀树（子链和复杂的状态转换），对费用的承诺（关于状态转换的费用树），梅克尔交易，从父/子区块传过来的数据，见过父/子区块的承诺（阻止重排序），以及其它一些业务逻辑（如，词数统计的例子中，将具有针对单词以及它被看到的地方的排序的承诺）。通过构建梅克尔承诺，可以在根或父链创建智能合约，可以用来证明不正确的状态转换。也许存在一些问题集与这个格式不匹配，但常规的不需要太多内存计算的都是可能的。关于内存的限制，你可以这么想，把对计算所需要的最大内存限制等同于在欺诈证明中所允许的最大的数据量限制。

一系列的map和reduce函数允许区块链按照处理数据的义务来运行。这需要父和子来创建执行的义务。子链需要包含父链传过来的数据，否则链将停止。父可以强制在子链中的计算，如果子链停止了，强制计算可以通过在父链广播数据来证明这个证据。在TrueBit的构建中主要的威胁在于围绕区块链停止的相关问题，因此如果子链停止了，需要关注构建是否允许持续性的运行，尽管这非常复杂，特别是随着时间的推移（数据集可能改变，并且具有时间一致性更难以推断某些问题）。

通过和子链一起在一个mapReduce的框架中构建区块链计算，这可能将现有的计算机科学研究直接应用于区块链的分布式系统的问题集中。可能能构建一个solidity合约来产生许多有效的可扩展的商业应用。其中只需要计算和验证与自己有关的活动。

10 应用的例子

去中心化的应用可以解构为一个mapReduce问题，并通过绑定代币以经济驱动的方式来保证正确的行为。

10.1 区块链上的Reddit克隆

首先是区块链上的数据存储（CRUD）。主要的计算和证明是围绕访问控制，身份（投票和文章）以及评论。许多的web应用在后端都只有CRUD操作。

根区块链包含智能合约共识规则和欺诈证明。最顶层的父链包含subreddits账户。每一个subreddit是父链的一个子Plasma区块链。每一个subreddit是一个Plasma的文章链。文章链的子链还包含评论。共识机制强制要求访问控制。对前一个块数据的承诺随机化（由父链提供的随机数）并提交到每一个区块的头中。一个reduce函数会周期性的运行以计算最佳文章以及其它的数据。

个人用户的电脑下载数据和软件到本地计算机来格式化数据。提交数据需要支付交易费来激励对数据的包含，也许需要因为依赖于可用性而支付费用来下载老的区块数据。

如果查看一个特定的文章，用户校验根链上的提交数据，然后来到最顶层的父节点的头部（返回n个块来到确定期（finality），也许一个星期），在账户状态前缀树中找到关联的subreddit。连接到一个DHT网络来发现subreddit上的节点，下载subreddit的链头（检查最近的n个区块）来查看文章列表，在一个轻节点上下载状态树和文章及其所带的评论的原始数据。用户仅仅需要关注Plasma上与自己有关的那一部分（下载文章和与自己有关的subreddit）。

这是一个简单的在区块链上带一些计算的数据存储的例子。验证者可能完整的校验所有的节点，然而，也有可能将之分解出来。但是一旦分片太过，就会出现信息可用性的问题。一种解决办法是把子链的控制权完整的交给subreddit的所有者。

10.2 去中心化的交易所

上述reddit克隆，虽然已实现了对web应用的CRUD影响，除站点统计信息外，并没有显著利用MapReduce操作。

去中心化的交易所例子将会演示在高计算容量下也能有低延迟。因为存在许多的状态，所以输出将会定义为账户模型而不是UTXO，或者状态机里的每一步，都会有一个更大的位图（bitmap）来代表每个状态而不再使用单个布尔值来代表位图中某个位的花费状态。

与subreddit类似，交易对会由一个子链树来表示。每一个子链树中又是一个树链，来最大化扩展性（低交易量的交易对也许只有一个Plasma树，高活跃度的交易对链也许有非常多的子链）。每一个链都有押金行为（bonded activity），每轮可以交易的数量由绑定的数量（bonded amount）来限制。

第一步是在子链中有余额，如此一来，这就首先像一个带支付的Plasma链。

接下来，订单会发布到子链上。作为对父链提交数据的一部分，所有的订单将被聚合成单一订单簿（order book）的梅克尔提交，被表示为那个链的一个订单。递归的将所有子链的订单簿（order book）reduce为那个链的一个订单簿（order book），直到到了父Plasma链。接收到订单后，订单的窗口将关闭，订单将批量的执行。

reduce步骤结束后，将会提交到根区块链上，通过一个map的步骤，每个链将会得知他们的分配量。父链会告诉子链他们确定的订单完成（filled）量是怎么样的。这让子链可以看见其它的订单（这也意味着在这个步骤中也可以观察父链），他们将可以证明在map步骤中有正确执行的分配。在接收到分配后，map步骤持续递归执行到所有子链。

当这一步执行时，最终的reduce步骤将是提交所有资金更新到根链，提交所有的区块头（header）到他们各自的父节点。

未来的一个优化点是，在发生显著价值变化时，允许多轮MapReduce的执行（支持价格的高精准度），然而这种结构将会使得量级非常大。理论上能在这个框架上执行这个世界上所有的交易行为（只是有一些速度上的折衷），通过将它变为一个批量执行的交易所，完整的提交并绑定到根区块链上。

这种类型的构建对于许多类型的金融活动和计算都是有用的。

10.3 去中心化的邮件

要创建D-Mail，可以在Plasma链中表示一个账户，需要支付来接收邮件（往链上插入信息）。提交由那个人的公钥（public key）签名的数据。强制的保证未知的一方必须支付，未来的优化点是使用zk-SNARKS。父链包含一个链的目录来强制支付。简单的设计。

10.4 去中化的CDN

存在去中化心的CDN。与以太坊的分片提案类似的构建。把每一个子区块链看作一个分片。存在一个随机信标（可以是根区块哈希或者其它）。在每n个区块的分片间混淆数据。父链有责任来提交混淆的数据。其它的也许会懒惰的保持着归档数据。数据丢失会通知，那些保持归档的将会被奖励。鼓励传播，因为只有其它分片有数据才会得到奖励。健壮性依赖于流长度的需求；越健壮，在某个时间点越需要多的分片拷贝。关键点是，存储是带宽的功能。数据不被视为磁盘上的固定数据。 所有数据实际上都在流动并移动到下一个目的地; 非常道教的做法。

下载数据时，验证父链的分片和随机信标来知道哪个分片有数据，通过DHT认证的节点连接到他并下载数据。

10.5 私有链

参与者没有义务向链上的其它人披露数据（尽管没有什么能阻止他公开），因此如果链上的参与者想要拥有一些由根链强制执行的私有区块链网络，他们可以这样做。这与internet/intranet的分离类似。交易可以发生于本地的私链，但也可以通信与公链有经济行为的绑定。

攻击，风险和消除的方案

11.1 智能合约代码

写好智能合约代码是非常难的。安全依赖于正确执行的欺诈证明。可能有些欺诈证明应该包含但没能包含，导致不正确的状态转换会在根链上生效。

11.2 主链上关闭交易将会非常贵

存在能在主链上关闭交易的风险，但不一定有执行的经济性（没有经济动力去这样做）。这也许会导致某些特定类型的欺诈，比如，通过将非常大量的小额交易凑成一个大额而引起损失。

这可以通过设置退出条款来解决，通过退出条款对所有交易进行分类，并设置一个调解期，允许调解期满后立即退出整个链。此外，允许第三方观察者来监督某些人的行为。然而，这个构建将显著增加复杂性。这些预签名的合并交易会传播到它的父网络，传播到的父网络取决于链的可用状态，或者最终传播到根网络。然而，这也取决于所谓的各方的正确的行为，这也是为什么需要每个个体应该合并所有的未花费支付（unspent payments）为单个输出（output）或者输出集合（set of outputs），通过这样，退出交易才更具经济可行性。

此外，可以把小额支付放到链上，并通过高价值的代币作为押金，并搭载该价值（因为有足够的抑制来完全的杀死Plasma链）。

如果通用的递归SNARKs/STARKs变得可行了，在理论上能保证取款的实体不会有权限来做未授权的退出，即使是在发生区块扣留的区块上。

11.3 确定性（Finality）

退出（exit）的调整窗口期根本上创建了一个确定（finality）的假设。如果底层链有非常大的押金成本来重组，并强制达到确定，那么它可以显著降低深链重组（deep chain rorg）的风险，从而引起链之间的同步问题。计划中的以太坊CAPSER确定性工具是一个解决方案的例子。

11.4 根链缺乏容量以及提升成本

如果没有缓解措施，在手续费或者gas变得越来越贵时，在一个指定的周期内退出交易变得不太可能。如，交易费/gas增加50倍或者当前没有足够的空间来退出交易，同时矿工也不再提高空间和gas限制。

通过暂停允许有序退出的退出计数机制，来延长退出延迟，有几种缓解措施。这可以通过暂停退出来完成，只要过去的x块中包含了某个人的交易就暂停。这样，如果最近都能有至少一个交易，这将允许每个人都能有出去的机会。如果一个退出发生于某个退出之前，那么计数器将会重置。其结果是，无法确定在收回资金之前必须等多久，这将会增加流动性提供者的（liquidity provider）手续费率。如果平均区块链gas/手续费在某个特定的非常高的值上，一个简单的机制是暂停对取款时间的限制（设置一些合理的上限时间，在这个时间内可以保持这个暂停状态）。

持有资金的用户需要保持至少一个父链有一定程度的数据可用性（理想情况下是多个独立的父链）。

11.5 根链的中心化

这个设计假设超过51%的根链节点是诚实的。如果根链的参与者联合起来通过中心化区块来攻击网络，那么会引起退出交易的强制性，状态更新，严重的丢失资金等问题。中心化是安全、价值风险和确定（finality）的主要因素，需要在未来的链中进行限制。

这可以通过增加zk-SNARKs/zk-SNARKs的资金证明来解决，但需要在这块工程和研究投入。

每个退出交易使用一个大额的押金的欺诈证明方式，因为矿工可以得到欺诈证明奖励，通过这样，中心化可以显著的被抑制。

为网络提供安全的是父Plasma链的诚信和正确性，根链和余额大小的一个函数。

关于全局范围内传输量的系统性限制（每个区块的退出[exit]速度限制），保证传输量低于确定性小工具（finality gadget）可能是一个解决方案。

11.6 链停止

如果链停止了，在某个设定的时间周期后，可以有一个预提交的状态转换申请（offer）。响应的区块链可以接手这个链的所有交易，然后广播对这个链的接受（accept）以及整个链的移动。仅仅允许在某个设定的时间周期后，这个链还没有向前移动时才发生（忽略广播到父链上的交易）。欺诈证明可用于调解链头（chain tip）。

对于涉及复杂的状态转换的金融活动，对于链停止的情况，可能还需要其它形式的激励。

11.7 不能改变共识规则

由于设计是前置式的，因此不可能在没有提前编程的情况下改变共识规则。可以通过将升级路径做为系统的一部分来解决这个问题（如，在某个特定的日期后强制停止）。这种无能（inability）也将带来关于不能停止区块链的社会影响，因为，对于代币持有者来说，有经济上的驱动来持续的运行这个系统。由此，在Plasma链启动后，停止它将变得非常困难。

12 未来的研究

未来研究的其它领域包括围绕安全的好处。当前研究的领域是通用递归SNARKs/STARKs，将会显著提升退出（exit）交易的安全性。深度的防御是可取的，由此防御的最后一条底线将是直接的去中心化退出机制，支持调解证明（disputed proof），前线则是新型的加密技术和安全硬件元素。配对密码术或其他形式的同态加密，在密码学上的新用途的进一步发展也将是有用的。

在保持同步的同时，观察多个根链的能力需要更高的特异性（除了简单地强制硬同步之外）。

未来的研究围绕确定性（finality）以及跨多个区块链的互动，也包括进一步的减少区块链退出的风险（SNARKs/STARKs也将起到一些作用）。

13 结论和总结

Plasma的设计主要关注的是在数据压缩的情况下保证信息的可用性（提供关于区块扣留攻击的信息）。

我们提出了一个机制，通过它，可以提交可强制执行的承诺，从而允许在链上持有资金，资金的状态由根链进行最终保证。

这允许通过宽广的无定形网络计算机进行计算和存储。网络中的行为，通过经济因素来保证承诺的强制执行，强制执行由其所有父链，最终流向根链，并通过根链上的智能合约来保证了正确性。这个构建允许进行状态转换而不用担心在根链上直接运行的成本。

区块链上的这个构建几乎可以执行全球范围内的经济活动计算（只要同一时间不需要占用过多的内存）。仅且当无效的计算证明被提交后，无效的承诺才会被回滚。不需要对链的运行者给予信任。

为了减少链停止、以及其它Byzantine行为的动机，手续费激励了链的持续运行。如果Plasma链的行为绑定了特定的代币，链停止是不被鼓励的。因为，如果链发生了停止，那么链的价值会下降，将会对能否持续运行产生显著影响（译者注：让大家对这个链失去了信心，则代币不值钱，从而不愿意运行链）。

这个激励和结构允许创建去中心化的自动程序，通过交易费来支持程序的自动运行。这样的去中化自动程序可以创建真正意义上的云计算，执行计算和验证数据，但其中提供服务的节点是随时变化和异构的。Plasma可以允许区块链扩容到支持不限用户量的通用应用。一个应用的创建者可以只写智能合约代码，提交到区块链上，然后通过激励，永久的运行这些合约中的计算，使用Plasma链来支付费用。

14 致谢

Many thanks go out to the TrueBit authors for a design and implementation of merkleized proofs, including Chrstian Reitwießner for review. Thanks to Vlad Zamfir for many areas of inspiration and his general framing of ideas helpful in formalizing these ideas. Thanks to Thomas Greco, Piotr Dobaczewski and Pawe l Peregud for feedback and contributions.
TODO: Ask others for acknowledgements.
TODO: Improve bibliography and get more citations TODO: Finish diagrams

References
[1] Joseph Poon and Tadge Dryja. Lightning Network. https://lightning.network/ lightning-network-paper.pdf, Mar 2015.
[2] Ethereum. Ethereum. https://ethereum.org.
[3] Gavin Wood. ETHEREUM: A SECURE DECENTRALISED GENERALISED
TRANSACTION LEDGER. http://gavwood.com/paper.pdf, Feb 2015.
[4] Raiden. Raiden Network. https://raiden.network/.
[5] Jeffrey Dean and Sanjay Ghemawat. Mapreduce: Simplified data processing on large clusters. In OSDI, pages 137–150. USENIX Association, 2004.
[6] Satoshi Nakamoto. Bitcoin: A Peer-to-peer Electronic Cash System. https:// bitcoin.org/bitcoin.pdf, Oct 2008.
[7] Nick Szabo. Formalizing and Securing Relationships on Public Networks. http:// szabo.best.vwh.net/formalize.html, Sep 1997.
[8] Fred Erhsam. Blockchain Tokens and the dawn of the De- centralized Business Model. https://blog.coinbase.com/ app-coins-and-the-dawn-of-the-decentralized-business-model-8b8c951e734f.
[9] Naval Ravikant. The Bitcoin Model for Crowdfunding. https://startupboy.com/ 2014/03/09/the-bitcoin-model-for-crowdfunding/.
[10] Jason Teutsch and Christian Reitwiessner. A scalable verification solution for blockchains. https://people.cs.uchicago.edu/~teutsch/papers/truebit.pdf, Mar 2017.
46
[11] Vitalik Buterin. Ethereum Sharding FAQ. https://github.com/ethereum/wiki/ wiki/Sharding-FAQ.
[12] Adam Back, Matt Corallo, Luke Dashjr, Mark Friedenbach, Gregory Maxwell, Andrew Miller, Andrew Poelstra, Jorge Timn, and Pieter Wuille. Enabling Blockchain Inno- vations with Pegged Sidechains. https://blockstream.com/sidechains.pdf, Oct 2014.
[13] Paul Sztorc. Drivechain - The Simple Two Way Peg. http://www.truthcoin.info/ blog/drivechain/.
[14] Bitcoin Wiki. Merged mining specification. https://en.bitcoin.it/wiki/Merged_ mining_specification.
[15] Peter Todd. Tree Chains. https://github.com/petertodd/tree-chains-paper.
[16] Eli Ben-Sasson, Alessandro Chiesa, Eran Tromer, and Mardas Virza. Succinct Non- Interactive Zero Knowledge for a von Neumann Architecture. https://eprint.iacr. org/2013/879.pdf, May 2015.
[17] Alessandro Chiesa, Eran Tromer, and Madars Virza. Cluster Computing in Zero Knowledge. https://eprint.iacr.org/2015/377.pdf, Apr 2015.
[18] Jae Kwon. Cosmos: A Network of Distributed Ledgers. https://github.com/cosmos/ cosmos/blob/master/WHITEPAPER.md, Sep 2016.
[19] Gavin Wood. POLKADOT: VISION FOR A HETEROGENEOUS MULTI-CHAIN FRAMEWORK. https://github.com/w3f/polkadot-white-paper/raw/master/ PolkaDotPaper.pdf, Nov 2016.
[20] Sergio Demian Lerner. lumino transaction compression protocol (ltcp). https: //uploads.strikinglycdn.com/files/9dcb08c5-f5a9-430e-b7ba-6c35550a4e67/ LuminoTransactionCompressionProtocolLTCP.pdf, Feb 2017.
[21] Ilja Gerhardt and Timo Hanke. Homomorphic Payment Addresses and the Pay-to- Contract Protocol. http://arxiv.org/abs/1212.3257, Dec 2012.
[22] Tier Nolan. Re: Alt chains and atomic transfers. https://bitcointalk.org/index. php?topic=193281.msg2224949#msg2224949.

目标是构建一个方式，每个参与者可以使用区块链的原生币或代币，不需要链上的状态。Plasma开始模糊链上和链下的界限（例如，链上或链下的分片?（shards））。

在构建涉及多方的链下通道的努力中，有两个常见问题。第一个问题是，当需要在整个系统中进行一个状态更新时，需要在所有参与方间同步状态变化（或否则失去全局状态实时性做为一种平衡），且要求所有参与方必须在线。第二个问题是添加或者移除参与方需要大量的链上更新，需要所有的参与方的添加与移除。

另一种可选的方案是构建一个机制，多方参与者在不需要主链状态更新的情况下添加或移除节点，内部状态更新也不需要所有参与方，仅当有关余额变更或检测到Byzantine行为时才需要同步状态。

一种常见的构建方式是在子区块链中，允许在根区块链（如，以太坊）的智能合约中，来代表自身余额。子Plasma区块链的最终区块状态由根链的智能合约的余额的代表和分配。这允许大家在子链中持有本地代币，来代表在父区块链中的余额，且允许在争议调解期后取款。

为达到这个目标，我们为账本构建了一个UTXO(Unspent Transaction Output)模型。虽然这不是一个必须的要求，但通过这个推断快速取款变得更容易。UTXO模型的原理，是可以很容易的表达一个状态发生与否。这可以在一个梅克尔证明的树前缀中表示出来，也可通过位图（bitmap）来进一步压缩表示，同时这种数据结构也方便其它人解析。换句话说，根链中的账户持有智能合约，但Plasma链维护了一个，在主链的账户中的余额花费情况的一个UTXO的集合。对于那些没有明显的状态转换需要的子链，可以使用账户模型（account model）来应对更复杂和频繁的状态转换，然而这也将更依赖于父区块链的区块空间可用性。

目前，大家可以推断单个的区块领导者如何选择子Plasma链的区块。我们可以将这个构建为一个Pos集合，或一个命名预置的n/m验证器，然而在下述例子中，我将使用单一的命名验证器来简化说明。验证者的角色是提议一个完成了交易排序的区块。验证者/提议者由父区块链智能合约中构建的欺诈证明所约束。如果传播一个无效状态志换的块，所有其它接收到这个区块的参与者可以提在父区块链中提交一个梅克尔证明，无效的区块将会被回滚并施以削减（奖励？）的惩罚。

区块也会传播给想观察区块的参与方，包括那些持有余额，或者想关注或强制执行单个Plasma链上运算。

维护离线状态的存款只需要最低的复杂度，状态转换和取款将更为复杂。

5.1 欺诈证明(Fraud Proofs)

子链中的所有状态，都通过欺诈证明强制执行，从而允许任何参与方检验无效区块，推断区块数据的可用性。

然而，这个构建方案最大的难点在于，它不会明确保证数据/区块的可用性。

在根链（比如，以太坊）上，当区块数据可用时，存在一个欺诈证明的集合，保证所有的状态转移是有效的。对于复杂的计算，状态转换必须是梅克尔化的，以支持有效率的验证。

另外，状态转换也可以通过zk-SNARKs/STARKs来强制执行，通过它保证了不恰当的退出（exit）是不可能的。一个zk-SNARKs的构建需要递归的SNARKs才能获得最大功效，因此需要进一步的研究可行性。然而，这个系统被设计为不需要SNARKs也可以工作。

图10：每个人都有1-4区块的区块数据。第4个区块的提交的状态转换被证明是欺诈的，通过前一个块的数据和第4个块中的梅克尔证明。

欺诈证明保证了所有的状态转换是有效的。示例的欺诈证明是交易是否可花费的证明（检验在当前的UTXO中资金是否可用），状态转换的证明（包括检查交易签名看输出是否可用，跨区块的包含/排除，存款/取款证明）。一些更复杂的证明需要一个交互的游戏。通常的构建是采用一种函数的方法来进行区块校验。如果大家用程序把这段共识在solidity中实现，用于校验的区块的梅克尔证明的函数方法，将会多一个额外的输入参数，输出将会返回校验是否通过。人们可以简单的复制共识校验代码，以紧凑的梅克尔证明的形式来运行（这样人们不用执行整个块来生成欺诈证明）。

图11：Alice有所有区块的数据，所以在主链上提交了一个欺诈证明。第四个区块从而变得无效并回滚。第4个区块的提交者失去了在智能合约中的押金从而得到了惩罚。当前的区块是区块3（蓝色）。在某些设置的时间以后，区块将确定下来，且不能再提交欺诈证明。人们应该通过完整的校验区块，来在没有被证明是欺诈的区块上建块。

然而，为了构建最小的证明，所有的区块必须提交当前状态的梅克尔前缀树，输出花费（outputs spent）的前缀证明，交易的梅克尔树，以及前一个被修改状态的引用。

欺诈证明保证参与者合谋也不能在不受到惩罚的情况下创建欺诈的块。当欺诈的块被检测到或者在主链上（或者父plasma链）被发现时，无效的块将被回滚。这将鼓励个人参与者有动力来反对Byzantine行为，这将解决在比特币联盟侧链的状态转换漏洞。

结果是高度可扩展的状态转换能够在plasma区块链中进行，同时确保有权访问块数据的观察者（observer）能够证明（并因此阻止）无效状态转换。 换句话说，支付可以发生在这条链上，只需在根链上进行周期性的提交。

5.2 存款（Deposits）

来自主链的存款将直接发送给主合约。合约有责任跟踪当前的提交状态，使用欺诈证明来惩罚无效的提交，以及执行取款（withdrawals）。由于子plasma区块链是一个对主链的完整校验者，提交的交易必须以二阶段锁定（two-phase lock-in）的方式来执行。

存款必须包括目标链的blockhash，从而来指定目标的子链，通过多步流程（multi-step process）来保证代币不可被恢复来达成。

图12：Alice有一个1ETH的账户。她想将之发送到子Plasma链。她将它发送到Plasma合约。

1. 货币或代币（如，ETH或ERC-20代币）发送到主链的Plasma合约。这些币在某些设定的时间是可恢复的，以支持挑战/回复（challenge/response）。
2. Plasma区块链引入了一个即将到来的交易证明（incoming transaction proof）。此时，Plasma链承诺交易即将到来，当由存款者或者发起一个锁定交易（lock-in transaction），或者产生一个花费的事件，前述的余额变得可花费。当上述已经包括，区块链承诺遵守提款请求。然而，目前还没有确认存款人是否有足够的信息来产生欺诈证据，因此存款人尚未作出承诺。这个区块链包括状态树，位图（bitmap），和交易树，以便有一个正常包含的紧凑证明。
3. 存款者在子Plasma链上签名一个交易，激活交易，包括一个承诺，他已经在链提交的第二阶段看到了这个区块。这个阶段的作用是存款人证明他们有足够的信息来提现资金。

在这些流程之后，链承诺会处理这些币，并进行预留，以便取款可以得到证明。在第三阶段中，用户认证了他们可以取款的事实。

图13：Alice现在在Plasma区块链中有1ETH。她承诺他看见了资金且当前被锁定了。资金由主链上的智能合约持有，但账本记录在某个特定的Plasma区块链上（于是，状态转换，比如，发送资金到另一个智能合约）可以在不需要大量的根链的消耗下发生。

如果存款者没有通过第三阶段，存款者可以在主链上进行取款。存款者提交一个未确认的取款请求，必须等待一些额外的非常长的时间，以便网络上的任何人能有机会生成欺诈证明，证明存款者登出并在Plasma区块链上锁定了资金。如果没有证明，然后存款者可以取出他的未确认资金。这个取款需要一个比较大的主链上的押金来确保不会出现Byzantine行为。

5.3 大量的取款与位图状态（Mass Withdrawals and Bitmapped State）

整个系统首要的问题是不能验证状态。

为了能最大程度的压缩交易的状态，输出可以选择性的在一个位图中表示。这对取款证明是有用的，因为在主链上执行的成本很高。这种结构的目标是允许在Plasma子链上持有少量余额（译者注：原因是一定的不安全性？）。整个余额由主链的合约完全控制，但完整的账本信息并不在区块链上。首要被解决的攻击是持有无效的块（且提交到了根链上）。当系统发现了无效的状态转换时，参与者会进行一个大量的交易的退出。

位图这种结构，取款中将包括想退出的交易签名的位图。一个游戏/协议会由智能合约强制执行来保证信息的正确。位图信息保证每个人都能推断出输出的是什么。

作为位图，状态以UTXO（unspent transaction output）的数据结构有一定的必要性，以达到小额账户最大的可用性。花费可以被紧凑的证明，同时可以清晰的强制执行一大组状态转换。在预定义的某个清算时间后，这些字节位还可以被重用。

整个渐进的，成本高保证性强，成本低保证性弱：

1. 账本状态在主链上
2. 账本状态在Plasma，经济上可行，用单个链上
3. 账本状态在Plasma，经济上可行，用位图（1-2个位的成本）
4. 账本状态在Plasma，经济上不可行，在主链上用位图来保证强制执行。1-2个字节位的在大量取款的情况下成本太高。

对于那些可以在主链上强制执行的余额来说，执行一个UTXO的位图格式是没有必要的。然而，对于那些持有余额的，如果1-2位的在主链上的交易费/gas足够的低，强制执行也是可行的。

对于第四种类型（在大量取款情况下，1-2字节的链上成本较高），整个系统仍设计为有一定的扩展性（尽管是一些假设，但具名实体将会是可靠的）。本论文的后续章节将描述一个多层级的区块链结构，来创建许多分支，其中大家可以大量的经济的取款。此外，如果第四类交易的总价值显着低于代币价值，那么从理论上来说，攻击这些余额的成本可能太昂贵，因为代币持有者还将遭受声誉损害。

5.4 状态转换

默认情况下，Plasma链上的状态转换，与存款的多阶段流程类似。都是为了保证用户有可用的信息来提供给状态转换。然而，与存款结构不同的是，一旦一个交易进行了签名且被包含进了一个区块，需要参与一个提交。出于这个原因，状态转换需要包括签名，状态更新（如，目标，数量，代币，其它关联的状态数据），其它一些过期时间设置，如存活时间（TTL，time to live），以及提交到某个特定的区块。该TTL，虽然不是必须的，应该低于构建退出证明的时间，来保证相应的退出情况是可知的。预签名的交易，当然不能包括一个TTL。假设这个构建存在缺陷，因为已经存在关于深度重组的退出活动的假设。区块的提交是由Plasma链的花费者（spender），这个实体来进行的提交，它声明观察到链达到一个状态，必须在区块后的输出中花费真正发生后，可以强制执行证明。

多阶段的提交按如下的方式发生以达到快速的确定性：

1. Alice希望在Plasma链上转移他的资金给Bob（不需要将完整的记录提交到区块链上）。她创建了一个交易，在Plasma链上花费她的支出，签名，广播这个交易。
2. 这个交易被Plasma链的验证者校验后，头部的信息会作为区块的一部分放入父Plasma链或者主链，最终会被提交并打包到主链中。
3. Alice和Bob观察到了这个交易，签名确认他们看到了这个交易和区块。确认需要签名同时被包含进另一个Plasma区块中。

对于不需要很快达到确定性的情况下，只需要第一步发生：
当确认发生后，交易可以被认为已经确定。第三步存在的原因是为了保证区块的可用性，通过参与者（Alice和Bob）来保证。第三步并不是必须的，但没有它会显著的延迟确定。原理是，一个交易不能，在区块校验，由交易所有有关的参与方证明信息可用前，被视为达到确定状态。

如果在第一步后，发生区块扣留，Alice不清楚她的交易花费输出是否有效。如果一个交易已经被包含进一个区块（无论发生区块扣留与否），如果第三步还没有完成，它都将被视为未确认。因此，如果她在提交之前没有签署提交，那么Alice仍然可以撤回这些资金。前提是她在区块最终确定前，在根/母区块链提交了撤消消息。Alice不能在区块确定（finalization）后进行取款，区块将假设已发送给Bob。如果区块在确定前被扣留了（在步骤1和2时），Alice和/或Bob观察到，Alice可以取出她还未确定（finalization）的资金。如果区块在步骤2之后，但在步骤3之前发生的扣留（withhold），因此假设Bob有足够的信息来取款，但由于Alice或Bob都没有完整的提交这个支付，故交易被视为不完整的，这取决于任何一方在理论上可获得的信息可用性。如果双方都在第3步中进行了确认，那么它将被假设真正意义上的确定了（finalization）。当这步发生后，特别是当签名可在链上被观察到时，付款合同哈希（pay-to-contract-hash）将强制执行。当某方拒绝签名，或区块被扣留时，则以赎回证明为条件。因为所有状态将最终通过梅克尔证明提交到链，因此会减少一些对付款合同哈希（pay-to-contract-hash）的依赖，因为支付在确定（finalization）后可证明且可强制执行。

需要注意的是步骤3可以基于智能合约而不是双方的签名，如，状态可以通过之前预设的HTLC的释放。这将允许多链或多交易的原子性。合约的创建复杂度将上升，如果需要这样的特性，可以通过更高级别的语言/工具来解决这个问题。

5.5 周期性提交到主链（Periodic Commitments to the Root Chain）

Plasma链必须能创建区块链的顺序。在Plasma链中，区块内有顺序，但区块没有自证顺序。作为一个结果，有必要在主链上创建一个提交。Plasma链发布了它的区块头到主链上，区块头由欺诈证明强制执行。如果发布的欺诈头包含其他人的数据可用性，则任何其他参与者都可以发布欺诈证明，然后提交和区块将会回滚，并对发布商进行处罚。

这些提交在后续支持没有模棱两可的真正的顺序。 如果试图模糊，将有足够的欺诈证据，对这样的行为进行惩罚。 区块在一段时间之后进行确定态，并且因此不能重新排序，也让根链达到足够的确定态。

5.6 取款（Withdrawals）

Plasma允许从主链存入原生货币或者代币（如，ETH和ERC20代币）。它额外允许了在Plasma链间的状态转换，其状态由根区块链强制执行，前提是存在信息可用性。当发生信息可用性失败时，需要在Plasma链上进行大量的退出（exit）。最后，也可以在Plasma链上进行一个简单的取款。

然而，在常规的情况下，大家可以进行一个简单的取款。

5.6.1 简单取款（Simple Withdrawal）

简单取款，只允许已经提交到主链后才能取款，最终在Plasma链上完成确定（finalize）。

我们已经描述了存款的设计，通过紧凑的格式表示账本状态和状态转换。直到这个阶段，除了欺诈证明外，主链上没有当前Plasma链的账本信息。在取款时，尽管如此，需要一种特定的证明，证明资金由Plasma链持有且当前存 在。

取款是最最关键的部分，因为这将保证主链与子Plasma链间代币的可互换性。如果人们可以存款到Plasma链上，进行状态转换（如，向其它方转移代币），其它方还能取现，那么代币的价值将与主链的代币价值一致。在某些情况下，Plasma链上的资金更为有用，因为它支持更高的交易容量，同时交易安全最终也是由主链保证。

对于一个简单的取款，所有的资金需要一个很大的押金，所有的取款请求必须包括一个很大的押金作为欺诈证明。如果当前的区块数据是可用的，那么第三方在很低成本情况下提供这个证明是可能的，因为第三方的服务可以验证Plasma区块链的存活状态，确保取款证明是有效的。

Plasma链的所有参与方必须验证所有的父Plasma链和根链，来确保在更新状态时，对于某个特定的账户和输出没有进行中的取款。如果取款在进行中，后续的区块不能使用硬币/代币，这里任何的byzantine行为都违反了共识，并且受到根区块链中Plasma合约的欺诈证明，处罚和封锁逆转的影响。

一个取款有如下步骤：

1. 一个签名的取款交易被提交到根链或父Plasma链。取款的数量必须是完整的输出（不是部分的取款）。取款也可以有多个输出，但他们必须在同一个Plasma链中。输出（output）的位图位置将会作为取款的一部分被公开。另还需要一个额外的押金来惩罚不正确的取款请求。
2. 存在一个预定义超时周期用于调解纠纷。这与闪电网络的调解期类似。在这种情况下，如果任何人可以证明在链中的一个输出（output）已经被花费了（大多数情况下，在主链上），取款将被取消，取款请求的押金将被没收。任何人发现了都可以进行调解。如果提供了关于花费的欺诈证明，将失去押金，同时取款也将取消。
3. 存在第二个延迟来等待任何由较低的区块确认高度的取款请求。这将强制在某个特定的Plasma链或根链的的顺序取款。
4. 如果Plasma之前定义的调整期已过，在根链和父链上并没有提供人提供欺诈证明，那我们可以假设取款是正常的，取款者可以在根链或父链上赎回资金。取款将由旧到新以UTXO/account的年龄来顺序执行。

需要注意的是，如果经济上可行的话，可以在发生区块扣留的Plasms链上进行取款。

欺诈证明仅仅需要在网络上的任何人证明在同一个输出（output）存在一个双花签名，可以被非常简洁的证明。对于闪电网络或其它一些状态通道，一个额外的需要是必须证明一个更高的nonce。对于通道，如果取款尝试一个较低的nonce，资金将仍保留在Plasma链中，对于能提供正确签名的取款可用。其它的构建也是可能的，但设计可能需要作为创建Plasma链的智能合约欺诈证明的一部分进行预加载。

因为常规的取款慢，且成本很高，它将可能被合并为一个单一的取款，或者其它人也希望向其它链交换币使用闪电网络或原子交换（atomic swap）。

5.6.2 快速取款（Fast withdrawal）

快速取款与简单取款的构建方式类似，但资金会发送到一个合约以进行原子交换（atomic swap）。根/父链上被交换的资金，有一个资金的低时间锁（low timelock for funds）和退出Plasma链的高时间锁（high timelock）。

快速取款并不是实时的。然而，只要保证Plasma链提供交易的确定性，即不是Byzantine的（Byzantine行为包括区块扣留等情况），它可以显著减少取款的时间。因为这个原因，快速取款不能在区块扣留攻击时使用，应该用一个慢的批量取款请求代替。

快速取款有如下几个步骤组成：

1. Alice想取款到根链，但是不想等。她愿意为此付出时间价值（time-value）。Larry（流动性供应商）愿意提供这个服务。Alice与Larry协调一致在根链上进行一个取款。我们假设Plasma链当前是non-Byzantine的。
2. 资金被锁定在Plasma特定输出的某个合约上。这与普通的转账的方式有些类似，双方会广播一个交易，然后后一个提交承诺自己在Plasma链上看到了交易。合约的条款是如果一个合约在根链上广播了且确定（finalized），那么支付就可以在Plasma链上进行。如果不能提供交易的证明，Alice就可以赎回自己的资金。也可以通过让Alice生成一个preimage来构建一个HTLC，仅仅在她认为可以接受并且资金被转移时才释放它。
3. 在上述的Plasma块确定（finalized）后，Larry非常有信心他可以在合同条件满足时赎回自己的资金，Larrry创建了一个链上合约，向Alice允许支付指定数额（数额是应收减去整个服务的收费）。

在我们的例子中，流动性提供商（Liquidity Provider）Larry必须在线且需要在接受交换（swap）前完整校验Plasma区块链的正确性。如果Larry不能完整的校验Plasma链（或者不熟悉主链中定义的欺诈证明智能合约），他不应该进行取款。如果Larry不想要链上的资金，而是需要根链上的资金，Larry可以在这一切完成后，发起一个取款，或者进行一个原子交换（atomic swap）并作为取款的一部分。

在许多情况下，在Plasma链上与流动性供应商进行网络结算的成本效率更高。转移可以在Plasma链上通过闪电网络或者原子交换（atomic swaps）来支持快速的确定性。

因为这是一个原子的跨链交换，Alice和Larrry没有给予彼此资金的保管信托。Alice在根链/主链上有资金，Larrry在稍后将能完全访问他们。根链提供了低成本的区块可用性和保证确定性的非Byzantine行为，Larrry可以有信心相信他能得到资金，即使Larry自身并不信任Plasma链。

5.7 对抗式大量取款（Adversarial Mass Withdrawal）

对抗式大量取款交易存在于plasma框架下，它不是做为协议必须的，它主要设计来解决在发生区块扣留（block withholding）时状态的经济健壮性（低gas/手续费）。如果某人希望使用Plasma链中的账户状态，那么它也将依赖于其它的一些设计，比如分层的支付（payments）。额外的，需要注意的是这里使用了UTXO模型，但这个系统仅当主链使用账户模型时，才会良好的工作。更进一步来说，如果大量取款不是必须的，或者不是需要的特性，那么在Plasma链中使用账户模型来持有资金是可能的，同时我们只允许简单取款（simple withdrawals，使用一个递增的序号）。

因为Plasma这个设计主要考虑的是关于在区块扣留攻击时防止欺诈（以及缺乏数据可用性后的其它影响），在检测到数据不可用情况时需要减少其影响。当Plasma链上的用户检测到区块数据不可用时，对于参与者来说，需要在某个时间之前紧急撤出。当链未能及时退出时，结果与闪电网络类似不对不正确的取款提出异议。这个机制是保证Plasma链正确性的关键。Plasma依赖于一个事实，需要用户通过区块扣留来检测Byzantine行为，用户也有责任及时的退出不正确的Plasma链。这里的原因是，在主链上探测某个区块是否处于区块扣留的状态是不可能的（要么用户断言他从来没有接收到某个区块，要么Plasma链可以断言用户拒绝承认区块的可用性，用户在说谎）。因此，这种传统的方式，用断言数据不可用的成本来实现了链上当前状态的透明化（这也正是闪电网络正在做的）。然而，对于非常大的区块和状态转换，这将会变得异常昂贵，Plasma并没有使用这种构建方式，因为它对谁需要对这个成本负责说得不清楚。相反，Plasma链假设如果用户相信正在对抗区块扣留，将会影响到未来执行强制状态转换的能力，那么用户应该简单的尽可能快的从这个Plasma链上退出（exit）。

因此，这就是对抗性批量取款的定义范围。如果区块不可用，那么就可以假设Plasma链处于对抗或Byzantine。批量退出（mass exit）保证了Plasma链的Byzantine行为在某个时间和链暂停期间，不会影响大家的资金。

它也假设额外的在未来使用SNARKs来提升安全性的可能，设计方案还在公开讨论中。整体结构并不依赖SNARKs以进行取款，因为它需要主链上的观察者（observers）周期性的在线，然而通过在Plasma链内的强制状态转换，攻击或者Byzantine Plasma链来执行区块扣留，从而对那么不周期性的监督Plasma链的主链实现资金窃取能力，可以通过SNARKs的安全特性来大大减少。这种情况下，将需要SNARKs证明来实现状态转换、取款，以进一步的提升保障。然而，Plasma的目标是不依赖于SNARKs就可以提供正确的状态转换行为，主要是通过用户关注（observe）链，智能合约保证机制的正确性，且提供在主链取款的能力。类似的理念也可以用于闪电网络中保证当前状态的正确性上，通过离线的状态仅由支持智能合约的第三方提交的递归SNARKs证明来保证。

Plasma链可以通过不同层次的保障来实现安全，第一环是是元素/硬件，第二环是SNARKs/STARKs，最后一环才是链上的交互游戏。第一环有可能失败，第二环通过密码学加密，最后一环是公开的透明交互游戏。Plasma主要作为最后一环的一个解决方案。

一个批量取款，是一个交互游戏，其中退出（exit）的实现有如下步骤：

1. Alice与其它人协调一致以实现在Plasma链上的批量退出。许多批量退出可以一次性发生，但他们不能包含重复的取款。如果发生了这样的情况，批量退出会更新余额，同时它们会顺序的执行，那个重复的用户将会受到惩罚。所有参与方应该一致的发送他们的资金到另一个Plasma链。
2. Pat，退出的执行者，打算来组织这次退出。Pat协调资金要发送到的目标链，且自动承诺承认资金在批量退出后，在新链上的资金可用性。
3. Pat验证了到数据还可用时的链数据。时机点必须是纠纷调解接受期或Plasma链的确定阶段（与主链的确定性无关）且符合智能合约的条款。Pat在新链上向所有参与方展示正添加到目标账本。Pat持有所有希望退出的参与者的签名（包括我们例子中的，Alice）。Pat校验所有参与方直到数据可用高位时是否有权限退出。Pat创建一个带有大量押金的退出交易（正如根链智能合约中定义的一样）。Pat也许会收取所有参与方的退出手续费。
4. 用户在下载所有签名后对这个大量取款再签一次名。这将允许用户知道Pat不会受到惩罚，同时现在资金也被锁定了。那些没有进行第二次签名的用户不会包含他们的位。
5. Pat然后会关注当前是否有其它退出交易，同时移除那些可能的重复，然后签名这个退出交易，广播交易到根链或者父Plasma链。当发生重复时，父链会按顺序执行（根链有最高优先执行权）。早期的交易的优先顺序较高。广播批量退出发起交易（MEIT，mass exit intiation transaction），Pat正在证明他以下信息的有效性：区块正确性，区块高度的UTXO集合，非最终确定（finalize），UTXO的位图映射，提交的金额（为了快速证明的梅克尔求和树），Alice和其它人的签名。作为MEIT的一部分，Pat还需要公布退出状态的完整位图。这样其它观察根/父链的参与者可以验证正在退出的，并挑战那些不正确的。MEIT的确定性需要很长时间，也许会花费数周，由此MEIT是最后一笔交易（未来我们可以通过SNARKs来加速）。
6. 如果出现重复的取款，Pat可以一个较短的宽限期内更新位图和余额。
7. 任何网络中的参与者可以通过DMET(Disputed Mass-Exit Transaction)挑战（challenge）MEIT中的数据。然而，因为Pat不可能知道未来的某个块替换了输出，如果资金在未来被花费了，Pat不会受到惩罚（但在未来花费这笔资金的用户会）。如果出现了挑战，资金将被冻结直到挑战结束。挑战必须发生在早期的宽限期，如果一个挑战是有效的，那么Pat必须更新取款的余额。（译者注：会不会一直有挑战，导致整个取款一直延迟）
8. 如果没有挑战，那么在前述的MEIT的确定时间后，用户将收到他们的资金。

Plasma链进入确定状态的这个时间窗口，是为了保证一个人最少的周期性的观察链的时间。在确定的时间窗口过去后，将会假设所有人在那个时间窗口结束前都已经验证了Plasma链的区块数据的可用性。

实际上，当Pat创建MEIT时，Pat证明了在某个特定的区块高度，某些记录的正确性，同时也证明他有输出的取款的签名。在证明阶段后，Pat并不会因为在输出中有双花的情况而受到惩罚（因为区块扣留不应该惩罚Pat）。

5.7.1 批量取款纠纷：不正确的取款的挑战

当发生用户，比如，Alice发现Pat未经其同意就进行一个批量取款时，她可以通过创建一个挑战来作废这次取款。

1. Alice在Pat的批量取款中发现了她自己在Plasma链中的输出（output），比如其中的位图字段是打开的状态。Alice广播一个带有大量押金的挑战。押金保证了不会随便产生挑战，她在区块链上广播这个信息。
2. 如果挑战在一个设定的时间里没有被质疑，Alice将会得到押金的退款，而且整个MEIT将会被取消。如果挑战被Pat或其它任何方通过欺诈证明为无效，MEIT仍旧有效，同时她的押金将会没收。

参与者需要确定签名可用，因为在MEIT中有第二个阶段（第四步），因此当挑战不正确时，他们有足够的信息来质疑挑战。我们通过激励来阻止产生错误的挑战，因为他们将因为区块的正常可用和根链的非中心化而受到惩罚。

5.7.2 批量退出交易质疑（Disputed Mass-Exit Transaction）

当发生某个输出（output）在MEIT后的某个区块被花费时，Pat将不可能知道这一切，所以他将不会受到惩罚，因为人们不能证明区块扣留。

将会存在多个质疑者来质疑同一个位图组，但他们都必须附加一个较大的押金。

任何的参与方都可以通过一个大的押金来说明发现的位图/范围的重复消费。这个较大的押金证明了一个币在稍后的某个块中被消费，并提交到区块头中。

然而，质疑的处理过程不能简洁的进行证明，所以另一个迭代的挑战变为可能，一个针对批量退出交易质疑的挑战（CDMET，Challenge on the Disputed Mass-Exit Transaction）。

质疑的挑战流程如下：

1. Alice注意到某些人（如，链的操作者在进行区块扣留）正试图质疑她参与中的某个批量退出。她提交一个附带有大量押金的针对质疑的挑战，来证明挑战的提出者不能提供一个有效的花费。
2. 质疑的提交者必须在某个时间内对挑战进行回应。如果提交者不能产生一个花费的证明，本质是提供一个在后续交易中是否发生了的签名，那么Alice就被平反了，然后整个纠纷将被取消（这就是为什么允许重复的质疑）。如果提交者证明了币被花费，那么Alice将失去她的押金，质疑而且会将继续。

5.8 回收UTXOs

当一个输出确定（finalized）后，我们将可能重用UTXO位图。

5.9 总结

作为批量取款游戏的结果，对于许多参与者取款，最乐观情形下，我们可能只需要为每个取款占用1-2字节位的空间来完成批量取款。

批量退出在发生区块扣留时是必须的。然而，这也仍是非常高成本的。为此，我们仍需其它的解决策略来不加重主链的负担。

这个结构允许许多参与者在他们的子链中持有资金，如果区块信息可用通过欺诈证明能校验有效性，状态转换可以发生（如，支付），取款可用，批量退出（会有一些延迟），这些都是在发生区块扣留时可用的。

主要介绍白皮书第三节通过网络通道扩容的理念，以及介绍plasma参考的一些项目（可以看出项目的优劣）。
阅读用时约：7分钟

3 设计栈和智能合约

从历史上看，大部分人相信匹块链的最佳适用场景是交易性的支付，比如利润结算系统。然而，我们意识到这样的结算系统很难扩展。而面向网络结算（net-settled）的设计，比如闪电网络，一个支付通道网络，改变了这个结构来允许参与者无限次的交易。渠道通过在区块链之上的网络结算（net-settled），交易容量可以显著的增加。支付可以路由到上述所说的渠道组成的网络进行处理。

这种结构还支持有效的即时支付。这对于无论是对时间高度敏感的支付，还是合约支付都非常有帮助。

Plasma并不是设计来快速的达到确定态（finality），尽管交易可以在子链上得到快速的确认，但它仍需要在底层的主链上达到确定态（finality）。通道需要得到一个能快速返回的，虽然是子链的确定态（最终能在链上强制（enforcible））。

在智能合约中，有一个“自由选择问题（free option problem）”，智能合约的接收者（第二个或最后一个）需要最终对一个合约签名并广播以让其强制执行--但接收者也许会把它认为是一个可选项，如果没能吸引到它，它也许会拒绝执行上述操作。因为智能合约在处理不可信的第三方时最有效（因为交易对手风险越小，信息成本越小），这一点让上述情况尤为突出。

Plasma并没能解决这个问题，因为区块链并没有一种交互协议能保证第一步和第二步签名的原子性。

闪电网络（包括基于Plasma之上的闪电网络），可以支持大量的更新，同时保证可接受的确定性。取代一次性的支付，一个支付可以被分成许多的小支付，支付仍需要最后参与方的选择。这可将自由选择的数额降到最低。由于智能合约的后续参与方，仅有拆分数额的自由选择权，自由选择的影响数量被最小化了。

基于上述的用例，闪电网络也许可以成为在Plasma之上，快速金融支付/合约的主要接口层，Plasma可以只需要小量的主链账本更新。

图9：最底层是区块链，是合约和支付的判决层。合约本身在主链上。Plasma链上包含了当前账本的状态，可以在主链上清算和赎回。如果存在欺诈将允许资金的赎回。Plasma提供了一种链嵌套的结构，创建了一个场所，以最小的链上的交易，实现资金的可扩容的存取。闪电网络又基于其上，支持即时的支付。

3.1 分片（Sharding）最重要的问题是信息

在数据分片的情况下，极有可能单个分片的数据不足，从而无法生成欺诈证明。

我们尝试通过下述三个策略来解决这个问题：

1. 一个新的Pos的机制来鼓励区块数据的传播。底层机制并不需要完全依赖于激励。即使这样也将极大的减少欺诈行为。
2. 取款延迟是用来保证取款证明。个人不需要经常的关注区块链，出现错误行为的plasma链上的任何一个诚实的用户都可以在主链上终止这种行为。当区块扣留（block withholding）发生时，plasma链可以立即通过一个证明锁定资金，阻止攻击者提交一个虚假的取款证明。当攻击者尝试在Plasma取款超出限额时，同时更多的资金将被锁定，被攻击的plasma链将失去他们的存款。
3. 创建子链，交易将经由此传递到父链。所以，网络中的参与者应该将交易提交到子链上。这提高了小额余额用户的经济效率，因为不用支付主链上的高额交易费，由此，许多的小额帐户中转移资产变得可能了。大家在使用时应该尽量使用足够深嵌套的子链，将会带来非常大的价值。请注意，对于持有非常小的余额用户，仍需要注意选择那些有较高信誉的链。安全模型是plasma链的关键创新。

4 相关工作

一些相关的项目提议使用一个精简步骤的梅克尔树（merkle tree）来作为计算证明（proof of computation），然而这个提议主要围绕数据可用性，支持降低欺诈证明的成本，通过经济驱动来进行区块链群的分片（sharding）持久化，他们使用一个协议来管理。

其它的一些相关工作提议一个子链系统，但在实现上有根本的不同。

Plasma使用梅克尔证明（merkleized proof）来保证子链的强制执行。

4.1 TrueBit

Plasma对于欺诈证明的想法极大的参考了TrueBit[10]。欺诈证明的构建与TrueBit类似，几乎TrueBit上的所有成果可以直接应用于Plasma，尤其是关于状态转移的梅克尔证明（merkleized proof）。

TrueBit的设计允许创建精简的证明，来提交到以太坊区块链，其成果对Plasma来说非常需要。所以几乎所有Truebit白皮书涉及到的和团队完成的繁重的工作都可以直接应用到plasma的设计中。包括验证游戏（Verification Game），提供递增的奖励，以尽量少的计算规模的方式来生成梅克尔证明（merklized proof）。同时与TrueBit类似的假设也适用，即计算状态必须可计算且能在线上广播（大的数据块应该拆分到多个回合中），解决数据可用性的问题，失败状态能及时暴露。我们主要着力解决后两个问题。

Plasma尝试基于TrueBit之上构建解决的主要问题是，多方需要在一个共享状态上完成计算。例如，一组参与者只关心一个数据的子集，计算也只应该计算与他们有关的部分（例如，BBS或交易所）。我们也尝试通过链下的强制执行来解决需要回合式计算的场景。

4.2 区块链分片（sharding）

当前的区块链分片的工作，使用与以太坊分片提案类似的技术和目标。我们作为一个更高层级协议，可以兼容底层的分片机制（sharding）。如果主链是分片的，plasma可以运行于其之上，获得扩展性和其它的好处。plasma也可以成为不同分片技术的测试平台，因为在以太坊或其他的区块链中都不需要改变共识来支持Plasma链的基本运行。

4.3 联盟侧链（Federated Sidechains）

Plasma不是一个联盟侧链[12]，因为Plasma并不需要联盟来保证诚实的行为，且也不需要在链内依赖诚实的参与者来强制状态。Plasma同时也扩展了其它区块链的账本状态来允许使用这种代币，然而如果欺诈证明可用的话，它会进行强制执行校验。因为Plasma并不依赖于参与者的强联盟，联盟链需要保证参与者的正确性，所以，它并不是一个联盟侧链。

Drivechains[13]使用类似联盟侧链的方案，仅仅在验证者上有所不同，使用了未知的，一个变化的参与者集合（矿工们），有更大的去中心化性。

4.4 联合挖矿区块链

例子包括Namecoin，通过主链[14]来创建当前的区块。前提是需要对区块链的完整性进行校验，由此并不会带来扩展的好处。扩展区块是联合挖矿的另一个例子，它允许主链和联合挖矿链的资金的互相转移（要求主链上的矿工的共识来保证强制性）。联合链允许其它共识规则存在，通过选举用户来验证他们感兴趣的链，但矿工/验证者需要校验所有东西。Plasma的目标是保证用户和矿工仅验证与他们有关的链。

4.5 Treechains

Treechains[15]提议了一个树结构的区块链，通过在子区块中使用POW证明进行校验。主链是所有子区块链的工作量证明的聚合。随着层级的降低安全性能较好的保证，随着层次的提升也许会或也许不会提升安全性，这取决于后续层级的验证级别和工作。因为treechain的拓扑图是一个树形结构，它的结构依赖于通过分支聚合的挖矿的安全性。这个安全模型在叶子节点有较低的安全性，因为它是POW保证的。Plasma的安全性主要在根节点上，这点与之相反，安全性和证明从根流向叶节点。相类似的工作是以一个树形格式构建区块的证明。

4.6 zk-SNARKS和zk-STARKs

不需要交互的计算证明使得人们在可伸缩计算中获得显著好处[16]。zk-SNARKSs/STARKs和其它形式的非交互式紧凑证明是Plasma的重要补充。他们可以提供一个梅克尔（merklized）计算的结果证明。另外，对于子链上持有小额帐户的情况来说，可以减少系统性攻击。在SNARKs中已经有了MapReduce功能的研究[17]，我们希望能够利用这一研究成果，Plasma通过在一个区块链群中，提供有序的证明和执行的强制性扩展了它。

未来可支持的还有，允许更快的同步和校验链本身的计算证明。需要注意的是zk-SNARKs并没能解决数据可用性的问题，只是减少了需要的数据量和计算量。这可以作为任何基于时间的资产/挑战机制（asset/challenge time-based mechanisms）的替换或补充。zk-SNARKs可以成为安全的一环，如果最后一层区块链的保护没有使用什么密码学特性，那么第二层保护可以是zk-SNARKs，第一层保护是可信的计算机硬件。

从plasma链中取款会通过zk-SNARKs保证安全，带来的好处是可以选择性的不需要位图（bitmap），但在这种情况下仅允许小额的转移。

4.7 Cosmos/Tendermint

Cosmos[18]将区块链组织为一个个的Cosmos的Hub，同时有名为Zones的子区块链，来实现对pos系统的校验。Plasma与之在子链组织上有非常大的相似性，然而Plasma依赖于欺诈证明来保证子链上的状态的强制执行，同时也具有普适性适用于许多的链。Cosmos的权益证明的构建假设2/3的验证者需要为诚实节点，其中包括Cosmos的Zones里的验证节点。

4.8 Polkadot

Polkadot[19]也构建了一个分层的区块链结构。Plasma与Polkadot的设计有些相似之处。但我们使用了一系列的子链通过梅克尔证明来保证状态的执行，而不是使用类似Polkadot的fishermen的机制。Polkadot的构建依赖于子区块链（parachains）的状态，状态的可用性由fishermen来保证。

4.9 Lumino

Lumino[20]是区块链上能压缩状态更新的EVM智能合约。这允许参与者仅仅更新最小的提交状态。Plasma的输出管理的设计将这个事情推进了一步，只需要通过一个位来表示一个特定的输出。这允许在子Plasma链失败时，可以快速的，低成本的协调大量的取款操作。

Plasma是一个激励，和强制智能合约执行的框架。可以扩容达到每秒大量的状态更新（能达到每秒10亿级），在区块链上能支持全球范围内的大量的去中心化金融应用。这些智能合约通过网络交易手续费用于激励持续的自动化运作，最终依赖于底层的区块链（比如，以太坊）来强制交易状态的锁定。

我们提议的这种去中化的可扩展的自动运行应用，不仅可以用来处理金融行为，也可以通过构建面向全球的持久化数据服务的经济激励，来成为当前中心化云服务的一种备选方案。

Plasma由两个核心部分构成：重组所有区块链计算为一组MapReduce函数，和一个可选的方法，在现存的区块链上，以不鼓励区块扣留的Nakamoto共识原则，来实现一个Pos的代币押金机制。

这种构建通过在主链上编写智能合约，使用欺诈证明，可以在主链上强制状态的锁定。我们将区块链编组为一个树形的分层结构，将每一个区块链视为一个独立的分支，强制将整个区块链的历史，和可MapReduce的计算提交到Merkle证明。通过主链强制将某个链的帐本信息打包到子区块链中，这个链将通过最低的信任达到不可思议的扩容（假定根链的可用性和扩展性）。

围绕全局强制非全局数据的数据可用性，区块扣留攻击是是一个非常复杂的问题。Plasms通过对有问题链的退出机制来缓解了这个问题，同时也创建了一个激励和持续的强制的执行数据的正确性机制。

仅仅通过周期性的将正常状态的Merkle证明广播到主链（比如，以太坊），这将允许不可思议的扩展性，降低交易成本和计算量。Plasma支持了大规模去中心化应用的持续运行。

1 可扩展的多方计算

在区块链中，对于正确性的校验，一般是让每个参与方自行验证每个链的正确性。为了接受一个新区块，需要参与方完整的检验区块从而保证其正确性。扩展区块交易容量的努力来自（比如，闪电网络）引入时间承诺来建立一个押金机制，（一个断言、挑战协议）这样断言的数据必须经历一个争议期后，才会真正放到区块链上来锁定状态。断言/挑战的构建过程，是允许某方断言某个特定的状态是正确的，如果断言不正确，且存在着一个争议期，争议期内，另一方可以在约定的特定时间内，提供一个证明来挑战这个断言。当出现错误的行为时，区块链可以惩罚不正当行为方。这创建了一种机制来鼓励参与方来强制执行那些不正确的断言。通过这种断言、挑战证明机制，感兴趣的参与方可以向主链上不感兴趣的各方证明某种事实（如以太坊[2][3]）。

这种结构可以不仅用于支付，也可以扩展到计算层，这样区块链作为智能拿给的裁决层。然而这种假设需要所有的参与方均是计算验证的参与方（译者注：即主链是否需要关心子链，但子链可能不使用主链货币，不需要主链的计算证明）。以闪电网络为例，这种结构可以让人们提交一个需要计算的合约状态承诺（如，通过一个树级的状态变化的预签名）。

这种结构允许可扩展的高强力计算，但也有一些问题，需要汇总一些外部的状态（比如，整个系统、市场，大量的分片、不完成状态的计算，大量贡献者的状态的汇总）。这种形式的多方离线链状态（”状态通道“）承诺，需要参与各方来提供完整的计算证有，否则有重要的信任建立在计算本身上，即使是一个单回合的模式。此外，这里引入了一个回合的假设，在合约启动前，执行的步骤是完全展开的，这给了参与方一个机会来提前退出并强制在链上进行昂贵的计算（因为不能知道哪一方有问题）。

取而代之，我们试图设计一个系统，计算可以链下发生，但最终可在链上强制执行小量的更新，使能扩展到每秒数10亿的计算量。这样的状态更新通过一系列自动的Pos验证者，他们被激励，通过欺诈证明，来促进子链上的正确的行为；从而避免单方的轻易的暂停计算服务。这将有利于减少数据可用性方面的问题（如，区块扣留问题），减少主链上的状态更新的必要，在出现byzantine阻止主链上的交易费的折扣风险，一种强制状态变化的机制。

与闪电网络类似，Plasma是一系列的运行于现存区块链之上的智能合约，来强制保证大家可以可以在一个合约状态中持有资金，且能在后面的某个时间在网络上进行清算、取款。

2 Plasma

Plasma是一种实现区块链扩容计算的方式，通过创建经济激励来实现自动和链上状态的持久化，而不需要合约创建者的裡的状态转换管理。节点自身被激励来运行一个链。

额外的，重要的可扩展性是通过减少单次花费的资金表达方式为一个位图中的一个位来实现，这样，一个交易和一个签名代表一个与多方的交易聚合。我们将这与一个MapReduce框架结合，同时使用含押金的智能合约来构建可扩展的计算强制性。

这种构建方式允许大家让外部的参与方持有资金，并根据自己的行为计算合约，类似于一个矿工，但是Plasma是运行于一个已存在的区块链上，由此大家不用在每次状态更新时在主链上创建对应的交易（即使包括添加新用户的账本），而只需要将合并后的状态变化这样的少量信息写到链上。

图1：每个人都可以创建一个自定义的Plasma链，在不同场景下实现可扩展性。Plasma是一系列的智能合约，允许在主链里有许多的区块链。主链可以强制Plasma链中的状态。主链是全局计算的强制检查者，但也只计算和惩罚那些存在欺诈的行为。许多的Plasma的区块链可以并存，且有他们独自的商业逻辑和合约术语。在以太坊中，Plasma将会由EVM智能合约组成，并直接在以太坊上运行，但只会执行很小的几次，但可以在非Byzantine的情况下代表不可思议的大量计算和金融账本实体。

Plasma由五个核心部分构成：1）一个激励层，用于持续的以优化的价格执行合约，以一种树状态形式来组织子链来尽可的提高成本效率和网络交易清算的效率，2）一个MapReduce框架，构建一个状态转换的的欺诈证明，在嵌套的子链中，兼容树结构同时重组状态转换为可扩展的，3）一个共识机制，依赖于主链，尝试复制Nakamoto共识激励，4）一个位图的UTXO提交结构，保证在主链下的确定的状态转换，同时尽可能降低退出费用。5）允许在数据不可用或者其它Byzantine行为时可以退出，也是Plasma的运行中的关键设计点。

2.1 Plasma区块链，或者外化的多方通道

我们提出了一种方法，多方链下通道可以代表他人持有某个状态。我们称这个框架为一个Plasma区块链。对于在Plasma链中持有的资金，这将允许向Plasma链中存取资金，通过在欺诈证明中提供状态转换证明。这允许强制的状态和可互换性的存储与取款，考虑在Plasma块中的情况，匹配其在主链中持有的资金（Plasma并不是设计为银行那种准备金）。

图二、Plasma区块链是一个在区块链中的链，这个系统由押金的欺诈证明驱动强制执行。Plasma区块链没有向主链（比如，公开链）公开自身链的内容。取而代之的是，区块的头哈希将会提交到主链，当出现需要欺诈证明的时候，然后块将回滚，区块的创建者将会受到惩罚。这将非常有效，因为许多的状态更新表示为一个哈希（加上少量的关联数据）。这个更新可以表示一个在主链上尚未显示的余额变化（Alice在主链上没有她的账本余额，她的账本在Plasma链上，主链上的余额代表的是智能合约强制执行Plasma链本身的结果（译者注：相当于是Plasma链的帐户？））。灰色的项目是旧的区块，黑色的则是最近的被广播和提交到主链上的块。

不可想像的大量的交易可以提交到Plasma链上，只有非常少的数据落地到主链上。每一个参与方可以转移资产给任何人，包括转移给非当前存在的参与者。这些转移可以用主链的自身货币或代币支付或取现（需要一些时间上的延迟和证明）。

Plasma允许大家（或者Pos网络的参与者）管理区块链，既不需要主链的一个完整的账本的备份记录，也不需要向第三方出示个人的信用信息。在最差情况下，资金被锁定，因为大量的退出，时间价值（time-value）丢失了。

我们在主链上构建了一系列的防欺诈的智能合约，来强制让状态在当前建立的通道内，由此试图进行欺诈，或者非共识（non-Byzantine）的行为可以大大的消减。

欺诈证明使用一种交互式的资金取款协议强制执行。与闪电网络类似，当取款时，取款行为需要申请一定的时间来到账。我们构建了一个交互式的游戏，退出方需要向参加者的帐本位图（账本内容是申请提现，结构是以UTXO模型）提交一个认证。在网络上的每个人都可以提交一个带押金的证明，来认证资金是否已经用掉。假如这是不正确的，网络上的任何一个人都可以举报欺诈行为，得到押金，回滚认证。在足够的时间之后，第二轮允许真正提现的押金回合开始了，押注在某个提交的时间戳前有效。这一轮允许批量的退出行为，保证一个有问题的Plasma链可以快速退出。对于批量的退出情况下，参加者也能在消耗最多2位主链的区块链空间来实现退出（以太坊为例的最差情形下）。

当发生区块扣留攻击时，参与者可以快速和低成本的进行一个批量退出，能相比其它离线提案大幅的减少花费。额外的，这并不需要某些验证者节点的支持（侧链，polkadot的fishermen）

图三：当发生区块扣留攻击时的资金退出机制。红色的区块（Block #4）是一个被扣留，提交到主链上的区块，但ALICE不能访问到Plasma的区块4。她将通过广播一个在主链上的资金证明来退出，他的取现只需要一点时间，因为需要公告以解决争议。

类似于闪电网络的在两方中结算的交互机制，支持强制的无限的双方之间的交易，Plasma支持n方的交互。主要的区别在于不需要所有参与者在线来更新状态，参与者甚至不需要在主链上有一个记录项来参与进来-大家可以将资金放到Plasma链上，甚至不需要与主链直接交互，只需要以树状形式构建Plasma链时需要一点点交易确认数据。

2.2 区块链中的区块链的强制性

图4：Plasma以树状组织区块链。区块的提交依次向下流动。退出可以提交给任一父链。最终被提交到主链。

我们构建了一个类似法院的系统。如果闪电网络为支付建立了一个适配层，最终会在主链上强制执行。我们创建了一个更高层级的，下层法院来最大化可用性，最小化在非共识的状态下成本。如果一个链是Byzantine的，它可以选择去任何一个他的父链（包括主链）来继续他的操作或退出当前的提交状态。我们并未通过一个可以不断递增的现时状态（通过撤销状态），我们构建了一个欺诈证明机制来强制让余额或者状态迁移以分层的方式展示出来。

实际上，我们可创建状态迁移，仅仅只会周期性的提交到父链（最终将流向主链）。这将允许不可思议的计算能力和账户支持的扩张。因为我们能仅在Byzantine状态下提交原始数据到父节点（或者主链）。从有问题的Byzantine状态中恢复的成本将最小化，因为只需要去父Plasma链上申明某个状态。

子区块链运行于主链之上（主链可以是以太坊），从主链的角度来看，仅仅会看到在合约中有周期性的带代币押金的提交，用于强制运行Pos共识或者那个对应链的业务逻辑。

这一切的显著好处在于可以最大化区块的可用性，同时最小化验证某人的代币所需的押金。然而并不是所有的数据都传播到了所有的参与方（仅仅传播到了那些希望验证某个特定状态的），参与方有责任持续的周期性监控特定的链，那些他们感兴趣的，以在他们有欺诈行为时惩罚他们，同时也能在出现区块扣留攻击时，能自身快速的退出。

图5：有问题的区块链（上图红色），通过提交到父Plasma链/主链（右侧的蓝色虚线）来绕过。在第三级的Plasma链的参与者，在一段时间后，进行了一个到其它链的批量迁移（左侧蓝色虚线）

这种构建在非Byzantine环境中，整合区块链状态树，同时更新所有的子Plasma链。横跨所有链的一整个状态更新集合可以经一个32位的签名来进行证明。

2.3 Plasma的Pos

通过一个单一的验证者，可以代表他人代持资金是一件非常有意思的事。我们提议一种方案，单方可以通过一系列的验证者来保证状态的确定性，通常在一个需要ETH或者代币为押金的框架下。

这个Pos系统的共识机制，再次，通过链上的区块链智能合约来保证他的确定性。

我们尝试复制Nakamoto共识，但是以Pos的押金形式。我们相信构成Nakamoto机制的其中一个更有用的激励机制是不可思议的激励来减少区块扣留攻击（双花攻击，扣留A块，但打包另一个交易）。这也是最长链通过概率指定的原因。最长节点经过时间推移会概率性的被知道（最初的实现版本中是6个确认）。当人们发现一个区块时，大家也许会觉得他是最长的那条链，但也不是非常确定它是不是最长的。为保证它是最长的，他们附加自己的块并广播给网络中的参与者，来增大它的机率。我们相信如果它不是Nakamoto机制最关键的贡献的话，也是非常重要的，我们也在尝试复制这个激励。

Pos整合面临着这个问题，如果人们直接选举新的主节点，进行主要节点进行区块扣留攻击（一般意义上的数据可用性），这个问题将非常可能被放大。

我们在Plasma的Pos中通过允许权益所有者在主链或父Plasma链中发布一个新区块的提交哈希来减轻这个问题。验证者仅会在他们完全验证过的节点上建新的区块，他们可以并行创建区块（为了鼓励最大化的信息共享）。我们创建了一个验主者的激励来让最近100个块与他们的当前的权益成正比（比如，如果一个节点的权益占3成，那么过去的100个块也需要占3成），通过对这种精确的表现奖励更多的交易费。超出的费用（基于那些表现不理想的权益者）将会进入一个池在将来支付费用。在每个块里存在一个提交包含最近的100个块（和一个nonce）。正确的链将是总权重最高的链，一段时间后整个链将会确定下来（finalize）。

图6：假设Alice，Bob和Carol是三个有相同权重的验证者。他们聚在一起构成一种轮循的结构来获得最大的收益。新的变化提交到了父或主链。链的末端是通过n个时期的正确分布后的最大权重分来偶然选定的（蓝色是当前的候选尾端节点，红色是个孤立节点）。次优链的末端的让所有的费用进行一个池，供正确性在某个阀值之上的验证者使用（比如阀值90%）。在n个周期后，我们可以假设蓝色的链末端进入到确定状态。

这将鼓励大家参与进来，复制Nakamoto共识中的51%攻击假设。当出现一个链被区块扣留攻击或者其它的byzantine行为，非Byzantine的参与者在父或主链进行一个批量的取款。如果最高的Plasma链的押金是用代币的形式，那么非常可能的，这个代币的价值将因为大量的退出而贬值。

2.4 区块链以MapReduce的方式

blockchain : git : Plasma : Hadoop

通过以MapReduce的格式来构建一个计算，以层级树组织的方式来设计计算状态迁移变得相对来说比较容易。

MapReduce提供了一个框架来通过上千个节点进行高扩展计算。区块链面对着类似的问题，来达到这样的运算规模，同时需要额外的计算证明的生成。

图7：左侧蓝色虚线是Plasma从父节点传递到子节点的消息。子节点必须在n个节点内提交到父节点，否则链将暂停。向子链通过数据分发工作，子链提交工作证明。上图中，第三级的子节点完成这些计算，并返回一个字典表（比如，在他们需要计算的章节，统计出”hello“出现了三次等等）。结果字典表会做为提交的一部分被返回回来，字典表在子链中被组合并提交到父节点，最终完成一个全局的字典（比如，统计出整篇文章出现了100次”Hello“等等）。这创造了在大规模情况下强制计算执行的可能，只需要一个区块头提交到主链但却可涵盖大量的数据和工作。除需要发布某个区块是无效数据时，其它情况下仅需周期性的提交很小的数据量到主链。

我们提出了一个方法，Map阶段把用于计算的提交数据做为输入，当返回结果时，在reduce里包含状态转换的Merkle证明。Merkle状态迁移证明通过主链上构建的欺诈证明来保证会强制执行。当然构建一个zk-SNARK的状态转换证明也是可能的。对于某些计算的构建，状态迁移的bitmap，在reduce步骤中也需要（由此每个UTXO/账户在这些情况下会用超过一个bit位）。

上述的结构允许不可估量的高扩展计算，同时兼具时间和速度的权衡。这些权衡产生了一个网络，其中的节点假定计算的有效性，参与者有责任来校验他们。它不是一个这样的系统，大家可以无信任的输出计算能力，而是通过启用了一种能力，能把计算打包进一个绑定的押金证明上。这些绑定的证明鼓励参与者为诚实作证，否则将没收押金。再一次，跟随闪电网络的理念，如果一棵树落在森林中，没有人听他，我们会假设它并不重要，无论它是否产生了声响。类似的，如果没有人来关注/强制计算的执行，则假设它是正确的，或者它最终的结果是正确与否并不重要。计算可以被开放网络上的任何人关注，但利益相关者或者需要整个网络正确的运行的需要周期性的监督这个区块链来保证正确性。扩展性的提升来源于移除了对不会对你产生经济影响的链的关注，人们应该只关注他们需要产生正确行为的链。同时，其它Plasma链的行为整体可以作为reduce步骤中的一部分网罗进来，由此影响到的某个人的其它计算会以最小状态表示。比如，在一个去中化的交易所，人们不关注谁会放入什么订单，它仅仅只会看到一个聚合的订单表，所以它需要把所有其它链看作一个第三方整体，来保证它当前的交易正确执行，最后订单就正确的人执行了（也包括它自身的）。另一个例子是，一个人可以在一个Plasma链上构建一个BBS，它并不需要接收它不关心的主题的更新。

图8：一个人仅仅需要关注那些他希望强制执行的数据。如果经济行为或者计算发生在其它的Plasma链上，它不需要强制执行的（灰色部分），它可以把所有其它链整体作为一个第三方。如，在一个Plasma的去中心化交易所，人们只需要关注影响到自己提交的链（蓝色粗线）。

2.5 关于持久化的去中化化的自治区块链的经济驱动

我们提议了一个结构，其中人们可以创建一个经济驱动，来激励子链永久的运行下去。对于不需要显著复杂性和依赖的状态转换，原生代币（如eth之于以太坊）可以用于状态转换的押金。然而，对于复杂的合约，如需要根据激励来确保在线或订单的公平性，则需要对持续运行进行重要的激励。

每一个Plasma链由一系列的合约表示。这些合约强制执行链上的共识规则，欺诈将导致严重的惩罚，如果能构造出欺诈的证明。

然而，为了激励避免出现Byzantine状态，尤其是保证正确性和可用性，理想情况下每个合约可以创建一个代币。代币代表的是运行这个合约的网络效应，同时创造了一个激励来最大化保证这个合约的安全。因为Plasma链运行于Pos的机制下，需要代币来保证网络的安全，权益相关者不被激励来赞同Byzantine行为或错误行为，因为这会降低所持代币的价值。代币在其中的角色是将成本本地化，因为它作恶，它的代币价值下降，影响的是他自己。

只是简单的合约和商业逻辑，比如代表它人持有资金的简单合约账户，以太坊押金可以用来在Plasma链中代表权益。

那些放上押金的权益者（无论是代币还是eth）都被激励持续的运作网络，因为它们能收到交易费。这些交易费又被用来支付给网络中的权益相关者，从而又激励他们避免Byzantine行为，来创建一个拥有长期价值的代币。

由于权益相关者被激励来持续的运行网络来得到交易费，它们会持久的运行链，同时又受到主链中欺诈合约的约束。

Plasma简述

Plasma是以太坊的一种二层协议扩容方案。方案最早在twitter上公布，白皮书。

下面会尽量以简单的方式来说明其工作方式，来帮助大家入门。

扩容比特币有个闪电解决方案，以太坊对应的叫雷电网络。

这些解决方案的根本的思路是，把小笔交易由链上转移到链下，通过生成代币转移的签名信息，用户间私下交换这些签名信息来实现代币转移。当用户需要兑现转移后的代币，才会把已经签名的交易放到区块链上执行。

雷电网络实现了一个P2P通道，并把以太坊作为存款网络来保证在区块链上达到预期的共识。

雷电网络实现为以太坊的一个扩展。雷电网络会与以太坊网络并行运行，同时与其它的雷电节点通信，实现价值转移；同时也与以太坊网络通信，来管理存款。

即使你发送数百万次的离线交易，你的gas花费仍会非常低，因为只需要极少量的链上的交易来保证交易结算的安全。

随着多个渠道并行在链上清算，可支持的交易量可以大幅增加。支付可以路由到这样一些清算渠道组成的网络上。但雷电或闪电网络并不只限于解决支付问题。它可以用来解决合约状态变化的扩容问题。当然这也正是Plasma正在解决的。

Plasma通过在以太坊整个网络之上增加了一层协议来解决这个问题，下面是架构图：

区块链中的区块链

与闪电网络类似，Plasma是一系列的运行在区块链上的智能合约（比如，以太坊主链）。主网络合约只需要处理来自子区块链非常少量的承诺，然而却能在大多数情况下能够执行令人难以置信的大量计算。承诺会周期性的从子链向主链广播。大家可以把主链看做最高法，而所有下级法院从中获得权利。

然而，不是所有的数据都需要传播到所有的参与方（仅仅只有那些需要验证某个特定状态的才需要），但参与方有义务周期性的监控某些他们感兴趣的特定链，并惩罚其中的违规行为。当攻击发生时，所有的参与者，可以快速和低成本的从某个连到主链的子链中退出。

区块链可以按分层的方式以树状进行排列。这将允许创建一个足够平衡的系统，来最大化数据可用性、安全，同时减少成本。挖矿以绝对安全的方式，仅在主链上，使用主链的安全和有效性证明。

额外的缩放为了消除必须要查看链状态的需要，大家需要时刻监督子链来保证正确的行为。

有许多的系统，比如Cosmos、Polkadot也是以层级的方式来排列区块链的。

每一个子链都可以有自己的token（一种对矿工的糖果奖励）来激励这个链的验证者持续运行下去，同时提供对欺诈状态的保护，这个状态由欺诈证明规则检查（Fraud Proofs rules）（译者注：多链模型？糖果？）。一旦欺诈被检测到（扣留攻击或者一般的数据可用性问题），流氓验证者的存款（比如，押金，债券）就被没收了。

欺诈证明（Fraud proofs）

子链里的所有状态都强制需要通过欺诈证明（智能合约逻辑保证），它可以向各方保证没有无效块，并假定区块数据的有效性。欺诈证明保证所有的状态转换都是有效的。此外，欺诈证明强制执行一个资金提取协议，类似于闪电网络需要一定时间的才能取款退出机制。

译者注

是不是读完之后，也仍然不太明白是怎么一回事。

我说说我自己的理解，可能有差错的，大家要保持自己的思考，谢谢。如果想讨论的，可以在关于本站，找到我的联系方式。

以下内容非常有可能有错，注意，一定要保持您的独立思考

如果你看过Polkadot或者Cosmos是不是发现会有些相似。但他们非常不同。它们实现了一些独立的网络，网络中会有一个独立的，比如Polkadot共识机制来检验所有并行链的共识，而Cosmos则是使用Tendermint共识机制来与其它并行链交互。本质相当于把各个异构链的共识抽象成一个统一共识来实现真正跨链。

而Plasma，是基于某个主链，比如以太坊，更像是对以太坊功能的扩展。类似一个，内部生态网络。子链上可以增加隐私，加密等各种功能，这种功能增强，通过一种类闪电网络的方式，但他可以不止实现闪电网络的支付，还能实现状态转移。

这样一听是不是很鸡肋。但是，对，凡事有个但是。想像一下以太坊内的DAPP，本质上只有部分需要上共识，如果以后每个DAPP都用Plasma都做一个子链，子链解决大部分共识，小部分才上主链。这样是不是一种解决扩容的方案呢。有人说，这与eos的多链方案有点像哦。

A1：是的，可以简单用区块链是一种防伪技术来说明。区块链只是一种技术，就像JAVA，或者其它，它不能直接增加价值，不直接带来价值，不值钱。

但技术与业务的实际结合，可能能体现它的价值。区块链技术现在也有成功的落地应用了。它第一个成功的应用是比特币，第二个成功的应用是ico。先说第二个落地应用ico。ico是什么呢，是取的类似IPO的概念，把其中的p换为了c。不发行股权，而是发行代币。

如果你知道众筹，那么理解起来就容易一些了。任何一个人，有自己的想法，都可以发起一个众筹。任何感兴趣的人，都可以投资，获得使用最初产品的权利。但遗憾的是，参与众筹的人没有股权，就像oculus卖给facebook后，所有参与众筹的人，没有得到任何的利益。

使用区块链这种技术，一个新项目通过ico众筹，并获得项目发给的对应的代币，代币可以代表对这个项目的投票权，分红权。而更多的是，整个项目需要这个代币才能驱动运行。比如IPFS项目，是一个文件存储项目，通过大家贡献自己的闲置硬盘，提供类似dropbox的云服务存储能力。它自己建立了一条区块链，实现对存储内容的加密，分片，冗余存储。一旦存储者能通过存储内容、存储时间证明后，就会奖励存储者代币。这个代币可以直接到二级市场中换成钱，整个系统就靠代币来驱动跑起来。

由于代币记录在区块链帐本上，你投多少，它都接受，想转手就转手（原来的VC，入门门槛高，小散只能去二手市场捡剩的）。ico有点类似改变了天使投资，传统VC。

回过头来，再说第二个应用，比特币。比特币不直接值钱。但现在ico领域发行了约700多种代币，整个区块链的市值达到了百亿级。

由于比特币是第一个，是所有数字货币的鼻祖，总发行量恒定为2100万枚，全球的认可度，了解度都是独一无二的（有一些是坏的，比如勒索病毒）。领域内的人越来越认可其为类似法币社会的黄金，故现在单币市值达到了721亿美元。

Q2: 比特币的匿名？

A2: 所有的数字货币都不完全具有匿名性。对，也最好不做非法的事，也从来没有鼓励大家做非法的事。其实如果你参与数字货币的买卖。在与法币接口的交易所，都需要kyc。你需要提供你的身份认证信息，上传你拿着身份证的照片。所以只有线下，场外交易可能不被监管。

元交易是一个来自于Christian Lundkvist教授的2年前的一个设想。通过设想所带来的效果，我们可能能明白它可以做的，效果就是用户与以太坊的交互不一定需要用户持有以太币（译者注：另一个项目EOS，也有类似的理念，EOS之前的一个项目steem，比较好的诠释了这点）。

这是一个根本的改进。在某些情况下，一些平台型的应用，用户对于其本身基于的平台一无所知。但在以太坊平台之上建立的应用，所有的操作都需要gas，这样就会带来一个糟糕的用户体验，想像一下下面的场景：

1. 用户A想试某个Dapp。
2. 用户下载了某个应用，他发现自己需要一些ether来进行应用操作。
3. 用户必须找到一个值得信任的交易所，上传自己的身份信息。使用法币购买对应的代币。然后要知道如果转移代币到自己的应用。

简单来说，这样的复杂流程不是每个人能接受的。接下来介绍的meta transaction正尝试来解决这个问题。

Meta Transaction是如何工作的

用户使用它的私匙签名一些数据，并把这些数据发给replayer（某个拥有特别权限来转发用户数据的合约）。Replayer将会为这个交易支付gas，并通过这个用户的专用代理合约发送数据到网络中。

//to be continued!

从入门到精通，干货篇。

必读，如果你：

• 是一个专业的程序员
• 如果你想了解以太坊当前可以做到什么程度，通过什么，如何做到。

预备知识：

1. 你需要知道区块链的概念及实现一个无需信任的电子货币的运作原理。可以先看看长版，如果你觉得太长，可以看看短版。但我还是建议，看那个长的视频。
2. 如果你是一名软件工程师，拥有软件开发的经验。能知道从系统、架构角度学一个东西，其实能倍增学习效果。
3. 如果有一周的空闲时间。好了，下面开始就不再是废话了。
4. 你需要了解merkle tree的基本概念，看他是如何做到防止信息篡改，以及信息自校验的（译者注：可以看我曾经翻译的以太坊官方的关于merkle tree的文章，http://me.tryblockchain.org/Ethereum-MerklePatriciaTree.html ）。

不用必须读白皮书，只需要了解一些基本概念。但说实话，如果不读，不会相信这些概念，从而不能真正明白这些概念，所以读白皮书也许仍然是最快的方式。

我建议你完整的读一下本文，从一个较高的层面了解一下，然后再挑感兴趣的，一一钻研，也许要花几天时间哦。

你最后会发现，区块链就是建立在朴实无华的基本技术之上，一点也不神奇。虽然最近各种ICO把它炒得非常热。每个人都是站在巨人的肩膀上，如果你是程序员，你能对这些项目和技术，理解得更深。所以不要因为其它一些糟粕，而失去了一个提升自己的机会。

以太坊

以太坊，Ethereum是一个分布式的计算机，有许多的节点，其中的每一个节点，都会执行字节码（其实就是智能合约），然后把结果存在区块链上。由于整个网络是分布式的，且应用就是一个个的状态组成，存储了状态就有了服务；所以它就能永不停机，没有一个中心化的结点（没有任何一个节点说了算，去中心化的），任何第三方不能干预。

显然上面这一段话，直接解释了以太坊是什么。但你可能有非常多的问题。可以先读一下以太坊的白皮书。或者看下这个视频，25分钟理解以太坊。（译者注：以太坊入门，确实没有什么好的办法，就是看白皮书最好，最快）

智能合约

智能合约与平时的代码其实没有什么区别，只是运行于一个以太坊这样的分布式平台上而已。这个运行的平台，赋予了这些代码不可变，确定性，分布式和可自校验状态等特点。代码运行过程中状态的存储，是不可变的。每一个人，都可以开一个自己的节点，重放整个区块链，将会获得同样的结果（译者注：能控制所有节点都达到一致状态，就是所谓的共识）。

在以太坊中，每个合约都有一个唯一的地址来标识它自己（由创建者的哈希地址和曾经发送过的交易的数量推算出来）。客户端可以与这个地址进行交互，可以发送ether，调用函数，查询当前的状态等。

智能合约，本质上来说就是代码，以及代码运行后存储到区块链上的状态两个元素组成。比如，你用来收发ETH的钱包，本质上就是一个智能合约，只是外面套了一个界面。

概念非常强大，而我相信你已经看完了。而你在看相关的新闻，经常听到这个非常有潜力，经常听到资产/权利管理，分权自治组织（DAO），身份，社交网络等炫酷。但他本质就是这些。

Gas

智能合约，就是一些代码，运行整个分布式网络中。由于网络中的每一个节点都是一个全节点。这样的好处是容错性强，坏处是效率低，消耗资源与时间（译者注：原来只在一个节点执行一次就行，现在所有节点中每一个，都要执行一模一样的运算）。因为执行计算要花钱，而要执行的运算量与代码直接相关。所以，每个在网络运行的底层操作都需要一定量的gas。gas只是一个名字，它代表的是执行所需要花费的成本（译者注：由于以太坊是图灵完备的，随便一个死循环就将导致网络不可用，所以引入了gas的概念）。整个分布式网络引入了强制限制，来避免停机问题。因此如果你写一个死循环，当gas耗尽后，网络就会拒绝执行接下来的操作，并且回滚你之前的所有操作。

gas的价格由市场决定，类似于比特币的交易费机制。如果你的gas价格高，节点则将优先因为利益问题打包你的交易。

一般来说，在Ethereum中计算和存储东西比在传统环境中做的更为昂贵，但是，Ethereum为您的代码提供了上述我们讨论过的那些好的属性，这可能是一样有价值的。

一般来说，在以太坊网上读取状态是免费的，只有写入状态是收费的。下面这个文章是gas概念的一些深度解析。

分布式APP（ĐApp / Dapp / dapp/ dApp）

一个分布式App是指，服务端运行于以太坊网络上一个或多个智能合约。

一个分布式的App不用将所有状态都存储在区块链上，或者在链上进行所有计算（译者注：比如图形渲染），这样就太花gas了。所以一个分布式App把需要大家共同信任的状态存在区块链上就好了。许多的分布式应用使用后面提到的技术，如IPFS和Gelem，在链下进行分布式存储和计算。虽然没在以太坊上，但仍使用的是区块链技术。

我不知道谁开始在D上使用这个小小的缺点，是看起来酷，但会影响搜索。 你可以自由使用，但尽量方便别人的搜索。

以太坊的github上，有一个dapp-bin的目录，有一些文档和示例。使用前，你需要看看文件最近的状态，因为他们将很可能已经被淘汰。

DApp客户端

大多数的分布式应用都通过一些用户友好的前端提供服务，因为不是所有人都愿意通过命令行，通过自己手动组装哈希串和操作指令码进行交易。

一个DApp与传统的开发中的，客户端或前端是类似，区别仅在于它们与以太坊的区块链进行交互（也可以同时与其它服务交互）。这些客户端往往用JS编写，因为当前还暂时没有完成全部的向NodeJS的转换。

另外，大多数的Dapp客户端使用JS的原因，是因为它可以在浏览器中运行，因为大家都有浏览器，这样每个人都可以运行了。由于有更多的go语言的开发工具，使用go语言来写客户端的也不少。在现在这个激烈的发展期，这意味着，除非你有自己的偏好，否则可能要从go和JS（也许还有，Rust）来选择一种语言，来与以太坊区块链，以及基于以太坊开发的协议进行交互了。

以太坊的一个核心开发者，写了一篇关于使用Meteor工具来创建Dapp的文章，这意味着Meteor已经成为Dapp客户端开发的新标准。这绝对是基于JS建立全栈应用时的一个首选方法。但需要注意的是Meteor只是提供了一个开发工具，与DApp客户端并不等同，DApp客户端也完全可以由其它方式开发。（译者注：还有一些其它的开发工具，如Truffle，也是非常不错的哦）。

因为围绕Meteor和DApp开发的活跃，有非常多的包在Atmophere（Meteor的包管理工具），它提供了许多常见的操作，如帐户管理，从区块链中获得最新的50个区块等等。

DApp浏览器

一个DApp浏览器，正如它字面所表达的，用来让DApp客户端（常常使用JS与以太坊的智能合约进行交互）的使用更加容易。

DApp浏览器的主要目的是：

1. 提供到一个以太坊节点的连接（或者连接到一个本地节点或者远程节点），和一个方便的切换不同节点（甚至是不同的网络）。
2. 提供一个帐户（或者一个钱包）来方便用户与DApp交互。

Mist是以太坊官方的DApp浏览器。一个漂亮的界面来与以太坊节点交互，与智能合约发、收交易。

Status是一个手机上可以使用的DApp浏览器。

MetaMask是一个Google浏览器扩展，把Chrome变成了一个DApp浏览器。它的核心特性是注入以太坊提供的js客户端库web3，到每一个界面，来让DApp连接到MetaMask提供的以太坊节点服务。不过这个Chrome扩展，可以允许你管理你的钱包，以及连接到不同的以太坊网络（译者注：包括本地的开发网络）。

Parity是一个以太坊客户端（也是一个全节点的实现），集成到了Web浏览器，并使之成为一个DApp浏览器。

以太坊节点

与比特币的节点类似。每个节点都存储了整个区块链的数据，并重放所有的交易以验证结果的状态。你可以通过geth来运行一个全节点（官方的节点，go语言），或者parity来运行一个轻节点，它是第三方的，Rust语言写的。

你的节点需要知道从哪个区块链下载数据，以及与哪些节点交互，后面会说明一些常见的网络。

你也许可以运行下所有这些节点客户端。如果你不想自己运行一个这样的节点，有第三方的网关服务，比如Infura可以选择。另外还有专门用于测试和开发的，本地版本的节点，后面会提到。

如果你正在开发一个DApp的客户端，你并不总是需要主动提供连接到以太坊的节点。因为DApp的浏览器一般会提供对应的连接（译者注：话说这样，那使用这个，还得额外安装一个DApp浏览器呀）。

以太坊代币

现在你应该知道我们可以通过写智能合约，并将状态存到区块链上了？那如果，在状态这块，我们存的是一个Map类型，键是地址，值是整数。然后我们将这些整数值叫做余额，谁的余额呢？它就是我们要说的代币（译者注：代币的数据结构就是这样简单，存的就是某个用户，它当前的余额）。

是的，所有你刚才听到的代币，只是一些数据，存储在一个哈希表里，通过api或者所谓的协议，来进行增删改查。这是一个简单的基本合约。

你可以看看ethereum的创建一个众筹合约的官方教程。你将会发现它仅仅是一个合约（Crowdsale）与另一个合约（MyToken）交互，和前面的基本合约类似。并没有什么神奇的地方。

人们使用代币来做各种各样的事情，阻拦大家如何使用的只有想像力。代币常常用来激励用户与某个协议进行交互，或者证明对某个资产的所有权，投票权等等。Coinbase的Fred有一个很好的关于代币，为什么存在，如何使用的文章。

Ethereum的创始人Vitalik最近有一个关于代币发售模型，也是一篇不错的文章。

ERC20代币与ERC23代币

每个人都开始定义自己与代币的交互协议，但这些很快显得陈旧，所以一些人开始集结起来，创建了ERC20代币接口标准。大概意思是说，我们定义这些接口，这样大家可以相互统一调用，比如转帐定义为transfer，第一个参数为要转去的帐户地址address _to，第二个参数为要发送的ether的uint _value数量。

有些人觉得ERC20协议过于复杂了，所以他们提议了ERC197，稍微简单一点。

由于在ERC20中存在的一个小问题，有人提议了一个新的ERC23。ERC23是向后兼容ERC20的。如果你已经创建了一个代币合约，可以尝试来支持ERC23。

看起来ERC223和ERC23是相同的概念；ERC的值是223，但是当引用时，作者和所有的其它人误写成了ERC23非常多次，它现在也还是这样引用的。如果一句话说清楚的话，ERC223是规范号，代币说明时称为ERC23代币就好了。

协议代币与App币

协议代币为用来激励对某个协议的使用。比如，REP，Augur的声誉代币，用来鼓励对Augur去中心化预测协议的使用。大多数的以太坊的ERC20/ERC23代币都是协议代币，比如Golem的GNT，ICONOMI，BAT等等。

App币则是用来激励对某个特定DApp或客户端的使用，而不是因为其使用的协议提供的价值。其中一个例子是Status的SNT代币，可以用来在应用内获得价值（比如，进行消息推送，投票权，获得用户名等等）。

这种范式的转变是，我们可以开始投资协议代币而不是应用程序代币，因为我们可以建立在它们之上（任何人都可以在协议之上构建一个dapp，或为实现该协议的Dapp构建一个Dapp客户端）。

之前，这并不可能，因为加密代币，以及接下来的协议创新的时代，为了实现货币化，你自己可以在协议之上创建一个应用，并实现赢利。因为你自己可以实现协议的货币化，大家可以在未来更好的协作。

你也许可以阅读一下，关于0xProject的下面这篇文章，关于这两者区别的详细说明。

与智能合约交互

你与智能合约的交互（也称做调用函数和读取状态）通过连接到某个以太坊节点，并执行操作码。当前有各种各样的以太坊客户端，可以方便进行开发。Geth和parity都提供了控制台或浏览器的方式来更好的与智能合约交互。

如果你想要一个程序的库用来与智能合约交互的接口，也有这样的客户端实现。对于JS语言，可以使用web3.js。以于go语言，可以使用在go-ethereum中的abigen的程序，提供了go包，用来与智能合约交互。

如果只是用来测试和开发，可以使用ethereumjs-testrpc来运行一个本地节点（译者注：这个节点压短区块时间等，可以方便打整的开发与测试）。

当你部署了一个智能合约，你实际进行的操作是向地址0x0发送了一个交易，使用当前合约内容作为参数，一个以太坊交易详解。

Truffle和Embark

一旦你开始写智能合约，你会重复做大量的操作，比如编译源码为字节码和abi，部署到网络，测试然后部署合约等等。你也许希望更关注于你想要实现的东西。

Truffle和Embark框架，标准化和自动化了这些琐碎的工作。它们提供了一个好的开发，部署，以及更为重要的，测试智能合约的体验。

你可以查看这个文章来开启使用Truffle的旅程。

这篇文章，提供了使用Truffle来部署以及与智能合约交互的文章。

Embark提供了类似的，帮助开发者组织工程的稍有些不同的工具。

当你一开始接触智能合约这块时，应该尽量不要使用框架。直到你明白了使用框架能带来的价值时，才应该开始使用，正如你不应该通过rails new来学习HTML语言一样。

ETHPM

分享是关心，所以ETHPM是一个去中心化的智能合约包管理资源库。使用ETHPM，你可以关联或连接到某个著名的合约或库，减少代码重复，尽可能理想的为未来的开发提供好的基础。

这里的这个规范，详细的说明了相关的信息以及背景。Truffle和Embark均可与之集成，并创造一个愉快的开发体验。

网络

Mainnet-以太坊主网，通常是所有客户端的默认网络。

Ropsten - 以太坊使用工作量证明的主测试网络。这个网络，因为低的计算量，容易遭到DDOS攻击，分片，或者其它问题。垃圾邮件攻击后被暂时放弃，最近才恢复使用。

Kovan-parity客户端组成的测试网络，使用授权证明来提升对垃圾邮件攻击的抗扰度，并且持续4秒的阻塞时间。

Rinkeby-geth客户端组成的测试网络，使用集团共识，尽管计算量低，但是对恶意行为者更有弹性。

你可以自己搭建你自己的测试网络，也许使用kubernetes或者docker-compose，但也许你将很快就可以不需要花什么时间。

帐户与钱包

一个以太坊帐户就是一个私钥和公钥地址对。它们可以用来存储ether，创建时不需要花费gas。

钱包则是用来管理ether的智能合约（一些代码）。这里是使用solidity写的一个钱包，运行于Mist浏览器。他们可以有许多的特性，比如多用户签名，纸？等等。

这样，我们就正确的定义了两个名词，前面看到其它人对这两个术语的困惑，并把所有能存ether的都叫作Wallet。

EVM以及智能合约创建的状态

在每个全节点网络上运行的智能合约代码在EVM内执行。这是您的标准虚拟机，执行一些字节码，除了这个vm与网络，文件系统，进程等隔离。没有人想要编写字节码，所以我们有一些更高级别的语言编译为EVM字节码。

Solidity

Solidity是第一批的描述智能合约的语言。当前是最流行的语言，因此也有最多的例子，文档，和教程。你应该学习这个，除非你有要学习其它的理由。

你可以使用基于浏览器的Remix IDE来进行快速验证。

下面是一个Solidity的合约：

pragma solidity ^0.4.11;
contract BasicToken {
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns () {
    balances[msg.sender] = balances[msg.sender] - _value;
    balances[_to] = balances[_to] + _value;
  }
function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
  }
}

LLL

LLL，是一门Lisp风格的底层编程语言，就像语言名称看到的这样。虽然以太坊官方并没有将它作为主要需要支持的语言，但它仍旧持续进行着更新，且与solidity在同一个资源库。

这是一个使用LLL语言写的一个ERC20代币的合约

LLL示例如下：

(seq
  (def 'node-bytes  0x00)
  (def 'owner    0x20) ; address
  (def 'set-node-owner    0x5b0fc9c3) ; setOwner(bytes32,address)
  (def 'get-owner (node)
      (sload (+ node owner)))

//只是用来示例，不能编译通过

如果你正在学习，也许不是那么的容易习惯LLL语言的写法。

Serpent

Serpent是一个类Python的高级语言，最终也会被编译为EVM字节码。它主要被Augur团队使用。

但最近Zeppelin Solution团队发现其编译器有一个严重的bug，在这个问题被修复之前都不建议继续使用。

如果你对Augur如何解决这些漏洞感兴趣，你可以阅读Zeppelin Solution的这篇文章。

Serpent的合约看起来如下：

def register(key, value):
    # Key not yet claimed
    if not self.storage[key]:
        self.storage[key] = value
        return(1)
    else:
        return(0)  # Key already claimed

def ask(key):
    return(self.storage[key])

其它

在各种可用性和发展状态中还有一堆其他的高级语言，而且无疑将会被开发出来。 为了广泛采用，语言和编译器必须经过彻底的审查和测试，这当然需要时间。

智能合约反编译/Disassembly

可以通过prosity来反编译以太坊智能合约的字节码，可以使用evmdis来Disassembly。

智能合约的安全

一旦一个智能合约部署到了以太坊的网络上，它将是永不可变的，且将永久存在。如果你写了一个bug，你将不能下架这个有问题的版本，你只能在后续的版本中修复。

由于许多工程师开发的Ethereum和其他智能合同平台来自于Web开发，所以这个概念实在是太新，而且是疯狂的。

ConsenSys有一个非常棒的资源叫智能合约的最佳实践，你应该深入的理解一下。

一个Parity的钱包被黑的解释。

在你部署你的智能合约的时候，由于你管理的是真正的资金，你应该先开一个赏金计划，并尽量保证它完整的测试过。

Whisper

Whisper是一个集成进以太坊的消息系统。它允许DApp发布小量的信息来进行非实时的消息通信。

它使用shh协议。

尽管它已经有段时间没有更新了，这是一个使用Whisper协议实现一个聊天客户端的例子。

去中心自动化组织（DAOs）

这是一个组织（就像，一群人），其中，使用代码来保证最终的强制执行，而不是使用传统的法律文件。这群人使用智能合约来做常见组织做的所有的事情，比如在某件事上进行投票，比如决定是否对什么进行投资等等。

副作用是决策，管理，以及对什么进行投资的结果将会不可改变的存储在区块链上。

之前slock.it创建了标准的DAO框架来说明这个理念。在这里有对DAO概念的总览，以及如何使用框架来实现一个自己的DAO（译者注：这个项目由于bug被黑客攻击了）。

Aragon

Aragon也正在应对挑战，设计一个根据智能合约逻辑运作的公司，重点是创建一个可以接受投资，处理会计，支付雇员，分配股权，正如我们现在知道的完成每天的公司的业务。他们也实现了漂亮的DApp客户端来让他们的协议使用起来更为简单。

查看这里Aragon核心合约来更多的理解它是如何做的。

IPFS&FileCoin

IPFS（星际文件系统）是一个协议，用来分发文件。你可以认为它是一个基于bittorrent和git这样概念的一个文件系统，文件可以定位，且是不可变的。IPFS以IPLD数据模型存储信息，它非常有趣，提供了一些特别的特性，你可以通过下面的说明了解一些。

这是一个新的协议，它有一个http的网关和文件系统适配器，这让你可以通过http，挂载整个互联网文件系统到你本地的盘/ipfs。IPFS还提供了一个寻址服务IPNS（星际命名空间），它允许可变的状态（需要注意的是在IPFS里的所有东西都是不可变的）。你甚至可以使用DNS TXT记录来定位到你的IPNS客户端，允许你生成用户友好的链接来指向到对应的数据。

FileCoin是Protocol Lab为创建一个去中心化的基于IPFS的存储市场的努力结果，也就是向整个网络提供存储资源的激励层。FileCoin的共识协议没有使用浪费资源的工作量证明，而是使用了Proff of Replication和Proof of SpaceTime来保证每片数据被复制某个特定的拷贝数量且存储某个特定的时间。

你应该读一下IPFS的白皮书，FileCoin的白皮书，以及IPLD的规范。

由于当前FileCoin还没有上线，你可以使用当前的IPFS存储网络来运行html/css/js，并把作为一个类似orbit-db的数据库。

Swarm

Swarm是一个去中心化的存储网络，集成于以太坊生态系统，作为第一阵营的项目，看看这里关于IPFS与这个项目的比较和优劣。但本质上，基本上是一样的，除了它们有不同的哲学，并在底层使用稍微不同的协议。

项目

Augur

Augur是一个去中心化的预测市场，让大家对于某个现实世界的事件进行对赌。一方面，用户在某个具体可以发生的事件上投注，一旦结果成真，它们赢得的代币有真正的价值。为了实现这个，你需要实现一个去中心化的先知协议，来输入现实世界中的信息，它使用REP协议代币来进行经济激励。

你可以看看Augur项目的合约代码，以及了解下Augur Master Plan。

Gnosis

Gnosis与Augur有类似的理念，也是一个去中心化的预测市场。这是项目的白皮书，以及与Augur项目的对比。

Golem

Golem是一个分布式的算力市场，以与IPFS一样的方式构建了一整套的提供算力市场。

你可以看看FAQ来更好的理解。

0xProject

0xProject创建了一个交换代币的协议，以及一个DApp来实现这个协议。开发者可以创建一个基于它们自己的分布式应用创建交易所（技术上叫中继层），而用户也不用信任这些app就可完成交易，结算在区块链上完成。0x协议旨在使用离线的第三方来广播交易和管理订单（可以创建/更新/删除订单，而不用直接向Ethereum发送缓慢/昂贵的交易），但最终会使用Ethereum进行结算。

它们实现了场外交易，一个DApp使用这个协议来在用户之间直接交换代币。你可以在github上查看他们的合约。

你还可以跳过这些酷炫的概念，直接阅读FAQ。

Swap

ConsenSys的Swap协议也是非常类似的，但更专注于p2p的直接交易（而不是基于订单表），这里有一个白皮书，可以看看，这里有一个关于Swap协议的介绍。

Bancor

代币的流动性是相对来说在加密币的生态中是一个非常大的问题。在用户间的交易需要满足买方和卖方两边的想法。

Bancor是一个协议，可以让你的代币1）可以根据订单自动给予价格2）可以通过持有其它的代币作为抵押器来即时创造流动性。

查看这里的白皮书

Makerdao & Dai

以太坊区块链管理的代币价值往往会有巨大的波动。这个特性在现实生活中则非常不好，比如你的目标是用来保值。

Maker DAO是一个DAO来管理Dai稳定币。Dai现在还不存在，但他们已经发布了一个alpha的版本叫Sai来展示这门技术。

这里是DAI的白皮书。

Oraclize

如果我们要向智能合约中输入一些信息，比如纽约今天的天气，我也许需要实现一个去中心化的先知协议询问一批人（花费高且慢），但如果写一个服务以中心化的方式来提供信息，又违背了去中心化应用的理念。

Oraclize尝试用以下方式来解决问题1）从一个外部数据源向你的智能合约发送数据。2）提供一个证明，数据来自某个数据源，且没有被修改过。由此如果你信任random.org，你可以使用Oraclize来提供一个随机数生成合约。

他们的集成非常强大; 您可以获取URL，解析JSON和XPATH，查询Wolfram Alpha等。

BTCRelay

BTCRelay作为比特币区块链交易的先知机制，这意味着你可以在以太坊上编写智能合约来响应比特币区块链上的某个交易，进行触发后续的操作。比如，你可以让人通过BTC为你的服务付费，使用BTCRelay在以太坊上校验付款成功后，继而在以太坊上提供对应的服务。

Open Zeppelin & zeppelinOS

Zeppelin Solutions是一个科技公司，在这个领域内正完成一些伟大，而且专业的事。它们实在做了太多事，太难一一说清了。

他们管理了Open Zeppelin，一系列经过审查的，最佳的智能合约实践，你可以继承并应用于你自己的DApp中。你可以查看他们的github资源来学习更多。你应该读一下里面的每一个合约。

他们坚持代码复用的理念，然后进一步创建了Zeppelin OS。你可以忽略OS，它不是传统意义上的操作系统的概念。zeppelinOS特性，工具和服务的集合，旨在提供稳固的开发人员体验，同时最大限度地提高智能合同安全性。

zeppelinOS中的其中一部分是“zeppelinOS Kernel”。其实他们不是传统意义上的核心，而且是一组库。它们是通过库模型实现的可升级的智能合约，可以在出现安全问题时独立的进行更新。因为你在合约内包含的代码更少，部署也将花费更少的gas，而开发者也减少了代码的重复。

zeppelinOS还有一些其他整齐的规划，比如调度程序（智能合约的异步执行，因为默认合同一般不会主动触发某个行为），市场级的协议和链下开发者体验工具。

ENS - 以太坊的命名服务

ENS是一个去中心化的名称注册服务。并有一个描述性的项目名称。

BAT 基础注意力代币 & Brave浏览器

BAT尝试去中心化广告系统，通过监控大家的注意力，并在内容提供商，广告商和用户之间分发收益，切掉中间人。

Brave和BAT由JS创始人Brendan Eich创建，同时他也是Mozilla的联合创始人。

uPort

uPort在解决去中心化的身份识别问题。

district0x

district0x是一个更高层级的去中心化的市场和社区。核心是通过一系列的智能合约来管理用户发布信息，搜索，过滤信息，在社区内维护信誉，管理支付等等。它可以用来建议如Ethlance和NameBazaar这样的市场。

他们有非常棒的视觉设计。

Steem

Steem是区块链上的reddit，它使用协议代币（STEEM）来激励这个社交社区的参与度。

在这里查看白皮书。

有一些关于Steemit块链如何启动以及支持组织如何运作的反应。

参与者与领域内的玩家

ConsenSys

ConsenSys（有点像共识Consensus，但作为一个公司名称;它很聪明，巧妙的把u改成了s，但我一般念为“con-SEn-SIS”，避免读错）是一个“风险投资和产品工作室”。他们是一个（其实非常大）伞形组织，它赞助了一大堆项目和核心组件的开发。值得一提的是，它们资助了Truffle，Infura，MetaMask，Gnosis和uPort。

Zeppelin Solutions

Zeppelin Solutions在上面我们有提到过，他也审查智能合约代码，提供咨询服务。他们的博客质量相当高。

Protocol Labs

Protocol Labs是一群让人印象深刻的人，致力于IPFS，FileCoin，lip2p以及IPLD等其它项目的开发。

区块链资本概况

Etienne Brunet有一篇关于代币，ICO和VC的概况文章。

社区

你可以加入以太坊的社区。

未来

未来展望。

最后

显然，这篇文章将非常快的过时，所以如果某个协议，平台，技术，或团队，你非常喜欢，你可以告诉我，我考虑将他们加到文章内。

因为智能合约往往涉及金钱，保证Soldity代码没有错误，以及足够的安全是非常根本的。Zeppelin Solutions，一个智能合约审查服务商，已经意识到相关的需求。建立在他们的合约审查经验之上，他们把一些最佳实践整理到了OpenZeppelin。

我们可以使用和扩展这些合约，以在更少的时间内创建更安全的DAPP。OpenZeppelin为各种各样重要的功能提供了广泛的智能合约（在这里查看全部支持合约）。而今天，我们来看看其中的代币合约。具体来说，我们打算扩展其中提供了StandardToken.sol来创建一个我们自己的支持ERC-20标准的代币。

环境

这个教程需要你对Truffle、Ethereum和Solidity已经有一些了解。你可以先从宠物商店这个教程开始。

查看更多相关的信息

• Truffle的文档
• 以太坊概述

• Solidity语言文档

  我们倾向于在教程中使用命令行。所以你需要了解一些如何在你所在环境使用命令行的一些知识。

概述

在这个教程里你将学到下述的知识：

• 拆箱即用的前端
• 使用OpenZeppelin的StandardToken来创建自己的TutorialToken
• 编译和部署智能合约到testrpc
• 与自己新创建的前端交互

拆箱即用的前端

开发的主要精力应该放在智能合约上。为达到这个目的，Truffle以truffle box的方式提供了拆箱即用的前端。打开命令行，进入到某个工作空间。在这里我们选择工作空间oz-workspace。

$ cd oz-workspace
$ truffle unbox tutorialtoken

备注: Truffle要升级到最新版，可以用命令sudo npm i -g truffle升级。

当前文章的Truffle版本：

$ truffle version
Truffle v3.4.7 (core: 3.4.7)
Solidity v0.4.13 (solc-js)

成功安装后的目录如下：

下一步，我们要集成OpenZeppelin。最新版本的OpenZeppelin可以通过npm来安装使用。

npm install zeppelin-solidity

集成成功后，在node_modules有zeppelin-solidity的依赖，如下图所示：

2. 创建TutorialToken智能合约

使用已经搭建好的前端环境，现在让我们来创建TutorialToken合约。在contracts目录下，创建名为TutorialToken.sol的智能合约，内容如下：

pragma solidity ^0.4.4;
import 'zeppelin-solidity/contracts/token/StandardToken.sol';

contract TutorialToken is StandardToken {

}

在上面的代码中，import了StandardToken.sol，并声明TutorialToken继承自StandardToken。这样就继承了StandardToken合约中所有变量和函数。继承的合约可以被覆盖，只要在子类重定义对应的变量与函数就行了。

接下来，设置代币的参数，需要定义自己的name，symbol，decimals和INITIAL_SUPPLY。

string public name = 'TutorialToken';
string public symbol = 'TT';
uint public decimals = 2;
uint public INITIAL_SUPPLY = 12000;

name和symbol变量，定义了代币的一个独一无二的标识。decimals变量定义了代币可被细分的程度。在上面的例子里decimals我们的取值为2，效果类似于美元和美分。最后，INITIAL_SUPPLY变量定义了在合约部署时，代币将创建的数量。在这个例子中，我们选择的是12000。

最后在构造函数中我们简单设置totalSupply来等于INITIAL_SUPPLY，同时把所有的币赋值给部署者的帐户。

function TutorialToken() {
  totalSupply = INITIAL_SUPPLY;
  balances[msg.sender] = INITIAL_SUPPLY;
}

这样，使用小于15行手写的Solidity代码，我们创建了一个自己的ERC-20的代币。下一步，我们将部署代币，并与代币进行交互。

3. 编译与部署

在/migrations目录下，用下述内容创建文件2_deploy_contracts.js：

var TutorialToken = artifacts.require("./TutorialToken.sol");

module.exports = function(deployer) {
  deployer.deploy(TutorialToken);
};

TutorialToken合约内的import语句会由编译器进行自动处理，它会自动导入StandardToken内的相关引用包。

现在，我们可以编译与部署了：

## 启动testrpc
$ testrpc
## 编译合约
$ truffle compile
## 部署合约
$ truffle migrate

migrate时默认选择的网络是development
你当前的Truffle默认配置truffle.js应该如下（即默认部署到testrpc）：

module.exports = {
  networks: {
    development: {
      host: "localhost",
      port: 8545,
      network_id: "*" // Match any network id
    }
  }
};

4. 与TutorialToken交互

对于这部分的教程，我们推荐使用MetaMask的Chrome插件。它能轻松的在不同的帐户间快速切换，对于测试我们新创建代币的转发非常方便。这里有设置metamask与testrpc的教程

另外，我们已经为你安装了lite-server，所以可以在oz-workspace目录，跑下面的命令，跑起来一个简单的页面：

npm run dev

运行后会弹出一个界面如下：

这个简单的dapp显示了当前的余额。

可以尝试转移一些代币到其它的帐户，下面这里，转移了2000TT到第二个帐户。

Truffle + OpenZeeelin 超级开发体验

Truflle很激动的看到，类似Zeppelin Solutions这样解决方案对于合约标准化，以及提升安全性上的贡献。结合OpenZeppelin的合约和Truffle的工具集，可以非常容易的创建工业级的分布式应用。

enjoy。

update20170902:好多人说，看不到余额？显示是TT。

确保你已经安装了MetaMask，这个浏览器插件，帮你注入web3.js到前端中。

官网：https://metamask.io ，google插件应该在这里：https://chrome.google.com/webstore/detail/nkbihfbeogaeaoehlefnkodbefgpgknn

详细集成TestRpc与MetaMask教程：http://truffleframework.com/tutorials/pet-shop#using-our-dapp-in-chrome

一个小插曲，使用MetaMask，一直连不上我的TestRpc。于是我使用 http://localhost:8545 放到浏览器中，一直显示400 bad request。这个尝试误导了我，其实MetaMask是通过配置的IP与端口，以RPC方式访问，直接http访问是不行。但我的MetaMask就是不能切换到TestRPC，结果花了两个小时，发现是我的电脑开了全局代理。浏览器，走了代理，所以不行，/笑哭。

1. 首先部署

部署成功后，你能看到successful字样

2. 导入帐户

由于Truffle默认是使用TestRpc的第一个帐户来进行发布的，所以代币也是初始分配给了第一个帐号。所以我们要回到TestRpc，找到第一个帐户并导入到MetaMask。

这是我本地的TestRpc的启动输出结果。由于是可以通过私匙推出公匙，所以MetaMask导入时，使用私匙导入就可以，选择下面的Import Account。

输入第一个私匙，其实就是创建合约的那个帐户。切换到这个帐户后，你就能看到你自己代币的余额了。

成功后，可以看到下面的界面了。

最近EOS官网出了文档，说可以跑通一个独立测试的节点了。这周尝试自行搭建了一下，由于自己不完全做mac下的开发，且这玩意是C写的，所以make起来遇到不少坑，记录下来。附完整踩坑、填坑记录。

1. 搭建环境

在mac下大家应该都用brew来管理包吧。首先官方说要安装：

• Boost 1.64
• OpenSSL
• LLVM 4.0

通过下面命令，可以尽可能全的安装编译环境：

brew install autoconf automake libtool boost openssl pkg-config

另外需要安装的下面这个，brew并没有，需要手动安装：

• secp256k1-zkp (Cryptonomex branch)

步骤如下：

git clone https://github.com/cryptonomex/secp256k1-zkp.git
cd secp256k1-zkp
./autogen.sh
./configure
make
sudo make install

2. 编译LLVM和clang来支持智能合约运行的WASM环境

默认安装的LLVM和clang并不会包含WASM模块，所以需要自行编译，下面是实现仅仅编译LLVM只会生成WASM模块。

mkdir  ~/wasm-compiler
cd ~/wasm-compiler
git clone --depth 1 --single-branch --branch release_40 https://github.com/llvm-mirror/llvm.git
cd llvm/tools
git clone --depth 1 --single-branch --branch release_40 https://github.com/llvm-mirror/clang.git
cd ..
mkdir build
cd build
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=.. -DLLVM_TARGETS_TO_BUILD= -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly -DCMAKE_BUILD_TYPE=Release ../
make -j4 install

3. 获取EOS源码

递归取下来所有的EOS及其模块代码：

git clone https://github.com/eosio/eos --recursive

如果你没有带--recursive标志，可以运行下面的命令来抓下来需要的模块（这个命令我没有试，使用时，要看是不是需要进到目录内）：

git submodule update --init --recursive

4. 使用WASM编译器完整编译EOS源码

需要配置WASM_LLVM_CONFIG环境变量来找到上面构建的WASM的编译器。这个编译器是用来编译eos/contracts下的合约例子，和相应的测试用例的。

git clone https://github.com/eosio/eos --recursive
mkdir -p eos/build && cd eos/build
export WASM_LLVM_CONFIG=~/wasm-compiler/llvm/bin/llvm-config 
cmake ..
make -j4

上面的cmake ..会遇到一些坑，可参考使用第7节中完整填坑后的cmake脚本。

5. 创建并运行一个测试网节点

进入到编译目录

$ cd programs/
$ /eosd/eosd

运行上述命令后会立即报错，按Ctrl C强制中止后，命令运行目录下，会生成默认的./data-dir/目录，目录下有./data-dir/config.ini配置。可以略微看看默认的配置，再启动就好了（这里相当于没有配置，帮你生成了默认配置，所有人都一样，不安全）：

如果要支持命令行，在config.ini下，添加下述配置。参见 https://eosio.github.io/eos/group__eosc.html

plugin = eos::chain_api_plugin

这样，就可以通过EOS自己的命令行工具eosc来进行交互，如下：

./eosc/eosc info

输出效果：

{
  "head_block_num": 0,
  "last_irreversible_block_num": 0,
  "head_block_id": "0000000000000000000000000000000000000000000000000000000000000000",
  "head_block_time": "2017-03-30T12:00:00",
  "head_block_producer": "",
  "recent_slots": "1111111111111111111111111111111111111111111111111111111111111111",
  "participation_rate": "1.00000000000000000"
}

6. 可能遇到的坑

6.1 可能遇到GMP包找不到的报错：

CMake Error at /usr/local/Cellar/cmake/3.9.0/share/cmake/Modules/FindPackageHandleStandardArgs.cmake:137 (message):
Could NOT find GMP (missing: GMP_LIBRARIES GMP_INCLUDE_DIR)
Call Stack (most recent call first):
/usr/local/Cellar/cmake/3.9.0/share/cmake/Modules/FindPackageHandleStandardArgs.cmake:377 (_FPHSA_FAILURE_MESSAGE)

解决办法：

brew install gmp

6.2 可能遇到ssl相关的错

CMake error: Could not find openSSL or GCrypt

但明明已经安装，原因是由于新版mac已经移除了openssl，所以我们需要手动配置环境变量，可以在cmake的命令行中通过-D的方式传入OPENSSL_ROOT_DIR和OPENSSL_LIBRARIES两个环境变量：

cmake -DOPENSSL_ROOT_DIR=/usr/local/Cellar/openssl/1.0.2l -DOPENSSL_LIBRARIES=/usr/local/Cellar/openssl/1.0.2l/lib ..

6.3 最后的联接时失败Link failed

第一种，使用brew install llvm后会遇到下面的报错：

- Configuring ChainBase on OS X

CMake Error at libraries/wasm-jit/Source/Runtime/CMakeLists.txt:26 (find_package):

Could not find a package configuration file provided by "LLVM" (requested

version 4.0) with any of the following names:

LLVMConfig.cmake

llvm-config.cmake

Add the installation prefix of "LLVM" to CMAKE_PREFIX_PATH or set

"LLVM_DIR" to a directory containing one of the above files.  If "LLVM"

provides a separate development package or SDK, be sure it has been

installed.

-- Configuring incomplete, errors occurred!

解决办法，配置环境变量：

export LLVM_DIR=/usr/local/Cellar/llvm/4.0.1/lib/cmake/llvm

另一种可能，是手动安装llvm遇到下面的报错：

typeinfo for LLVMJIT::UnitMemoryManager in libRuntime.a(LLVMJIT.cpp.o)
"typeinfo for llvm::CmpInst", referenced from:
typeinfo for llvm::FCmpInst in libRuntime.a(LLVMEmitIR.cpp.o)
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [libraries/wasm-jit/Source/Programs/wavm] Error 1
make[1]: *** [libraries/wasm-jit/Source/Programs/CMakeFiles/wavm.dir/all] Error 2

初步怀疑这种是因为在第2节中，使用的是默认的llvm编译了，但却后续又使用手动安装的llvm进行后续操作导致的。故统一使用brew管理的llvm。

完整的解决过程，参考这里：https://github.com/EOSIO/eos/issues/99

7. 完整的cmake脚本供参考

## 引入支持合约运行的编译器WASM
export WASM_LLVM_CONFIG=~/develop/eos/environment/wasm-compiler/llvm/bin/llvm-config
## 引入LLVM
export LLVM_DIR=/usr/local/Cellar/llvm/4.0.1/lib/cmake/llvm
## 新版mac移除了openssl的环境变量配置，手动设置并cmake
cmake -DOPENSSL_ROOT_DIR=/usr/local/Cellar/openssl/1.0.2l -DOPENSSL_LIBRARIES=/usr/local/Cellar/openssl/1.0.2l/lib ..

如果你是以太坊开发的新手，我们推荐你在继续本文前，先读一下我们的以太坊智能合约指南（基本概念及环境搭建）：https://medium.com/bitcorps-blog/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05#.6dob381ks

安全的开发以太坊的智能合约，是非常需要花费精力的。已经有一些好的指南以及汇总，比如 Consensys的智能合约最佳实践，和Solidity官方文档的安全指南。但除非真正写代码，这些概念很难被记住和理解。

本文会尝试一个有点不同的办法。首先解释提升智能合约安全的一些策略，并展示一些不遵从，而引起问题的例子。最后给一些已经调整地，可以直接使用的最佳实践。希望，这能帮助你创建避免某些不安全行为的肌肉记忆，从而在写代码的时候意识到可能的风险。

不啰嗦了，进入正题吧。

尽早且明确的暴露问题

一个简单且强大的最佳实践是，让尽早且明确的暴露问题。接下来，看一个有问题的函数实现：

// 有问题的代码，不要使用！
contract BadFailEarly {
  uint constant DEFAULT_SALARY = 50000;
  mapping(string => uint) nameToSalary;
  function getSalary(string name) constant returns (uint) {
    if (bytes(name).length != 0 && nameToSalary[name] != 0) {
      return nameToSalary[name];
    } else {
      return DEFAULT_SALARY;
    }
  }
}

为避免合约潜在的问题，或者让合约运行于一个不稳定或不一致的状态。上面例子中的函数getSalary应该在返回结果前，检查参数。那现在的例子有什么问题呢，问题在于，如果条件不满足，将返回默认值。这将掩盖参数的严重问题，因为仍然可以按正常业务逻辑返回值。这虽然是一个比较极端的例子，但却非常常见，原因是大家在程序设计时，担心程序兼容性不够，所以设置一些兜底方案。但真相是，越快失败，越容易发现问题。如果我们不恰当的掩盖错误，错误将扩散到代码的其它地方，从而引起非常难以跟踪的不一致错误。下面是一个调整后的示例：

contract GoodFailEarly {
  mapping(string => uint) nameToSalary;
  
  function getSalary(string name) constant returns (uint) {
    if (bytes(name).length == 0) throw;    
    if (nameToSalary[name] == 0) throw;
    
    return nameToSalary[name];
  }
}

这个版本的代码，还展示了另外一种推荐的编码方式，一种将条件预检查分开，分开判断，验证失败的方式。原因是可以使用Solidity提供的修改器的特性，来实现重用。

在支付时使用（pull）模式而不是（push）模式

每次ether的转移，都需要考虑对应帐户，潜在的代码执行。一个接收的合约可以实现一个默认的回退函数，这个函数可能抛出错误。由此，我们永远要考虑在send执行中的可能的错误。一个解决方案是，我们应该在支付时使用（pull）模式而不是（push）模式。来看一个看起来没有问题的，关于竞标函数的例子：

// 有问题的代码，请不要直接使用！
contract BadPushPayments {
  address highestBidder;
  uint highestBid;
 
  function bid() {
    if (msg.value < highestBid) throw;
    if (highestBidder != 0) {
      // return bid to previous winner
      if (!highestBidder.send(highestBid)) {
        throw;
      }
    }
    highestBidder = msg.sender;
    highestBid = msg.value;
  }
}

上述的合约，调用了send函数，检查了返回值，看起来是非常符合常理的。但它在函数中调用了send函数，这带来了不安全，为什么？需要时刻记住的一点是，就像之前说的，send会触发另外一个合约的代码执行。

假如某个竞标的地址，它会在每次有人转帐给他时throw。而此时，其它人尝试追加价格竞标时会发生什么呢？那么send调用将总是会失败，从而错误向上抛，让bid函数产生一个异常。一个函数调用如果以错误结束，将会让状态不发生变更（所有的变化都将回滚）。这将意味着，没有人将能继续竞标，合约失效了。

最简单的解决方案是，将支付分离到另一个函数中，让用户请求（pull）金额，而不依赖于余下的合约逻辑：

contract GoodPullPayments {
  address highestBidder;
  uint highestBid;
  mapping(address => uint) refunds;
  
  function bid() external {
    if (msg.value < highestBid) throw;
    
    if (highestBidder != 0) {
      refunds[highestBidder] += highestBid;
    }
    
    highestBidder = msg.sender;
    highestBid = msg.value;
  }
  
  function withdrawBid() external {
    uint refund = refunds[msg.sender];
    refunds[msg.sender] = 0;
    if (!msg.sender.send(refund)) {
      refunds[msg.sender] = refund;
    }
  }
}

这次，我们使用一个mapping来存储每个待退款的竞标者的信息，提供了一个withdraw用于退款。如果在send调用时抛出异常，仅仅只是那个有问题的竞标者受到影响。这是一个非常简单的模式，却解决了非常多的问题（比如，可重入）。所以，记住一点，当发送ether时，使用（pull）模式而不是（push）模式。

我已经实现了一个使用这个模式的合约，可以方便的继承使用。

函数代码的顺序：条件，行为，交互

作为尽可能早的暴露问题的原则的一个延伸，一个好的实践是将你的函数结构化为：首先，检查所有前置的条件；然后，对合约的状态进行修改；最后，与其它合约进行交互。

条件，行为，交互。坚持使用这样的函数结构，将会让你避免大部分的问题。下面来看使用了这个模式的一个例子：

function auctionEnd() {
  // 1. Conditions
  if (now <= auctionStart + biddingTime)
    throw; // auction did not yet end
  if (ended)
    throw; // this function has already been called

  // 2. Effects
  ended = true;
  AuctionEnded(highestBidder, highestBid);

  // 3. Interaction
  if (!beneficiary.send(highestBid))
    throw;
  }
}

这首先符合尽可能早的暴露问题的原则，因为条件在一开始就进行了检查。它让存在潜在交互风险的，与其它合约的交互，留到了最后。

留意平台局限性

EVM有非常多的关于合约能做的硬限制。这些是平台级的安全考虑，如果你不知道的话，却可以会威胁你的合约安全。下面来看一个看起来正常的，雇员津贴管理的代码：

// 不安全的代码，不要直接使用！
contract BadArrayUse {
  
  address[] employees;
  
  function payBonus() {
    for (var i = 0; i < employees.length; i++) {
      address employee = employees[i];
      uint bonus = calculateBonus(employee);
      employee.send(bonus);
    }     
  }
  
  function calculateBonus(address employee) returns (uint) {
    // some expensive computation ...
  }
}

读完代码，业务实现非常直接，看起来也没有什么问题，但却潜藏三个问题，基于平台的一些独特性。

第一个问题是i的类型将会是uint8，因为如果要存0，如果不指定类型，将自动选择一个占用空间最小的，恰当的类型，在这里将是uint8。所以如果这个数组的大小超过255个元素，这个循环将永远不会结束，最终将导致gas耗尽。应当在定义变量时，尽可能的不要使用var，明确变量的类型，下面我们来修正一下上面的例子：

// 仍然是不安全的代码，请不要使用！
contract BadArrayUse {
  
  address[] employees;
  
  function payBonus() {
    for (uint i = 0; i < employees.length; i++) {
      address employee = employees[i];
      uint bonus = calculateBonus(employee);
      employee.send(bonus);
    }     
  }
  
  function calculateBonus(address employee) returns (uint) {
    // some expensive computation ...
  }
}

第二个你需要考虑的事情是gas的限制。gas是以太坊的一种机制，来对资源的使用收费。每一个修改状态的功能调用都会花费gas。假如calculateBonus计算津贴时有些复杂的运算，比如需要跨多个项目计算利润。这将消耗非常多的gas，将会很容易的达到交易和区块的gas限制。如果一个交易达到了gas的限制，所有的状态的改变都将会撤销，但消耗的gas不会退回。当使用循环的时候，尤其要注意变量对gas消耗的影响。让我们来优化一下上述的代码，将津贴计算与循环分开。但需要注意的是，拆开后仍然有数组变大后，带来的gas消耗增长的问题：

// UNSAFE CODE, DO NOT USE!
contract BadArrayUse {
  
  address[] employees;
  mapping(address => uint) bonuses;  
  
  function payBonus() {
    for (uint i = 0; i < employees.length; i++) {
      address employee = employees[i];
      uint bonus = bonuses[employee];
      employee.send(bonus);
    }     
  }
  
  function calculateBonus(address employee) returns (uint) {
    uint bonus = 0;
    // some expensive computation modifying the bonus...
    bonuses[employee] = bonus;
  }
}

最后，还有一个关于调用栈调用深度的限制。EVM栈调用的硬限制是1024。这意味着如果嵌套调用的深度达到1024，合约调用将会失败。一个攻击者可以调用递归的调用我们的合约1023次，从而因为栈深度的限制，让send失败。前述的（pull）模式，可以比较好的避免这个问题（译者注：原链接找不到了，但找下github上的讨论：https://github.com/OpenZeppelin/zeppelin-solidity/issues/15）。

下面是一个最终的修改版，解决了上述的所有问题：

import './PullPaymentCapable.sol';
contract GoodArrayUse is PullPaymentCapable {
  address[] employees;
  mapping(address => uint) bonuses;
  
  function payBonus() {
    for (uint i = 0; i < employees.length; i++) {
      address employee = employees[i];
      uint bonus = bonuses[employee];
      asyncSend(employee, bonus);
    }
  }
  function calculateBonus(address employee) returns (uint) {
    uint bonus = 0;
    // some expensive computation...
    bonuses[employee] = bonus;
  }
}

总结一下，需要记住的 1）使用的变量类型的限制，2）合约的gas消耗，3）栈调用1024的限制。

测试用例

编写测试用例会占用大量的时间，但也能抵消你在添加新功能后回归问题需要花费的时间。回归问题具体是指在添加功能的修改过程中，导致之前的组件出现bug。

我将尽快写一个更加广泛的关于测试的指南，如果你比较好奇，可以先看看关于Truffle的测试指南（译者注：原文链接失效了，也许是这个）。

容错及自动bug奖励

首先感谢Peter Borah带来的这两个想法的灵感。代码审查和安全审核对保证安全来说还不足够。我们的代码需要做好最坏情况的准备。当我们的智能合约中有漏洞时，应该有一种方法可以安全的恢复。不止如此，我们也应该尽可能早的发现漏洞。下面是一个内置的自动bug奖励机制带来的作用。

下面我们就来看一个自动bug奖励的假设的代币管理的例子：

import './PullPaymentCapable.sol';
import './Token.sol';
contract Bounty is PullPaymentCapable {
  bool public claimed;
  mapping(address => address) public researchers;
  
  function() {
    if (claimed) throw;
  }
  
  function createTarget() returns(Token) {
    Token target = new Token(0);
    researchers[target] = msg.sender;
    return target;
  }
  
  function claim(Token target) {
    address researcher = researchers[target];
    if (researcher == 0) throw;
    
    // check Token contract invariants
    if (target.totalSupply() == target.balance) {
      throw;
    }
    asyncSend(researcher, this.balance);
    claimed = true;
  }
}

首先，正如前面所述，我们使用PullPaymentCapable来让我们的支付更加安全。这个赏金合约，允许研究者创建当前我们审核的Token合约的副本。任何人都可以参与到这个赏金项目，通过发送交易到这个赏金项目地址。如果任何研究者可以攻破他自己的Token合约的拷贝，让一些本不该变的情况变化（比如这里，让总代币发行量与当前代币余额不一致），他将获得对应的赏金。一旦赏金被领取了，合约将不再继续接受新的资金（无名的函数被称为合约的回退函数，在每次合约接收ether时自动执行）。

正如你看到的，它有一个非常好的特性是分离了合约，不需要对原始的Token合约进行修改。这里有一个完整，任何人都可以使用的版本。

而对于容错性，我们需要修改我们原来的合约来增加额外的安全机制。一种简单的方案是允许合约的监督者可以冻结合约，作为一种紧急的机制。我们来看一个通过继承实现这种行为的例子：

contract Stoppable {
  address public curator;
  bool public stopped;
  modifier stopInEmergency { if (!stopped) _ }
  modifier onlyInEmergency { if (stopped) _ }
  
  function Stoppable(address _curator) {
    if (_curator == 0) throw;
    curator = _curator;
  }
  
  function emergencyStop() external {
    if (msg.sender != curator) throw;
    stopped = true;
  }
}

Stoppable允许指定一个监督者，可以来停止整个合约。实现方式是，通过继承这个合约，在对应的功能上使用修改器stopInEmergency和onlyInEmergency，下面我们来看一个例子：

import './PullPaymentCapable.sol';
import './Stoppable.sol';
contract StoppableBid is Stoppable, PullPaymentCapable {
  address public highestBidder;
  uint public highestBid;
  
  function StoppableBid(address _curator)
    Stoppable(_curator)
    PullPaymentCapable() {}
  
  function bid() external stopInEmergency {
    if (msg.value <= highestBid) throw;
    
    if (highestBidder != 0) {
      asyncSend(highestBidder, highestBid);
    }
    highestBidder = msg.sender;
    highestBid = msg.value;
  }
  
  function withdraw() onlyInEmergency {
    suicide(curator);
  }
}

在上面这个非常简单的例子中，bid可以被一个监督者停止，监督者在合约创建时指定。StoppableBid在正常情况下，只有bid函数可以被调用，而当出现紧急情况时，监督者可以介入，并激活紧急状态。并让bid函数不再可用，同时激活withdraw功能。

在上面的例子中，紧急模式将允许监督者销毁合约，恢复资金。但在实际场景中，恢复的逻辑更为复杂（举例来说，需要返还资金给每个投资者）。这里有一个可停止合约的实现（译者注：给的这个链接无法访问了）。

限制可存入的资金

另一个保护我们智能合约远离攻击的方式是限制。攻击者最有可能针对管理数百万美元的高调合同。并不是所有的合约，有这样的高的资金量。尤其是当我们正在初期。在这种情形下，限制合约可以接收的资金量就将非常有用。最简单的方式，可以实现为一个余额的硬上限。

下面是一个简单的例子：

contract LimitFunds {
  
  uint LIMIT = 5000;
  
  function() { throw; }
  
  function deposit() {
    if (this.balance > LIMIT) throw;
    ...
  }
}

回退函数里，会拒绝接收所有的直接支付。deposit函数会首先检查合约的余额是否已经超限，超限将直接抛出异常。其它一些更有意思的，比如动态上限，管理限制也很容易实现。

简单和模块化的代码

安全来自，我们想写的与代码实际可以做的距离。这非常的难以验证，特别是当代码量又大，又混乱时。这就是为什么写简单和模块化的代码变得非常重要。

这意味着，函数应该尽可能的简单，代码之间的依赖应该极尽可能的少，文件应该尽可能的小，将独立的逻辑放进模块，每块的职责更加单一。

命名是我们在编码过程中表达我们意图的方式。想一个好的名字，尽可能的让名字清晰。

让我们来看一个关于Event的差命名的例子。看看DAO里的函数。其中的函数代码都太长了。

最大的问题是太长，而且功能复杂。尽可能的让你的函数短小，比如，最多不超过30到40行代码。理想情况下，你应该在1分钟内弄明白函数的意图。另一个问题是关于事件Transfer在第685行的命名。这个名字与一个叫transfer的函数名只有一字之差。这将带来误解。一般来说，关于事件的推荐命名是使用Log打头，这样的话，这个事件应该命名为LogTransfer。

记住，尽可能的将你的合约写得简单，模块化，良好的命名。这将极大的帮助其它人和你自己审查你自己的代码。

不要从0开始写所有的代码

最后，正如一句格言所说，“不要从头发明你自己的加密币”。我想它也适用于智能合约代码。你的操作与钱有关，你的数据是公开的，你正在一个全新的成长中的平台上。代价非常高，糟蹋机会的人无处不在。

上述这些实践帮助我们写出更安全的合约。但最终，我们应该开发出更好的创建智能合约的工具。这里有一些先行者，包括better type systems，Serenity Abstractions 和the Rootstock platform。

现在已经有非常多的安全的代码，以及框架出现了。我们整合了一部分最佳实践到Github的资源库Open Zeppelin。欢迎看看以及贡献新代码，以及提供代码审查建议。

总结一下

回顾一下，这篇文章中描述的安全模式有：

1. 尽早且明确的暴露问题。
2. 使用（pull）模式而不是（push）模式
3. 代码结构遵从：条件，行为，交互
4. 注意平台限制
5. 测试用例
6. 容错及自动bug奖励
7. 限制存入的资金
8. 简单与模块化的代码
9. 不要从零开始写代码

如果你想讨论与智能合约相关的问题，欢迎加入Slack，让我们一起来提升智能合约编程标准。

想要获得持续的更新，欢迎关注我们的Medium和Twitter；

（完）

存储，计算和通信

原文翻译自：https://blog.bigchaindb.com/blockchain-infrastructure-landscape-a-first-principles-framing-92cc5549bafe

Ethereum，IPFS/Filecoin，和BigChainDB是如何实现互相补充的呢？那Golem，Polkadot或Interledge又是如何的呢。我经常问我自己这样的问题。所以我打算写篇文章来阐述自己的，第一性原理框架，并来回答这些问题。

简短的答案是：没有一个叫“区块链”的银弹，它能神奇的做所有的事情。相反，这里有的是非常好的实现图灵完备的各种各样的组件，你可以使用它们来搭建有效率的去中心化应用。以太坊可以参与其中，BigchainDB可以，所有其它组件也都可以，我们来一起看看...

背景

组成一个程序的要素有存储，计算和通信。大型机，个人电脑，手机和云计算，每一个都以自己独特的方式来表达了这些组成元素。专用于某一方面的组件出现来与其它组件合作来达到我们想要的结果。

举例来说，在存储元素中，我们可以选择文件系统和数据库系统组件。文件系统使用层级式的目录，存储像mp3这样的二进制的大对象，而数据库则用来存储结构化的元数据，通过SQL这样的语言来进行操作。在中心化的云上，我们则会使用Amazon S3来进行二进制大对象的存储，使用MongoDB做为数据库存储，而使用Amazon EC2来做为计算服务器。

本文将聚集于区块链的技术概貌：程序用到的每个要素的相关组件，对应组件的实际项目的例子。对于每个组件，我会尽量的全面阐述。

区块链的一些基本组件

下面是程序的基本要素中，每个要素对应到块（译者注：核心职责，价值）：

• 存储：代币存储，数据库，文件系统/二进制大对象存储
• 计算：有状态的业务逻辑，无状态的业务逻辑，高性能计算（HPC）
• 通信：数据，价值，状态

区块链基础设施概貌

每一个组件中的对应的区块链技术如下：

程序的三要素，及对应的组件，示例项目，去中心化版（后附原图，对比看，更清晰）

存储

程序中最基本的元素，存储，有下述一些可用的组件：

代币存储：代币存储的是价值（资产或安全）。无论这个价值是比特币，飞行里程，艺术品的电子版权。一个代币存储系统的主要操作就是发行和转移代币（满足各种各样的条件下），系统需要保证不会双花等。

比特币和Zcash是两个专注于代币存储的纯粹系统。以太坊恰好使用它的代币达到了世界计算机的目标（译者注：由于以太坊是图灵完备的，愿景是成为永不停机的世界计算机，但现在大多数人用它来进行代币的发行，作者在这里是一种调侃吧）。上述这些是代币被用来作为内部激励，驱动整个网络基础设施。

其它一些代币没有集成于整个网络内来驱动整个网络，而是用来激励更高层级的网络，但底层基础架构实际存储着对应的代币。一个例子是运行于以太坊主网上的ERC20标准的Golem（GNT）。另一个例子是运行在IPDB上的EnvokeIP授权代币。

最后，我使用“.*”来说明大多数的区块链系统都有代币的存储机制。

数据库：数据库专指存储结构化的数据，比如表（关系型数据库），文档存储（比如，JSON），键值对存储，时间序列或图；然后可以通过快速查询语言（比如：SQL）进行数据搜索。

传统的分布式（但中心化）数据库比如Mongo和Cassandra经常存储TB，甚至PB级的数据，而写性能能超过1000000每秒，正如这里所述。

查询语言SQL是非常巧妙的，因为他将规范与实现分开，这样它就不再与某种应用绑定。SQL在最近数十年一直是一个标准规范。这也让同样的数据库系统可以横跨不同的工业领域进行使用。

换种思路：如果你想将比特币更广泛的推广到其它的应用，没有任何特定应用程序的代码，你没有必要一定实现图灵完备。你只是需要一个数据库。这将在简单与规模间具有相应的优势。当然实现图灵完备在有些地方仍然是非常有用的；我们后面的关于去中心化的计算章节来更多的讨论一下。

BigchainDB是一个去中心化的软件；专注于文档存储。基于MongoDB（或RethinkDB）之上，它继承了Mongo的查询与扩容功能。但它仍有区块链的特性，比如去中心化的控制，防篡改和代币功能的支持。IPDB是BigchainDB的一个拥有治理功能的公网版本。

同样在区块链领域里，我们可以认为IOTA是一个按时间序列的数据库，如果换一个角度来看的话。

文件系统、二进制数据存储： 这些是用来存储大文件（比如电影，mp3，超大数据集），以目录、文件这样的层级结构存储的系统。

IPFS和Tahoe-LAFS是去中心化的文件系统，整合了去中心化和中心化的二进制大对象的存储。FileCoin，Storj，Sia，Tieron实际进行二进制的存储。当然也包括老的BitTorrent，尽管他使用的是针对性的解决方案，而不是代币。以太坊的Swarm，Dat和Swarm-JS也差不多是在做这些。

计算

接下来我们聊聊，程序的第二要素计算。

“智能合约”系统是指使用去中心化方式进行计算的系统。系统可以区分为两大类，无状态（组合）的业务逻辑和有状态（顺序）的业务逻辑。无状态与有状态在复杂上，可验证性等上有着根本的区别。我们还有第三类的去中心化的计算组件：高性能计算（HPC）。

无状态（组合）的业务逻辑：在内部的任何逻辑里都不需要保留状态。 如果用电子工程术语来说的话，它是由数字逻辑回路组成。 逻辑表示为真值表，示意图或代码的条件语句（组合if/then，逻辑与，逻辑或）。 由于它们没有状态，因此很容易验证大型无状态智能合同，并由此构建大型校验/安全系统。 N个输入和一个输出需要O（2 ^ N）次计算来进行验证。

Interledger协议包含一个加密币条件（crypto-conditions aka. CC）协议来清晰的指定组合的回路。因为CC通过IETF成为了互联网的标准协议，同时ILP也正被中心化和去中心化的支付网络（75家银行采用了Ripple的协议）广泛的采纳，所以你最好对之有些了解。CC在JavaScript，Python，Java等都有单独的实现。 BigchainDB，Ripple等系统使用CC; 因此支持组合业务逻辑/智能合同。

由于有状态业务逻辑是无状态逻辑的超集，因此支持状态业务逻辑的系统也支持无状态业务逻辑（牺牲额外的复杂性和可验证性挑战）。

有状态（顺序）的业务逻辑：任何内部的业务逻辑都有状态。这就是说，他有记忆（译者注：根据经历的形成的不同记忆有不同的选择）。或者是说，它是具有至少一个反馈回路（和时钟）的组合逻辑电路。 例如，微处理器具有根据发送给它的机器码指令进行更新的内部寄存器。 更一般地说，有状态的业务逻辑是图灵机，其接收输入序列，并且返回一系列的输出。 实现了这样逻辑（实际近似）的系统是图灵完备的。

以太坊是最知名的实现了有状态的逻辑和智能合约的链上（on-chain）系统。Lisk，RChain，DFINITY，EOS，Tezos，Fabric，Sawtooth，及很多其它的也实现了。可以运行一个“就在那里，但也可能是任何地方”的代码是非常强大的一个想法，有非常多的使用场景。这也侧面解释为什么以太坊会成功，为什么它的生态系统发展成为一个平台，以及为什么在这个领域里有如此多的竞争。

同时因为序列逻辑是组合逻辑的超集，这样的系统也支持组合逻辑。

有状态的业务逻辑的问题是，代码中的非常小的错误，将引发严重的后果，正如DAO的被黑事件所展示的那样。形式验证可以帮助解决这个问题，正如它在芯片行业所做的那样。以太坊基金正在积极引入形式验证。然后有状态业务逻辑的另一个问题是有规模的限制。对于组合回路，所有的可能的组合是2的所有可能输入的次方。对于有状态逻辑来说，内部状态的数量，假设所有的状态是布尔的，就是2的所有内存状态变量。举例来说，如果你有3种可能的输入，对于组合回路来说就是2的3次方，8种所有的可能。而对于有状态的逻辑来说，如果可改变状态的操作有32种，那么将检查2的32次方，即42亿个状态（译者注：实际的实现不会看起来的这么低效能，这里主要是为了说明复杂性）。这是有状态逻辑的复杂性限制（因为你需要相信这门技术，相信它最终实现的是你真正想要的，否则就会成为一个bug，带来经济损失）。“尽可能正确的创建”是另一种让智能合约可信的一种方法，正如Rchain使用的rho演算（译者注：对于这里，读者应保持自己的观点，图灵完备确实会让写的代码不可控，容易出bug，但它的想像力是比较大的。请保持自己独立思考）。

如果你想使用去中心化的计算，对于许多的情形来说，这里有一个简单的方法：在浏览器或者移动设备，可运行JavaScript和Swift这样的客户端上简单的执行就可以了。这里，你必须要相信在你的客户端上所进行的操作，但由于设备在你的手上，一般你会容易接受这点（译者注：可能会疑惑，平时就是这样做的，为什么要刻意强调。因为这里想说明的是去中心的运算是无信任任何节点，但浏览器的后端确定了，必须要相信现在配置的这个节点）。我们把这叫做胖客户端以区别于胖协议框架。这个架构对于主流的web开发者来说非常好理解。举例来说，所有许多的web应用程序都需要状态。要创建这样一个程序，你需要JS + IPDB（使用js-bigchaindb-driver）。又或者你的应用需要使用到二进制的大对象存储或支付，可以包含IPFS的js版本（ipfs.js）和以太坊的js版本（web3.js）。下面是一个例子：

高性能计算（HPC）：为渲染，机器学习，电路仿真，天气预报，蛋白质折叠等方面的“重”计算的处理。 计算任务将使用一个机器集群（CPU，GPU，甚至TPU），花上几个小时或甚至几个星期。

有如下的一些去中心化的实现HPC的方式：

• Golem和iEx.ec框架整合去中心化的超级电脑的算力与相关的应用程序。
• Nyriad作为存储执行。这种计算基于去中心化的存储（对于存储Nyrid也有自己的解决方案）。
• TrueBit允许第三方进行计算，然后进行事后的计算检查（如果可能则进行隐式检查;如果有问题，则进行显示的检查）。
• 而另一些人只是在VM或Docker容器上运行大量计算，并将结果（最终的VM状态快照或刚刚计算的结果）存到一个需要权限才能访问的blob中。 然后，使用代币的方式来售卖访问权限。 这种方法要求更多的客户来验证结果，但好的是，今天所有这些技术都是可能的。 当TrueBit成熟时，这种方式将自然与TrueBit结合。

通信

最后我们将来说明一下程序的第三个要素，通信。通信方式有很多种; 我将专注于连接网络的这个层面。 它有三个层次：数据，价值和状态。

数据：在60年代时，我们有了ARPAnet。它成功的延伸出了类似的网络，如NPL，CYCLADES，随之诞生的问题时，大家不能互相交流。Cerf和Kahn在70年代发明了TCP/IP协议来把大家连在一起。TCP/IP现在是连接网络的事实上的标准。OSI是另一套与之竞争的协议，则显得逊色不少（尽管讽刺的是，它的模型已被证明是有用的）。所以，除了它的发明时间有点长，TCP/IP仍无可争议的是去中心组件的重要一环，用于连接网络中的数据（译者注：IPFS正打算创建一套全新的协议。）。

价值：TCP/IP仅仅提供了在数据层面连接网络。你可以重复发送数据，从而造成一些错误，但底层的TCP/IP协议并不关心这些。但如果你想要通过连接的网络发送资产呢。举例来说，从比特币发到以太坊，或发送到使用国际货币支付框架SWIFT协议的支付网络。你将期望你的代币一次只能转给一个目标（译者注：如果同一份钱，可以转给两个目标，那么这个网络将因为不可靠而失去大家的信任，因为可以双花）。一种连接整个网络，同时防止双花的方式是使用交易所，一种传统的非常重的方式。然而，你可以通过加密托管的方式来抽离交易所的本质，通过自动化的代码来移除对中间人的需要来实现。例如Alice可以通过Mallory向Bob转帐，Mallory中转资金但不能花费它们（资金会有一个超时，从而Mallory也不能永久的持有资金）。这也正是Interledger Protocol（ILP）的内在理念。这与双向锚定的概念类似以及状态通道（如Lighting网络和Raiden网络）；但这些网络连接都是100%专注于面向价值的连接（译者注：因为要传输价值，所以建立的网络连接）。除ILP以外，还有Cosmos为了更加方便使用，增加了更多的复杂性。

状态：在通过网络连接价值以外，还有什么呢。想象一下一台计算机病毒，其自己的比特币钱包可以从一个网络跳到另一个网络。或某个以太坊的智能合约，可以移动他的状态到另一个以太坊网络，甚至到另一个匹配的不同网络？或者说，为什么限制AI DAO于某个具体的网络呢？

这正是Polkadot正在做的，连接网络的状态。Aeternity同样适用于价值网络与状态网络间的某个地方。

例子

我们刚回顾了程序的三个主要要素（存储，计算和通信），去中心的组件分类，每个组件内的一些对应的项目。

人们正在基于这些项目的组合来建造项目。有非常多同时组合两个以上的组件，如IPFS + 以太坊或者IPFS + IPDB。但也有同时组合三个及以上的组件。下面有几个前沿的例子：

• Ujo使用了IPFS或Swarm 加上IPDB加上以太坊来实现去中心化的音乐，愿景在这里。IPFS或Swarm用于文件和二进制存储。IPDB（使用BigchainDB）用于元数据存储和查询。以太坊用来做代币存储和需要状态的业务逻辑。

• Innogy使用IPFS加IPDB加IOTA来实现供应链和物联网。IPFS用于文件和二进制大对象的存储。IPDB（使用BigchainDB）用于元数据存储和查询。IOTA用于需要时序的数据。

相关的工作

后面是在区块链社区的其它一些相关的技术框架；所有这些我都与之进行过愉快的交流。

Joel Monegro的胖协议框架强调每一个组件都是一个协议。我认为这是一个非常酷的框架，尽管它强制所有组件通过网络协议进行交互。这里还有其它的方式：区块间可以简单的通过一个import导入或库的调用进行通信。

使用import的方式的原因是（a）低延迟。如果通过网络调用，会影响甚至完全让应用不可用；（b）简单。使用库（甚至内嵌代码）总是比连接网络实现上简单，而且也不用花费代币等。（c）更成熟。协议栈的解决方案现在才出现，而现存在大量可使用的库，比如UNIX库，即使Python和JS的模块库也已经有15年的历史了。

Fred Ehrsam的“DAPP开发栈”适用于web的业务模型。它也非常有用，但它并不旨在对于给定的程序元素（例如文件系统与数据库），并在组件之间进行细粒度区分。

BigchainDB白皮书（第一次发布于2016年2月），为了方便说明，下图给出了一个早期版本的开发栈：

当时的这个版本关注于处理，文件系统，数据库。当时还并没有从程序的要素的角度来清晰划分，同时也没有详细的区分去中心化的计算这块（译者注：上图中，当时版本里面，只有一个模糊的VM）。现在的这个文章，是在当时的白皮书的基础上，经过了1年半的思维革新后；在某些演讲中持续更新后所得，正如5月22号在2017共识大会上的演讲一样，就已经非常趋同于当前的这篇文章了（写这篇文章的另一个原因是我收到了大量的请求，希望我能用文字的方式将这些记录下来）。

上面这张旧图也强调了一个完全中心化的到一个完全去中心化的转变的解决方案。这可以用来帮助将现存的软件系统更新为更去中心化的系统，关注于更新那些最值得更新的组件就好了。

Stephan Tual的“Web3.0的重访问”提到的技术栈与本文类似，只是它更关注于以太坊相关的技术栈。它尝试将相似的项目归类到某些组件中，并形成一个地图，来服务社区。我非常惊喜想法与我的非常类似。然而文中服务应用的区块层（用于消息通信，存储，共识，治理的区块）混入了三种东西：apps，“什么”，“如何解决”。对我来说，区块是“什么”。所以消息通信是应用（应该属于应用层）;而存储层应该更加细粒度的；共识是“如何实现”的那层（隐藏于某些区块里）；治理是“如何实现”的另外一部分（因而也是隐藏于区块里的）。它也有[网络]协议作为分离的底层的块，同样我也赞同这是一种区块间，与库函数调用一起，相互通信的方式。尽管如些，我仍认为那是一篇非常好的文章和技术栈说明。

Alexander Ruppert的“去中心化世界的地图”有差不多20个组组成，x轴给出了从基础层到应用层的四个层次，但使用中间件和流动性作为关联性的层级。这也是一件巨作，我很高兴能帮助Alex把它整理出来。它更集中于边界，而没有那么强调基本的架构；然而这篇正是源自第一性原理框架关于核心基础设施的说明文章。

未来

像Ujo这样的系统，组合许多的组件到一起，比如IPFS等。最终他也能从所有的这些组件系统中受益。

我非常期待当大家更好的了解了组件间的关联关系后，这个趋势将进一步的加速。这样的分组比把所有组件揉为一个叫区块链的更能提高大家的生产率。

随着去中心化的生态演变，我期望这个技术栈不断迭代。AWS刚推出时只有一个服务：S3用于存储二进制的大对象。然后它发展了计算：EC2。既而一路向前，这里是它发展的完整时间线。AWS现在有超过50个组件；尽管其中只有一小部分是最重要的。下面是一张AWS提供的服务的图片。

我预见在去中心的领域也将发生类似的事情。作为第一步，大家可以想像一下每一个AWS组件对应的去中化版本。然而，这其中，肯定会存在一些不同，每个生态（云计算 vs 去中心化）都会有一些自己独有的，比如去中化中特有的代币存储。让我们一起来开启这个有趣的旅程吧。

（完）

如果你不知道Naval Ravikant，你应该了解一下他。在投资领域，他是最好的。他投资了数百家公司，其中包括像Twitter，Uber这样的科技独角兽。他还建立了AngelList，一个用于天使投资人和初创企业的快速配对平台。

但如果仅凭这些，还不足以让我给予这个人很高的评价。不像大多人，我不通过一个人的成功来评判一个人。你可以是个笨蛋，但你仍然可以很成功。就像Eckhart Tolle曾经说过的一样，如果你想赚钱，你不一定睿智，你只需要聪明就好了。

但Ravikant是非常睿智的。

这不仅仅是因为他的书单与我的某些最爱书相近。

我曾经读了悉达多二十余次。如果你惊奇的发现一个天使投资人的书单上居然有一堆的精神和哲学的书籍，这说明你有一个独一无二的大脑。大多数我认识的，在纽约大学商学院兄弟们认为，安兰德的源泉是她写过的唯一的书。

翻翻Ravikant的推文，或者听听这个采访，你将很快发现，他比谁都知道如何去思考。批判性思维是当今以及未来世界最重要的技能。

最近他有一些关于区块链的思考（以及另外两个技术，将被认为是改变世界的，基因编辑技术和AI）。几个星期前，他在推特上写了史诗般的关于区块链的36条推文以及未来世界的市场。他们注定要成为经典。我已经读了无数次，而我还打算再读无数次。每一次读的时候，都会带来更深的理解。

https://youtu.be/BTiZD7p_oTc?list=RDBTiZD7p_oTc

上面的视频是一些分形（fractal），看起来似乎永远无限下沉。

关于区块链的这些推文，他没有办法把他们清晰的阐述出来，如果他做到了，他将比我想像的更为睿智。但我怀疑他已经说得足够清晰了（译者注：作者也许想表达是我们自己没有足够理解）。但显而易见的是，这些推文，是多年的关于区块链对社会和整个世界的思考结果的精华。

区块链的革新性的到来就像海啸一样，将会重新改成社会每个角落，但大多数人仍视而不见。这是因为对于每个人的影响还在后面。人们常常在理解突破性的技术时受挫，因为他们没有形成一个自己的参考框架。想像一下，你向一个18世纪的农场主介绍浏览器技术时，他根本搞不明白。

到目前为止，即使是一些我非常尊敬的聪慧的人仍然视比特币或加密货币为：

• 旁氏骗局
• 郁金香热（译者注：史上第一个泡沫经济）
• 自由主义者一个邪恶的阴谋
• 毒品贩子货币（译者注：有些人用来作非法交易，留下的恶名）
• 书呆子搞的货币（译者注：原文为nerd money）

在流行媒体中关于加密货币相关报道是极其惨的（即使他正在持续的增长与繁荣，但他仍被宣布即将消亡1000次了），虽然一切正一步步的变得好起来。在我的文章中为什么每个人都错过了最近500年最重要的发明，我全力驳斥了大部分的相关争论，但当然大多数人并没有遵从自己的逻辑来承认这些。

最后，加密货币和区块链将正如一个古老的作家的格言来证明它在世界上的存在：

Show don't tell

换句话说，区块链必须开始驱动普通人每天的生活中，而不仅仅是一些日常的交易。这正在来临。但这需要达到区块链自己的微信时刻，一个连奶奶都能简单使用区块链技术的时刻。现在我们来看看区块链已经发展到哪一步了。

这正是Naval的推文所说的内容。当前正在发生的。

我们从他的推文的第一条开始吧：

Blockchains will replace networks with markets.

他到底想说什么呢，为了理解它，你首先需要理解他所说的网络。

词典给网络的定义是互相联系的人或事物群体或系统。其它的定义包括任何网状细丝，线条，纹，通道的组合。这也是正是系统视角的理念，一种在某个环境的上下文环境中，把系统中的所有行为都考虑在内的系统视角。

但说起来，网络是一个元模式。这是一个跨越空间，时间和精神的连接网络。

想像一下大城市交错的街道或街道下下水道所组成的迷宫。 你的神经系统和你头脑密集的树枝状森林都是网络，蜿蜒的河流像地球上的动脉一样流过这片土地。 你的神经系统和你头脑密集的树枝状森林都是网络，蜿蜒的河流像地球上的动脉一样流过地面。

网络不仅限于物理存在的事物。他们是物理的，数字的，精神的，连接我们的路。这意味着从一个不同的视角，几乎所有的东西都是一个网络，从我们大脑信仰中的纠缠到不同思想人之间的言语互动，再到以数字信息的方式，金钱和能量在整个地球中的流动。

“Overlapping networks create and organize our society…Money is a network. Religion is a network. A corporation is a network. Roads are a network. Electricity is a network.”

其中一些如此显而易见，但另一些则不然。通过网络连接的路很好理解，但是企业如何通过网络连接呢？一群人为同一个目标完全分散的进行工作（译者注：Aragon项目，提供了一种通过区块链连接投资方，技术接入方，服务提供方，消费用户的离散公司网络）。宗教？通过共同信仰团结起来的民众的网络。

世界通过推动不同的群体而不断演变。有共同信仰系统聚集到一起，形成复杂的影响力链，经济和军事力量。早期的部族和氏族从来没有离开我们，只是像池塘的水波不断向外扩展，渗于其中从而变得更加的错综复杂了。

这些大型部族间斗争正在全面的全力以赴的扩张。他们正在改变越来越多的人看待整个宇宙的方式，网络（译者注：这里的网络专指web，web1.0，web2.0这样通用网络概念，如果把下一代web叫做价值互联网的话，这将更有意义）的影响力正在持续增长。

“Networks have ‘network effects.’ Adding a new participant increases the value of the network for all existing participants. Network effects thus create a winner-take-all dynamic. And the Rulers of these networks become the most powerful people in society.”

网络渗透得越深，它将会更深刻的改变现实社会的结构。 “The leading network tends towards becoming the only network.”这样的网络变成了我们生活和在其中工作的网络。如果那样的网络是好的话，生活也是好的，如果那个网络是恶魔的话，生活也会变得悲惨而饱受苦痛。

那我们怎样达到一个好或坏的网络呢？

简单。我们有两种方式来达成网络的主导权：

• 暴力和控制
• 开放和民主

如果你仔细思量，你会发现这是两套完全不同的信仰系统在驱使着这一切。

一个是现实的黑暗。愤怒是其中的引导性情绪。这样的信仰系统里将严格的等级制度视为至关重要的。仅仅只有某些人可以控制所有其它人可以做的。信奉这套哲学的人崇拜地位与权力。暴力是他们的首要武器。

硬币的反面，一个好的网络是开放和民主的。它是分工协作的，也是包容的。最好的想法获得最后的胜利，而无关乎这个想法来自哪里。分类与等级的概念被消融了，理想的方式贯穿整个网络，并被整个网络所采纳。这是一种务实的哲学，从而不会主动挑起战端，但如果被迫，却会全力以赴。

这些哲学之间的争论是永无止境的。

封闭意味着黑暗（译者注：如果类比苹果为封闭，其实封闭也不一定意味着黑暗）。

开放是光明的。

世界史就是一块封闭与开放之间，中心化到去中心化之间，等级森严到自由流动之间的一种斗争。

变化的钟摆来自摆动，永不停歇（译者注：有点“分久必合，合久必分”的意思）。

省略一段，讨论开放与封闭的优劣，大意是想说开放带来创新，封闭只有恐惧与害怕，扼杀创新的种子。自已看原文吧，谢谢（。

在每个分支上，每一个可能性一个个的串联起来，就像一条绳上的珠串。

就像Yoda（译者注：星球大战里面的尤达大师？）所说，恐惧引至愤怒，愤怒引至嫉恨，嫉恨招至痛苦。

随着时间的推移，这些分支路径向外扩展，滋生更多的绝望或更多的快乐和自由。运动中的物体往往持续的在运动中。 它要么变得黑暗和衰退，要么生长和繁荣，不断向光延伸。

除非它被瓦解。

瓦解引向变化和新的可能性。

新生

我们现在比以往更需要瓦解。

最近50年，世界趋向于集中化，控制和不平等。钟摆摆得太远了。即便倡导开放和民主的互联网也开始衰落。他们过于中心化和过于集中化了（译者注：想想BAT三家独大，遏制新的创新的出现，也许能比较好的理解这段）。

https://youtu.be/JkZa6PE0SkI

“Overspecialize and you breed in weakness. It’s slow death.” — Ghost in the Shell

是什么引致一个系统的成功。

信仰系统。

你的信仰决定了你的现实。

“Your beliefs become your thoughts,
Your thoughts become your words,
Your words become your actions,
Your actions become your habits,
Your habits become your values,
Your values become your destiny.”
— Gandhi

每一个信仰系统都认为它自己保有全部的真理。

但没有其中任何一个真正做到了，包括你、我以及所有其它人当前信奉的系统。

我们仅仅是向真理一步步的靠近了，而我们离最终的目标还有很远。如果我们拒绝去发现身边正确的东西，我们的决定终将失败，因为他来源于一个虚假的假设。错误的开始引致错误的结束。

Each person and each group is like a point on a sphere, limited by what we can see from our particular angle, but imagining that we can see the whole sphere.

群体看清的真实现实与他们想象中现实的对比决定了他们的痛苦水平。

如果两个群体有不同的现实的憧憬，谁会获胜呢？

我们如何决定呢？

其中我们曾经创建过的一个最强大的系统叫市场。如果我认为我有一个其它人需要的货物或服务，这是我信仰的系统。它本身可能是对的，也可能是错的，我的产品可能是惊艳的或者是极差的。

无论是哪种情况，市场将让我知道答案。如果没有人愿意花钱买他，我非常可能正在做一件错事。也许是我卖的方式不对，或者产品还不是足够的好，我需要回过头去接续改进。

市场是不完美的，但它在持续的修正自己来得到越来越好的答案，一点点的接近真理。最好的答案，增加了整个系统的价值和财富，以及系统中的每个个体。在整个系统里，所有的玩家正努力的实现积极的纳什均衡，关于纳什平衡的细节，可以看看相关的书或电影美丽心灵。

最终，市场会让所有的回归其正常的次序。世界可能会暂时忽视梵高在他一生中的天才，直到后来才意识到，这些绿色和金色的旋转画风令人难以着迷，并为每幅画花费数百万美元。

在整个历史中，市场和网络是相关但分开的。 市场只不过是一种网络。它只不过是一种交换商品和服务的网络。真正的是蕴含于其中的宗族的，暴力，胁迫和稀缺性的力量。

直到现在。

今天，由于一个全新的市场的出现（译者注：这里特指，网络与市场结合的一种新市场Market networks，），暴力部落的时代正在快速的临近：

“Market networks. Open AND meritocratic.”

区块链融合了市场和网络为一个智能的，混合系统。

区块链是一个新的发明，允许对开放网络有贡献的人来控制整个网络，而不是通过统治者或钱的驱使。它们是基于贡献的，防篡改的，开放的，投票系统。贡献是指凡是有助于提升整个网络的。正如社会因为你提供了它需要的服务，而反馈给你钱。区块链给予你代币，因为你提供给了整个网络它需要的东西。

这些代币要求不同种类的工作。每个区块链都有他自己的目的。比如，支付比特币是为了保证记的帐目的安全。以太坊则是为计算（执行和校验）付款。

其中的每个区块链大多遵从UNIX的类似哲学，只做一件事，把这件事做好，而不是同时做很多事，而每件事都做得不好。随着市场-网络的发展，我们将看到越来越多的专业化网络，一些专注于分布式，防篡改存储，处理去中心化的身份验证，另一些则负责执行智能合同，及支持更先进的法律框架等。

这些系统将会比我们当前的系统更为有效率。

在今天的专业网络中，权力集中在少数军阀的手中，这些军阀越来越强大，掐断了这个世界其它人的希望和梦想。最终贪婪和愚蠢导致他们误入歧途，他们希望通过后门和消弱网络的功能来控制网络。当一种主宰了所有其它的观点，社会倾向于衰亡和消退，系统也将变得不再包容，从而最终爆发。

相比较而言，分布式的区块链系统可以抵挡敌对的腐败行为，将那些受限的观点容纳并包。这是因为没有任何一个持有某种信仰的群体唯一掌握了通向王国的钥匙。取而代之的是，每一个网络中的参与者，掌握着一把钥匙，有效的通过整个网络分发能量（译者注：区块链将贡献记录下来了，让整个网络自动根据贡献来赋权。而中心化的系统是通过赋予权力，或垄断）。

这将引向一个新的动态平衡：

Competing groups must cooperate to reach consensus or they crash the whole system and they all suffer.

与现在的系统不同的是，现在系统都是被单一强大的群体所严格控制，因为他们对别人没有同情心（一种宗族的想法的特征），他们对整体造成了巨大的伤害，造成了广泛的痛苦，而同时，他们还觉得他们做得挺对。

我们可以来看看现代的银行系统。银行系统持有所有的钱并制定所有的规则。他们购买影响力，调整规则来达到自己的意愿。 如果按他们自己的方式，他们会建立自己控制的不完整意义上的区块链，所以他们可以继续任意改变游戏的规则。这些是精英和暴徒控制的区块链：简而言之，不完整的和无用的区块链，根本不是区块链。

“It’s nonsensical to have a blockchain controlled by a sovereign, a corporation, an elite, or a mob.”

理由非常简单。只有当银行，银行的股东，存款者，监管者同时持有主动权才能达到所谓的平衡。虽然我们有各自不同的兴趣，不同的信仰，看到问题的不同侧面，但我们必须达成共识，以让整个系统获益，或打破整个系统。但由于没有人想要摧毁整个系统，因为所有人都将失去一切，所以最终大家会打破分歧，达成一致。

这有一点类似于Satoshi在他的白皮书里讨论的51%攻击问题。如果一个矿工或某个群体拥有了51%的算力，他们不会篡改之前的交易，他们只会拒绝接收新的某些交易。另外Satoshi也明智的认为到，这并不是一个问题。如果有任何一个人投入了如此大量的时间和钱来建立了一个如此强大的算力，维持这个系统的正常运转将会获得最大的收益。在系统中作恶获得的一点小小的收益，最终将导致大家对整个系统失去信心，从而对整个市场造成压力，最终让他们投入的时间和金钱变得一文不值。

“Merit in markets is determined by a commitment of resources. The resource is money, a form of frozen and trade-able time”

没有人愿意燃毁所有这些“冻结和可交易的时间”，所以他们的目标从破坏性行为转变为有利于整个系统的行为，并使其运行顺利。

分形的宇宙

区块链的可能性是无限的，从透明的端到端的可校验投票，到股票和分红的发放，再到安全，计算，预测，注意力经济，带宽，能量，存储，分发，内容等等。

在这里，我不打算一个个深入的说明，因为我已经在一系列其它的文章中提到了，你可以看看，如果你喜欢，但几乎不用说的是：

随着时间的推移，这些可能性将只会扩大和蓬勃发展，渗透于生活的各个方面。 区块链将产生一个新兴的微观经济体系，堆叠在微观经济体上，而这些微观经济体在大型元链无限回归之间相互联系（译者注：可以看看前面的那个Fractal的视频）。

这将改变整个世界。

今天，我们的网络由“国王，牧师，精英，公司和暴徒”统治。“把它当成是一个宝座的游戏。 这是一场黑暗野蛮的游戏。

区块链永远打翻了他们头上的动态。他们将大大的改变这个星球上权力的平衡，并朝向更好的方向。

“Blockchains’ open and merit based markets can replace networks previously run by kings, corporations, aristocracies, and mobs.”

去中心化的力量将小而增长迅猛，遵循库兹维尔的“加速回报法”。

“Blockchain based market-networks will replace existing networks. Slowly, then suddenly. In one thing, then in many things.”

过渡将会令人不安，令人震惊。

这一切甚至可能是讨厌的，因为中心化的既得利益者不惜一切代价坚持过去。 但最终，他们将会像Trilobites（三叶虫）进入历史。

这一切结束后，没有人会哀悼过去。

（完）

本文是翻译，请访问原文：https://hackernoon.com/reflections-on-the-best-blockchain-tweets-ever-written-d488af960d4f

声明：翻译文章，并不代表翻译者支持，或反对文章观点。只是翻译学习之用。如有版权问题，请随时联系删除，谢谢。

作为最近的文章 NSA backdooring RSA libraries得到的启发，我写了一份简单的，不完整的，NSA后门的历史。如果有人愿意将文章变得更好，可以联系：ethan.r.heilman@gmail.com

更新：增加了Actel后门，更新2: 在这里有讨论。更新3：增加了最后发现的邮件侵入后门安装。

1946-1970, The Ultra Secret： 在第二次世界大战后，英国向许多盟国和前殖民地出售了德国Enigma密码加密机。美国和英国已经破译了Enigma加密，但是却没有告诉他们，这样他们就能破译盟国或其殖民地的加密信息，在30年间这些国家都因为这些机器中的缺陷而被泄密。

1957 - 当前, The Boris Project: 在1957年，NSA的William Friedman与他的老朋友Boris Hagelin见了面。他们的目标是启动the Boris Project，让Crypto AG生产的加密器存在后门，从而可以让NSA来监听NATO的通信（有证据表明，Boris项目早于本次会议）。这次会议首先在Friedman的自己的自传中被公开，书名是The Man Who Broke Purple。更多的细节也因为The Puzzle Palace的发行而被披露，其中的一些信件显示了Friedman对于项目进行方式的担心。通过与前Crypto AG公司的前雇员的访谈，后续开始并没有继续增加后门，而且很可能在1970年前，且持续到现在。这些后门包括隐蔽通道，允许全私匙重建。

逐步的，大家发现Crypto AG不是一个可依赖的加密硬件商。在1986年李根向Libyans透露，美国可以解密他们通过在TV上通过Libya加密的信息。1991年，伊朗人了解到，伊朗外交通讯记录最后出现在了法国的法庭案中，NSA可能已经破译了他们的外交通讯。1992年伊朗对于Crypto AG公司非常恼怒，并因为他们从事间谍活动进行了巨额罚款。尽管如此，但仍有证据表明，伊朗似乎继续使用Crypto AG机器进行外交交流，直到2003年，也许超过了2003年。2004年，艾哈迈德·沙拉比（Ahmed Chalabi）被指控向伊朗出售美国破译他们代码的方法。据推测这可能与Crypto AG的后门有关。

1979 - 当前, DES：数据加密标准被NSA修改过，以使数学攻击更难，但通过Brute Force方法却很容易。DES的原始版本称为Lucifer，使用128位的密钥长度，有差分密码分析的漏洞。NSA希望已经非常小的63字节的私匙进一步缩短到48字节，IBM的坚持，最终妥协到56字节。这样的长度允许NSA可以破译通过DES加密的通信。

1993, Clipper Chip： NSA非常担心美国出现他们不可破解的加密手段。1993年，他们提出通过称为“Clipper Chip”的加密芯片来确保语音通信。但实际上Clipper Chip是有后门的，从而通过他的通信都能被破译。不同于这个列表中的大多数后门，NSA主动宣布后门的存在。 由于其已知的不安全性，Clipper Chip从未被广泛采用。

1997 Lotus Notes： NSA要求Lotus弱化其加密算法，从而让NSA可以破译其算法加密的文档和邮件。这个软件被民众，公司，及全世界的政府使用。

200? - Present, Actel ProASIC3 FPGA：2012年，Skorobogatov和Woods发现，Actel军用级FPGA包含一个后门。研究人员可以通过对私匙的逆向工程，可以暴露后门。这些芯片被用于美国的军事系统，核设施及通讯。所有其它的Actel芯片也含有类似的后门。起初，大家非常担心后门是被外国的组织所植入，调查后发现，Actel故意增加了这个后门。

虽然看不到这个后门与NSA的关系，但一个美国公司，在没得到许可的情况下，设计一个复杂的后门，并植入到芯片中，且是美国最关键的系统，根本无法解释。即便Actel是在没有得到许可的情况下做的这些，那么我们理应看到美国政府更多的回应。但据我了解，美国政府自始至终都对整个事件保持沉默。

2004 - 2013, Dual_EC_DRBG：双椭圆曲线确定性随机位发生器[或Dual_EC_DRBG是由NSA创建的随机数发生器。在设计时，NSA精心选择了常量以让基于Dual_EC_DRBG进行安全加密的，可以被破解。Dual_EC_DRBG的这个属性在2006年被布朗发现，由Shumow和Ferguson在2007年重新发现，导致公众猜测Dual_EC_DRBG是有后门的。在2004年，NSA支付RSA1000万美元，以让其将Dual_EC_DRBG作为其某些库中的默认选择。NSA随后使用RSA使用Dual_EC_DRBG的这个事实，并推进它成为了NIST的一个标准。

2013, Enabling for Encryption Chips：在NSA的Edward Snowden发布的预算文件中，NSA的SIGINT项目的目标之一是在2013年底完全后门化或启用某些特定加密。但没有明确公布他们所指的加密芯片。

2013, Trusted Computing Platforms/Modules:与前面的信息源一样，草案中资源是利用外部可信计算平台和技术。 德国方面一直表示关注微软TCM 2.0可能存在NSA的后门。

? - Present, Postal Interception Backdoor Installation: 根据2010年向卫报报告的报告，NSA的访问和目标开发部门通常会拦截通过邮件发送的计算机设备，并添加了后门。 通常是网络设备和服务器的设备随后被发送到目标个人和组织使用。 这些后门允许NSA连接到空中专用的私人网络。

原作者还有一篇旧文章讨论，I speculate about designing a cipher with a backdoor.。

请注意发表这个文章，不代表作者支持或是反对文中项目，原文观点不代表翻译者观点，翻译只是对项目的思想进行了解，如果版权问题，随时联系删除，谢谢。

distict0X项目，初展Ethereum结合Aragon后形成的开发栈的锋芒。

软件允许我们基于现有的功能进行抽象，从而关注于实现自己的业务。

在Aragon，我们使用以太坊（ethereum）。以太坊提供我们共识层，同时保证智能合约的创建与强制执行。

所以，一般来说，我们不需要特别关注以太坊自身所提供的能力。我们使用它，从而推动对这个平台的使用，从而增加它的价值。由此，我们间接的支持了基于它之上的开发与使用。

这是整个平台代币化后，带来的整个系统的良性的循环。

现在，Aragon也是类似。我们正建筑的正是其它项目想要剥离的。我们正在创建一个最完整的创建、维护DAO（DAO: 去中心化的自助组织）的解决方案，关注于智能合约的更新，冲突解决等。

许多在这一领域出现的项目都将需要DAO，或将在某些方面使用DAO。最常见的需求有代币驱动的决策，但还有更多。

更加重要的一点是，Aragon不止是一个仅仅让人使用的项目，更多的是可以作为整个构建层次中的一环。

Aragon提供了一种新的栈模型，可以让开发者不用考虑区块链的底层，而是只需要关注栈层次中的某一层。

第一个应用这个栈模型的是district0x。这个项目的目标是创建一个基于以太坊的去中心化的市场。

它们的平台由以太坊、Aragon、IPFS三种技术的结合来驱动。以太坊提供的能力通过Aragon传导给district0x，那谁可以从中受益呢。district0x作为一个平台创建了其它人可以从中获益的机会。使用district0x的Decentraland又会让整个技术栈上获益。一个由以太坊运行的智能合约，通过Aragon的管理，又由district0x进行市场活动，大家都在整个栈中各施其职，最终使得Decentraland能够在虚拟现实中创造和探索一种共享体验。

这里有个介绍视频，关于district0x的 https://youtu.be/m1B7R7jMvK0

district0x的许多地方都是让人激动的。首先，它让市场真的p2p了。当前的众筹，共享经济等等都不是真正意义上的p2p，虽然他们也实现了无需公司或集团的点对点的交易，但却始终有个中间节点在两个终端用户间协调来实现这一切。

中心化的出现就会导致激励的错位，中心化的公司有动机来通过交易双方的信息差来尽可能的增加收入。

在Argon，我们认为去中介化的模式能更好的调整激励措施，或者正如前面所说：

去中介化的人类交易-商业-是走向一个更公平世界的第一步。

在区块链的栈上，每个区块链项目有时都有一些自己的愿景，展示的是一种思想与价值观。

当你选择区块链栈，你间接的选择了你的价值观。

以太坊的愿景是，将整个世界去中心化。
Aragon的愿景是，将交易去中介化。
district0x的愿景是，将市场去中心化。
Decentraland的愿景是，实现一个去中心化的虚拟现实。
每个人的愿景，也是其它人的一部分。
如果你之前写过代码，这些听起来就像一个继承关系。

所有这一切，都通过代币驱动。

在之前，如果有人使用了你的工作，会被认为是一个小偷，偷窃。现在，越多的人基于你之上工作，你就将越成功。这也为开源项目提供了一个新的成长和持续发展的路径。

使用别人的工作，更是在帮助其它项目实现它们的愿景。如果有人使用district0x创建了一个新的领域时，它正在帮助实现district0x，同时也是Aragon，以太坊的各自愿景。网络之间互相叠加产生更大的效应。

所以，如果district0x成功，区块链栈中的每一环都实现了自己。district0x当前是第一个来尝试这个区块链栈模型，Aragon也作为其中的一部分，为此我们都很激动。

关于作者

专注基于以太坊（Ethereum）的相关区块链（Blockchain）技术，了解以太坊，Solidity，Truffle，web3.js。

个人博客: http://me.tryblockchain.org
版权所有，转载注明出处

参考资料