{
  "block": 106144491,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "7109.980958 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2026-05-18T01:07:33",
  "trx_id": "35d66d32294dbc6224ffb2721093f91f766b6bbc",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 105979947,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "4397.770553 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2026-05-12T07:22:42",
  "trx_id": "ca21ab12333f8a2696d99d3662f2e9f14a9203d9",
  "trx_in_block": 4,
  "virtual_op": 0
}

{
  "block": 105512116,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "7122.496714 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2026-04-26T00:26:57",
  "trx_id": "1f39b27f763f712d46e6994d2198ea7ba12e4548",
  "trx_in_block": 1,
  "virtual_op": 0
}

{
  "block": 102854617,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "4439.317372 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2026-01-23T10:08:33",
  "trx_id": "64bdb303ec95abf5f0c3194d00474e7343493234",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 91300995,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "4603.536569 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2024-12-17T05:26:30",
  "trx_id": "1ff755e3acfc41a5546b119d234912add2852ad5",
  "trx_in_block": 6,
  "virtual_op": 0
}

{
  "block": 79855186,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "4772.670101 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2023-11-13T21:08:54",
  "trx_id": "77d2a1972d250541bc0bf08518e393b529195d67",
  "trx_in_block": 2,
  "virtual_op": 0
}

{
  "block": 78349059,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "7709.948887 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2023-09-21T22:51:30",
  "trx_id": "a2d37c4e95e61bfc0def08e6f13386f903e735c9",
  "trx_in_block": 2,
  "virtual_op": 0
}

{
  "block": 69114235,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "7931.630325 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2022-11-03T12:31:06",
  "trx_id": "f392f7410984129730ccdfd127f4b630bb8dad84",
  "trx_in_block": 3,
  "virtual_op": 0
}

{
  "block": 60810322,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8152.163556 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2022-01-17T11:43:00",
  "trx_id": "bc5e0d16ec99091d1eae3a608f76e7e615b43143",
  "trx_in_block": 25,
  "virtual_op": 0
}

{
  "block": 54608664,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8335.932214 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2021-06-14T01:36:06",
  "trx_id": "0cee404c0d57f9418867e7f3ff71c0dd26e416ef",
  "trx_in_block": 5,
  "virtual_op": 0
}

{
  "block": 49356085,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8523.354188 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-12-11T11:53:39",
  "trx_id": "0a373484c9a80211a2166acfcb3ac1b409eae669",
  "trx_in_block": 2,
  "virtual_op": 0
}

{
  "block": 49207647,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "1912.543513 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-12-06T05:30:45",
  "trx_id": "bcfe6e315baad381bd140fe43c46e0c9338ef823",
  "trx_in_block": 3,
  "virtual_op": 0
}

{
  "block": 49191181,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8529.562042 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-12-05T15:31:36",
  "trx_id": "6f38432e04ae73be49cbefdedf2ff49128c9aa10",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 48259662,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "1920.017158 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-11-02T17:13:09",
  "trx_id": "840ef8b289634b3a1695a24ab00e835027ba30df",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 43217906,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8732.367401 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-05-09T06:28:51",
  "trx_id": "029e2ceaa2eb1493e0cd903520897d17d858ad3b",
  "trx_in_block": 18,
  "virtual_op": 0
}

{
  "block": 43194139,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "1953.311140 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-05-08T10:12:06",
  "trx_id": "af99a00a2a72a5ffc65f4f849a2c49c0f8a2cd6a",
  "trx_in_block": 3,
  "virtual_op": 0
}

{
  "block": 42565786,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8745.254849 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2020-04-16T00:23:36",
  "trx_id": "69257d980b0d5124ef4b36f42a1703ef03993b0b",
  "trx_in_block": 6,
  "virtual_op": 0
}

{
  "block": 34653865,
  "op": [
    "comment",
    {
      "author": "steemitboard",
      "body": "Congratulations @hh3755! You received a personal award!\n\n<table><tr><td>https://steemitimages.com/70x70/http://steemitboard.com/@hh3755/birthday2.png</td><td>Happy Birthday! - You are on the Steem blockchain for 2 years!</td></tr></table>\n\n<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@hh3755) and compare to others on the [Steem Ranking](https://steemitboard.com/ranking/index.php?name=hh3755)_</sub>\n\n\n###### [Vote for @Steemitboard as a witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1) to get one more award and increased upvotes!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}",
      "parent_author": "hh3755",
      "parent_permlink": "4ojtse",
      "permlink": "steemitboard-notify-hh3755-20190714t114114000z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2019-07-14T11:41:15",
  "trx_id": "01e507c7b2366bfdebacc7443e2c1bd1af91deb7",
  "trx_in_block": 9,
  "virtual_op": 0
}

{
  "block": 32848575,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "8940.871662 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2019-05-12T17:28:36",
  "trx_id": "8a8d81bafda8c2bf1c6cd99bcba7bf2b7df805b4",
  "trx_in_block": 22,
  "virtual_op": 0
}

{
  "block": 24168272,
  "op": [
    "comment",
    {
      "author": "steemitboard",
      "body": "Congratulations @hh3755! You have received a personal award!\n\n[![](https://steemitimages.com/70x70/http://steemitboard.com/@hh3755/birthday1.png)](http://steemitboard.com/@hh3755)  1 Year on Steemit\n<sub>_Click on the badge to view your Board of Honor._</sub>\n\n\n**Do not miss the last post from @steemitboard:**\n[SteemitBoard World Cup Contest - Home stretch to the finals. Do not miss them!](https://steemit.com/steemitboard/@steemitboard/steemitboard-world-cup-contest-home-stretch-to-the-finals-do-not-miss-them)\n\n---\n**Participate in the [SteemitBoard World Cup Contest](https://steemit.com/steemitboard/@steemitboard/steemitboard-world-cup-contest-collect-badges-and-win-free-sbd)!**\nCollect World Cup badges and win free SBD\nSupport the Gold Sponsors of the contest: [@good-karma](https://v2.steemconnect.com/sign/account-witness-vote?witness=good-karma&approve=1) and [@lukestokes](https://v2.steemconnect.com/sign/account-witness-vote?witness=lukestokes.mhth&approve=1)\n\n---\n\n> Do you like [SteemitBoard's project](https://steemit.com/@steemitboard)? Then **[Vote for its witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1)** and **get one more award**!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}",
      "parent_author": "hh3755",
      "parent_permlink": "4ojtse",
      "permlink": "steemitboard-notify-hh3755-20180714t122205000z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2018-07-14T12:22:03",
  "trx_id": "73a250f274a008e2f339a6f2a7c82d7c23b7ccf7",
  "trx_in_block": 50,
  "virtual_op": 0
}

{
  "block": 22489910,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "9140.520060 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2018-05-16T20:20:27",
  "trx_id": "40b5f7ca03f18533e9ca741900e797b8a4e368e6",
  "trx_in_block": 8,
  "virtual_op": 0
}

{
  "block": 18819585,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "29691.510444 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2018-01-09T06:39:18",
  "trx_id": "0fa1477e884be2a62ebabc9fdc671ecfccfe06ad",
  "trx_in_block": 14,
  "virtual_op": 0
}

{
  "block": 14271380,
  "op": [
    "delegate_vesting_shares",
    {
      "delegatee": "hh3755",
      "delegator": "steem",
      "vesting_shares": "29942.321152 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-08-04T05:14:51",
  "trx_id": "b0d83ca3522bb7f767c92e04fa0cbe1e68643708",
  "trx_in_block": 28,
  "virtual_op": 0
}

{
  "block": 14130537,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "4ojtse",
      "voter": "sweethoney",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-30T07:47:03",
  "trx_id": "4e0953e86bab997d679576c15a502af0073eed83",
  "trx_in_block": 10,
  "virtual_op": 0
}

{
  "block": 14130168,
  "op": [
    "author_reward",
    {
      "author": "hh3755",
      "permlink": "6f3kje",
      "sbd_payout": "0.253 SBD",
      "steem_payout": "0.000 STEEM",
      "vesting_payout": "415.188989 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-30T07:28:39",
  "trx_id": "0000000000000000000000000000000000000000",
  "trx_in_block": 4294967295,
  "virtual_op": 4
}

{
  "block": 14129934,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "本文翻译自`zeppelin`的 https://blog.zeppelin.solutions/onward-with-ethereum-smart-contract-security-97a827e47702\n\n\n如果你是以太坊开发的新手，我们推荐你在继续本文前，先读一下我们的以太坊智能合约指南（基本概念及环境搭建）：https://medium.com/bitcorps-blog/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05#.6dob381ks\n\n<!-- more -->\n\n\nhttps://cdn-images-1.medium.com/max/800/1*basr8iGFNi6HSf_d2fMhzg.jpeg\n\n\n安全的开发以太坊的智能合约，是非常需要花费精力的。已经有一些好的指南以及汇总，比如 [Consensys的智能合约最佳实践](https://github.com/ConsenSys/smart-contract-best-practices)，和[Solidity官方文档的安全指南](http://solidity.readthedocs.io/en/latest/security-considerations.html)。但除非真正写代码，这些概念很难被记住和理解。\n\n\n本文会尝试一个有点不同的办法。首先解释提升智能合约安全的一些策略，并展示一些不遵从，而引起问题的例子。最后给一些已经调整地，可以直接使用的最佳实践。希望，这能帮助你创建避免某些不安全行为的`肌肉记忆`，从而在写代码的时候意识到可能的风险。\n\n不啰嗦了，进入正题吧。\n\n## 尽早且明确的暴露问题\n\n一个简单且强大的最佳实践是，让[尽早且明确的暴露问题](https://oncodingstyle.blogspot.com.ar/2008/10/fail-early-fail-loudly.html)。接下来，看一个有问题的函数实现：\n\n```\n// 有问题的代码，不要使用！\ncontract BadFailEarly {\n  uint constant DEFAULT_SALARY = 50000;\n  mapping(string => uint) nameToSalary;\n  function getSalary(string name) constant returns (uint) {\n    if (bytes(name).length != 0 && nameToSalary[name] != 0) {\n      return nameToSalary[name];\n    } else {\n      return DEFAULT_SALARY;\n    }\n  }\n}\n```\n\n为避免合约潜在的问题，或者让合约运行于一个不稳定或不一致的状态。上面例子中的函数`getSalary`应该在返回结果前，检查参数。那现在的例子有什么问题呢，问题在于，如果条件不满足，将返回默认值。这将掩盖参数的严重问题，因为仍然可以按正常业务逻辑返回值。这虽然是一个比较极端的例子，但却非常常见，原因是大家在程序设计时，担心程序兼容性不够，所以设置一些兜底方案。但真相是，越快失败，越容易发现问题。如果我们不恰当的掩盖错误，错误将扩散到代码的其它地方，从而引起非常难以跟踪的不一致错误。下面是一个调整后的示例：\n\n```\ncontract GoodFailEarly {\n  mapping(string => uint) nameToSalary;\n  \n  function getSalary(string name) constant returns (uint) {\n    if (bytes(name).length == 0) throw;    \n    if (nameToSalary[name] == 0) throw;\n    \n    return nameToSalary[name];\n  }\n}\n```\n\n这个版本的代码，还展示了另外一种推荐的编码方式，一种将条件预检查分开，分开判断，验证失败的方式。原因是可以使用Solidity提供的[修改器](http://solidity.readthedocs.io/en/latest/contracts.html#function-modifiers)的特性，来实现重用。\n\n## 在支付时使用（pull）模式而不是（push）模式\n\n每次`ether`的转移，都需要考虑对应帐户，潜在的代码执行。一个接收的合约可以实现一个默认的[回退函数](https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function)，这个函数可能抛出错误。由此，我们永远要考虑在`send`执行中的可能的错误。一个解决方案是，我们应该[在支付时使用（pull）模式而不是（push）模式](https://github.com/ethereum/wiki/wiki/Safety#favor-pull-over-push-for-external-calls)。来看一个看起来没有问题的，关于竞标函数的例子：\n\n```\n// 有问题的代码，请不要直接使用！\ncontract BadPushPayments {\n  address highestBidder;\n  uint highestBid;\n \n  function bid() {\n    if (msg.value < highestBid) throw;\n    if (highestBidder != 0) {\n      // return bid to previous winner\n      if (!highestBidder.send(highestBid)) {\n        throw;\n      }\n    }\n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n}\n```\n\n上述的合约，调用了`send`函数，检查了返回值，看起来是非常符合常理的。但它在函数中调用了`send`函数，这带来了不安全，为什么？需要时刻记住的一点是，就像之前说的，`send`会触发另外一个合约的代码执行。\n\n假如某个竞标的地址，它会在每次有人转帐给他时`throw`。而此时，其它人尝试追加价格竞标时会发生什么呢？那么`send`调用将总是会失败，从而错误向上抛，让`bid`函数产生一个异常。一个函数调用如果以错误结束，将会让状态不发生变更（所有的变化都将回滚）。这将意味着，没有人将能继续竞标，合约失效了。\n\n最简单的解决方案是，将支付分离到另一个函数中，让用户请求（pull）金额，而不依赖于余下的合约逻辑：\n\n```\ncontract GoodPullPayments {\n  address highestBidder;\n  uint highestBid;\n  mapping(address => uint) refunds;\n  \n  function bid() external {\n    if (msg.value < highestBid) throw;\n    \n    if (highestBidder != 0) {\n      refunds[highestBidder] += highestBid;\n    }\n    \n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n  \n  function withdrawBid() external {\n    uint refund = refunds[msg.sender];\n    refunds[msg.sender] = 0;\n    if (!msg.sender.send(refund)) {\n      refunds[msg.sender] = refund;\n    }\n  }\n}\n```\n\n这次，我们使用一个`mapping`来存储每个待退款的竞标者的信息，提供了一个`withdraw`用于退款。如果在`send`调用时抛出异常，仅仅只是那个有问题的竞标者受到影响。这是一个非常简单的模式，却解决了非常多的问题（比如，[可重入](http://hackingdistributed.com/2016/07/13/reentrancy-woes/)）。所以，记住一点，当发送`ether`时，使用（pull）模式而不是（push）模式。\n\n我已经实现了一个[使用这个模式的合约，可以方便的继承使用](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/payment/PullPayment.sol)。\n\n\n## 函数代码的顺序：条件，行为，交互\n\n作为尽可能早的暴露问题的原则的一个延伸，一个好的实践是将你的函数结构化为：首先，检查所有前置的条件；然后，对合约的状态进行修改；最后，与其它合约进行交互。\n\n条件，行为，交互。坚持使用这样的函数结构，将会让你避免大部分的问题。下面来看使用了这个模式的一个例子：\n\n```\nfunction auctionEnd() {\n  // 1. Conditions\n  if (now <= auctionStart + biddingTime)\n    throw; // auction did not yet end\n  if (ended)\n    throw; // this function has already been called\n\n  // 2. Effects\n  ended = true;\n  AuctionEnded(highestBidder, highestBid);\n\n  // 3. Interaction\n  if (!beneficiary.send(highestBid))\n    throw;\n  }\n}\n```\n\n这首先符合尽可能早的暴露问题的原则，因为条件在一开始就进行了检查。它让存在潜在交互风险的，与其它合约的交互，留到了最后。\n\n## 留意平台局限性\n\n[EVM](http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#index-6)有非常多的关于合约能做的硬限制。这些是平台级的安全考虑，如果你不知道的话，却可以会威胁你的合约安全。下面来看一个看起来正常的，雇员津贴管理的代码：\n\n```\n\n// 不安全的代码，不要直接使用！\ncontract BadArrayUse {\n  \n  address[] employees;\n  \n  function payBonus() {\n    for (var i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = calculateBonus(employee);\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    // some expensive computation ...\n  }\n}\n```\n\n读完代码，业务实现非常直接，看起来也没有什么问题，但却潜藏三个问题，基于平台的一些独特性。\n\n第一个问题是`i`的类型将会是`uint8`，因为如果要存`0`，如果不指定类型，将自动选择一个占用空间最小的，恰当的类型，在这里将是`uint8`。所以如果这个数组的大小超过255个元素，这个循环将永远不会结束，最终将导致`gas`耗尽。应当在定义变量时，尽可能的不要使用`var`，明确变量的类型，下面我们来修正一下上面的例子：\n\n\n\n```\n// 仍然是不安全的代码，请不要使用！\ncontract BadArrayUse {\n  \n  address[] employees;\n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = calculateBonus(employee);\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    // some expensive computation ...\n  }\n}\n```\n\n第二个你需要考虑的事情是`gas`的限制。[gas](https://ethereum.gitbooks.io/frontier-guide/content/costs.html)是以太坊的一种机制，来对资源的使用收费。每一个修改状态的功能调用都会花费`gas`。假如`calculateBonus`计算津贴时有些复杂的运算，比如需要跨多个项目计算利润。这将消耗非常多的`gas`，将会很容易的达到交易和区块的`gas`限制。如果一个交易达到了`gas`的限制，所有的状态的改变都将会撤销，但消耗的`gas`不会退回。当使用循环的时候，尤其要注意变量对`gas`消耗的影响。让我们来优化一下上述的代码，将津贴计算与循环分开。但需要注意的是，拆开后仍然有数组变大后，带来的`gas`消耗增长的问题：\n\n```\n// UNSAFE CODE, DO NOT USE!\ncontract BadArrayUse {\n  \n  address[] employees;\n  mapping(address => uint) bonuses;  \n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = bonuses[employee];\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    uint bonus = 0;\n    // some expensive computation modifying the bonus...\n    bonuses[employee] = bonus;\n  }\n}\n```\n\n最后，还有一个关于调用栈调用深度的限制。EVM栈调用的硬限制是1024。这意味着如果嵌套调用的深度达到1024，合约调用将会失败。一个攻击者可以调用递归的调用我们的合约1023次，从而因为栈深度的限制，让`send`失败。前述的（pull）模式，可以比较好的避免这个问题（译者注：原链接找不到了，但找下github上的讨论：https://github.com/OpenZeppelin/zeppelin-solidity/issues/15）。\n\n下面是一个最终的修改版，解决了上述的所有问题：\n\n```\nimport './PullPaymentCapable.sol';\ncontract GoodArrayUse is PullPaymentCapable {\n  address[] employees;\n  mapping(address => uint) bonuses;\n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = bonuses[employee];\n      asyncSend(employee, bonus);\n    }\n  }\n  function calculateBonus(address employee) returns (uint) {\n    uint bonus = 0;\n    // some expensive computation...\n    bonuses[employee] = bonus;\n  }\n}\n```\n\n总结一下，需要记住的 1）使用的变量类型的限制，2）合约的`gas`消耗，3）栈调用1024的限制。\n\n## 测试用例\n\n编写测试用例会占用大量的时间，但也能抵消你在添加新功能后[回归问题](https://en.wikipedia.org/wiki/Software_regression)需要花费的时间。回归问题具体是指在添加功能的修改过程中，导致之前的组件出现bug。\n\n我将尽快写一个更加广泛的关于测试的指南，如果你比较好奇，可以先看看关于Truffle的测试指南（译者注：原文链接失效了，也许是[这个](http://truffleframework.com/docs/getting_started/testing)）。\n\n\n## 容错及自动bug奖励\n\n[首先感谢Peter Borah带来的这两个想法的灵感](https://medium.com/@peterborah/we-need-fault-tolerant-smart-contracts-ec1b56596dbc#.uugpuufoa)。代码审查和安全审核对保证安全来说还不足够。我们的代码需要做好最坏情况的准备。当我们的智能合约中有漏洞时，应该有一种方法可以安全的恢复。不止如此，我们也应该尽可能早的发现漏洞。下面是一个内置的自动bug奖励机制带来的作用。\n\n下面我们就来看一个自动bug奖励的假设的代币管理的例子：\n\n```\nimport './PullPaymentCapable.sol';\nimport './Token.sol';\ncontract Bounty is PullPaymentCapable {\n  bool public claimed;\n  mapping(address => address) public researchers;\n  \n  function() {\n    if (claimed) throw;\n  }\n  \n  function createTarget() returns(Token) {\n    Token target = new Token(0);\n    researchers[target] = msg.sender;\n    return target;\n  }\n  \n  function claim(Token target) {\n    address researcher = researchers[target];\n    if (researcher == 0) throw;\n    \n    // check Token contract invariants\n    if (target.totalSupply() == target.balance) {\n      throw;\n    }\n    asyncSend(researcher, this.balance);\n    claimed = true;\n  }\n}\n```\n\n首先，正如前面所述，我们使用`PullPaymentCapable`来让我们的支付更加安全。这个赏金合约，允许研究者创建当前我们审核的`Token`合约的副本。任何人都可以参与到这个赏金项目，通过发送交易到这个赏金项目地址。如果任何研究者可以攻破他自己的`Token`合约的拷贝，让一些本不该变的情况变化（比如这里，让总代币发行量与当前代币余额不一致），他将获得对应的赏金。一旦赏金被领取了，合约将不再继续接受新的资金（无名的函数被称为合约的回退函数，在每次合约接收`ether`时自动执行）。\n\n正如你看到的，它有一个非常好的特性是分离了合约，不需要对原始的`Token`合约进行修改。[这里有一个完整，任何人都可以使用的版本](https://github.com/OpenZep/zep-solidity/blob/master/contracts/Bounty.sol)。\n\n\n而对于容错性，我们需要修改我们原来的合约来增加额外的安全机制。一种简单的方案是允许合约的监督者可以冻结合约，作为一种紧急的机制。我们来看一个通过继承实现这种行为的例子：\n\n```\ncontract Stoppable {\n  address public curator;\n  bool public stopped;\n  modifier stopInEmergency { if (!stopped) _ }\n  modifier onlyInEmergency { if (stopped) _ }\n  \n  function Stoppable(address _curator) {\n    if (_curator == 0) throw;\n    curator = _curator;\n  }\n  \n  function emergencyStop() external {\n    if (msg.sender != curator) throw;\n    stopped = true;\n  }\n}\n```\n\n`Stoppable`允许指定一个监督者，可以来停止整个合约。实现方式是，通过继承这个合约，在对应的功能上使用修改器`stopInEmergency`和`onlyInEmergency`，下面我们来看一个例子：\n\n```\nimport './PullPaymentCapable.sol';\nimport './Stoppable.sol';\ncontract StoppableBid is Stoppable, PullPaymentCapable {\n  address public highestBidder;\n  uint public highestBid;\n  \n  function StoppableBid(address _curator)\n    Stoppable(_curator)\n    PullPaymentCapable() {}\n  \n  function bid() external stopInEmergency {\n    if (msg.value <= highestBid) throw;\n    \n    if (highestBidder != 0) {\n      asyncSend(highestBidder, highestBid);\n    }\n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n  \n  function withdraw() onlyInEmergency {\n    suicide(curator);\n  }\n}\n```\n\n在上面这个非常简单的例子中，`bid`可以被一个监督者停止，监督者在合约创建时指定。`StoppableBid`在正常情况下，只有`bid`函数可以被调用，而当出现紧急情况时，监督者可以介入，并激活紧急状态。并让`bid`函数不再可用，同时激活`withdraw`功能。\n\n在上面的例子中，紧急模式将允许监督者销毁合约，恢复资金。但在实际场景中，恢复的逻辑更为复杂（举例来说，需要返还资金给每个投资者）。[这里有一个可停止合约的实现](https://github.com/OpenZep/zep-solidity/blob/master/contracts/Stoppable.sol)（译者注：给的这个链接无法访问了）。\n\n## 限制可存入的资金\n\n另一个保护我们智能合约远离攻击的方式是限制。攻击者最有可能针对管理数百万美元的高调合同。并不是所有的合约，有这样的高的资金量。尤其是当我们正在初期。在这种情形下，限制合约可以接收的资金量就将非常有用。最简单的方式，可以实现为一个余额的硬上限。\n\n下面是一个简单的例子：\n\n```\ncontract LimitFunds {\n  \n  uint LIMIT = 5000;\n  \n  function() { throw; }\n  \n  function deposit() {\n    if (this.balance > LIMIT) throw;\n    ...\n  }\n}\n```\n\n回退函数里，会拒绝接收所有的直接支付。`deposit`函数会首先检查合约的余额是否已经超限，超限将直接抛出异常。其它一些更有意思的，比如动态上限，管理限制也很容易实现。\n\n## 简单和模块化的代码\n\n安全来自，我们想写的与代码实际可以做的距离。这非常的难以验证，特别是当代码量又大，又混乱时。这就是为什么写简单和模块化的代码变得非常重要。\n\n这意味着，函数应该尽可能的简单，代码之间的依赖应该极尽可能的少，文件应该尽可能的小，将独立的逻辑放进模块，每块的职责更加单一。\n\n命名是我们在编码过程中表达我们意图的方式。想一个好的名字，尽可能的让名字清晰。\n\n让我们来看一个关于[Event](https://solidity.readthedocs.io/en/latest/contracts.html#events)的差命名的例子。[看看DAO里的函数](https://github.com/slockit/DAO/blob/develop/DAO.sol#L618-L691)。其中的函数代码都太长了。\n\n最大的问题是太长，而且功能复杂。尽可能的让你的函数短小，比如，最多不超过30到40行代码。理想情况下，你应该在1分钟内弄明白函数的意图。另一个问题是关于事件`Transfer`在第685行的命名。这个名字与[一个叫transfer](https://github.com/slockit/DAO/blob/develop/DAO.sol#L755)的函数名只有一字之差。这将带来误解。一般来说，关于事件的推荐命名是使用`Log`打头，这样的话，这个事件应该命名为`LogTransfer`。\n\n记住，尽可能的将你的合约写得简单，模块化，良好的命名。这将极大的帮助其它人和你自己审查你自己的代码。\n\n## 不要从0开始写所有的代码\n\n最后，正如一句格言所说，“不要从头发明你自己的加密币”。我想它也适用于智能合约代码。你的操作与钱有关，你的数据是公开的，你正在一个全新的成长中的平台上。代价非常高，糟蹋机会的人无处不在。\n\n上述这些实践帮助我们写出更安全的合约。但最终，我们应该开发出更好的创建智能合约的工具。这里有一些先行者，包括[better type systems](https://www.youtube.com/watch?v=H2uwUdzVD9I&feature=youtu.be)，[Serenity Abstractions](https://blog.ethereum.org/2015/12/24/understanding-serenity-part-i-abstraction/) 和[the Rootstock platform](http://rsk.co/)。\n\n现在已经有非常多的安全的代码，以及框架出现了。我们整合了一部分最佳实践到[Github的资源库Open Zeppelin](https://github.com/OpenZeppelin/zeppelin-solidity)。欢迎看看以及贡献新代码，以及提供代码审查建议。\n\n## 总结一下\n\n回顾一下，这篇文章中描述的安全模式有：\n\n1. 尽早且明确的暴露问题。\n2. 使用（pull）模式而不是（push）模式\n3. 代码结构遵从：条件，行为，交互\n4. 注意平台限制\n5. 测试用例\n6. 容错及自动bug奖励\n7. 限制存入的资金\n8. 简单与模块化的代码\n9. 不要从零开始写代码\n\n如果你想讨论与智能合约相关的问题，欢迎加入[Slack](https://zeppelin-slackin.herokuapp.com/)，让我们一起来提升智能合约编程标准。\n\n想要获得持续的更新，欢迎关注我们的[Medium](https://medium.com/zeppelin-blog)和[Twitter](https://twitter.com/maraoz)；\n\n（完）",
      "json_metadata": "{\"tags\":[\"cn\"],\"image\":[\"https://cdn-images-1.medium.com/max/800/1*basr8iGFNi6HSf_d2fMhzg.jpeg\"],\"links\":[\"https://blog.zeppelin.solutions/onward-with-ethereum-smart-contract-security-97a827e47702\",\"https://medium.com/bitcorps-blog/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05#.6dob381ks\",\"https://github.com/ConsenSys/smart-contract-best-practices\",\"http://solidity.readthedocs.io/en/latest/security-considerations.html\",\"https://oncodingstyle.blogspot.com.ar/2008/10/fail-early-fail-loudly.html\",\"http://solidity.readthedocs.io/en/latest/contracts.html#function-modifiers\",\"https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function\",\"https://github.com/ethereum/wiki/wiki/Safety#favor-pull-over-push-for-external-calls\",\"http://hackingdistributed.com/2016/07/13/reentrancy-woes/\",\"https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/payment/PullPayment.sol\",\"http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#index-6\",\"https://ethereum.gitbooks.io/frontier-guide/content/costs.html\",\"https://github.com/OpenZeppelin/zeppelin-solidity/issues/15）。\",\"https://en.wikipedia.org/wiki/Software_regression\",\"http://truffleframework.com/docs/getting_started/testing\",\"https://medium.com/@peterborah/we-need-fault-tolerant-smart-contracts-ec1b56596dbc#.uugpuufoa\",\"https://github.com/OpenZep/zep-solidity/blob/master/contracts/Bounty.sol\",\"https://github.com/OpenZep/zep-solidity/blob/master/contracts/Stoppable.sol\",\"https://solidity.readthedocs.io/en/latest/contracts.html#events\",\"https://github.com/slockit/DAO/blob/develop/DAO.sol#L618-L691\",\"https://github.com/slockit/DAO/blob/develop/DAO.sol#L755\",\"https://www.youtube.com/watch?v=H2uwUdzVD9I&feature=youtu.be\",\"https://blog.ethereum.org/2015/12/24/understanding-serenity-part-i-abstraction/\",\"http://rsk.co/\",\"https://github.com/OpenZeppelin/zeppelin-solidity\",\"https://zeppelin-slackin.herokuapp.com/\",\"https://medium.com/zeppelin-blog\",\"https://twitter.com/maraoz\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "4ojtse",
      "title": "安全编写以太坊的智能合约指南"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-30T07:16:54",
  "trx_id": "04ac9322291e1f9dcd33b156d590dbfa09b046c9",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 14129922,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "本文翻译自`zeppelin`的 https://blog.zeppelin.solutions/onward-with-ethereum-smart-contract-security-97a827e47702\n\n\n如果你是以太坊开发的新手，我们推荐你在继续本文前，先读一下我们的以太坊智能合约指南（基本概念及环境搭建）：https://medium.com/bitcorps-blog/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05#.6dob381ks\n\n<!-- more -->\n\n\nhttps://cdn-images-1.medium.com/max/800/1*basr8iGFNi6HSf_d2fMhzg.jpeg\n\n\n安全的开发以太坊的智能合约，是非常需要花费精力的。已经有一些好的指南以及汇总，比如 [Consensys的智能合约最佳实践](https://github.com/ConsenSys/smart-contract-best-practices)，和[Solidity官方文档的安全指南](http://solidity.readthedocs.io/en/latest/security-considerations.html)。但除非真正写代码，这些概念很难被记住和理解。\n\n\n本文会尝试一个有点不同的办法。首先解释提升智能合约安全的一些策略，并展示一些不遵从，而引起问题的例子。最后给一些已经调整地，可以直接使用的最佳实践。希望，这能帮助你创建避免某些不安全行为的`肌肉记忆`，从而在写代码的时候意识到可能的风险。\n\n不啰嗦了，进入正题吧。\n\n## 尽早且明确的暴露问题\n\n一个简单且强大的最佳实践是，让[尽早且明确的暴露问题](https://oncodingstyle.blogspot.com.ar/2008/10/fail-early-fail-loudly.html)。接下来，看一个有问题的函数实现：\n\n```\n// 有问题的代码，不要使用！\ncontract BadFailEarly {\n  uint constant DEFAULT_SALARY = 50000;\n  mapping(string => uint) nameToSalary;\n  function getSalary(string name) constant returns (uint) {\n    if (bytes(name).length != 0 && nameToSalary[name] != 0) {\n      return nameToSalary[name];\n    } else {\n      return DEFAULT_SALARY;\n    }\n  }\n}\n```\n\n为避免合约潜在的问题，或者让合约运行于一个不稳定或不一致的状态。上面例子中的函数`getSalary`应该在返回结果前，检查参数。那现在的例子有什么问题呢，问题在于，如果条件不满足，将返回默认值。这将掩盖参数的严重问题，因为仍然可以按正常业务逻辑返回值。这虽然是一个比较极端的例子，但却非常常见，原因是大家在程序设计时，担心程序兼容性不够，所以设置一些兜底方案。但真相是，越快失败，越容易发现问题。如果我们不恰当的掩盖错误，错误将扩散到代码的其它地方，从而引起非常难以跟踪的不一致错误。下面是一个调整后的示例：\n\n```\ncontract GoodFailEarly {\n  mapping(string => uint) nameToSalary;\n  \n  function getSalary(string name) constant returns (uint) {\n    if (bytes(name).length == 0) throw;    \n    if (nameToSalary[name] == 0) throw;\n    \n    return nameToSalary[name];\n  }\n}\n```\n\n这个版本的代码，还展示了另外一种推荐的编码方式，一种将条件预检查分开，分开判断，验证失败的方式。原因是可以使用Solidity提供的[修改器](http://solidity.readthedocs.io/en/latest/contracts.html#function-modifiers)的特性，来实现重用。\n\n## 在支付时使用（pull）模式而不是（push）模式\n\n每次`ether`的转移，都需要考虑对应帐户，潜在的代码执行。一个接收的合约可以实现一个默认的[回退函数](https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function)，这个函数可能抛出错误。由此，我们永远要考虑在`send`执行中的可能的错误。一个解决方案是，我们应该[在支付时使用（pull）模式而不是（push）模式](https://github.com/ethereum/wiki/wiki/Safety#favor-pull-over-push-for-external-calls)。来看一个看起来没有问题的，关于竞标函数的例子：\n\n```\n// 有问题的代码，请不要直接使用！\ncontract BadPushPayments {\n  address highestBidder;\n  uint highestBid;\n \n  function bid() {\n    if (msg.value < highestBid) throw;\n    if (highestBidder != 0) {\n      // return bid to previous winner\n      if (!highestBidder.send(highestBid)) {\n        throw;\n      }\n    }\n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n}\n```\n\n上述的合约，调用了`send`函数，检查了返回值，看起来是非常符合常理的。但它在函数中调用了`send`函数，这带来了不安全，为什么？需要时刻记住的一点是，就像之前说的，`send`会触发另外一个合约的代码执行。\n\n假如某个竞标的地址，它会在每次有人转帐给他时`throw`。而此时，其它人尝试追加价格竞标时会发生什么呢？那么`send`调用将总是会失败，从而错误向上抛，让`bid`函数产生一个异常。一个函数调用如果以错误结束，将会让状态不发生变更（所有的变化都将回滚）。这将意味着，没有人将能继续竞标，合约失效了。\n\n最简单的解决方案是，将支付分离到另一个函数中，让用户请求（pull）金额，而不依赖于余下的合约逻辑：\n\n```\ncontract GoodPullPayments {\n  address highestBidder;\n  uint highestBid;\n  mapping(address => uint) refunds;\n  \n  function bid() external {\n    if (msg.value < highestBid) throw;\n    \n    if (highestBidder != 0) {\n      refunds[highestBidder] += highestBid;\n    }\n    \n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n  \n  function withdrawBid() external {\n    uint refund = refunds[msg.sender];\n    refunds[msg.sender] = 0;\n    if (!msg.sender.send(refund)) {\n      refunds[msg.sender] = refund;\n    }\n  }\n}\n```\n\n这次，我们使用一个`mapping`来存储每个待退款的竞标者的信息，提供了一个`withdraw`用于退款。如果在`send`调用时抛出异常，仅仅只是那个有问题的竞标者受到影响。这是一个非常简单的模式，却解决了非常多的问题（比如，[可重入](http://hackingdistributed.com/2016/07/13/reentrancy-woes/)）。所以，记住一点，当发送`ether`时，使用（pull）模式而不是（push）模式。\n\n我已经实现了一个[使用这个模式的合约，可以方便的继承使用](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/payment/PullPayment.sol)。\n\n\n## 函数代码的顺序：条件，行为，交互\n\n作为尽可能早的暴露问题的原则的一个延伸，一个好的实践是将你的函数结构化为：首先，检查所有前置的条件；然后，对合约的状态进行修改；最后，与其它合约进行交互。\n\n条件，行为，交互。坚持使用这样的函数结构，将会让你避免大部分的问题。下面来看使用了这个模式的一个例子：\n\n```\nfunction auctionEnd() {\n  // 1. Conditions\n  if (now <= auctionStart + biddingTime)\n    throw; // auction did not yet end\n  if (ended)\n    throw; // this function has already been called\n\n  // 2. Effects\n  ended = true;\n  AuctionEnded(highestBidder, highestBid);\n\n  // 3. Interaction\n  if (!beneficiary.send(highestBid))\n    throw;\n  }\n}\n```\n\n这首先符合尽可能早的暴露问题的原则，因为条件在一开始就进行了检查。它让存在潜在交互风险的，与其它合约的交互，留到了最后。\n\n## 留意平台局限性\n\n[EVM](http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#index-6)有非常多的关于合约能做的硬限制。这些是平台级的安全考虑，如果你不知道的话，却可以会威胁你的合约安全。下面来看一个看起来正常的，雇员津贴管理的代码：\n\n```\n\n// 不安全的代码，不要直接使用！\ncontract BadArrayUse {\n  \n  address[] employees;\n  \n  function payBonus() {\n    for (var i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = calculateBonus(employee);\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    // some expensive computation ...\n  }\n}\n```\n\n读完代码，业务实现非常直接，看起来也没有什么问题，但却潜藏三个问题，基于平台的一些独特性。\n\n第一个问题是`i`的类型将会是`uint8`，因为如果要存`0`，如果不指定类型，将自动选择一个占用空间最小的，恰当的类型，在这里将是`uint8`。所以如果这个数组的大小超过255个元素，这个循环将永远不会结束，最终将导致`gas`耗尽。应当在定义变量时，尽可能的不要使用`var`，明确变量的类型，下面我们来修正一下上面的例子：\n\n\n\n```\n// 仍然是不安全的代码，请不要使用！\ncontract BadArrayUse {\n  \n  address[] employees;\n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = calculateBonus(employee);\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    // some expensive computation ...\n  }\n}\n```\n\n第二个你需要考虑的事情是`gas`的限制。[gas](https://ethereum.gitbooks.io/frontier-guide/content/costs.html)是以太坊的一种机制，来对资源的使用收费。每一个修改状态的功能调用都会花费`gas`。假如`calculateBonus`计算津贴时有些复杂的运算，比如需要跨多个项目计算利润。这将消耗非常多的`gas`，将会很容易的达到交易和区块的`gas`限制。如果一个交易达到了`gas`的限制，所有的状态的改变都将会撤销，但消耗的`gas`不会退回。当使用循环的时候，尤其要注意变量对`gas`消耗的影响。让我们来优化一下上述的代码，将津贴计算与循环分开。但需要注意的是，拆开后仍然有数组变大后，带来的`gas`消耗增长的问题：\n\n```\n// UNSAFE CODE, DO NOT USE!\ncontract BadArrayUse {\n  \n  address[] employees;\n  mapping(address => uint) bonuses;  \n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = bonuses[employee];\n      employee.send(bonus);\n    }     \n  }\n  \n  function calculateBonus(address employee) returns (uint) {\n    uint bonus = 0;\n    // some expensive computation modifying the bonus...\n    bonuses[employee] = bonus;\n  }\n}\n```\n\n最后，还有一个关于调用栈调用深度的限制。EVM栈调用的硬限制是1024。这意味着如果嵌套调用的深度达到1024，合约调用将会失败。一个攻击者可以调用递归的调用我们的合约1023次，从而因为栈深度的限制，让`send`失败。前述的（pull）模式，可以比较好的避免这个问题（译者注：原链接找不到了，但找下github上的讨论：https://github.com/OpenZeppelin/zeppelin-solidity/issues/15）。\n\n下面是一个最终的修改版，解决了上述的所有问题：\n\n```\nimport './PullPaymentCapable.sol';\ncontract GoodArrayUse is PullPaymentCapable {\n  address[] employees;\n  mapping(address => uint) bonuses;\n  \n  function payBonus() {\n    for (uint i = 0; i < employees.length; i++) {\n      address employee = employees[i];\n      uint bonus = bonuses[employee];\n      asyncSend(employee, bonus);\n    }\n  }\n  function calculateBonus(address employee) returns (uint) {\n    uint bonus = 0;\n    // some expensive computation...\n    bonuses[employee] = bonus;\n  }\n}\n```\n\n总结一下，需要记住的 1）使用的变量类型的限制，2）合约的`gas`消耗，3）栈调用1024的限制。\n\n## 测试用例\n\n编写测试用例会占用大量的时间，但也能抵消你在添加新功能后[回归问题](https://en.wikipedia.org/wiki/Software_regression)需要花费的时间。回归问题具体是指在添加功能的修改过程中，导致之前的组件出现bug。\n\n我将尽快写一个更加广泛的关于测试的指南，如果你比较好奇，可以先看看关于Truffle的测试指南（译者注：原文链接失效了，也许是[这个](http://truffleframework.com/docs/getting_started/testing)）。\n\n\n## 容错及自动bug奖励\n\n[首先感谢Peter Borah带来的这两个想法的灵感](https://medium.com/@peterborah/we-need-fault-tolerant-smart-contracts-ec1b56596dbc#.uugpuufoa)。代码审查和安全审核对保证安全来说还不足够。我们的代码需要做好最坏情况的准备。当我们的智能合约中有漏洞时，应该有一种方法可以安全的恢复。不止如此，我们也应该尽可能早的发现漏洞。下面是一个内置的自动bug奖励机制带来的作用。\n\n下面我们就来看一个自动bug奖励的假设的代币管理的例子：\n\n```\nimport './PullPaymentCapable.sol';\nimport './Token.sol';\ncontract Bounty is PullPaymentCapable {\n  bool public claimed;\n  mapping(address => address) public researchers;\n  \n  function() {\n    if (claimed) throw;\n  }\n  \n  function createTarget() returns(Token) {\n    Token target = new Token(0);\n    researchers[target] = msg.sender;\n    return target;\n  }\n  \n  function claim(Token target) {\n    address researcher = researchers[target];\n    if (researcher == 0) throw;\n    \n    // check Token contract invariants\n    if (target.totalSupply() == target.balance) {\n      throw;\n    }\n    asyncSend(researcher, this.balance);\n    claimed = true;\n  }\n}\n```\n\n首先，正如前面所述，我们使用`PullPaymentCapable`来让我们的支付更加安全。这个赏金合约，允许研究者创建当前我们审核的`Token`合约的副本。任何人都可以参与到这个赏金项目，通过发送交易到这个赏金项目地址。如果任何研究者可以攻破他自己的`Token`合约的拷贝，让一些本不该变的情况变化（比如这里，让总代币发行量与当前代币余额不一致），他将获得对应的赏金。一旦赏金被领取了，合约将不再继续接受新的资金（无名的函数被称为合约的回退函数，在每次合约接收`ether`时自动执行）。\n\n正如你看到的，它有一个非常好的特性是分离了合约，不需要对原始的`Token`合约进行修改。[这里有一个完整，任何人都可以使用的版本](https://github.com/OpenZep/zep-solidity/blob/master/contracts/Bounty.sol)。\n\n\n而对于容错性，我们需要修改我们原来的合约来增加额外的安全机制。一种简单的方案是允许合约的监督者可以冻结合约，作为一种紧急的机制。我们来看一个通过继承实现这种行为的例子：\n\n```\ncontract Stoppable {\n  address public curator;\n  bool public stopped;\n  modifier stopInEmergency { if (!stopped) _ }\n  modifier onlyInEmergency { if (stopped) _ }\n  \n  function Stoppable(address _curator) {\n    if (_curator == 0) throw;\n    curator = _curator;\n  }\n  \n  function emergencyStop() external {\n    if (msg.sender != curator) throw;\n    stopped = true;\n  }\n}\n```\n\n`Stoppable`允许指定一个监督者，可以来停止整个合约。实现方式是，通过继承这个合约，在对应的功能上使用修改器`stopInEmergency`和`onlyInEmergency`，下面我们来看一个例子：\n\n```\nimport './PullPaymentCapable.sol';\nimport './Stoppable.sol';\ncontract StoppableBid is Stoppable, PullPaymentCapable {\n  address public highestBidder;\n  uint public highestBid;\n  \n  function StoppableBid(address _curator)\n    Stoppable(_curator)\n    PullPaymentCapable() {}\n  \n  function bid() external stopInEmergency {\n    if (msg.value <= highestBid) throw;\n    \n    if (highestBidder != 0) {\n      asyncSend(highestBidder, highestBid);\n    }\n    highestBidder = msg.sender;\n    highestBid = msg.value;\n  }\n  \n  function withdraw() onlyInEmergency {\n    suicide(curator);\n  }\n}\n```\n\n在上面这个非常简单的例子中，`bid`可以被一个监督者停止，监督者在合约创建时指定。`StoppableBid`在正常情况下，只有`bid`函数可以被调用，而当出现紧急情况时，监督者可以介入，并激活紧急状态。并让`bid`函数不再可用，同时激活`withdraw`功能。\n\n在上面的例子中，紧急模式将允许监督者销毁合约，恢复资金。但在实际场景中，恢复的逻辑更为复杂（举例来说，需要返还资金给每个投资者）。[这里有一个可停止合约的实现](https://github.com/OpenZep/zep-solidity/blob/master/contracts/Stoppable.sol)（译者注：给的这个链接无法访问了）。\n\n## 限制可存入的资金\n\n另一个保护我们智能合约远离攻击的方式是限制。攻击者最有可能针对管理数百万美元的高调合同。并不是所有的合约，有这样的高的资金量。尤其是当我们正在初期。在这种情形下，限制合约可以接收的资金量就将非常有用。最简单的方式，可以实现为一个余额的硬上限。\n\n下面是一个简单的例子：\n\n```\ncontract LimitFunds {\n  \n  uint LIMIT = 5000;\n  \n  function() { throw; }\n  \n  function deposit() {\n    if (this.balance > LIMIT) throw;\n    ...\n  }\n}\n```\n\n回退函数里，会拒绝接收所有的直接支付。`deposit`函数会首先检查合约的余额是否已经超限，超限将直接抛出异常。其它一些更有意思的，比如动态上限，管理限制也很容易实现。\n\n## 简单和模块化的代码\n\n安全来自，我们想写的与代码实际可以做的距离。这非常的难以验证，特别是当代码量又大，又混乱时。这就是为什么写简单和模块化的代码变得非常重要。\n\n这意味着，函数应该尽可能的简单，代码之间的依赖应该极尽可能的少，文件应该尽可能的小，将独立的逻辑放进模块，每块的职责更加单一。\n\n命名是我们在编码过程中表达我们意图的方式。想一个好的名字，尽可能的让名字清晰。\n\n让我们来看一个关于[Event](https://solidity.readthedocs.io/en/latest/contracts.html#events)的差命名的例子。[看看DAO里的函数](https://github.com/slockit/DAO/blob/develop/DAO.sol#L618-L691)。其中的函数代码都太长了。\n\n最大的问题是太长，而且功能复杂。尽可能的让你的函数短小，比如，最多不超过30到40行代码。理想情况下，你应该在1分钟内弄明白函数的意图。另一个问题是关于事件`Transfer`在第685行的命名。这个名字与[一个叫transfer](https://github.com/slockit/DAO/blob/develop/DAO.sol#L755)的函数名只有一字之差。这将带来误解。一般来说，关于事件的推荐命名是使用`Log`打头，这样的话，这个事件应该命名为`LogTransfer`。\n\n记住，尽可能的将你的合约写得简单，模块化，良好的命名。这将极大的帮助其它人和你自己审查你自己的代码。\n\n## 不要从0开始写所有的代码\n\n最后，正如一句格言所说，“不要从头发明你自己的加密币”。我想它也适用于智能合约代码。你的操作与钱有关，你的数据是公开的，你正在一个全新的成长中的平台上。代价非常高，糟蹋机会的人无处不在。\n\n上述这些实践帮助我们写出更安全的合约。但最终，我们应该开发出更好的创建智能合约的工具。这里有一些先行者，包括[better type systems](https://www.youtube.com/watch?v=H2uwUdzVD9I&feature=youtu.be)，[Serenity Abstractions](https://blog.ethereum.org/2015/12/24/understanding-serenity-part-i-abstraction/) 和[the Rootstock platform](http://rsk.co/)。\n\n现在已经有非常多的安全的代码，以及框架出现了。我们整合了一部分最佳实践到[Github的资源库Open Zeppelin](https://github.com/OpenZeppelin/zeppelin-solidity)。欢迎看看以及贡献新代码，以及提供代码审查建议。\n\n## 总结一下\n\n回顾一下，这篇文章中描述的安全模式有：\n\n1. 尽早且明确的暴露问题。\n2. 使用（pull）模式而不是（push）模式\n3. 代码结构遵从：条件，行为，交互\n4. 注意平台限制\n5. 测试用例\n6. 容错及自动bug奖励\n7. 限制存入的资金\n8. 简单与模块化的代码\n9. 不要从零开始写代码\n\n如果你想讨论与智能合约相关的问题，欢迎加入[Slack](https://zeppelin-slackin.herokuapp.com/)，让我们一起来提升智能合约编程标准。\n\n想要获得持续的更新，欢迎关注我们的[Medium](https://medium.com/zeppelin-blog)和[Twitter](https://twitter.com/maraoz)；\n\n（完）",
      "json_metadata": "{\"tags\":[\"cn\"],\"image\":[\"https://cdn-images-1.medium.com/max/800/1*basr8iGFNi6HSf_d2fMhzg.jpeg\"],\"links\":[\"https://blog.zeppelin.solutions/onward-with-ethereum-smart-contract-security-97a827e47702\",\"https://medium.com/bitcorps-blog/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05#.6dob381ks\",\"https://github.com/ConsenSys/smart-contract-best-practices\",\"http://solidity.readthedocs.io/en/latest/security-considerations.html\",\"https://oncodingstyle.blogspot.com.ar/2008/10/fail-early-fail-loudly.html\",\"http://solidity.readthedocs.io/en/latest/contracts.html#function-modifiers\",\"https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function\",\"https://github.com/ethereum/wiki/wiki/Safety#favor-pull-over-push-for-external-calls\",\"http://hackingdistributed.com/2016/07/13/reentrancy-woes/\",\"https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/payment/PullPayment.sol\",\"http://solidity.readthedocs.io/en/latest/introduction-to-smart-contracts.html#index-6\",\"https://ethereum.gitbooks.io/frontier-guide/content/costs.html\",\"https://github.com/OpenZeppelin/zeppelin-solidity/issues/15）。\",\"https://en.wikipedia.org/wiki/Software_regression\",\"http://truffleframework.com/docs/getting_started/testing\",\"https://medium.com/@peterborah/we-need-fault-tolerant-smart-contracts-ec1b56596dbc#.uugpuufoa\",\"https://github.com/OpenZep/zep-solidity/blob/master/contracts/Bounty.sol\",\"https://github.com/OpenZep/zep-solidity/blob/master/contracts/Stoppable.sol\",\"https://solidity.readthedocs.io/en/latest/contracts.html#events\",\"https://github.com/slockit/DAO/blob/develop/DAO.sol#L618-L691\",\"https://github.com/slockit/DAO/blob/develop/DAO.sol#L755\",\"https://www.youtube.com/watch?v=H2uwUdzVD9I&feature=youtu.be\",\"https://blog.ethereum.org/2015/12/24/understanding-serenity-part-i-abstraction/\",\"http://rsk.co/\",\"https://github.com/OpenZeppelin/zeppelin-solidity\",\"https://zeppelin-slackin.herokuapp.com/\",\"https://medium.com/zeppelin-blog\",\"https://twitter.com/maraoz\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "4ojtse",
      "title": "#安全编写以太坊的智能合约指南"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-30T07:16:18",
  "trx_id": "2e2e8bdd5031c9092cdd988f9b91317095b2927b",
  "trx_in_block": 4,
  "virtual_op": 0
}

{
  "block": 14093277,
  "op": [
    "custom_json",
    {
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hh3755\",\"following\":\"peterchen145\",\"what\":[\"blog\"]}]",
      "required_auths": [],
      "required_posting_auths": [
        "hh3755"
      ]
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-29T00:43:57",
  "trx_id": "92ded3ead2355b4a6c4f5f5842c45acbf2d2e171",
  "trx_in_block": 4,
  "virtual_op": 0
}

{
  "block": 14093273,
  "op": [
    "vote",
    {
      "author": "peterchen145",
      "permlink": "52zpud-eos",
      "voter": "hh3755",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-29T00:43:45",
  "trx_id": "793cec381e0c73e352d10d8df4a3291b867ce4b3",
  "trx_in_block": 14,
  "virtual_op": 0
}

{
  "block": 14008353,
  "op": [
    "comment",
    {
      "author": "maxtill94",
      "body": "分析2队长 ： -NEVERDIE 最后7天所有参与众筹的参与者给予20%的NDC币做赏赐。\n最少参与额为 5以太坊，只有在NEVERDIE 中国链接上可参与。\nhttps://neverdie.io/ch.html",
      "json_metadata": "{\"tags\":[\"cn\"],\"links\":[\"https://neverdie.io/ch.html\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "hh3755",
      "parent_permlink": "nsa",
      "permlink": "re-hh3755-nsa-20170726t015610072z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-26T01:56:09",
  "trx_id": "5a7148d3b8bc774bc1339e99ebe99e3119b01237",
  "trx_in_block": 7,
  "virtual_op": 0
}

{
  "block": 13930605,
  "op": [
    "comment",
    {
      "author": "lemooljiang",
      "body": "进来学习！",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "hh3755",
      "parent_permlink": "6f3kje",
      "permlink": "re-hh3755-6f3kje-20170723t090332785z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-23T09:04:12",
  "trx_id": "5360d0f22b68cbb1fc292579a1cab22ae70c65d0",
  "trx_in_block": 8,
  "virtual_op": 0
}

{
  "block": 13930588,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "6f3kje",
      "voter": "lemooljiang",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-23T09:03:21",
  "trx_id": "3a205a892119191b79d97b04b6d5e74e7ad2fe54",
  "trx_in_block": 5,
  "virtual_op": 0
}

{
  "block": 13928722,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "6f3kje",
      "voter": "myfirst",
      "weight": 4700
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-23T07:29:54",
  "trx_id": "a167470fb733f826c616f102d3f45239b6c628fa",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 13928697,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "# 区块链基础设施概览：第一性原理框架\n\n> 存储，计算和通信\n\n原文翻译自：https://blog.bigchaindb.com/blockchain-infrastructure-landscape-a-first-principles-framing-92cc5549bafe\n\nEthereum，IPFS/Filecoin，和BigChainDB是如何实现互相补充的呢？那Golem，Polkadot或Interledge又是如何的呢。我经常问我自己这样的问题。所以我打算写篇文章来阐述自己的，第一性原理框架，并来回答这些问题。\n\n简短的答案是：没有一个叫“区块链”的银弹，它能神奇的做所有的事情。相反，这里有的是非常好的实现图灵完备的各种各样的组件，你可以使用它们来搭建有效率的去中心化应用。以太坊可以参与其中，BigchainDB可以，所有其它组件也都可以，我们来一起看看...\n\n## 背景\n\n组成一个程序的要素有存储，计算和通信。大型机，个人电脑，手机和云计算，每一个都以自己独特的方式来表达了这些组成元素。专用于某一方面的组件出现来与其它组件合作来达到我们想要的结果。\n\n举例来说，在存储元素中，我们可以选择文件系统和数据库系统组件。文件系统使用层级式的目录，存储像mp3这样的二进制的大对象，而数据库则用来存储结构化的元数据，通过SQL这样的语言来进行操作。在中心化的云上，我们则会使用Amazon S3来进行二进制大对象的存储，使用MongoDB做为数据库存储，而使用Amazon EC2来做为计算服务器。\n\n本文将聚集于区块链的技术概貌：程序用到的每个要素的相关组件，对应组件的实际项目的例子。对于每个组件，我会尽量的全面阐述。\n\n## 区块链的一些基本组件\n\n下面是程序的基本要素中，每个要素对应到块（译者注：核心职责，价值）：\n\n* *存储：*代币存储，数据库，文件系统/二进制大对象存储\n* *计算：*有状态的业务逻辑，无状态的业务逻辑，高性能计算（HPC）\n* *通信：*数据，价值，状态\n\n## 区块链基础设施概貌\n\n每一个组件中的对应的区块链技术如下：\n\n程序的三要素，及对应的组件，示例项目，去中心化版（后附原图，对比看，更清晰）\n\n存储|计算|通信|\n---|----|----|\n代币存储<br>Bitcoin，Zcach，.*|有状态的业务逻辑<br>Ethereum，Lisk，Rchain，Eos，Tezos，...客户端计算（JS，Swift）|数据<br>TCP/IP，HTTP\n文件系统或二进制数据<br>IPFS/FileCoin，Eth Swarm，Storj，Sia，Tieron，LAFS|无状态的业务逻辑<br>加密币条件（如BigchainDB），Bitshares，及所有的有状态的业务逻辑|价值<br>Interledger，Cosmos\n数据库<br>BigchainDB + IPDB，IOTA|高性的运算<br>TrueBit，Golem，Iex.ec，Nyriad，VMs，客户端计算|状态<br>PolkaDot，Aeternity\n\nhttps://cdn-images-1.medium.com/max/1600/1*zh6b8FRUK33z09EY83Z9mA.png\n\n## 存储\n\n程序中最基本的元素，存储，有下述一些可用的组件：\n\n***代币存储：***代币存储的是价值（资产或安全）。无论这个价值是比特币，飞行里程，艺术品的电子版权。一个代币存储系统的主要操作就是发行和转移代币（满足各种各样的条件下），系统需要保证不会双花等。\n\n比特币和Zcash是两个专注于代币存储的纯粹系统。以太坊恰好使用它的代币达到了世界计算机的目标（译者注：由于以太坊是图灵完备的，愿景是成为永不停机的世界计算机，但现在大多数人用它来进行代币的发行，作者在这里是一种调侃吧）。上述这些是代币被用来作为内部激励，驱动整个网络基础设施。\n\n其它一些代币没有集成于整个网络内来驱动整个网络，而是用来激励更高层级的网络，但底层基础架构实际存储着对应的代币。一个例子是运行于以太坊主网上的ERC20标准的Golem（GNT）。另一个例子是运行在[IPDB](https://ipdb.io/)上的[Envoke](http://envoke.cre8tives.org/)IP授权代币。\n\n最后，我使用“.*”来说明大多数的区块链系统都有代币的存储机制。\n\n***数据库：***数据库专指存储结构化的数据，比如表（关系型数据库），文档存储（比如，JSON），键值对存储，时间序列或图；然后可以通过快速查询语言（比如：SQL）进行数据搜索。\n\n传统的分布式（但中心化）数据库比如Mongo和Cassandra经常存储TB，甚至PB级的数据，而写性能能超过1000000每秒，正如[这里](https://medium.com/netflix-techblog/benchmarking-cassandra-scalability-on-aws-over-a-million-writes-per-second-39f45f066c9e)所述。\n\n查询语言SQL是非常巧妙的，因为他将规范与实现分开，这样它就不再与某种应用绑定。SQL在最近数十年一直是一个标准规范。这也让同样的数据库系统可以横跨不同的工业领域进行使用。\n\n换种思路：如果你想将比特币更广泛的推广到其它的应用，没有任何特定应用程序的代码，你没有必要一定实现图灵完备。你只是需要一个数据库。这将在简单与规模间具有相应的优势。当然实现图灵完备在有些地方仍然是非常有用的；我们后面的关于去中心化的计算章节来更多的讨论一下。\n\n[BigchainDB](http://www.bigchaindb.com/)是一个去中心化的软件；专注于文档存储。基于MongoDB（或RethinkDB）之上，它继承了Mongo的查询与扩容功能。但它仍有区块链的特性，比如去中心化的控制，防篡改和代币功能的支持。[IPDB](https://ipdb.io/)是BigchainDB的一个拥有治理功能的公网版本。\n\n同样在区块链领域里，我们可以认为[IOTA](https://iota.org/)是一个按时间序列的数据库，如果换一个角度来看的话。\n\n***文件系统、二进制数据存储：*** 这些是用来存储大文件（比如电影，mp3，超大数据集），以目录、文件这样的层级结构存储的系统。\n\n[IPFS](https://ipfs.io/)和[Tahoe-LAFS](https://tahoe-lafs.org/trac/tahoe-lafs)是去中心化的文件系统，整合了去中心化和中心化的二进制大对象的存储。[FileCoin](http://filecoin.io/)，[Storj](https://storj.io/)，[Sia](http://sia.tech/)，[Tieron](https://tierion.com/)实际进行二进制的存储。当然也包括老的[BitTorrent](http://www.bittorrent.com/)，尽管他使用的是针对性的解决方案，而不是代币。[以太坊的Swarm](https://github.com/ethersphere/swarm)，[Dat](https://datproject.org/)和[Swarm-JS](https://github.com/gritzko/swarm)也差不多是在做这些。\n\n## 计算\n\n接下来我们聊聊，程序的第二要素计算。\n\n“智能合约”系统是指使用去中心化方式进行计算的系统。系统可以区分为两大类，无状态（组合）的业务逻辑和有状态（顺序）的业务逻辑。无状态与有状态在复杂上，可验证性等上有着根本的区别。我们还有第三类的去中心化的计算组件：高性能计算（HPC）。\n\n***无状态（组合）的业务逻辑：***在内部的任何逻辑里都不需要保留状态。 如果用电子工程术语来说的话，它是由数字逻辑回路组成。 逻辑表示为真值表，示意图或代码的条件语句（组合if/then，逻辑与，逻辑或）。 由于它们没有状态，因此很容易验证大型无状态智能合同，并由此构建大型校验/安全系统。 N个输入和一个输出需要O（2 ^ N）次计算来进行验证。\n\n[Interledger协议](https://interledger.org/)包含一个加密币条件（crypto-conditions aka. CC）协议来清晰的指定组合的回路。因为CC[通过IETF](https://tools.ietf.org/html/draft-thomas-crypto-conditions-01)成为了互联网的标准协议，同时ILP也正被中心化和去中心化的支付网络（[75家银行采用了Ripple的协议](https://finance.yahoo.com/news/75-banks-now-ripples-blockchain-network-162939601.html)）广泛的采纳，所以你最好对之有些了解。CC在[JavaScript](https://github.com/interledgerjs/five-bells-condition)，[Python](https://github.com/bigchaindb/cryptoconditions)，[Java](https://github.com/interledger/java-crypto-conditions)等都有单独的实现。 BigchainDB，Ripple等系统使用CC; 因此支持组合业务逻辑/智能合同。\n\n由于有状态业务逻辑是无状态逻辑的超集，因此支持状态业务逻辑的系统也支持无状态业务逻辑（牺牲额外的复杂性和可验证性挑战）。\n\n\n***有状态（顺序）的业务逻辑：***任何内部的业务逻辑都有状态。这就是说，他有记忆（译者注：根据经历的形成的不同记忆有不同的选择）。或者是说，它是具有至少一个反馈回路（和时钟）的组合逻辑电路。 例如，微处理器具有根据发送给它的机器码指令进行更新的内部寄存器。 更一般地说，有状态的业务逻辑是图灵机，其接收输入序列，并且返回一系列的输出。 实现了这样逻辑（实际近似）的系统是图灵完备的。\n\n以太坊是最知名的实现了有状态的逻辑和智能合约的链上（on-chain）系统。[Lisk](https://lisk.io/)，[RChain](https://www.rchain.coop/)，[DFINITY](https://dfinity.network/)，[EOS](http://www.eos.io/)，[Tezos](https://tezos.com/)，[Fabric](https://hyperledger-fabric.readthedocs.io/en/latest/)，[Sawtooth](https://intelledger.github.io/introduction.html)，及很多其它的也实现了。可以运行一个“就在那里，但也可能是任何地方”的代码是非常强大的一个想法，有非常多的使用场景。这也侧面解释为什么以太坊会成功，为什么它的生态系统发展成为一个平台，以及为什么在这个领域里有如此多的竞争。\n\n同时因为序列逻辑是组合逻辑的超集，这样的系统也支持组合逻辑。\n\n有状态的业务逻辑的问题是，代码中的非常小的错误，将引发严重的后果，正如DAO的被黑事件所展示的那样。形式验证可以帮助解决这个问题，正如它在芯片行业所做的那样。以太坊基金正在积极引入形式验证。然后有状态业务逻辑的另一个问题是有规模的限制。对于组合回路，所有的可能的组合是2的所有可能输入的次方。对于有状态逻辑来说，内部状态的数量，假设所有的状态是布尔的，就是2的所有内存状态变量。举例来说，如果你有3种可能的输入，对于组合回路来说就是2的3次方，8种所有的可能。而对于有状态的逻辑来说，如果可改变状态的操作有32种，那么将检查2的32次方，即42亿个状态（译者注：实际的实现不会看起来的这么低效能，这里主要是为了说明复杂性）。这是有状态逻辑的复杂性限制（因为你需要相信这门技术，相信它最终实现的是你真正想要的，否则就会成为一个bug，带来经济损失）。“尽可能正确的创建”是另一种让智能合约可信的一种方法，正如[Rchain](http://rchain-architecture.readthedocs.io/en/latest/introduction/introduction.html)使用的rho演算（译者注：对于这里，读者应保持自己的观点，图灵完备确实会让写的代码不可控，容易出bug，但它的想像力是比较大的。请保持自己独立思考）。\n\n如果你想使用去中心化的计算，对于许多的情形来说，这里有一个简单的方法：在浏览器或者移动设备，可运行JavaScript和Swift这样的客户端上简单的执行就可以了。这里，你必须要相信在你的客户端上所进行的操作，但由于设备在你的手上，一般你会容易接受这点（译者注：可能会疑惑，平时就是这样做的，为什么要刻意强调。因为这里想说明的是去中心的运算是无信任任何节点，但浏览器的后端确定了，必须要相信现在配置的这个节点）。我们把这叫做[胖客户端](https://blog.bigchaindb.com/bigchaindb-version-1-0-released-932bee682266)以区别于[胖协议](http://joel.mn/post/148641439498/fat-protocols)框架。这个架构对于主流的web开发者来说非常好理解。举例来说，所有许多的web应用程序都需要状态。要创建这样一个程序，你需要JS + IPDB（使用[js-bigchaindb-driver](https://www.npmjs.com/package/js-bigchaindb-driver)）。又或者你的应用需要使用到二进制的大对象存储或支付，可以包含IPFS的js版本（[ipfs.js](https://github.com/ipfs/js-ipfs)）和以太坊的js版本（[web3.js](https://github.com/ethereum/web3.js)）。下面是一个例子：\n\nhttps://cdn-images-1.medium.com/max/1600/1*ZiExDXrFKLWLKiw_2UoE_A.png\n\n\n***高性能计算（HPC）：***为渲染，机器学习，电路仿真，天气预报，蛋白质折叠等方面的“重”计算的处理。 计算任务将使用一个机器集群（CPU，GPU，甚至[TPU](https://en.wikipedia.org/wiki/Tensor_processing_unit)），花上几个小时或甚至几个星期。\n\n有如下的一些去中心化的实现HPC的方式：\n\n* [Golem](https://golem.network/)和[iEx.ec](http://iex.ec/)框架整合去中心化的超级电脑的算力与相关的应用程序。\n* [Nyriad](http://www.nyriad.com/)作为存储执行。这种计算基于去中心化的存储（对于存储Nyrid也有自己的解决方案）。\n* [TrueBit](http://truebit.io/)允许第三方进行计算，然后进行事后的计算检查（如果可能则进行隐式检查;如果有问题，则进行显示的检查）。\n* 而另一些人只是在VM或[Docker](https://www.docker.com/)容器上运行大量计算，并将结果（最终的VM状态快照或刚刚计算的结果）存到一个需要权限才能访问的blob中。 然后，使用代币的方式来售卖访问权限。 这种方法要求更多的客户来验证结果，但好的是，今天所有这些技术都是可能的。 当TrueBit成熟时，这种方式将自然与TrueBit结合。\n\n## 通信\n\n最后我们将来说明一下程序的第三个要素，通信。通信方式有很多种; 我将专注于连接网络的这个层面。 它有三个层次：数据，价值和状态。\n\n\n***数据：***在60年代时，我们有了[ARPAnet](https://en.wikipedia.org/wiki/ARPANET)。它成功的延伸出了类似的网络，如[NPL](https://en.wikipedia.org/wiki/NPL_network)，[CYCLADES](https://en.wikipedia.org/wiki/CYCLADES)，随之诞生的问题时，大家不能互相交流。Cerf和Kahn在70年代发明了[TCP/IP](https://de.wikipedia.org/wiki/Transmission_Control_Protocol/Internet_Protocol)协议来把大家连在一起。TCP/IP现在是连接网络的事实上的标准。OSI是另一套与之竞争的协议，则显得逊色不少（尽管讽刺的是，它的模型已被证明是有用的）。所以，除了它的发明时间有点长，TCP/IP仍无可争议的是去中心组件的重要一环，用于连接网络中的数据（译者注：IPFS正打算创建一套全新的协议。）。\n\n***价值：***TCP/IP仅仅提供了在数据层面连接网络。你可以重复发送数据，从而造成一些错误，但底层的TCP/IP协议并不关心这些。但如果你想要通过连接的网络发送资产呢。举例来说，从比特币发到以太坊，或发送到使用国际货币支付框架SWIFT协议的支付网络。你将期望你的代币一次只能转给一个目标（译者注：如果同一份钱，可以转给两个目标，那么这个网络将因为不可靠而失去大家的信任，因为可以双花）。一种连接整个网络，同时防止双花的方式是使用交易所，一种传统的非常重的方式。然而，你可以通过加密托管的方式来抽离交易所的本质，通过自动化的代码来移除对中间人的需要来实现。例如Alice可以通过Mallory向Bob转帐，Mallory中转资金但不能花费它们（资金会有一个超时，从而Mallory也不能永久的持有资金）。这也正是[Interledger Protocol](http://www.interledger.org/)（ILP）的内在理念。这与双向锚定的概念类似以及状态通道（如[Lighting网络](https://lightning.network/)和[Raiden网络](http://raiden.network/)）；但这些网络连接都是100%专注于面向价值的连接（译者注：因为要传输价值，所以建立的网络连接）。除ILP以外，还有[Cosmos](https://cosmos.network/)为了更加方便使用，增加了更多的复杂性。\n\n***状态：***在通过网络连接价值以外，还有什么呢。想象一下一台计算机病毒，其自己的比特币钱包可以从一个网络跳到另一个网络。或某个以太坊的智能合约，可以移动他的状态到另一个以太坊网络，甚至到另一个匹配的不同网络？或者说，为什么限制[AI DAO](https://blog.bigchaindb.com/ai-daos-series2-3876510d6eb4)于某个具体的网络呢？\n\n这正是[Polkadot](http://polkadot.io/)正在做的，连接网络的状态。[Aeternity](https://www.aeternity.com/)同样适用于价值网络与状态网络间的某个地方。\n\n## 例子\n\n我们刚回顾了程序的三个主要要素（存储，计算和通信），去中心的组件分类，每个组件内的一些对应的项目。\n\n人们正在基于这些项目的组合来建造项目。有非常多同时组合两个以上的组件，如IPFS + 以太坊或者IPFS + IPDB。但也有同时组合三个及以上的组件。下面有几个前沿的例子：\n\n* [Ujo](https://blog.ujomusic.com/ujo-x-rac-under-the-hood-the-future-of-licensing-d4f38e2efabd)使用了IPFS或Swarm 加上IPDB加上以太坊来实现去中心化的音乐，愿景在[这里](https://medium.com/ipdb-blog/a-decentralized-content-registry-for-the-decentralized-web-99cf1335291f)。IPFS或Swarm用于文件和二进制存储。IPDB（使用BigchainDB）用于元数据存储和查询。以太坊用来做代币存储和需要状态的业务逻辑。\n\n* [Innogy](https://medium.com/@cstoecker/implementing-first-industry-4-0-use-cases-with-iota-dag-tangle-machine-tagging-for-digital-twins-baf1943c499d)使用IPFS加IPDB加IOTA来实现供应链和物联网。IPFS用于文件和二进制大对象的存储。IPDB（使用BigchainDB）用于元数据存储和查询。IOTA用于需要时序的数据。\n\n## 相关的工作\n\n后面是在区块链社区的其它一些相关的技术框架；所有这些我都与之进行过愉快的交流。\n\nJoel Monegro的[胖协议](http://joel.mn/post/148641439498/fat-protocols)框架强调每一个组件都是一个协议。我认为这是一个非常酷的框架，尽管它强制所有组件通过网络协议进行交互。这里还有其它的方式：区块间可以简单的通过一个`import`导入或库的调用进行通信。\n\n使用import的方式的原因是（a）低延迟。如果通过网络调用，会影响甚至完全让应用不可用；（b）简单。使用库（甚至内嵌代码）总是比连接网络实现上简单，而且也不用花费代币等。（c）更成熟。协议栈的解决方案现在才出现，而现存在大量可使用的库，比如UNIX库，即使Python和JS的模块库也已经有15年的历史了。\n\nFred Ehrsam的“[DAPP开发栈](https://medium.com/@FEhrsam/the-dapp-developer-stack-the-blockchain-industry-barometer-8d55ec1c7d4)”适用于web的业务模型。它也非常有用，但它并不旨在对于给定的程序元素（例如文件系统与数据库），并在组件之间进行细粒度区分。\n\n[BigchainDB白皮书](https://www.bigchaindb.com/whitepaper/bigchaindb-whitepaper.pdf)（第一次发布于2016年2月），为了方便说明，下图给出了一个早期版本的开发栈：\n\nhttps://cdn-images-1.medium.com/max/1600/1*jz8Z8-oD_wqlvUNj51AHVg.png\n\n当时的这个版本关注于处理，文件系统，数据库。当时还并没有从程序的要素的角度来清晰划分，同时也没有详细的区分去中心化的计算这块（译者注：上图中，当时版本里面，只有一个模糊的VM）。现在的这个文章，是在当时的白皮书的基础上，经过了1年半的思维革新后；在某些演讲中持续更新后所得，正如5月22号在[2017共识大会上的演讲](http://trent.st/content/20170522%20blockchains%20for%20ai%20-%20consensus%202017.pdf)一样，就已经非常趋同于当前的这篇文章了（写这篇文章的另一个原因是我收到了大量的请求，希望我能用文字的方式将这些记录下来）。\n\n上面这张旧图也强调了一个完全中心化的到一个完全去中心化的转变的解决方案。这可以用来帮助将现存的软件系统更新为更去中心化的系统，关注于更新那些最值得更新的组件就好了。\n\nStephan Tual的“[Web3.0的重访问](https://blog.stephantual.com/web-3-0-revisited-part-one-across-chains-and-across-protocols-4282b01054c5)”提到的技术栈与本文类似，只是它更关注于以太坊相关的技术栈。它尝试将相似的项目归类到某些组件中，并形成一个地图，来服务社区。我非常惊喜想法与我的非常类似。然而文中服务应用的区块层（用于消息通信，存储，共识，治理的区块）混入了三种东西：apps，“什么”，“如何解决”。对我来说，区块是“什么”。所以消息通信是应用（应该属于应用层）;而存储层应该更加细粒度的；共识是“如何实现”的那层（隐藏于某些区块里）；治理是“如何实现”的另外一部分（因而也是隐藏于区块里的）。它也有[网络]协议作为分离的底层的块，同样我也赞同这是一种区块间，与库函数调用一起，相互通信的方式。尽管如些，我仍认为那是一篇非常好的文章和技术栈说明。\n\nAlexander Ruppert的“[去中心化世界的地图](https://medium.com/birds-view/mapping-the-decentralized-world-of-tomorrow-5bf36b973203)”有差不多20个组组成，x轴给出了从基础层到应用层的四个层次，但使用中间件和流动性作为关联性的层级。这也是一件巨作，我很高兴能帮助Alex把它整理出来。它更集中于边界，而没有那么强调基本的架构；然而这篇正是源自第一性原理框架关于核心基础设施的说明文章。\n\n## 未来\n\n像Ujo这样的系统，组合许多的组件到一起，比如IPFS等。最终他也能从所有的这些组件系统中受益。\n\n我非常期待当大家更好的了解了组件间的关联关系后，这个趋势将进一步的加速。这样的分组比把所有组件揉为一个叫区块链的更能提高大家的生产率。\n\n随着去中心化的生态演变，我期望这个技术栈不断迭代。AWS刚推出时只有一个服务：S3用于存储二进制的大对象。然后它发展了计算：EC2。既而一路向前，这里是它发展的[完整时间线](https://en.wikipedia.org/wiki/Timeline_of_Amazon_Web_Services)。AWS现在有超过50个组件；尽管其中只有一小部分是最重要的。下面是一张AWS提供的服务的图片。\n\nhttps://cdn-images-1.medium.com/max/1600/1*4saBh4WuK_E27SSsB3ouGA.png\n\n\n我预见在去中心的领域也将发生类似的事情。作为第一步，大家可以想像一下每一个AWS组件对应的去中化版本。然而，这其中，肯定会存在一些不同，每个生态（云计算 vs 去中心化）都会有一些自己独有的，比如去中化中特有的代币存储。让我们一起来开启这个有趣的旅程吧。\n\n（完）",
      "json_metadata": "{\"tags\":[\"cn\"],\"image\":[\"https://cdn-images-1.medium.com/max/1600/1*zh6b8FRUK33z09EY83Z9mA.png\",\"https://cdn-images-1.medium.com/max/1600/1*ZiExDXrFKLWLKiw_2UoE_A.png\",\"https://cdn-images-1.medium.com/max/1600/1*jz8Z8-oD_wqlvUNj51AHVg.png\",\"https://cdn-images-1.medium.com/max/1600/1*4saBh4WuK_E27SSsB3ouGA.png\"],\"links\":[\"https://blog.bigchaindb.com/blockchain-infrastructure-landscape-a-first-principles-framing-92cc5549bafe\",\"https://ipdb.io/\",\"http://envoke.cre8tives.org/\",\"https://medium.com/netflix-techblog/benchmarking-cassandra-scalability-on-aws-over-a-million-writes-per-second-39f45f066c9e\",\"http://www.bigchaindb.com/\",\"https://iota.org/\",\"https://ipfs.io/\",\"https://tahoe-lafs.org/trac/tahoe-lafs\",\"http://filecoin.io/\",\"https://storj.io/\",\"http://sia.tech/\",\"https://tierion.com/\",\"http://www.bittorrent.com/\",\"https://github.com/ethersphere/swarm\",\"https://datproject.org/\",\"https://github.com/gritzko/swarm\",\"https://interledger.org/\",\"https://tools.ietf.org/html/draft-thomas-crypto-conditions-01\",\"https://finance.yahoo.com/news/75-banks-now-ripples-blockchain-network-162939601.html\",\"https://github.com/interledgerjs/five-bells-condition\",\"https://github.com/bigchaindb/cryptoconditions\",\"https://github.com/interledger/java-crypto-conditions\",\"https://lisk.io/\",\"https://www.rchain.coop/\",\"https://dfinity.network/\",\"http://www.eos.io/\",\"https://tezos.com/\",\"https://hyperledger-fabric.readthedocs.io/en/latest/\",\"https://intelledger.github.io/introduction.html\",\"http://rchain-architecture.readthedocs.io/en/latest/introduction/introduction.html\",\"https://blog.bigchaindb.com/bigchaindb-version-1-0-released-932bee682266\",\"http://joel.mn/post/148641439498/fat-protocols\",\"https://www.npmjs.com/package/js-bigchaindb-driver\",\"https://github.com/ipfs/js-ipfs\",\"https://github.com/ethereum/web3.js\",\"https://en.wikipedia.org/wiki/Tensor_processing_unit\",\"https://golem.network/\",\"http://iex.ec/\",\"http://www.nyriad.com/\",\"http://truebit.io/\",\"https://www.docker.com/\",\"https://en.wikipedia.org/wiki/ARPANET\",\"https://en.wikipedia.org/wiki/NPL_network\",\"https://en.wikipedia.org/wiki/CYCLADES\",\"https://de.wikipedia.org/wiki/Transmission_Control_Protocol/Internet_Protocol\",\"http://www.interledger.org/\",\"https://lightning.network/\",\"http://raiden.network/\",\"https://cosmos.network/\",\"https://blog.bigchaindb.com/ai-daos-series2-3876510d6eb4\",\"http://polkadot.io/\",\"https://www.aeternity.com/\",\"https://blog.ujomusic.com/ujo-x-rac-under-the-hood-the-future-of-licensing-d4f38e2efabd\",\"https://medium.com/ipdb-blog/a-decentralized-content-registry-for-the-decentralized-web-99cf1335291f\",\"https://medium.com/@cstoecker/implementing-first-industry-4-0-use-cases-with-iota-dag-tangle-machine-tagging-for-digital-twins-baf1943c499d\",\"https://medium.com/@FEhrsam/the-dapp-developer-stack-the-blockchain-industry-barometer-8d55ec1c7d4\",\"https://www.bigchaindb.com/whitepaper/bigchaindb-whitepaper.pdf\",\"http://trent.st/content/20170522%20blockchains%20for%20ai%20-%20consensus%202017.pdf\",\"https://blog.stephantual.com/web-3-0-revisited-part-one-across-chains-and-across-protocols-4282b01054c5\",\"https://medium.com/birds-view/mapping-the-decentralized-world-of-tomorrow-5bf36b973203\",\"https://en.wikipedia.org/wiki/Timeline_of_Amazon_Web_Services\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "6f3kje",
      "title": "区块链基础设施概览：第一性原理框架"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-23T07:28:39",
  "trx_id": "6da7e2bb51b4822ea4b63d0b4fb4f44257b30744",
  "trx_in_block": 0,
  "virtual_op": 0
}

{
  "block": 13921309,
  "op": [
    "author_reward",
    {
      "author": "hh3755",
      "permlink": "nsa",
      "sbd_payout": "0.033 SBD",
      "steem_payout": "0.000 STEEM",
      "vesting_payout": "49.593799 VESTS"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-23T01:18:54",
  "trx_id": "0000000000000000000000000000000000000000",
  "trx_in_block": 4294967295,
  "virtual_op": 3
}

{
  "block": 13908381,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "naval",
      "voter": "hh3755",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-22T14:32:21",
  "trx_id": "fd179afbbae4e48612dff384063ff7f0694cddc7",
  "trx_in_block": 4,
  "virtual_op": 0
}

{
  "block": 13907736,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "naval",
      "voter": "xiaobai",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-22T14:00:06",
  "trx_id": "7d096ba84df671ff5a6a24d4baa89027281441ae",
  "trx_in_block": 14,
  "virtual_op": 0
}

{
  "block": 13901148,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "That's very kind of you for refer the related tweets.",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "twitterbot",
      "parent_permlink": "re-naval-20170722t082836",
      "permlink": "re-twitterbot-re-naval-20170722t082836-20170722t083012424z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-22T08:30:12",
  "trx_id": "87e70b318096c26f605f8a1960be5cb9ea970125",
  "trx_in_block": 12,
  "virtual_op": 0
}

{
  "block": 13901116,
  "op": [
    "comment",
    {
      "author": "twitterbot",
      "body": "### ![jwangARK](https://pbs.twimg.com/profile_images/814307178852982784/iLj92QcV_normal.jpg) **[James Wang](https://twitter.com/@jwangARK/status/863957649364316165)** tweeted @ 15 May 2017 - 03:22 UTC\n\n> By far the three most important foundational technologies right now:\n– Deep learning\n– Blockchain\n– Crispr\n\n\n### ![naval](https://pbs.twimg.com/profile_images/749155852683055104/0StT9uYS_normal.jpg) **[Naval Ravikant](https://twitter.com/@naval/status/877467629308395521)** tweeted @ 21 Jun 2017 - 10:06 UTC\n\n> 1/ Blockchains will replace networks with markets.\n\n\n### ![fchollet](https://pbs.twimg.com/profile_images/831025272589676544/3g6BrXCE_normal.jpg) **[François Chollet](https://twitter.com/@fchollet/status/883785045722279936)** tweeted @ 08 Jul 2017 - 20:29 UTC\n\n> Over 8 years since launch, it seems people's motivations for buying / using BTC are still 1) speculation, 2) criminal activity\n\n\n### ![naval](https://pbs.twimg.com/profile_images/749155852683055104/0StT9uYS_normal.jpg) **[Naval Ravikant](https://twitter.com/@naval/status/877467874138378240)** tweeted @ 21 Jun 2017 - 10:06 UTC\n\n> 4/ Overlapping networks create and organize our society. Physical, digital, and mental roads connecting us all.\n\n\n### ![naval](https://pbs.twimg.com/profile_images/749155852683055104/0StT9uYS_normal.jpg) **[Naval Ravikant](https://twitter.com/@naval/status/877470481481220096)** tweeted @ 21 Jun 2017 - 10:17 UTC\n\n> 28/ To a blockchain, merit can mean security, computation, prediction, attention, bandwidth, power, storage, distribution, content...\n\n\n###### *Disclaimer: I am just a bot trying to be helpful.*",
      "json_metadata": "",
      "parent_author": "hh3755",
      "parent_permlink": "naval",
      "permlink": "re-naval-20170722t082836",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-22T08:28:36",
  "trx_id": "17c7aea6004fafc9d306148b9e316e982b96496d",
  "trx_in_block": 24,
  "virtual_op": 0
}

{
  "block": 13901099,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "原文翻译自：https://hackernoon.com/reflections-on-the-best-blockchain-tweets-ever-written-d488af960d4f\n\n如果你不知道[Naval Ravikant](https://twitter.com/naval)，你应该了解一下他。在投资领域，他是最好的。他投资了数百家公司，其中包括像Twitter，Uber这样的科技独角兽。他还建立了[AngelList](https://angel.co/)，一个用于天使投资人和初创企业的快速配对平台。\n\n但如果仅凭这些，还不足以让我给予这个人很高的评价。不像大多人，我不通过一个人的成功来评判一个人。你可以是个笨蛋，但你仍然可以很成功。就像Eckhart Tolle曾经说过的一样，如果你想赚钱，你不一定睿智，你只需要聪明就好了。\n\n但Ravikant是非常睿智的。\n\n这不仅仅是因为他的[书单](http://www.businessinsider.com/angellist-ceo-naval-ravikant-shares-his-favorite-books-2015-8/#meditations-by-marcus-aurelius-1)与我的某些最爱书相近。\n\nhttps://cdn-images-1.medium.com/max/600/1*_WM4zRjuaJ5d9o1IXubYlA.jpeg\n\n我曾经读了[悉达多](https://book.douban.com/subject/10549934/)二十余次。如果你惊奇的发现一个天使投资人的书单上居然有一堆的精神和哲学的书籍，这说明你有一个独一无二的大脑。大多数我认识的，在纽约大学商学院兄弟们认为，安兰德的[源泉](https://book.douban.com/subject/20376604/)是她写过的唯一的书。\n\n翻翻Ravikant的[推文](https://twitter.com/search?q=naval%20ravikant&src=tyah)，或者听听这个[采访](https://www.farnamstreetblog.com/2017/02/naval-ravikant-reading-decision-making/)，你将很快发现，他比谁都知道如何去思考。[批判性思维是当今以及未来世界最重要的技能](https://singularityhub.com/2017/07/04/7-critical-skills-for-the-jobs-of-the-future/?utm_content=buffere8953&utm_medium=social&utm_source=twitter-hub&utm_campaign=buffer)。\n\n最近他有一些关于区块链的思考（以及另外两个技术，将被认为是改变世界的，[基因编辑技术和AI](https://twitter.com/jwangARK/status/863957649364316165)）。几个星期前，他在推特上写了[史诗般的关于区块链的36条推文](https://medium.com/the-naked-founder/naval-ravikants-36-tweets-on-cryptocurrencies-f9b2b64106c1)以及未来世界的市场。他们注定要成为经典。我已经读了无数次，而我还打算再读无数次。每一次读的时候，都会带来更深的理解。\n\nhttps://youtu.be/BTiZD7p_oTc?list=RDBTiZD7p_oTc\n\n上面的视频是一些分形（fractal），看起来似乎永远无限下沉。\n\n关于区块链的这些推文，他没有办法把他们清晰的阐述出来，如果他做到了，他将比我想像的更为睿智。但我怀疑他已经说得足够清晰了（译者注：作者也许想表达是我们自己没有足够理解）。但显而易见的是，这些推文，是多年的关于区块链对社会和整个世界的思考结果的精华。\n\n区块链的革新性的到来就像海啸一样，将会重新改成社会每个角落，但大多数人仍视而不见。这是因为对于每个人的影响还在后面。人们常常在理解突破性的技术时受挫，因为他们没有形成一个自己的参考框架。想像一下，你向一个18世纪的农场主介绍浏览器技术时，他根本搞不明白。\n\n到目前为止，即使是一些我[非常尊敬的聪慧的人](https://twitter.com/fchollet/status/883785045722279936)仍然视比特币或加密货币为：\n\n* 旁氏骗局\n* 郁金香热（译者注：史上第一个泡沫经济）\n* 自由主义者一个邪恶的阴谋\n* 毒品贩子货币（译者注：有些人用来作非法交易，留下的恶名）\n* 书呆子搞的货币（译者注：原文为nerd money）\n\n在流行媒体中关于加密货币相关报道是极其惨的（[即使他正在持续的增长与繁荣，但他仍被宣布即将消亡1000次了](https://99bitcoins.com/bitcoinobituaries)），虽然一切正一步步的[变得好起来](https://www.wsj.com/articles/why-bitcoin-is-booming-1499638932)。在我的文章中[为什么每个人都错过了最近500年最重要的发明](https://hackernoon.com/why-everyone-missed-the-most-important-invention-in-the-last-500-years-c90b0151c169)，我全力驳斥了大部分的相关争论，但当然大多数人并没有遵从自己的逻辑来承认这些。\n\n最后，加密货币和区块链将正如一个古老的作家的格言来证明它在世界上的存在：\n\n> Show don't tell\n\n换句话说，区块链必须开始驱动普通人每天的生活中，而不仅仅是一些日常的交易。这正在来临。但这需要达到区块链自己的`微信时刻`，一个连奶奶都能简单使用区块链技术的时刻。现在我们来看看区块链已经发展到哪一步了。\n\n这正是Naval的推文所说的内容。当前正在发生的。\n\n我们从他的推文的第一条开始吧：\n\n> [Blockchains will replace networks with markets.](https://twitter.com/naval/status/877467629308395521)\n\n他到底想说什么呢，为了理解它，你首先需要理解他所说的网络。\n\n词典给网络的定义是互相联系的人或事物群体或系统。其它的定义包括任何网状细丝，线条，纹，通道的组合。这也是正是[系统视角](http://www.necsi.edu/guide/concepts/system_perspective.html)的理念，一种在某个环境的上下文环境中，把系统中的所有行为都考虑在内的系统视角。\n\n\nhttps://cdn-images-1.medium.com/max/600/1*zurZgQKI2UUjJLLFSR5BXg.jpeg\n\n但说起来，网络是一个[元模式](https://book.douban.com/subject/11881224/)。这是一个跨越空间，时间和精神的连接网络。\n\n想像一下大城市交错的街道或街道下下水道所组成的迷宫。 你的神经系统和你头脑密集的树枝状森林都是网络，蜿蜒的河流像地球上的动脉一样流过这片土地。 你的神经系统和你头脑密集的树枝状森林都是网络，蜿蜒的河流像地球上的动脉一样流过地面。\n\n网络不仅限于物理存在的事物。他们是[物理的，数字的，精神的，连接我们的路](https://twitter.com/naval/status/877467874138378240?ref_src=twsrc%5Etfw&ref_url=https%3A%2F%2Fmedium.com%2Fmedia%2F65fe97efe282a6501d838aefb5c5a8ea%3FpostId%3Df9b2b64106c1)。这意味着从一个不同的视角，几乎所有的东西都是一个网络，从我们大脑信仰中的纠缠到不同思想人之间的言语互动，再到以数字信息的方式，金钱和能量在整个地球中的流动。\n\n>“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.”\n\n其中一些如此显而易见，但另一些则不然。通过网络连接的路很好理解，但是企业如何通过网络连接呢？一群人为同一个目标完全分散的进行工作（译者注：Aragon项目，提供了一种通过区块链连接投资方，技术接入方，服务提供方，消费用户的离散公司网络）。宗教？通过共同信仰团结起来的民众的网络。\n\n世界通过推动不同的群体而不断演变。有共同信仰系统聚集到一起，形成复杂的影响力链，经济和军事力量。早期的部族和氏族从来没有离开我们，只是像池塘的水波不断向外扩展，渗于其中从而变得更加的错综复杂了。\n\n这些大型部族间斗争正在全面的全力以赴的扩张。他们正在改变越来越多的人看待整个宇宙的方式，网络（译者注：这里的网络专指web，web1.0，web2.0这样通用网络概念，如果把下一代web叫做价值互联网的话，这将更有意义）的影响力正在持续增长。\n\n>“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.”\n\n网络渗透得越深，它将会更深刻的改变现实社会的结构。 “The leading network tends towards becoming the only network.”这样的网络变成了我们生活和在其中工作的网络。如果那样的网络是好的话，生活也是好的，如果那个网络是恶魔的话，生活也会变得悲惨而饱受苦痛。\n\n那我们怎样达到一个好或坏的网络呢？\n\n简单。我们有两种方式来达成网络的主导权：\n\n* 暴力和控制\n* 开放和民主\n\n如果你仔细思量，你会发现这是两套完全不同的信仰系统在驱使着这一切。\n\nhttps://cdn-images-1.medium.com/max/600/1*BJoK_p6kSW7Hyd6ZnnfP7w.jpeg\n\n一个是现实的黑暗。愤怒是其中的引导性情绪。这样的信仰系统里将严格的等级制度视为至关重要的。仅仅只有某些人可以控制所有其它人可以做的。信奉这套哲学的人崇拜地位与权力。暴力是他们的首要武器。\n\n硬币的反面，一个好的网络是开放和民主的。它是分工协作的，也是包容的。最好的想法获得最后的胜利，而无关乎这个想法来自哪里。分类与等级的概念被消融了，理想的方式贯穿整个网络，并被整个网络所采纳。这是一种务实的哲学，从而不会主动挑起战端，但如果被迫，却会全力以赴。\n\n这些哲学之间的争论是永无止境的。\n\n封闭意味着黑暗（译者注：如果类比苹果为封闭，其实封闭也不一定意味着黑暗）。\n\n开放是光明的。\n\n世界史就是一块封闭与开放之间，中心化到去中心化之间，等级森严到自由流动之间的一种斗争。\n\nhttps://cdn-images-1.medium.com/max/600/1*r2ep618GAM-7CONk3QJ0xg.jpeg\n\n变化的钟摆来自摆动，永不停歇（译者注：有点“分久必合，合久必分”的意思）。\n\n> 省略一段，讨论开放与封闭的优劣，大意是想说开放带来创新，封闭只有恐惧与害怕，扼杀创新的种子。自已看原文吧，谢谢（。\n\n在每个分支上，每一个可能性一个个的串联起来，就像一条绳上的珠串。\n\nhttps://cdn-images-1.medium.com/max/600/1*kVaMhWrn4WDlwW6KHbEH2A.gif\n\n就像Yoda（译者注：星球大战里面的尤达大师？）所说，恐惧引至愤怒，愤怒引至嫉恨，嫉恨招至痛苦。\n\n随着时间的推移，这些分支路径向外扩展，滋生更多的绝望或更多的快乐和自由。运动中的物体往往持续的在运动中。 它要么变得黑暗和衰退，要么生长和繁荣，不断向光延伸。\n\n除非它被瓦解。\n\n瓦解引向变化和新的可能性。\n\n## 新生\n\n我们现在比以往更需要瓦解。\n\n最近50年，世界趋向于集中化，控制和不平等。钟摆摆得太远了。即便倡导开放和民主的互联网也开始衰落。他们过于中心化和过于集中化了（译者注：想想BAT三家独大，遏制新的创新的出现，也许能比较好的理解这段）。\n\nhttps://youtu.be/JkZa6PE0SkI\n\n>“Overspecialize and you breed in weakness. It’s slow death.” — Ghost in the Shell\n\n是什么引致一个系统的成功。\n\n信仰系统。\n\n你的信仰决定了你的现实。\n\n>“Your beliefs become your thoughts, \nYour thoughts become your words, \nYour words become your actions, \nYour actions become your habits, \nYour habits become your values, \nYour values become your destiny.”\n— Gandhi\n\n每一个信仰系统都认为它自己保有全部的真理。\n\n但没有其中任何一个真正做到了，包括你、我以及所有其它人当前信奉的系统。\n\n我们仅仅是向真理一步步的靠近了，而我们离最终的目标还有很远。如果我们拒绝去发现身边正确的东西，我们的决定终将失败，因为他来源于一个虚假的假设。错误的开始引致错误的结束。\n\nhttps://cdn-images-1.medium.com/max/600/1*g3qWNj4Dqt6S7JwhAN_D4g.jpeg\n\n\n>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.\n\n群体看清的真实现实与他们想象中现实的对比决定了他们的痛苦水平。\n\n如果两个群体有不同的现实的憧憬，谁会获胜呢？\n\n我们如何决定呢？\n\n其中我们曾经创建过的一个最强大的系统叫市场。如果我认为我有一个其它人需要的货物或服务，这是我信仰的系统。它本身可能是对的，也可能是错的，我的产品可能是惊艳的或者是极差的。\n\n无论是哪种情况，市场将让我知道答案。如果没有人愿意花钱买他，我非常可能正在做一件错事。也许是我卖的方式不对，或者产品还不是足够的好，我需要回过头去接续改进。\n\nhttps://cdn-images-1.medium.com/max/600/1*Dvjxaft5drgL2T5G1XXZbQ.jpeg\n\n市场是不完美的，但它在持续的修正自己来得到越来越好的答案，一点点的接近真理。最好的答案，增加了整个系统的价值和财富，以及系统中的每个个体。在整个系统里，所有的玩家正努力的实现积极的[纳什均衡](https://en.wikipedia.org/wiki/Nash_equilibrium)，关于纳什平衡的细节，可以看看相关的书中或电影[美丽心灵](http://amzn.to/2sZBcM5)。\n\n最终，市场会让所有的回归其正常的次序。世界可能会暂时忽视梵高在他一生中的天才，直到后来才意识到，这些绿色和金色的旋转画风令人难以着迷，并为每幅画花费数百万美元。\n\n\n在整个历史中，市场和网络是相关但分开的。 市场只不过是一种网络。它只不过是一种交换商品和服务的网络。真正的是蕴含于其中的宗族的，暴力，胁迫和稀缺性的力量。\n\n直到现在。\n\n今天，由于一个全新的市场的出现（译者注：这里特指，网络与市场结合的一种新市场`Market networks`，），暴力部落的时代正在快速的临近：\n\n>“Market networks. Open AND meritocratic.”\n\n区块链融合了市场和网络为一个智能的，混合系统。\n\n区块链是一个新的发明，允许对开放网络有贡献的人来控制整个网络，而不是通过统治者或钱的驱使。它们是基于贡献的，防篡改的，开放的，投票系统。贡献是指凡是有助于提升整个网络的。正如社会因为你提供了它需要的服务，而反馈给你钱。区块链给予你代币，因为你提供给了整个网络它需要的东西。\n\n这些代币要求不同种类的工作。每个区块链都有他自己的目的。比如，支付比特币是为了保证记的帐目的安全。以太坊则是为计算（执行和校验）付款。\n\n其中的每个区块链大多遵从UNIX的类似哲学，只做一件事，把这件事做好，而不是同时做很多事，而每件事都做得不好。随着市场-网络的发展，我们将看到越来越多的专业化网络，一些专注于分布式，防篡改存储，处理去中心化的身份验证，另一些则负责执行智能合同，及支持更先进的法律框架等。\n\n这些系统将会比我们当前的系统更为有效率。\n\n在今天的专业网络中，权力集中在少数军阀的手中，这些军阀越来越强大，掐断了这个世界其它人的希望和梦想。最终贪婪和愚蠢导致他们误入歧途，他们希望通过后门和消弱网络的功能来控制网络。当一种主宰了所有其它的观点，社会倾向于衰亡和消退，系统也将变得不再包容，从而最终爆发。\n\n相比较而言，分布式的区块链系统可以抵挡敌对的腐败行为，将那些受限的观点容纳并包。这是因为没有任何一个持有某种信仰的群体唯一掌握了通向王国的钥匙。取而代之的是，每一个网络中的参与者，掌握着一把钥匙，有效的通过整个网络分发能量（译者注：区块链将贡献记录下来了，让整个网络自动根据贡献来赋权。而中心化的系统是通过赋予权力，或垄断）。\n\n这将引向一个新的动态平衡：\n\n>Competing groups must cooperate to reach consensus or they crash the whole system and they all suffer.\n\n与现在的系统不同的是，现在系统都是被单一强大的群体所严格控制，因为他们对别人没有同情心（一种宗族的想法的特征），他们对整体造成了巨大的伤害，造成了广泛的痛苦，而同时，他们还觉得他们做得挺对。\n\n我们可以来看看现代的银行系统。银行系统持有所有的钱并制定所有的规则。他们购买影响力，调整规则来达到自己的意愿。 如果按他们自己的方式，他们会建立自己控制的不完整意义上的区块链，所以他们可以继续任意改变游戏的规则。这些是精英和暴徒控制的区块链：简而言之，不完整的和无用的区块链，根本不是区块链。\n\n>“It’s nonsensical to have a blockchain controlled by a sovereign, a corporation, an elite, or a mob.”\n\n\n理由非常简单。只有当银行，银行的股东，存款者，监管者同时持有主动权才能达到所谓的平衡。虽然我们有各自不同的兴趣，不同的信仰，看到问题的不同侧面，但我们必须达成共识，以让整个系统获益，或打破整个系统。但由于没有人想要摧毁整个系统，因为所有人都将失去一切，所以最终大家会打破分歧，达成一致。\n\n这有一点类似于Satoshi在他的[白皮书](https://bitcoin.org/bitcoin.pdf)里讨论的51%攻击问题。如果一个矿工或某个群体拥有了51%的算力，他们不会篡改之前的交易，他们只会拒绝接收新的某些交易。另外Satoshi也明智的认为到，这并不是一个问题。如果有任何一个人投入了如此大量的时间和钱来建立了一个如此强大的算力，维持这个系统的正常运转将会获得最大的收益。在系统中作恶获得的一点小小的收益，最终将导致大家对整个系统失去信心，从而对整个市场造成压力，最终让他们投入的时间和金钱变得一文不值。\n\n>“Merit in markets is determined by a commitment of resources. The resource is money, a form of frozen and trade-able time”\n\n没有人愿意燃毁所有这些“冻结和可交易的时间”，所以他们的目标从破坏性行为转变为有利于整个系统的行为，并使其运行顺利。\n\n## 分形的宇宙\n\n区块链的可能性是无限的，从透明的[端到端的可校验投票](https://en.wikipedia.org/wiki/End-to-end_auditable_voting_systems)，到股票和分红的发放，再到[安全，计算，预测，注意力经济，带宽，能量，存储，分发，内容](https://twitter.com/naval/status/877470481481220096)等等。\n\n在这里，我不打算一个个深入的说明，因为我[已经在](https://hackernoon.com/why-everyone-missed-the-most-important-invention-in-the-last-500-years-c90b0151c169)[一系列](https://artplusmarketing.com/how-we-can-deliver-a-universal-basic-income-right-now-and-save-ourselves-from-the-robots-without-e1972e22e8eb)[其它的文章](https://hackernoon.com/how-we-build-an-unstoppable-peer-to-peer-tor-with-a-billion-exit-nodes-4b232dac162d)中提到了，[你可以看看](https://hackernoon.com/how-the-decentralized-web-will-rewrite-the-rules-of-security-and-save-the-net-from-the-barbarian-23db16af34a1)，如果[你喜欢](https://hackernoon.com/the-good-the-bad-and-the-ugly-of-consensus-2017-8776056f97a3)，但几乎不用说的是：\n\n随着时间的推移，这些可能性将只会扩大和蓬勃发展，渗透于生活的各个方面。 区块链将产生一个新兴的微观经济体系，堆叠在微观经济体上，而这些微观经济体在大型元链无限回归之间相互联系（译者注：可以看看前面的那个Fractal的视频）。\n\n这将改变整个世界。\n\nhttps://cdn-images-1.medium.com/max/600/1*7yUTKWRwEwrn5sIt-TpzTQ.jpeg\n\n\n今天，我们的网络由“国王，牧师，精英，公司和暴徒”统治。“把它当成是一个宝座的游戏。 这是一场黑暗野蛮的游戏。\n\n区块链永远打翻了他们头上的动态。他们将大大的改变这个星球上权力的平衡，并朝向更好的方向。\n\n>“Blockchains’ open and merit based markets can replace networks previously run by kings, corporations, aristocracies, and mobs.”\n\n去中心化的力量将小而增长迅猛，遵循库兹维尔的“加速回报法”。\n\n>“Blockchain based market-networks will replace existing networks. Slowly, then suddenly. In one thing, then in many things.”\n\n过渡将会令人不安，令人震惊。\n\n这一切甚至可能是讨厌的，因为中心化的既得利益者不惜一切代价坚持过去。 但最终，他们将会像Trilobites（三叶虫）进入历史。\n\n这一切结束后，没有人会哀悼过去。\n\n（完）\n\n\n本文是翻译，请访问原文：https://hackernoon.com/reflections-on-the-best-blockchain-tweets-ever-written-d488af960d4f",
      "json_metadata": "{\"tags\":[\"cn\",\"blockchain\"],\"image\":[\"https://cdn-images-1.medium.com/max/600/1*_WM4zRjuaJ5d9o1IXubYlA.jpeg\",\"https://img.youtube.com/vi/BTiZD7p_oTc/0.jpg\",\"https://cdn-images-1.medium.com/max/600/1*zurZgQKI2UUjJLLFSR5BXg.jpeg\",\"https://cdn-images-1.medium.com/max/600/1*BJoK_p6kSW7Hyd6ZnnfP7w.jpeg\",\"https://cdn-images-1.medium.com/max/600/1*r2ep618GAM-7CONk3QJ0xg.jpeg\",\"https://cdn-images-1.medium.com/max/600/1*kVaMhWrn4WDlwW6KHbEH2A.gif\",\"https://img.youtube.com/vi/JkZa6PE0SkI/0.jpg\",\"https://cdn-images-1.medium.com/max/600/1*g3qWNj4Dqt6S7JwhAN_D4g.jpeg\",\"https://cdn-images-1.medium.com/max/600/1*Dvjxaft5drgL2T5G1XXZbQ.jpeg\",\"https://cdn-images-1.medium.com/max/600/1*7yUTKWRwEwrn5sIt-TpzTQ.jpeg\"],\"links\":[\"https://hackernoon.com/reflections-on-the-best-blockchain-tweets-ever-written-d488af960d4f\",\"https://twitter.com/naval\",\"https://angel.co/\",\"http://www.businessinsider.com/angellist-ceo-naval-ravikant-shares-his-favorite-books-2015-8/#meditations-by-marcus-aurelius-1\",\"https://book.douban.com/subject/10549934/\",\"https://book.douban.com/subject/20376604/\",\"https://twitter.com/search?q=naval%20ravikant&src=tyah\",\"https://www.farnamstreetblog.com/2017/02/naval-ravikant-reading-decision-making/\",\"https://singularityhub.com/2017/07/04/7-critical-skills-for-the-jobs-of-the-future/?utm_content=buffere8953&utm_medium=social&utm_source=twitter-hub&utm_campaign=buffer\",\"https://twitter.com/jwangARK/status/863957649364316165\",\"https://medium.com/the-naked-founder/naval-ravikants-36-tweets-on-cryptocurrencies-f9b2b64106c1\",\"https://youtu.be/BTiZD7p_oTc?list=RDBTiZD7p_oTc\",\"https://twitter.com/fchollet/status/883785045722279936\",\"https://99bitcoins.com/bitcoinobituaries\",\"https://www.wsj.com/articles/why-bitcoin-is-booming-1499638932\",\"https://hackernoon.com/why-everyone-missed-the-most-important-invention-in-the-last-500-years-c90b0151c169\",\"https://twitter.com/naval/status/877467629308395521\",\"http://www.necsi.edu/guide/concepts/system_perspective.html\",\"https://book.douban.com/subject/11881224/\",\"https://twitter.com/naval/status/877467874138378240?ref_src=twsrc%5Etfw&ref_url=https%3A%2F%2Fmedium.com%2Fmedia%2F65fe97efe282a6501d838aefb5c5a8ea%3FpostId%3Df9b2b64106c1\",\"https://youtu.be/JkZa6PE0SkI\",\"https://en.wikipedia.org/wiki/Nash_equilibrium\",\"http://amzn.to/2sZBcM5\",\"https://bitcoin.org/bitcoin.pdf\",\"https://en.wikipedia.org/wiki/End-to-end_auditable_voting_systems\",\"https://twitter.com/naval/status/877470481481220096\",\"https://artplusmarketing.com/how-we-can-deliver-a-universal-basic-income-right-now-and-save-ourselves-from-the-robots-without-e1972e22e8eb\",\"https://hackernoon.com/how-we-build-an-unstoppable-peer-to-peer-tor-with-a-billion-exit-nodes-4b232dac162d\",\"https://hackernoon.com/how-the-decentralized-web-will-rewrite-the-rules-of-security-and-save-the-net-from-the-barbarian-23db16af34a1\",\"https://hackernoon.com/the-good-the-bad-and-the-ugly-of-consensus-2017-8776056f97a3\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "naval",
      "title": "Naval关于区块链的推文的反思"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-22T08:27:45",
  "trx_id": "a50e0863f1ad8321518bc9f41599b380709fb39f",
  "trx_in_block": 20,
  "virtual_op": 0
}

{
  "block": 13844091,
  "op": [
    "comment",
    {
      "author": "maxtill94",
      "body": "你的文已看完，我已申请关注了，我也写了第一篇文，有空请阅下～\n个人认为NEVERDIE ICO 也不错，在我个人热帖里，Neverdie.com",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "hh3755",
      "parent_permlink": "aragon",
      "permlink": "re-hh3755-aragon-20170720t085356267z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-20T08:53:57",
  "trx_id": "4b880d451dfe141d50f2c8d703d792637008d1e5",
  "trx_in_block": 1,
  "virtual_op": 0
}

{
  "block": 13722335,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "nsa",
      "voter": "myfirst",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-16T03:24:09",
  "trx_id": "540500eac295d32a9c37fa7ac0ce7b9aefd2b8bc",
  "trx_in_block": 17,
  "virtual_op": 0
}

{
  "block": 13719870,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "nsa",
      "voter": "frantorr",
      "weight": 10000
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-16T01:20:51",
  "trx_id": "76af110b5420e463e2f724ff43a0efac7aed72c2",
  "trx_in_block": 4,
  "virtual_op": 0
}

{
  "block": 13719831,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "最近在Twitter上看到一篇关于加密学中常见的“坑”的文章，为扩充自己的视野，特地翻译并学习一下。原文在：http://ethanheilman.tumblr.com/post/70646748808/a-brief-history-of-nsa-backdoors\n\n声明：翻译文章，并不代表翻译者支持，或反对文章观点。只是翻译学习之用。如有版权问题，请随时联系删除，谢谢。\n\n作为最近的文章[ NSA backdooring RSA libraries](https://www.cnet.com/news/security-firm-rsa-took-millions-from-nsa-report/)得到的启发，我写了一份简单的，不完整的，NSA后门的历史。如果有人愿意将文章变得更好，可以联系：[email protected]\n\n*更新*：增加了Actel后门，*更新2*: 在[这里](http://t.umblr.com/redirect?z=https%3A%2F%2Fnews.ycombinator.com%2Fitem%3Fid%3D6947133&t=YWM0OWMzMjc0MDk1NDA3OTRjNDNiM2Y1OTExNjAwOTE3MTRjMGI1ZSwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1)有讨论。*更新3*：增加了最后发现的邮件侵入后门安装。\n\nhttp://68.media.tumblr.com/e73395a94755b6fb23a37df2b214153d/tumblr_inline_my4zhyzuRu1qf5p6p.jpg\n\n\n*1946-1970, The Ultra Secret*： 在第二次世界大战后，英国向许多盟国和前殖民地出售了[德国Enigma密码加密机](http://t.umblr.com/redirect?z=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FEnigma_machine&t=ZmJjOWQxN2Q5NzZjYzE3ZDUyNGU3Nzg5YWQ1YjdhM2E5N2MyMWYwNiwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1)。美国和英国已经破译了Enigma加密，但是却没有告诉他们，这样他们就能破译盟国或其殖民地的加密信息，在30年间这些国家都因为这些机器中的缺陷而被泄密。\n\n*1957 - 当前, The Boris Project*: 在1957年，NSA的`William Friedman`与他的老朋友`Boris Hagelin`见了面。他们的目标是启动`the Boris Project`，让[Crypto AG](http://t.umblr.com/redirect?z=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FCrypto_AG&t=NjFlYWUzOTAzNzgyMWE0MjVmYTQ4MGMyMjhiMmYxYzE5MWNkZTk1ZSwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1)生产的加密器存在后门，从而可以让NSA来监听NATO的通信（有证据表明，Boris项目早于本次会议）。这次会议首先在Friedman的自己的自传中被公开，书名是`The Man Who Broke Purple`。更多的细节也因为`The Puzzle Palace`的发行而被披露，其中的一些信件显示了Friedman对于项目进行方式的担心。通过与前Crypto AG公司的前雇员的访谈，后续开始并没有继续增加后门，而且很可能在1970年前，且持续到现在。这些后门包括隐蔽通道，允许全私匙重建。\n\n逐步的，大家发现Crypto AG不是一个可依赖的加密硬件商。在1986年李根向Libyans透露，美国可以解密他们通过在TV上通过Libya加密的信息。1991年，伊朗人了解到，伊朗外交通讯记录最后出现在了法国的法庭案中，NSA可能已经破译了他们的外交通讯。1992年伊朗对于Crypto AG公司非常恼怒，并因为他们从事间谍活动进行了巨额罚款。尽管如此，但仍有证据表明，伊朗似乎继续使用Crypto AG机器进行外交交流，直到2003年，也许超过了2003年。2004年，艾哈迈德·沙拉比（Ahmed Chalabi）被指控向伊朗出售美国破译他们代码的方法。据推测这可能与Crypto AG的后门有关。\n\n*1979 - 当前, DES*：数据加密标准被NSA修改过，以使数学攻击更难，但通过`Brute Force`方法却很容易。DES的原始版本称为Lucifer，使用128位的密钥长度，有差分密码分析的漏洞。NSA希望已经非常小的63字节的私匙进一步缩短到48字节，IBM的坚持，最终妥协到56字节。这样的长度允许NSA可以破译通过DES加密的通信。\n\n\n*1993, Clipper Chip*： NSA非常担心美国出现他们不可破解的加密手段。1993年，他们提出通过称为“Clipper Chip”的加密芯片来确保语音通信。但实际上Clipper Chip是有后门的，从而通过他的通信都能被破译。不同于这个列表中的大多数后门，NSA主动宣布后门的存在。 由于其已知的不安全性，Clipper Chip从未被广泛采用。\n\n*1997 Lotus Notes*： NSA要求Lotus弱化其加密算法，从而让NSA可以破译其算法加密的文档和邮件。这个软件被民众，公司，及全世界的政府使用。\n\n*200? - Present, Actel ProASIC3 FPGA*：2012年，Skorobogatov和Woods发现，Actel军用级FPGA包含一个后门。研究人员可以通过对私匙的逆向工程，可以暴露后门。这些芯片被用于美国的军事系统，核设施及通讯。所有其它的Actel芯片也含有类似的后门。起初，大家非常担心后门是被外国的组织所植入，调查后发现，Actel故意增加了这个后门。\n\n虽然看不到这个后门与NSA的关系，但一个美国公司，在没得到许可的情况下，设计一个复杂的后门，并植入到芯片中，且是美国最关键的系统，根本无法解释。即便Actel是在没有得到许可的情况下做的这些，那么我们理应看到美国政府更多的回应。但据我了解，美国政府自始至终都对整个事件保持沉默。\n\n*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的一个标准。\n\n*2013, Enabling for Encryption Chips*：在NSA的Edward Snowden发布的预算文件中，NSA的SIGINT项目的目标之一是在2013年底完全后门化或启用某些特定加密。但没有明确公布他们所指的加密芯片。\n\n*2013, Trusted Computing Platforms/Modules:*与前面的信息源一样，草案中资源是利用外部可信计算平台和技术。 德国方面一直表示关注微软TCM 2.0可能存在NSA的后门。\n\n*? - Present, Postal Interception Backdoor Installation*: 根据2010年向卫报报告的报告，NSA的访问和目标开发部门通常会拦截通过邮件发送的计算机设备，并添加了后门。 通常是网络设备和服务器的设备随后被发送到目标个人和组织使用。 这些后门允许NSA连接到空中专用的私人网络。\n\n原作者还有一篇旧文章讨论，[I speculate about designing a cipher with a backdoor.](http://ethanheilman.tumblr.com/post/28951702391/imagining-a-secure-backdoor-cipher)。",
      "json_metadata": "{\"tags\":[\"cn\"],\"image\":[\"http://68.media.tumblr.com/e73395a94755b6fb23a37df2b214153d/tumblr_inline_my4zhyzuRu1qf5p6p.jpg\"],\"links\":[\"http://ethanheilman.tumblr.com/post/70646748808/a-brief-history-of-nsa-backdoors\",\"https://www.cnet.com/news/security-firm-rsa-took-millions-from-nsa-report/\",\"http://t.umblr.com/redirect?z=https%3A%2F%2Fnews.ycombinator.com%2Fitem%3Fid%3D6947133&t=YWM0OWMzMjc0MDk1NDA3OTRjNDNiM2Y1OTExNjAwOTE3MTRjMGI1ZSwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1\",\"http://t.umblr.com/redirect?z=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FEnigma_machine&t=ZmJjOWQxN2Q5NzZjYzE3ZDUyNGU3Nzg5YWQ1YjdhM2E5N2MyMWYwNiwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1\",\"http://t.umblr.com/redirect?z=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FCrypto_AG&t=NjFlYWUzOTAzNzgyMWE0MjVmYTQ4MGMyMjhiMmYxYzE5MWNkZTk1ZSwwZFhIMlBDQQ%3D%3D&b=t%3Aekwnrt1MKmxqNGXkcTf6UQ&p=http%3A%2F%2Fethanheilman.tumblr.com%2Fpost%2F70646748808%2Fa-brief-history-of-nsa-backdoors&m=1\",\"http://ethanheilman.tumblr.com/post/28951702391/imagining-a-secure-backdoor-cipher\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "nsa",
      "title": "NSA后门的简史(翻译：资料来源于网络)"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-16T01:18:54",
  "trx_id": "8af6d6015a28b0920b2069485a5db8cf04eab320",
  "trx_in_block": 1,
  "virtual_op": 0
}

{
  "block": 13717340,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "是一种调侃么。但我个人觉得让每个人都有机会参与到ICO中，提升了融资的效率是百分之百有社会价值的。",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "jubi",
      "parent_permlink": "re-hh3755-aragon-20170715t144901686z",
      "permlink": "re-jubi-re-hh3755-aragon-20170715t231420771z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T23:14:21",
  "trx_id": "b063ba7160c9f1db3fad73df41da7b5cb057f9ae",
  "trx_in_block": 2,
  "virtual_op": 0
}

{
  "block": 13716530,
  "op": [
    "vote",
    {
      "author": "hh3755",
      "permlink": "aragon",
      "voter": "coldhair",
      "weight": 400
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T22:33:51",
  "trx_id": "8840745028d60173b8dc1c940a7db96e7d0ab545",
  "trx_in_block": 6,
  "virtual_op": 0
}

{
  "block": 13709037,
  "op": [
    "comment",
    {
      "author": "steemitboard",
      "body": "Congratulations @hh3755! You have completed some achievement on Steemit and have been rewarded with new badge(s) :\n\n[![](https://steemitimages.com/70x80/http://steemitboard.com/notifications/firstpost.png)](http://steemitboard.com/@hh3755) You published your First Post\n\nClick on any badge to view your own Board of Honor on SteemitBoard.\nFor more information about SteemitBoard, click [here](https://steemit.com/@steemitboard)\n\nIf you no longer want to receive notifications, reply to this comment with the word `STOP`\n\n> By upvoting this notification, you can help all Steemit users. Learn how [here](https://steemit.com/steemitboard/@steemitboard/http-i-cubeupload-com-7ciqeo-png)!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notifications.png\"]}",
      "parent_author": "hh3755",
      "parent_permlink": "aragon",
      "permlink": "steemitboard-notify-hh3755-20170715t161854000z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T16:18:54",
  "trx_id": "691c5d164fa4802753083b453bff58172e4e3a85",
  "trx_in_block": 9,
  "virtual_op": 0
}

{
  "block": 13707249,
  "op": [
    "comment",
    {
      "author": "jubi",
      "body": "感觉ico  提升了 图标设计行业，视频制作行业！",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}",
      "parent_author": "hh3755",
      "parent_permlink": "aragon",
      "permlink": "re-hh3755-aragon-20170715t144901686z",
      "title": ""
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T14:49:21",
  "trx_id": "d8ee49b8ef11e26c9fe07047e22b9a7a09a76bdc",
  "trx_in_block": 9,
  "virtual_op": 0
}

{
  "block": 13706281,
  "op": [
    "comment",
    {
      "author": "hh3755",
      "body": "最近关注Aragon的Twitter，发现他介绍了一个区块链开发栈模型（Ethereum stack model），有点小意思，所以翻译了一下[1]。\n\n请注意发表这个文章，不代表作者支持或是反对文中项目，原文观点不代表翻译者观点，翻译只是对项目的思想进行了解，如果版权问题，随时联系删除，谢谢。\n\n`distict0X`项目，初展Ethereum结合Aragon后形成的开发栈的锋芒。\n\n\nhttps://cdn-images-1.medium.com/max/1600/1*[email protected]\n\n\n软件允许我们基于现有的功能进行抽象，从而关注于实现自己的业务。\n\n在[Aragon](https://aragon.one)，我们使用[以太坊（ethereum）](https://ethereum.org)。以太坊提供我们共识层，同时保证智能合约的创建与强制执行。\n\n所以，一般来说，我们不需要特别关注以太坊自身所提供的能力。我们使用它，从而推动对这个平台的使用，从而增加它的价值。由此，我们间接的支持了基于它之上的开发与使用。\n\n这是整个平台代币化后，带来的整个系统的良性的循环。\n\n现在，Aragon也是类似。我们正建筑的正是其它项目想要剥离的。我们正在创建一个最完整的创建、维护DAO（DAO: 去中心化的自助组织）的解决方案，关注于智能合约的更新，冲突解决等。\n\n许多在这一领域出现的项目都将需要DAO，或将在某些方面使用DAO。最常见的需求有代币驱动的决策，但还有更多。\n\n更加重要的一点是，Aragon不止是一个仅仅让人使用的项目，更多的是可以作为整个构建层次中的一环。\n\n\nAragon提供了一种新的栈模型，可以让开发者不用考虑区块链的底层，而是只需要关注栈层次中的某一层。\n\n第一个应用这个栈模型的是[district0x](https://district0x.io/)。这个项目的目标是创建一个基于以太坊的去中心化的市场。\n\n它们的平台由以太坊、Aragon、IPFS三种技术的结合来驱动。以太坊提供的能力通过Aragon传导给district0x，那谁可以从中受益呢。district0x作为一个平台创建了其它人可以从中获益的机会。[使用district0x的Decentraland](https://blog.district0x.io/decentraland-districts-40b9ada0431b)又会让整个技术栈上获益。一个由以太坊运行的智能合约，通过Aragon的管理，又由district0x进行市场活动，大家都在整个栈中各施其职，最终使得[Decentraland](https://decentraland.org/)能够在虚拟现实中创造和探索一种共享体验。\n\n这里有个介绍视频，关于district0x的 https://youtu.be/m1B7R7jMvK0\n\ndistrict0x的许多地方都是让人激动的。首先，它让市场真的p2p了。当前的众筹，共享经济等等都不是真正意义上的p2p，虽然他们也实现了无需公司或集团的点对点的交易，但却始终有个中间节点在两个终端用户间协调来实现这一切。\n\n中心化的出现就会导致激励的错位，中心化的公司有动机来通过交易双方的信息差来尽可能的增加收入。\n\n在Argon，我们认为去中介化的模式能更好的调整激励措施，或者正如[前面所说](https://blog.aragon.one/decentralized-organizations-can-solve-the-worlds-worst-problems-840db6255d12)：\n\n>去中介化的人类交易-商业-是走向一个更公平世界的第一步。\n\n在区块链的栈上，每个区块链项目有时都有一些自己的愿景，展示的是一种思想与价值观。\n\n当你选择区块链栈，你间接的选择了你的价值观。\n\n以太坊的愿景是，将整个世界去中心化。\nAragon的愿景是，将交易去中介化。\ndistrict0x的愿景是，将市场去中心化。\nDecentraland的愿景是，实现一个去中心化的虚拟现实。\n每个人的愿景，也是其它人的一部分。\n如果你之前写过代码，这些听起来就像一个继承关系。\n\n所有这一切，都通过代币驱动。\n\n在之前，如果有人使用了你的工作，会被认为是一个小偷，偷窃。现在，越多的人基于你之上工作，你就将越成功。这也为开源项目提供了一个新的成长和持续发展的路径。\n\n使用别人的工作，更是在帮助其它项目实现它们的愿景。如果有人使用district0x创建了一个新的领域时，它正在帮助实现district0x，同时也是Aragon，以太坊的各自愿景。网络之间互相叠加产生更大的效应。\n\n所以，如果district0x成功，区块链栈中的每一环都实现了自己。district0x当前是第一个来尝试这个区块链栈模型，Aragon也作为其中的一部分，为此我们都很激动。\n\n#### 参考资料\n\n\n本文的英文原文在这里。https://blog.aragon.one/the-emergent-ethereum-stack-cbce1895142f",
      "json_metadata": "{\"tags\":[\"cn\",\"aragon\",\"district0x\"],\"image\":[\"https://cdn-images-1.medium.com/max/1600/1*[email protected]\",\"https://img.youtube.com/vi/m1B7R7jMvK0/0.jpg\"],\"links\":[\"https://aragon.one\",\"https://ethereum.org\",\"https://district0x.io/\",\"https://blog.district0x.io/decentraland-districts-40b9ada0431b\",\"https://decentraland.org/\",\"https://youtu.be/m1B7R7jMvK0\",\"https://blog.aragon.one/decentralized-organizations-can-solve-the-worlds-worst-problems-840db6255d12\",\"https://blog.aragon.one/the-emergent-ethereum-stack-cbce1895142f\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}",
      "parent_author": "",
      "parent_permlink": "cn",
      "permlink": "aragon",
      "title": "一种新出现的以太坊区块链开发栈模型-Aragon项目"
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T14:00:54",
  "trx_id": "c3ef1ebc62ff092f6591fdbe0a2d9308a2ac098e",
  "trx_in_block": 3,
  "virtual_op": 0
}

{
  "block": 13691631,
  "op": [
    "custom_json",
    {
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hh3755\",\"following\":\"dantheman\",\"what\":[\"blog\"]}]",
      "required_auths": [],
      "required_posting_auths": [
        "hh3755"
      ]
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T01:47:18",
  "trx_id": "59fc59f2ceba698f5a232e973dd5a8c0c8410390",
  "trx_in_block": 1,
  "virtual_op": 0
}

{
  "block": 13691626,
  "op": [
    "custom_json",
    {
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hh3755\",\"following\":\"iang\",\"what\":[\"blog\"]}]",
      "required_auths": [],
      "required_posting_auths": [
        "hh3755"
      ]
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T01:47:03",
  "trx_id": "3e4af0fb86ae56b75bf37e43322bf5e3f581f04b",
  "trx_in_block": 11,
  "virtual_op": 0
}

{
  "block": 13691624,
  "op": [
    "custom_json",
    {
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hh3755\",\"following\":\"eosio\",\"what\":[\"blog\"]}]",
      "required_auths": [],
      "required_posting_auths": [
        "hh3755"
      ]
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T01:46:57",
  "trx_id": "f3c2137b99c8e3d093b2488541431031af2f1cad",
  "trx_in_block": 11,
  "virtual_op": 0
}

{
  "block": 13691620,
  "op": [
    "custom_json",
    {
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hh3755\",\"following\":\"dan\",\"what\":[\"blog\"]}]",
      "required_auths": [],
      "required_posting_auths": [
        "hh3755"
      ]
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-15T01:46:45",
  "trx_id": "5a564c9a7875d53824b201ea5e344806c57f977b",
  "trx_in_block": 11,
  "virtual_op": 0
}

{
  "block": 13673476,
  "op": [
    "account_create_with_delegation",
    {
      "active": {
        "account_auths": [],
        "key_auths": [
          [
            "STM5A4sJfUQQuiW4seeFMwsZADpaeDU1sS6VjCWerf6UTn1FqRSks",
            1
          ]
        ],
        "weight_threshold": 1
      },
      "creator": "steem",
      "delegation": "57000.000000 VESTS",
      "extensions": [],
      "fee": "0.500 STEEM",
      "json_metadata": "",
      "memo_key": "STM5h3w84ybzr7WVeS3GNqsJ2pHdTxzmLrai7deSSD4y9eRnWHM86",
      "new_account_name": "hh3755",
      "owner": {
        "account_auths": [],
        "key_auths": [
          [
            "STM6S7tDpRte7qoNn6Nzu7uZG2eerrLDtgJUZa33oJ32F9uSuyEXQ",
            1
          ]
        ],
        "weight_threshold": 1
      },
      "posting": {
        "account_auths": [],
        "key_auths": [
          [
            "STM5LXToY9VQ56ovBXcnf5GSzXbcZSjcp4Ys8TpSCwKJPshbvUSjG",
            1
          ]
        ],
        "weight_threshold": 1
      }
    }
  ],
  "op_in_trx": 0,
  "timestamp": "2017-07-14T10:36:30",
  "trx_id": "2f44aa38380333f6eb957d74320287afb6912f1d",
  "trx_in_block": 13,
  "virtual_op": 0
}