「深度学习福利」大神带你进阶工程师,立即查看>>>
9日,比特币价格从5737美元一路向下,当日晚间跌破5000美元大关至4883美元；20日,比特币价格失守4500美元,当日晚间跌至4482美元,24小时里下跌14.41%；21日早上,比特币的价格最低触及4060美元,合人民币28196元,一夜跌回了17年8月份的价格。

一周跌幅30%,一年的时间则不见了七成。什么是惨烈,比特币的明明白白地告诉了你。
现在已经比特币暴跌超70%。

来看看这两天最火的一个截图。 一周最惨！上周看房子,本周送外卖！
当然,是段子还是现实谁能说的清呢！比特币价格最高时19891.99美元,可以说是风光无两,现在4600美元都不到。用媒体的话来说就是蒸发了一万亿,行情大跌之下都催生了段子手。

比特币持续暴跌引起了市场极度恐慌,在微博、微信朋友圈、比特币论坛等平台,最近几天亏损不少的炒家们也是一片“哀鸿遍野”。甚至某币圈资深玩家表示自己的资产已亏损85%以上,宣布“破产”。
这次大跌,是一个非常不好的事件,有业内人士表示,比特币可能进入熊市,下跌势头或将变得更糟,更有分析师将比特币价格看低至1500美元。

我认为比特币近期大跌的诱因是比特币现金(BCH)将迎“硬分叉”。还有投资者市场的恐慌所导致的。11月15日晚上,全球成千上万的BCH粉,守在Cash.Coin. Dance观战,通宵不睡,好像在看球赛,不同的是,里面火拼的不是球队,而是满屏变化的数字。在这场球赛中,俗称“澳洲中本聪”的Craig Wright（克拉格赖特）的SV派,坚持再扩容到128兆。Craig Wright博士坚持原版的中本聪愿景（Satoshi Vision中本聪愿景）,所谓成为点对点的现金系统；而另一派,ABC派,比特币大陆（矿机厂商）吴忌寒和Roger Ver（比特币**）,他们认为现在不需要增加区块容量。他们的开发者打算升级其网络功能,以降低交易成本。为了赢得这场赛事,各方抽调算力,数据显示,至开始以来,整个BTC全网算力已大跌13%。原本死气沉沉的币圈如今胆战心惊,整个社区在分裂,“币王”的地位在赓续颤抖。

币圈崩盘现在还不太可能,价格崩盘倒不好说。应该还没有到崩盘的时候。

首先,比特币目前的跌幅还不是历史之最。
在此之前,比特币的历史上,出现过两次大熊市。一次是2011年,比特币刚开始兴起之时,价格从30美元跌到2美元,跌幅超过93%。另一次是2013年底到2015年初,比特币从1150美元左右跌到了190美元左右,跌幅高达83%。前两次不但熬过来了,而且市场还在大起大落中发展壮大。而本轮熊市,截止到目前,跌幅还没有到80%,从前两次的经验来看,应该还不至于彻底崩盘。更何况,目前的市场体量更大。

其次,以比特币为首的数字货币有其使用价值。
比特币被称作为“数字黄金”,它跟黄金一样,具有基于共识和信任的价值基础,它全球流通,储量恒定,难以伪造。而且,相较于传统货币,它发行成本更低,还能够实现真正的全球流通。

目前,数字货币虽然没有得到全球的认可,但已经得到了很多人的认可,它的市值就是明证。在美国这个金融市场监管系统完善的国度,已经推出了数字货币期货交易,这也体现出传统金融对数字货币的认可。甚至在恶性通胀的委内瑞拉,民众利用数字货币来避险,数字货币算得上是该国的通用货币。

数字货币可能是未来货币发展的一个趋势。目前价格波动剧烈,根本原因是缺乏监管,市场还不够规范,且行业处于早期,各个方面还不够成熟。目前,各国的监管正在逐步完善中,未来,数字货币市场会越来越规范。

比特币每次下跌,崩盘的声音就出现了,其实,这部分声音大部分不是币圈的人,大部分是吃瓜群众看热闹。不管如何我个人还是非常看好比特币。春种、夏养、秋收、冬眠四季轮回,学会顺势而为,事半功倍。

阅读原文

「深度学习福利」大神带你进阶工程师,立即查看>>>
1. 问：你认为区块链技术中的区块意味着什么？
区块链由所有金融交易的信息组成。一个块只不过是一个记录列表。当这些列表相互结合时,它们被称为区块链。例如,一个组织有100个分类账簿,其中的组合被称为区块链,单个分类账将被视为一个区块。
2. 问：为什么区块链是一种值得信赖的方法
有很多原因,区块链可以被信任。第一个原因是它与其他商业应用程序有良好的兼容性,因为它是开源的。其次是它的安全性,因为它是为了在线交易而开发的,所以开发人员在保证安全性的同时也特别关注它的数据同步。由于其拥有的业务类型无关,所以在选择的时候区别链很容易地被考虑。
3. 问：区块链中是否有可能从网络中删除一个或多个区块？
当然可以,如果只考虑该在线分类帐的特定部分的时候。借助默认选项和过滤器,可以轻松完成此任务,而不需要付出太多。
4. 问：你对区块链了解多少？
这是一种实际上为比特币设计的技术,后来因为监控和记录网络上所有金融交易而带来的多种好处而获得了大量的推广。这是一种值得信赖的方法,目前情况下有很多组织正在使用它。由于一切都是十分安全的,并且它是一种开源方式,所以从长远来看,它可以轻松获得大家的信任。
5. 问：区块链方法如何识别区块？
在线分类帐中的每个块基本上都包含一个哈希指针,该指针指向它之前的块并形成链接,块中包含交易数据和时间戳。
6. 问：你认为一个区块的安全性究竟是什么？
网络上的所有用户都不能修改块。因此它提供了极好的安全级别。除此之外,每个区块都使用加密技术进行保护,这是另一项措施。因此,不需要担心块中存在的数据的安全性和安全性。
7. 问：在组织中使用区块链技术是否有网络特定的条件？
使用它没有特定的条件。但是,网络必须是有关协议下的对等网络。它实际上很简单地验证了新块,并帮助组织在不投资第三方应用程序的情况下保持同步。

「深度学习福利」大神带你进阶工程师,立即查看>>>
Netkiller Blockchain 手札
作者正在找工作,联系方式 13113668890
Mr. Neo Chan, 陈景峯(BG7NYT)

中国广东省深圳市望海路半岛城邦三期
518067
+86 13113668890
< netkiller@msn.com >
文档始创于2018-02-10
版权 © 2018 Netkiller(Neo Chan). All rights reserved.

版权声明
转载请与作者联系,转载时请务必标明文章原始出处和作者信息及本声明。

http://www.netkiller.cn
http://netkiller.github.io http://netkiller.sourceforge.net

微信订阅号 netkiller-ebook (微信扫描二维码）
QQ：13721218 请注明“读者” QQ群：128659835 请注明“读者”

2.10.6. 资产上链的 Hyperledger Fabic 链码
我们希望资产上链适用于任何领域,后面也方便将业务拓展。所以我实现了一个万能合约。以不变应万变。 package main import ( "fmt" "github.com/hyperledger/fabric/core/chaincode/shim" pb "github.com/hyperledger/fabric/protos/peer" ) type SmartContract struct {} func (s *SmartContract) Init(stub shim.ChaincodeStubInterface) pb.Response { return shim.Success(nil) } func (s *SmartContract) Query(stub shim.ChaincodeStubInterface) pb.Response { return shim.Success(nil) } func (s *SmartContract) Invoke(stub shim.ChaincodeStubInterface) pb.Response { // Retrieve the requested Smart Contract function and arguments function, args := stub.GetFunctionAndParameters() // Route to the appropriate handler function to interact with the ledger appropriately if function == "create" { return s.create(stub, args) } else if function == "find" { return s.find(stub, args) } else if function == "update" { return s.update(stub, args) } else if function == "delete" { return s.delete(stub, args) } return shim.Error("Invalid Smart Contract function name.") } func (s *SmartContract) create(stub shim.ChaincodeStubInterface, args []string) pb.Response { if len(args) != 2 { return shim.Error("Incorrect number of arguments. Expecting 2") } _key := args[0] _data := args[1] if(_data == ""){ return shim.Error("Incorrect string of data") } existAsBytes,err := stub.GetState(_key) if string(existAsBytes) != "" { fmt.Println("Failed to create account, Duplicate key.") return shim.Error("Failed to create account, Duplicate key.") } err = stub.PutState(_key, []byte(_data)) if err != nil { return shim.Error(err.Error()) } fmt.Printf("create %s %s \n", _key, string(_data)) return shim.Success(nil) } func (s *SmartContract) find(stub shim.ChaincodeStubInterface, args []string) pb.Response { if len(args) != 1 { return shim.Error("Incorrect number of arguments. Expecting 1") } _key := args[0] _data, err := stub.GetState(_key) if err != nil { return shim.Error(err.Error()) } if string(_data) == "" { return shim.Error("The key isn't exist.") }else{ fmt.Printf("query %s %s \n", _key, string(_data)) } return shim.Success(_data) } func (s *SmartContract) update(stub shim.ChaincodeStubInterface, args []string) pb.Response { if len(args) != 2 { return shim.Error("Incorrect number of arguments. Expecting 2") } _key := args[0] _data := args[1] if(_data == ""){ return shim.Error("Incorrect string of data") } err := stub.PutState(_key, []byte(_data)) if err != nil { return shim.Error(err.Error()) }else{ fmt.Printf("update %s %s \n", _key, string(_data)) } return shim.Success(nil) } // Deletes an entity from state func (t *SmartContract) delete(stub shim.ChaincodeStubInterface, args []string) pb.Response { if len(args) != 1 { return shim.Error("Incorrect number of arguments. Expecting 1") } _key := args[0] // Delete the key from the state in ledger err := stub.DelState(_key) if err != nil { return shim.Error("Failed to delete state") } return shim.Success(nil) } func main() { err := shim.Start(new(SmartContract)) if err != nil { fmt.Printf("Error creating new Smart Contract: %s", err) } }
链码有四个函数,分别是创建,查找,更新,删除。 if function == "create" { return s.create(stub, args) // 创建 } else if function == "find" { return s.find(stub, args) // 查找 } else if function == "update" { return s.update(stub, args) // 更新 } else if function == "delete" { return s.delete(stub, args) // 删除 }
上链使用 create 方法,函数有两个参数,一个是 key, 另一个是数据。
key 使用 UUID 存储再数据库和链上,同时 UUID 对应通证的
data 是序列化 byte 数据。例如可以使用 json, hession, msgpack 等序列化后的数据。 err = stub.PutState(_key, []byte(_data))
这个链码考虑到前期产品上市,不确定性因素很多,需要更新和删除等等。后期我们可以在数据中设置一个 status 变量,当 status = false 就不在允许数据的删除和更新。

「深度学习福利」大神带你进阶工程师,立即查看>>>
区块链应用要落地,要对使用场景进行思考；在区块链应用落地的过程中,高TPS能带来哪些改变？从工程实践的角度看,高TPS能做出哪些有用的东西？本期技术工坊星际区块信息有限（深圳）公司CEO谢建怀老师将结合项目落地的案例进行分享。
1
时间地点
**时间：**11月29日 19:00 -  21:30
地点 ：深圳市南山区宝深路科陆大厦A座 23层
线下分享+交流  9.8元/人
参会人员要求：
1） 技术背景人员,对区块链开发有兴趣；
2） 活动限额30人,报满截止。
2
活动流程
19:00-20:00  签到,自我介绍
20:00-21:00  高TPS和去中心化存储带来的第三代区块链技术革新机遇
21:00-21:30  互动交流
3
分享主题及嘉宾
分享话题：高TPS和去中心化存储带来的第三代区块链技术革新机遇
大纲：
1.高TPS能让我们做更多有意思的东西
2.第三代区块链技术能落地的思考
3.去中心化存储能在工程上带来哪些应用
4.我们团队在这两方面的探索
分享嘉宾：谢建怀
星际区块信息有限（深圳）公司CEO,大数据和AI背景,ROS和SLAM爱好者,区块链技术传道者
4
主办方及合作伙伴

5
报名方式
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>>
1
摘要
在STO通证的发行环节,与普通应用类通证的简单流程不同,证券类项目方需要特定的发币技术解决方案（协议级别）与法律合规的服务。由于证券类通证对投资者有要求,因此在交易通证时,需要将交易限制在合规的投资者之间或者其他条件的限制中。
本讲辉哥整理了跟STO通证发行配套的一些协议标准和公司介绍 ,公布了对应的官网和GITHUB地址,便于感兴趣人员做专业研究分析。
（1）Polymath - ST-20协议 （2）Swarm - SRC20协议 （3）Harbor - R-TOKEN （4）Securitize - DS Protocol协议 （5）ERC1400/ERC1410协议 （6）ERC1404协议 （7）Hashgard - TAMT协议
2
Polymath - ST-20协议
2.1 简介
Polymath成立于 2017 年, Polymath 是一个帮助资产实现证券化通证的平台。它提供证券类通证的底层协议（ST20） ,允许个人和机构投资者完成合格投资者认证,允许合法投资人在符合政府规定的前提下参与 STOs。 在Polymath 的平台上,汇集了 KYC 服务商、 法律顾问、技术开发者交以及投资者。 Polymath 协议致力于助力完全合规的证券类通证的发行,该协议将金融监管的需求嵌入到了通证的设计中,实现区块链上发行和交易证券类交易的无缝体验。
2.2 项目方发币流程
项目方首先通过平台,使用 ST20 协议在以太坊上生成自己的证券类通证。此时,所有的通证都在项目方处,且不支持交易（直到法律代理完成工作并通过合规手续）。
项目方首先在平台中双向选择法律代理商, 共同完成通证的合规手续。
项目方根据合规要求设置通证的交易限制,比如只有合规投资者可以购买等。当需要把法律代理建议的交易限制写入 STO 的合同时,项目方可以在平台内选择技术开发人员完成。
2.3 投资人购买通证流程
投资人通过平台内的 KYC 服务商完成 KYC。
通过 KYC 后,可以购买与自己情况符合的通证。个别通证的项目方对投资者有超过 KYC 的要求时,还需要投资者提交项目方要求的文件材料。当通过交易所购买通证时,投资者也需要提交相关材料。
2.4 ST20 实现简介
进入 ST-20 接口 — 验证身份 — 通证投资或转移。 在投资者可以从最初的发行中购买通证之前,必须将它们列入白名单。白名单过程可以由发行者以他们想要的任何方式执行,最终结果将是添加到安全通证智能合约中的白名单的以太坊地址列表。此白名单现在包含能够持有通证的人的以太坊地址,并且是用于确认是否可以发生转移的列表。
2.5 典型的通证转移场景
证持有者 0xabc 有 100 个 TORO 通证,她想转移给她的朋友 0x123。
0xabc 将使用她最喜欢的钱包通过输入她朋友的 ETH 地址和她想要发送给她的通证来启动转移。
由于 TORO 是 ST-20 通证,因此在传输之前它将在内部调用verifyTransfer。
反过来, verifyTransfer 使用 GeneralTransferManager 白名单来确定这两个帐户之间的转移是否可能发生。
GeneralTransferManager 在批准转让之前将检查 3 件事： 发件人和收件人都在其内部白名单中  0xabc（卖方）不受证券法规定的销售限制 0x123（买方）不受购买限制根据证券法
如果满足上述条件,则通过 verifyTransfer 检查并且可以执行转移交易。
如上所述, Security 通证已经以模块化方式设计并允许创建附加模块 以扩展或修改其自身行为。例如,可以将多个传输管理器连接到它以控 制不同交换机上的传输逻辑。
2.6 官网&GITHUB
官网地址： https://polymath.network/
协议开源代码： https://github.com/PolymathNetwork/polymath-core
3
Swarm - SRC20协议
3.1 简介
成立于 2014 年, Swarm 是一个去中心化的证券类通证的发行和 STOs市场,在 2018 年 1 月推出,在它的平台（Swarm invest） 上,可以用SWM, BTC 和 ETH 投资已经被通证化的实物资产,得到使用 SRC20 协议发放的通证,获得资产的所有权、管理权（通过投票 SecureVote 平台投票实现）、收益权。目前 swarm 平台基于 token-D 和 Stellar 网络。
3.2 SWM 通证
SWM 通证为ERC20 标准通证,用于创建子基金、参与 STO、购买独家资讯、执行管理 swarm平台的权力。
Swarm 平台上鼓励专家成立自己的投资组合,其他的投资者可以加入他的组合,或者跟随专家的投资( 打造投资 KOL),并且在类似于股票的投票方式中加入了锁仓等更进一步的投票机制。
3.3 SRC20 协议
SRC20 定义了证券类通证必须遵循的一套规则,并使开发人员能根据资产的特性构建应用。 Swarm 生态系统中构建的应用程序可以相互通信,并使用符合 ERC20 通证和 SWM 付费。投资平台,资产管理工具和交易所都是可以使用 SRC20 协议构建的应用程序。
与 ERC20 的区别： SRC20 在 ERC20 的基础上拓展了更多的性能来描述现实世界资产的特性,比如地址、目的、法律状态、义务和交易限制等。
3.4 官网&GITHUB
官网地址： https://swarm.fund/ GITHUB地址： https://github.com/swarmfund GITHUB 协议(SWM,未看到SRC20协议)： https://github.com/swarmfund/swarm-contracts-1
4
Harbor - R-TOKEN
4.1 简介
Harbor 是一个基于以太坊区块链的开源平台,致力于打造去中心化的合规协议（R-token compliance protocol）,实现项目方在符合证券、税务、以及其他监管条例的要求下发行基于 ERC20 的证券化通证。其标准化流程包括了包括 KYC/AML 合规服务、 税务、信息披露等等。
4.2 R-token 协议
是一种定义的证券类通证完全合规交易的开源标准,实现在以太坊链上的 KYC(Know Your Custom), AML(Anti-Money Laundering),税务等监管服务。
是一种 ERC-20 通证的智能合约,它主要是为了 ERC-20 通证在交易时核对监管要求,执行交易。比如符合要求即交易成功,不符合要求则退 回。
符合 R-token 标准的通证可以在任何支持 ERC-20 标准的交易所交易。
R-token 设计了两个合规层级: 参与者层级： 什么情况可以发送通证； 什么情况可以接受通证。比如合格投资者可以接受。 通证层级：锁仓交易规则；发送通证数量限制。比如 Reg D 规定的锁仓时间和一个合格投资人可以持有通证数量的上限。
4.3 R-token,监管者服务(regulator service),服务登记（service registry）的关系
三者互相协作完成通证的合规交易： 服务登记（service registry）将适用的监管要求（regulator service）地址发送给 R-token, R- token 负责检查本次交易是否符合要求。在一定程度上充当了监管机构的角色。 在初期,所有的监管规定都由 trade controller（个人或者机构,目前是Harbor）上传至 regulator service。 监管者服务(regulator service),服务登记（service registry）都可以写入 R�token 智能合约,三者成为一个智能合约。
4.4 官网&GITHUB
官网地址： https://harbor.com/ GITHUB： https://github.com/harborhq
5
Securitize - DS Protocol
5.1 简介
成立于 2018 年 1 月, 是从风投机构 SPiCE VC 分拆出的新公司Securitize 致力于成为合规的证券类通证发行和提供流动性的平台。 Securitize打造一个 Digital Security service（DS service）平台,使第三方开发者提供各类应用。应用之间的交互通过 DS Protocol 管理。最开始将在以太坊网络中开展工作,未来可能会迁移至其他网络。
5.2 Securitize 的平台构成
**DS token。**在 ERC-20 基础之上叠加了 DS Protocol。 DS token 可以检查。
账户的可以交易状态,防止违规的交易出现。此外还充分考虑了证券属 性,比如分红,投票和交易等情形,使证券类通证具有传统证券的特性
**DS app。**第三方的发行和交易全生命周期应用,比如发行类应用,交易 所应用 ,投票类应用或者分红类应用
DS service。  DS protocol 的基础设施, DS app 可以使用这些服务： 信任服务：管理不同的利益相关者 注册服务：链上的投资人信息 合规服务：对 DS token 实施具体的合规要求 交流服务：对相关的投资者提供交流平
5.3 Securitize 将给交易所提供链下的 API,方便他们进入生态系统,比如调取KYC 信息等。
Securitize DS Protocol Ecosystem
5.4 官网&GITHUB
官网地址： http://securitize.io/ GITHUB地址：未找到 发布合约1 https://etherscan.io/address/0x0324dd195d0cd53f9f07bee6a48ee7a20bad738f#code 发布合约2 https://etherscan.io/address/0x8fd3121013a07c57f0d69646e86e7a4880b467b7#code
6
ERC1400(ERC1410/ERC1411)
6.1 简介
该标准由 Gosselin, Adam Dossa, Pablo Ruiz 和 Fabian Vogelsteller 撰写。其中 Gosselin 和 Dossa 为 Polymath 工作,而 Ruiz 拥有国际商业和金融背景,而 Dossa 是以太坊开发人员和网页设计师。团队经验互补,有一定的实力。
ERC1410  (等同ERC1411)将 ERC20/ERC777 中不存在解释属性的余额,附加额外的信息,从而划分成不同的部分,就可以做一些操作上的限制。
而 ERC1400 (等同ERC1411)是对 ERC1410 标准的继承和改进,增加了证券相关业务会使用到的函数：证券增发,相关法律文件存储等。
在设计上,将 token 的余额通过一个叫做tranche 的属性,划分成不同的部分。可以对 tranche 做出不同解释,操作上进行不同的限制（例如：某些操作只限指定的 tranche,某些操作优先消耗指定 tranche 下的 token）,这有些 Non-fungible Token 的概念,但也存在不同： tranche 相同的 token价值相同,是可以随意置换的。结合了 Fungible Token 和 Non-fungible Token 两者,故称为 Partially-Fungible Token（部分可互换通证）。
部分可替代性是 ERC1400 通证标准的主要组成部分,这是指同一实体发出的一个 ERC1400 通证可能与另一个 ERC1400 通证不可交换,因为通证可能具有不同的属性。最流行的不可替代的通证当然是基于 ERC721 标准的CryptoKitties：你不会直接交换一只小猫,因为每只小猫都是独一无二的,价格也各不相同。但是, ERC1400 通证不一定像 CryptoKitties 那样彼此不同- 因此它们是“部分可互换的” 。
另一个 ERC1400 的部分可互换性是支持通证持的拆分和组合功能。 比如,可以将不同的期限和风险水平的债券或者其中的一部分按照自己的投资意愿组合成一个池,打个比方,你可能拥有抵押贷款支持的安全部分,其中包含 5 至 30 年期间的高风险和低风险抵押贷款。
实际应用场景中, 同一家企业发行的证券可能是存在差异的,如限售股/非限售股,优先股/普通股,原始股/增发股,这些不同性质的证券在分红,票权,流通性上不尽相同,其性质也可能在某个阶段发生转变,不同性质的证券在投资人眼里的价值可能是不同的。
6.2 GITHUB
状态：DRAFT GITHUB： https://github.com/ethereum/EIPs/issues/1411 GITHUB： https://github.com/ethereum/EIPs/issues/1410
7
ERC1404协议
7.1 简介
ERC1404由Ron Gierlach@rongierlach,James Poole@pooleja,Mason Borda@masonicGIT等提出。
通证发行人需要一种方法来限制ERC-20通证的转移,以符合证券法和其他合同义务。当前的实现不满足这些要求。
有些人把ERC1404/ERC1400/ERC1411/ERC1410混为一谈,辉哥此处做简单澄清,后面会有专文分析。
一些紧急的例子： 强制通证锁定期 执行通过AML / KYC检查 私人房地产投资信托基金 Delaware General Corporations Law Shares
此外,通证发行商之间的标准采用有可能演变为自动合规的动态和可互操作的环境。
以下设计为通证发行者提供了更大的自由度/可升级性,同时降低了开发人员和交易所的集成负担。
此外,我们认为适合提供一种模式,通过该模式可以在还原通证传输时返回人类可读的消息。关于转让通证转移的原因的透明度对于成功实施转让限制本身同样重要。
用于检测通证传输中的限制和消息传递错误的广泛采用的标准将极大地方便未来的交换,钱包和发行者。
7.2 GITHUB
状态：DRAFT GITHUB： https://github.com/ethereum/EIPs/issues/1404
8
Hashgard - TAMT协议
8.1 简介
可信资产管理通证（TAMT： Trusted Asset Management Token） 是由临界 Hashgard 提出的协议标准。 TAMT 是基于临界可信资产管理协议之上发行的通证,代表着持有者对数字金融资产的权益及所有权,该标准向后兼容 ERC20 ,并且开源、易扩展,具备无需交易方信任的数字资产原子交换功能。
与传统的资产管理方案相比, TAMT 不仅实现了投资者所拥有的金融资产权益的确权,而且金融资产本身的资产管理过程存于链上,历史交易记录不可篡改, 增强了金融产品业绩的真实性与可信度； TAMT 还对金融资产管理本身的策略进行了很好的隐私保护,管理人通过接口向 TAMT 合约发出交易指令,并不需要将策略算法写入合约之中； TAMT 还精简了管理人业绩的计算与分配方式,管理人可以通过增发特权通证来获得相应的收益分配。
目前 TAMT 处于起草阶段,会先在 ETH 网络上实现标准,未来将迁移至临界公有链。
8.2 TAMT 特性 兼容 ERC20 资产池（查询,注资,出资等管理） 交易限制模块(KYC/AML,时间锁定,账户冻结等) 高级通证发行模块（支持多种类数字资产的筹集） 合约层面的原子交换功能 分红管理
8.3 官网&GITHUB
官网地址： https://www.hashgard.pro/ GITHUB地址(未发布)： https://github.com/hashgard/TAMT
9
参考
（1）《证券类通证：开启数字金融新时代.vFinal 简体》- hashgard发布 （2） 各大STO标准厂家官网及GITHUB 本文译者：HiBlock区块链技术布道群- 辉哥
加微信baobaotalk_com,加入技术布道群
课程推荐

「深度学习福利」大神带你进阶工程师,立即查看>>>
写在前面：北京的小伙伴们注意啦~HiBlock区块链技术工坊（北京）将固定每周二晚19:00-21:30在P2联合创业办公社（锦湖中心店）举办。每期限定人数15人,和分享嘉宾一起交流学习区块链技术,关注公众号查看活动详情并报名哦~
自区块链技术诞生以来,对其“性能”的诟病就从来没有停止过。虽然从技术上说,一个基于分布式对等网络架构的系统,与成熟的中心化技术相比,其“性能”方面有着天然的劣势,但业内人士对区块链“扩容”的研究和努力也从没有停止过。近两年,所谓的“区块链 Layer2 扩展”的提法已经逐渐在业内达成共识,并出现了一些有潜力的项目。
11月27日,北京第一期技术工坊（总第27期） 杨镇老师将介绍Layer2 扩展定义、 Layer2 扩展价值以及目前有哪些可行思路或技术方案,还会包含一些具体的技术细节,比如状态通道的实现、Plasma MVP 和 Plasma Cash 的实现、TrueBit 的原理,以及几个几个有潜力的 Layer2 扩展项目简介,帮助参会者了解区块链Layer2 扩展的思路和目前相对成熟的几种技术方案。
1
时间地点
**时间：**11月27日 19:00 -  21:30
地点 ：北京市朝阳区白家庄东里23号锦湖中心B1 P2联合创业办公社
线下分享+交流  9.8元/人
参会人员要求：
1） 技术背景人员,对区块链开发有兴趣；
2） 活动限额15人,报满截止。
2
活动流程
19:00-20:00  签到,自我介绍
20:00-21:00  浅谈区块链的Layer2扩展
21:00-21:30  互动交流
3
分享主题及嘉宾
分享话题：浅谈区块链的Layer2扩展
分享大纲：
1.区块链的 Layer2 扩展的定义,产生 Layer2 扩展思路的原因；
2.典型的 Layer2 扩展方案：状态通道和广义状态通道、Plasma和侧链、TrueBit；
3.Layer2 扩展的发展现状和展望：典型项目简介。
分享嘉宾：杨镇
资深软件工程师、架构师；区块链技术布道者；有 17 年的软件行业从业经验。
2017年开始参与以太坊技术社区贡献；独立中译了以太坊 Homestead 官方文档；对以太坊黄皮书中文版进行了独立校订和增补更新；独立中译了以太坊分片技术说明；是 Solidity 官方文档中译项目的贡献者、校订人和项目管理员。
4
报名方式
感谢NEM对北京技术工坊的赞助支持。
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>>
1
摘要
网站太多,各种用户名/密码实在记不住。所以我们逐渐接受了BAT账号的授权登录功能。在以太坊DAPP应用中,也可以使用MetaMask实现授权后一键登录功能。MetaMask是去中心化钱包,授权信息不会如BAT中心一样存在被收集利用的问题。
本文从技术层面讲清楚原理,并结合代码说明如何实现。
2
授权一键式登录的利弊分析
我们往往被自己的密码难住,越来越抵制传统的电子邮件/密码注册流程。通过微信,QQ,支付宝,Facebook,Google或GitHub一键式社交登录功能可以省去记住密码或者密码泄露的而风险。当然,它也需要权衡利弊。
社交媒体登录集成的优点： 没有更麻烦的填表。 无需记住另一个用户名/密码对。 整个过程需要几秒钟而不是几分钟。
社交媒体登录集成的缺点： 由于用户的信息是从外部提供商处加载的,因此这会对提供商如何使用所有这些个人数据产生巨大的隐私担忧。例如,在撰写本文时,Facebook正面临着数据隐私问题（ https://www.reuters.com/article/us-facebook-privacy-costs-analysis/privacy-issues-emerge-as-major-business-risk-for-facebook-idUSKBN1GW01F）。
加密猫( https://www.cryptokitties.co/ )游戏中,用户不需要输入用户名,密码就可以建立自己的账户体系,进行登录交易。
签名导入-cancel
本文介绍下这个方法的原理和代码实现,使用MetaMask扩展的一键式加密安全登录流程,所有数据都存储在我们自己的后端。我们称为“使用MetaMask登录”。
3
** 如何使用Metamask进行一键式登录流程**
一键式登录流程的基本思想是,通过使用私钥对一段数据进行签名,可以很容易地通过加密方式证明帐户的所有权。如果您设法签署由我们的后端生成的精确数据,那么后端将认为您是该钱包地址的所有者。因此,我们可以构建基于消息签名的身份验证机制,并将用户的钱包地址作为其标识符。
如果它看起来不太清楚,那就没问题了,因为我们会逐一解释它： MetaMask浏览器扩展 登录流程如何工作 为什么登录流程有效 让我们一起建立它 今天就可以投入生产了 移动设备的缺点
请注意,虽然我们将使用连接到以太坊区块链（ https://www.toptal.com/ethereum）的工具（MetaMask,以太坊钱包地址）,但此登录过程实际上并不需要区块链：它只需要其加密功能。话虽如此,随着MetaMask成为如此受欢迎的扩展（https://twitter.com/metamask_io/status/942816957920829440）,现在似乎是介绍此登录流程的好时机。
4
MetaMask浏览器扩展
如果您已经知道MetaMask是什么,请跳过本节。
MetaMask（ https://metamask.io/）是一个浏览器插件,可作为MetaMask Chrome扩展（ https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn）或Firefox附加组件使用（https://addons.mozilla.org/en-US/firefox/addon/ether-metamask/）。它的核心是它作为以太坊钱包：通过安装它,您将可以访问一个独特的以太坊钱包地址,您可以使用它开始发送和接收以太币或ERC20通证。
但MetaMask不仅仅是以太坊钱包。作为浏览器扩展,它可以与您正在浏览的当前网页进行交互。它通过在您访问的每个网页中注入一个名为web3.js（ https://github.com/ethereum/web3.js/）的JavaScript库来实现。注入后,web3将通过window.web3的JavaScript代码为你访问的每个网页提供一个对象。要查看此对象,只需在Chrome或Firefox DevTools控制台键入window.web3（如果已安装MetaMask）,结果如下图。
web3.js
Web3.js是以太坊区块链的JavaScript接口。有以下功能： 获取最新的区块号（web3.eth.getBlockNumber） 检查MetaMask上的当前活动帐户（web3.eth.coinbase） 获取任何帐户的余额（web3.eth.getBalance） 发送交易（web3.eth.sendTransaction） 使用当前帐户的私钥对消息进行签名（web3.personal.sign） ......还有获取更多接口说明： https://github.com/ethereum/wiki/wiki/JavaScript-API
安装MetaMask时,任何前端代码都可以访问所有这些功能,并与区块链进行交互（ https://www.toptal.com/ethereum-smart-contract）。他们被称为dapps或DApps（去中心化的应用程序,有时甚至写成“ĐApps”）。
与DApp开发相关： 时间锁定钱包：以太坊智能合约简介 （ https://www.toptal.com/ethereum-smart-contract/time-locked-wallet-truffle-tutorial）
web3.js中的大多数函数都是读函数（get block, get balance, etc.）,web3立即给出响应。但是,某些功能（如web3.eth.sendTransaction和web3.personal.sign）需要当前帐户使用其私钥对某些数据进行签名。这些函数触发MetaMask显示确认弹窗,以仔细检查用户是否知道他或她正在签名的内容。
让我们看看如何使用MetaMask。要进行简单测试,请在DevTools控制台中粘贴以下行： web3.personal.sign(web3.fromUtf8("你好,我是辉哥！!"), web3.eth.coinbase, console.log);
此命令表示：使用coinbase帐户（即当前帐户）将我的消息（从utf8转换为十六进制）进行签名,并以打印作为回调函数打印出签名。输入回车后,将出现MetaMask弹窗,如果点击签名按钮,将打印签名的消息。
MetaMask确认弹出窗口
我们将web3.personal.sign在登录流程中使用。
关于这一部分的最后一点说明：MetaMask将web3.js注入到您当前的浏览器中,但实际上还有其他独立的浏览器也会注入web3.js,例如Mist（ https://github.com/ethereum/mist）。但是,在我看来,MetaMask为普通用户提供了探索dapps的最佳用户体验和最简单的转换。
5
登录流程如何工作
这是如何做到的呢？这部分内容讲说服你,证明这种方式是安全的。所以为什么部分的介绍就比较短了。
如前面所述,我们将忘记区块链。我们有一个传统的Web 2.0客户端 - 服务器RESTful架构。我们将做出一个假设：访问我们的前端网页的所有用户都安装了MetaMask。有了这个假设,我们将展示无密码加密安全登录流程的工作原理。
第1步：修改用户模型（后端）
首先,我们的User模型需要有两个新的必填字段：publicAddress和nonce。此外,publicAddress需要具有唯一性。你可以保持平常username,email和password字段,特别是如果你想平行实现您MetaMask登录电子邮件/密码登录,但它们是可选的。
如果用户希望使用MetaMask登录,则注册过程也会略有不同,因为注册时publicAddress将是必填字段。不过请放心,用户永远不需要手动输入publicAddress钱包地址,因为它可以通过web3.eth.coinbase变量来提取。
第2步：生成随机数（后端）
对于数据库中的每个用户,在nonce字段中生成随机字符串。例如,nonce可以是一个大的随机整数。
第3步：用户获取他们的随机数（前端）
在我们的前端JavaScript代码中,假设存在MetaMask,我们可以访问window.web3。因此,我们可以通知web3.eth.coinbase获取当前MetaMask帐户的钱包地址。
当用户单击登录按钮时,我们向后端发出API调用以检索与其钱包地址关联的随机数。像带参数获取例如GET /api/users?publicAddress=${publicAddress}应该做的事情那样。当然,由于这是一个未经身份验证的API调用,因此后端应配置为仅显示此路由上的公共信息包括nonce。
如果先前的请求未返回任何结果,则表示当前钱包地址尚未注册。我们需要先通过POST /users传递publicAddress请求消息体来创建一个新帐户。另一方面,如果有结果,那么我们存储它的nonce。
第4步：用户签署Nonce（前端）
一旦前端接收nonce到先前API调用的响应,它将运行以下代码： web3.personal.sign(nonce, web3.eth.coinbase, callback);
这将提示MetaMask显示用于签名消息的确认弹出窗口。随机数将显示在此弹出窗口中,以便用户知道她或他有没有签署某些恶意数据。
当她或他接受签名时,将使用带签名的消息（称为signature）作为参数调用回调函数。然后前端进行另一个API调用POST /api/authentication,传递一个带有signature和publicAddress的消息体。
第5步：签名验证（后端）
当后端收到POST /api/authentication请求时,它首先根据请求消息体中publicAddress获取数据库中的对应用户,特别是它相关的随机数nonce。
具有随机数,钱包地址和签名后,后端可以加密地验证（ https://en.wikipedia.org/wiki/Digital_signature）用户已正确签署了随机数。如果确认是这种情况,那么用户已经证明了拥有钱包地址的所有权,我们可以考虑对她或他进行身份验证。然后可以将JWT或会话标识符返回到前端。
第6步：更改Nonce（后端）
为了防止用户使用相同的签名再次登录（如果它被泄露）,我们确保下次同一用户想要登录时,她或他需要签署一个新的nonce。这是通过nonce为该用户生成另一个随机数并将其持久保存到数据库来实现的。
这就是我们管理nonce签名无密码登录流程的方法。
6
为什么登录流程有效
根据定义,身份验证实际上只是帐户所有权的证明。如果您使用钱包地址唯一地标识您的帐户,那么证明您加密方式拥有该帐户就非常简单。
为了防止黑客获取某个特定邮件及其签名（但不是您的实际私钥）,我们会强制需要签名的消息满足以下条件： 由后端提供 定期改变
在我们的demo样例中,每次成功登录后我们都改变了它,但也可以设想基于时间戳的机制。
MetaMask登录流程的六个步骤概述。
7
demo代码实现
在本节中,我将逐一完成上述六个步骤。我将展示一些代码片段,以便我们如何从头开始构建此登录流,或者将其集成到现有的后端,而不需要太多努力。
为了本文的目的,我创建了一个小型演示应用程序。我正在使用的堆栈如下： Node.js,Express和SQLite（通过Sequelize ORM）在后端实现RESTful API。它在成功验证时返回JWT。 在前端反应单页面应用程序。
我尝试使用尽可能少的库。我希望代码足够简单,以便您可以轻松地将其移植到其他技术堆栈。
访问 https://login-with-metamask.firebaseapp.com/可以获得一个演示,也可以参考步骤搭建自己的本地工程。
第1步：修改用户模型（后端）
需要两个字段：publicAddress和nonce。我们初始化nonce为随机大数。每次成功登录后都应更改此号码。我还在username这里添加了一个可选字段,用户可以更改。 .\backend\src\models

「深度学习福利」大神带你进阶工程师,立即查看>>>
这是有关如何使用EOS内置的 http_plugin 设置一个安全的HTTPS API的指南。自2018-04-27 release版发布以来SSL开始支持。
首先,你必须使用DAWN-2018-04-27-ALPHA以上版本。
如果你运行 nodeos --version 它应该输出 2594537369 。否则你必须进行版本更新。
要更新,请运行你的eos repo拷贝： $ cd [EOSIO_DIR] $ git pull $ git checkout DAWN-2018-04-27-ALPHA $ git submodule update --recursive $ ./eosio_build.sh $ cd build $ sudo make install
使用 Certbot 为你的域获取SSL证书： $ sudo add-apt-repository ppa:certbot/certbot $ sudo apt-get update $ sudo apt-get install certbot
Certbot 需要在端口80上侦听证书生成。如果你有任何使用它的服务,请先停止,然后运行： $ sudo certbot certonly --standalone --preferred-challenges http -d your-domain
现在将生成的文件复制到testnet文件夹： $ cd [TESTNET_FOLDER] $ sudo cp /etc/letsencrypt/live/your-domain/fullchain.pem . $ sudo cp /etc/letsencrypt/live/your-domain/privkey.pem . $ sudo chown user:user fullchain.pem privkey.pem
配置nodeos
编辑 config.ini 文件并添加以下行： https-server-address = 0.0.0.0:443 https-certificate-chain-file = /[TESTNET_FOLDER]/fullchain.pem https-private-key-file = /[TESTNET_FOLDER]/privkey.pem
如果你想完全禁用不安全的HTTP,只需设置（注释掉该行不会起作用） http-server-address =
启动nodeos并转到 https://your-domain/v1/chain/get_info 进行检查！ 你应该在chrome中看到绿色的锁,这表明TLS连接成功。
如果出现问题,请查看日志文件 stderr.txt 的第一行。
祝大家好运！
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 EOS.IO节点如何使用SSL

「深度学习福利」大神带你进阶工程师,立即查看>>>
Netkiller Blockchain 手札
作者正在找工作,联系方式 13113668890
Mr. Neo Chan, 陈景峯(BG7NYT)

中国广东省深圳市望海路半岛城邦三期
518067
+86 13113668890
< netkiller@msn.com >
文档始创于2018-02-10
版权 © 2018 Netkiller(Neo Chan). All rights reserved.

版权声明
转载请与作者联系,转载时请务必标明文章原始出处和作者信息及本声明。

http://www.netkiller.cn
http://netkiller.github.io http://netkiller.sourceforge.net

微信订阅号 netkiller-ebook (微信扫描二维码）
QQ：13721218 请注明“读者” QQ群：128659835 请注明“读者”

2.10.5. 资产投资与份额持有
传统艺术品投资门槛非常高,一是用户不知道从哪些渠道可以投资,二是艺术品价值过高,三是艺术品简单难。这导致了投资艺术品门槛过高。 Token 能实现份额化,实现人人参与,人人持有,P2P交易。
例如某机构上链一件艺术品,用户可以投资该艺术品的一定份额,可以转让他持有的权益。且交易去中心化,不受任何机构,管理者的制约。
下面的合约可以展示如何分割艺术品份额,最终达到链上资产的份额分割和持有与交易。 pragma solidity ^0.4.25; /** * @title SafeMath * @dev Math operations with safety checks that revert on error */ library SafeMath { /** * @dev Multiplies two numbers, reverts on overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } /** * @dev Integer division of two numbers truncating the quotient, reverts on division by zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); // Solidity only automatically asserts when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend). */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } /** * @dev Adds two numbers, reverts on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } /** * @dev Divides two numbers and returns the remainder (unsigned integer modulo), * reverts when dividing by zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract NetkillerAssetsToken is Ownable { using SafeMath for uint256; string public name; string public symbol; uint public decimals; uint256 public totalSupply; mapping(address => mapping(string => uint256)) internal balances; mapping(string => address) internal tokens; event Transfer(address indexed _from, address indexed _to, string indexed _tokenId); event Burn(address indexed from, string _tokenId); constructor( string tokenName, string tokenSymbol, uint decimalUnits ) public { owner = msg.sender; name = tokenName; symbol = tokenSymbol; decimals = decimalUnits; totalSupply = 0; } function add(address _owner, string _tokenId) onlyOwner returns(bool status){ balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals); tokens[_tokenId] = _owner; totalSupply = totalSupply.add(1); return true; } function balanceOf(address _owner, string _tokenId) constant returns(uint balance){ return balances[_owner][_tokenId]; } function ownerOf(string _tokenId) constant returns (address owner) { return tokens[_tokenId]; } function transfer(address _to, string _tokenId){ address _from = msg.sender; uint256 amount = balances[_from][_tokenId]; transfer(_to, amount, _tokenId); } function transfer(address _to, uint256 _value, string _tokenId){ require(msg.sender == ownerOf(_tokenId)); require(msg.sender != _to); require(_to != address(0)); address _from = msg.sender; uint256 amount = balances[_from][_tokenId]; require(amount >= _value); balances[_from][_tokenId] = balances[_from][_tokenId].sub(_value); balances[_to][_tokenId] = balances[_to][_tokenId].add(_value); tokens[_tokenId] = _to; emit Transfer(_from, _to, _tokenId); } function burn(address _owner, string _tokenId) onlyOwner public returns (bool success) { require(balances[_owner][_tokenId] > 0 && balances[_owner][_tokenId] == 100 * 10 ** uint256(decimals)); balances[_owner][_tokenId] = 0; tokens[_tokenId] = address(0); totalSupply = totalSupply.sub(1); emit Burn(msg.sender, _tokenId); return true; } }
由于 ERC721 不太符合我的需求,所以我结合 ERC20 和 ERC721 写出了我的合约。合约尽量保持了ERC20的使用习惯,函数定义尽量兼容 ERC20。
我们来看下面的构造方法,每个种类的物品一个合约,例如字画,陶瓷,青铜器。 constructor( string tokenName, string tokenSymbol, uint decimalUnits ) public { owner = msg.sender; name = tokenName; symbol = tokenSymbol; decimals = decimalUnits; totalSupply = 0; }
通过下面函数,添加资产到 Token,使链上资产与Token绑定。 function add(address _owner, string _tokenId) onlyOwner returns(bool status){ balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals); tokens[_tokenId] = _owner; totalSupply = totalSupply.add(1); return true; }
balances[_owner][_tokenId] = 100 * 10 ** uint256(decimals); 初始化份额是 100 表示 100%
totalSupply = totalSupply.add(1); 物品件数加一。可以用于统计链上资产的数量。
下面函数是查询资产的持有人 function ownerOf(string _tokenId) constant returns (address owner) { return tokens[_tokenId]; }
下面函数是,权益转让和权益份额转让。 function transfer(address _to, string _tokenId){ address _from = msg.sender; uint256 amount = balances[_from][_tokenId]; transfer(_to, amount, _tokenId); } function transfer(address _to, uint256 _value, string _tokenId){ require(msg.sender == ownerOf(_tokenId)); require(msg.sender != _to); require(_to != address(0)); address _from = msg.sender; uint256 amount = balances[_from][_tokenId]; require(amount >= _value); balances[_from][_tokenId] = balances[_from][_tokenId].sub(_value); balances[_to][_tokenId] = balances[_to][_tokenId].add(_value); tokens[_tokenId] = _to; emit Transfer(_from, _to, _tokenId); }
接下来,我们就是可以开发 Dapp 钱包了,在钱包中实现资产的转移交易。
这个合约可以一直到 EOS 上,Hyperledger Fabric 不可以,因为 Fabric 没有锁的机制,会导致计算出错。
作者的相关文章：
艺术品区块链溯源防伪平台（连载一）
Android 相机 LED 做手电筒
Android EventBus
Android 相机与相册开发
Android i18n 国际化
Android HTTP2 + Oauth2 + Jwt 接口认证实例
Android VideoView 视频播放完成例子（进度条,播放时间,暂停,拖动）

「深度学习福利」大神带你进阶工程师,立即查看>>>
本文首发于 深入浅出区块链社区 原文链接: 联盟链初识以及Fabric环境搭建流程 原文已更新,请读者前往原文阅读
这篇文章首先简单介绍了联盟链是什么,再详细的介绍了Fabric环境搭建的整个流程。
区块链分类：
以参与方式分类,区块链可以分为：公有链、联盟链和私有链。
定义：
我们知道区块链就是一个分布式的,去中心化的公共数据库（或称公共账本）。而联盟链是区块链的一个分支,所以它本身也是一个分布式的,去中心化的公共数据库,跟其他链的区别就是它是针对特定群体的成员和有限的第三方,其内部指定多个预选节点为记账人,其共识过程受到预选节点控制的区块链
本质
联盟链本质仍然是一种私有链,只不过它要比单个小组织开发的私有链更大,但是却没有公有链这么大的规模,可以理解为它是介于公有链和私有链的一种区块链。
联盟链的特点 交易速度快 我们知道对于公有链来说,要想达成共识,必须得由区块链中的所有节点来决定,本身公有链的节点数量就非常庞大,所以处理速度很慢。但对于联盟链来说,由于其节点不多的原因,而且只要当网络上2/3的节点达成共识,就可以完成交易,交易速度自然也就快很多。 数据默认不会公开 不同于公有链,联盟链上的信息并不是所有有访问条件的人就可以访问的,联盟链的数据只限于联盟里的机构及其用户才有权限进行访问。 部分去中心化 与公有链不同,联盟链某种程度上只属于联盟内部的所有成员所有,且很容易达成共识,因为其节点数毕竟是有限的。
联盟链的应用
R3：由40多加银行参与的区块链联盟R3,包括世界著名的银行（如摩根大通、高盛、瑞信、伯克莱、汇丰银行等）,IT巨头（如IBM、微软）。 超级账本（Hyperledger）:由 Linux基金会在2015年12月主导发起该项目, 成员包括金融,银行,物联网,供应链,制造和科技行业的领头羊。
Fabric介绍
我们知道智能合约比较成功的就是以太坊了。以太坊主要是公有链,其实对企业应用来说并不是特别合适,而且本身并没有权限控制功能,面向企业的,主要还是HyperLedger Fabric,当然还有R3的Corda。这里我们主要是讲Fabric。 Fabric是一个面向企业应用的区块链框架,基于Fabric的开发可以粗略分为几个层面： 1. 参与Fabric的底层开发,这主要是fabric,fabric-ca和sdk等核心组件。 2. 参与Fabric周边生态的开发,如支持如支持fabric的工具explorer, composer等。 3. 利用fabric平台开发应用,这就是利用fabirc提供的各种sdk来为应用服务（应用开发） 大部分企业会参与2-3的内容,以3为主来服务应用场景,以2为辅。因为现在除了区块链核心功能尚未完善外,对区块链的管理,运维,监控,测试,优化,调试等工具非常匮乏。企业将不得不面对自己开发一些工作。
Fabric环境依赖
fabric官方推荐的开发环境是基于docker搭建的,使用docker搭建需要一下前置条件： docker一一Docker version 17.06.2-ce 或以上版本 Docker Compose一一1.14或以上版本 Go一一1.10或以上版本, Node.js一一8.9.x或以上版本 Python一一主要是python-pip
Fabric环境搭建具体步骤：
这里使用的是Ubuntu 16.04.4版本
1.安装go及环境变量配置 (1)下载最新版本的go二进制文件 $ wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz
(2)解压文件 $ sudo tar -C /usr/local -xzf go1.9.2.linux-amd64.tar.gz
(3)配置环境变量 vim ~/.profile
添加以下内容： export PATH=$PATH:/usr/local/go/bin export GOROOT=/usr/local/go export GOPATH=$HOME/go export PATH=$PATH:$HOME/go/bin
编辑保存并退出vi后,记得使这些环境变量生效 source ~/.profile
2.安装docker Fabric的chaincode是运行在docker里的。 (1) 由于apt官方库里的docker版本可能比较旧,所以先卸载可能存在的旧版本： sudo apt-get remove docker docker-engine docker-ce docker.io
(2) 更新apt包索引： sudo apt-get update
(3) 安装以下包以使apt可以通过HTTPS使用存储库（repository）： sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
(4) 添加Docker官方的GPG密钥： curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 备注：可验证秘钥指纹 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88 使用如下命令验证： sudo apt-key fingerprint 0EBFCD88
(5) 使用下面的命令来设置stable存储库： sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
(6) 再更新一下apt包索引： sudo apt-get update
(7) 安装最新版本的Docker CE： sudo apt-get install -y docker-ce 注意：在生产系统上,可能会需要应该安装一个特定版本的Docker CE,而不是总是使用最新版本： 列出可用的版本：apt-cache madison docker-ce 选择要安装的特定版本,第二列是版本字符串,第三列是存储库名称,它指示包来自哪个存储库,以及扩展它的稳定性级别。要安装一个特定的版本,将版本字符串附加到包名中,并通过等号(=)分隔它们： sudo apt-get install docker-ce=
(8) 测试是否安装成功 docker --version
(9) 使用阿里提供的镜像,否则后面下载Fabric镜像会非常慢 cd到/etc/docker目录下,创建文件daemon.json,输入下面的内容： { "registry-mirrors": ["https://obou6wyb.mirror.aliyuncs.com"] }
保存并退出,接着执行： sudo systemctl daemon-reload sudo systemctl restart docker
(10) 查看docker服务是否启动： systemctl status docker
(11) 若未启动,则启动docker服务： sudo service docker start或者sudo systemctl start docker
3.安装最新版本的Docker-compose (1) Docker-compose是支持通过模板脚本批量创建Docker容器的一个组件。在安装Docker-Compose之前,需要安装Python-pip,运行脚本： sudo apt-get install python-pip
(2) 安装Docker-compose： pip install docker-compose
(3) 验证是否成功： sudo docker-compose --version
(这部分还可以看下此篇文章 https://blog.csdn.net/so5418418/article/details/78355868 )
4.Fabric源码分享 (1) 新建存放测试、部署代码的目录。 mkdir -p ~/go/src/github.com/hyperledger/
(2) cd到刚创建的目录 cd ~/go/src/github.com/hyperledger
(3) 下载Fabric,这里使用使用git命令下载源码： git clone https://github.com/hyperledger/fabric.git
特别注意这里： 直接使用上面的git clone下载会非常慢,因为github.global.ssl.fastly.Net域名被限制了。只要找到这个域名对应的ip地址,然后在hosts文件中加上ip–>域名的映射,刷新DNS缓存就可以了。 解决办法： 步骤【1】:查询域名 global-ssl.fastly.Net 和 github.com 公网地址 可以使用 https://www.ipaddress.com/ 这个查。 分别查找下面这两个域名的ip地址： github.global.ssl.fastly.net github.com
步骤【2】:将ip地址添加到hosts文件 sudo vim /etc/hosts
在文件下方输入下面内容并保存,前面两个ip就是我们刚才上面查找到的ip： 151.101.185.194 github.global.ssl.fastly.net 192.30.253.113 github.com
步骤【3】：修改完hosts还不会立即生效,你需要刷新DNS缓存,告诉电脑我的hosts文件已经修改了。 输入指令： sudo /etc/init.d/networking restart 即可,如果不行也可以尝试重启一下电脑。 接下来再去git clone就快很多了。
(4) 由于Fabric一直在更新,新版本的并不稳定,所有我们并不需要最新的源码,需要切换到v1.0.0版本的源码： git checkout v1.0.0
5.下载Fabric Docker镜像 (1) 前面步骤4下载完成后,我们可以看到当前工作目录(~/go/src/github.com/hyperledger/)下多了一个fabric的文件夹, 接下来我们cd到~/go/src/github.com/hyperledger/fabric/examples/e2e_cli目录下执行： source download-dockerimages.sh -c x86_64-1.0.0 -f x86_64-1.0.0
(注：一定要下载完所有镜像并且镜像版本要和Fabric版本一致如何没有下载问继续执行source download-dockerimages.sh命令直到在完如图所有镜像),执行完所有会用到的Fabric docker镜像都会下载下来了。 运行以下命令检查下载的镜像列表： docker images
注意 ：如果下载时遇到权限问题,需要切换到root用户下：su root (2) 重启docker service docker restart
6.测试Fabric环境是否成功 在~/go/src/github.com/hyperledger/fabric/examples/e2e_cli下执行如下命令启动测试 ./network_setup.sh up
这个指令具体进行了如下操作： 编译生成Fabric公私钥、证书的程序,程序在目录：fabric/release/linux-amd64/bin 基于configtx.yaml生成创世区块和通道相关信息,并保存在channel-artifacts文件夹。基于configtx.yaml生成创世区块和通道相关信息,并保存在channel-artifacts文件夹。 基于crypto-config.yaml生成公私钥和证书信息,并保存在crypto-config文件夹中。基于crypto-config.yaml生成公私钥和证书信息,并保存在crypto-config文件夹中。 基于docker-compose-cli.yaml启动1Orderer+4Peer+1CLI的Fabric容器。基于docker-compose-cli.yaml启动1Orderer+4Peer+1CLI的Fabric容器。 在CLI启动的时候,会运行scripts/script.sh文件,这个脚本文件包含了创建Channel,加入Channel,安装Example02,运行Example02等功能。
运行完如果出现下图所示,说明整个Fabric网络已经通了。
这里记录本人测试Fabric环境是否成功时遇到的问题
1. 如果发现运行 ./network_setup.sh up 命令 后提示在...fabric/release/linux-amd64/bin文件夹下找不到指定文件 解决办法 ： 可以在~/go/src/github.com/hyperledger/fabric/scripts文件下找到 bootstrap.1.0.0.sh 文件,手动运行它 ./bootstrap.1.0.0.sh , 此时可以在当前文件夹生成一个 bin 文件夹,bin里面的文件就是我们需要的,将它拷贝到前面的...fabric/release/linux-amd64/bin文件夹下
2. 如果出现：Error on outputBlock: Error writing genesis block: open ./channel-artifacts/genesis.block: is a directory不能生成创世块的错误。 解决办法： 可以在~/go/src/github.com/hyperledger/fabric/examples/e2e_cli/channel-artifacts目录下,将genesis.block这个目录删除, rm -rf genesis.block/
3. 如果出现：.ERROR: for orderer.example.com Cannot start service orderer.example.com: b'OCI runtime create failed: container_linux.go:348: starting container process caused "process_linux.go:402: container init caused \"rootfs_linux.go:58: 解决办法： 执行./network_setup.sh down 清除网络后再启动即可
接下来我们手动测试下Fabric网络：
fabric提供了SDK和CLI两种交互方式,这里我们使用的是CLI。 这里我们使用官方提供的小例子进行测试,在官方例子中,channel名字是mychannel,链码（智能合约）的名字是mycc。 首先要登录到CLI这个容器中,才能执行Fabric的CLI命令： docker exec -it cli bash
这时用户名变为root@caa22f87a5bf,当前目录变为/opt/go/src/github.com/hyperledger/fabric/peer#,接着可执行peer命令,体验区块链的命令行使用方式。 1.查看a账户的余额 peer chaincode query -C mychannel -n mycc -c '{"Args":["query","a"]}'
此时我们可以看到控制台输出有： Query Result: 90
这里90就是a账户的余额 2.调用链码,转账 这里我们让b账户向a账户转账10： peer chaincode invoke -o orderer.example.com:7050 --tls true --cafile /opt/go/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n mycc -c '{"Args":["invoke","b","a","10"]}'
转账成功后,我们可以看到有输出如下提示： DEBU 009 ESCC invoke result: version:1 response:接下来我们使用前面的命令继续查看a账户的余额,输出结果如下： Query Result: 100
很明显我们已经转账成功了。 退出cli容器： 直接执行 exit
最后如果我们要关闭Fabric网络,cd到~/go/src/github.com/hyperledger/fabric/examples/e2e_cli下（注意这里的路径按自己前面创建的,不一定要和我一样）,执行： ./network_setup.sh down
参看链接： https://blog.csdn.net/github_34965845/article/details/80610060 https://www.cnblogs.com/preminem/p/7729497.html https://www.cnblogs.com/gao90/p/8692642.html https://blog.csdn.net/so5418418/article/details/78355868 https://blog.csdn.net/iflow/article/details/77951610 https://blog.csdn.net/vivian_ll/article/details/79966210

「深度学习福利」大神带你进阶工程师,立即查看>>>
今天,我刷信用卡买了一杯好喝的抹茶拿铁（这要感谢在伯克利的 Asha）。刷卡后,作为对我支付金额的交换,店老板热情地把茶递给我。因为老板已经确认了交易完成并且之后这笔交易不会被撤销,他一定能够获得我支付的美元金额。 换句话说,交易已经确定（finalized）。 [作者编辑：感谢 Lawson Baker 和 Ari Paul 指出信用卡最终确定交易背后日益增加的复杂性。（请看我在右边标记出来的 Lawson 的回应）。而现金交易则实现了对财产的即时确定性。]
在区块链设置中,确定性 是保证了所有有效区块一旦被提交到区块链上就不会被撤销。当用户进行交易时,他们也希望在转账完成后能够保证转账操作不能随意更改或撤销。因此,在设计区块链共识协议时,确定性变得至关重要。目前基于中本聪共识的系统中,51％ 攻击和自私挖矿行为就是因为允许有撤销区块的可能,才会威胁到系统的健全（例如,如果作恶者累积了 51％ 的挖矿能力,他们就可以进行双花攻击）。这种协议提供了概率性确定,而其他一些协议则实现了绝对性确定。
1
确定性的类型
概率性确定（Probabilistic Finality）  是基于区块链的协议提出的确定性类型（例如,比特币的中本聪共识）。在概率性确定中,包含交易的区块在链上埋得越深,该交易被撤销的可能性越低。因为某一区块后面的区块越多,包含该区块的（分叉）链就越可能是最长的链。 这就是为什么建议等到包含交易的区块在比特币区块链的深度为 6 个区块时才能确认交易完成（大约需要 1 小时）,因为此时撤销交易的可能性非常低。
**绝对性确定（Absolute Finality） **是基于拜占庭容错（PBFT）的协议（例如 Tendermint）提出的确定性类型。在绝对性确定中,一旦交易被包含在区块中并添加到区块链上,该交易就会被立即视为最终确定。在这种情况下,一个验证者会先提出一个区块,而这个区块必须获得委员会中足够多验证者的认可才能提交到区块链上。
还有一个概念叫 经济确定性（Economic Finality） ,也就是说撤销区块所需的资金成本非常高。在使用罚没机制的权益证明基础系统（例如 Casper FFG,Tendermint）中,如果权益持有者在两个（校注：相同高度的）区块上都签了名,那么他们所有的权益都会被没收,这就是损害确定性的昂贵代价。例如,一个有 100 位权益持有者的网络,每位权益持有者持有价值 100 万美元的权益,那么整个网络一共有价值 1 亿美元的权益。 如果有两个区块出现在区块链的同一高度,命名为 B 和 B',此时 B 获得了 66％ 的权益持有者的投票（6600万美元）,B' 也获得了 66％ 的投票（6600万美元）,那么 B 和 B' 的交集（至少有 33％ 恶意的权益持有者）将失去他们所有的权益（至少 3300 万美元）。
2
CAP定理和确定性
看起来似乎绝对性确定比概率性确定更可行,但仍有一些基本权衡表明选择支持概率性确定的区块链更好。考虑如何在概率性确定与拜占庭容错确定性之间取得适当的平衡时,Eric Brewer 的 CAP 定理就发挥了作用。CAP 定理指出,在网络分区的情况下,分布式系统只能满足一致性或可用性。 满足一致性的系统会停止运行,不让错误的交易通过。而满足可用性的系统即使允许错误的交易通过也会继续运行 。一致性的系统具备拜占庭容错确定性（校注：即绝对性确定）,而可用性的系统具备概率性确定。
在支付的场景中,用户通常会选择概率性确定的区块链所提供的可用性（这就是为什么许多基于 DAG 的协议都把重点放在支持支付上,因为这些协议都是支持可用性而非一致性）,然而,许多区块链平台提供的不仅仅是支付,还支持以智能合约为基础的去中心化应用程序（DApp）。不同的 DApp 在确定性方面可能有不同的偏好：那些需要可行性的 DApp,哪怕交易信息不准确也总会让交易通过,更偏好概率性确定链；而倾向于一致性的 DApp,会让整个应用程序停止运行以阻止不正确的交易通过,偏好绝对性确定链。因此,确定性从根本上影响了用户体验。
3
权益证明共识中的确定性
在替代共识协议的元分析中,我们考量了一些主要的 PoS（权益证明）平台对确定性的保证,包括 Tendermint,Thunderella,Algorand,Dfinity,Ouroboros Genesis,Casper FFG 和 Casper CBC。 在这里,我们将简要概述这些平台如何实现确定性,但决定采用哪种协议更重要的是整体考察,而不是仅仅考虑一个参数（这里指的是对确定性的保障）。
Tendermint ：Tendermint 实现了绝对性确定。任何得到 ⅔ 或以上的预投票和预提交的区块都将被最终确定,并且此过程将无限期地继续。除非 ⅓ 或以上的验证者不响应,导致网络停止运行。因此,Tendermint 更偏好一致性而非可用性。另外,当权益证明的惩罚规则应用在 Tendermint 时,Tendermint 协议还能实现经济确定性。
Thunderella ：Thunderella 的快速路径提供了绝对性确定。任何获得公证的最大交易序列都被视为经过完全确认的输出。如果 3/4 的快速路径委员会是诚实且在线的,同时提议者也是诚实的,那么有效交易就能被即时确认。然而,快速路径确认与一般的确定性不同,它是乐观性确定。 一旦交易记录在了基础区块链上,该交易就被完全确定,这种情况既可以是基于链的,也可以是基于拜占庭容错的。但当快速路径发生问题时,Thunderella 会回退到基础区块链,因此 Thunderella 是优先考虑可用性。
Algorand ：Algorand 实现了概率性确定。只要攻击者控制的协议货币价值低于总价值的 1/3,Algorand 就可以保证分叉几乎是不可能的,从而允许协议以强同步方式运行,使得每个区块最终保持一致。而在弱同步中,Algorand 可能会发生分叉,但会使用 BA* 来决定选择哪个分叉链。因此,当协议恢复强同步时,Algorand 中的交易最后也能被最终确定。Algorand 优先考虑一致性而非可用性,因为它宁愿产生空白区块,也不会牺牲一致性。
Dfinity ：Dfinity 实现了概率性确定,其确定性的概率是随着链上区块权重的增加而增加。假设每一轮 r 的周期里我们会拒绝接收更多已公证的区块。在此周期内,我们可以最终确定第 r 轮,因为我们知道第 r 轮已公证的区块包含了第 r 轮之前的所有链上的交易。第 r 轮中,只要操作无误就能保证近乎即时的确定性,经过两次确认加上网络传输延迟,对观察者来说在第 r 轮里任何包含在区块中的交易都是最终确定的。Dfinity 优先考虑一致性,如果网络分区形成大小几乎相同的两半,它会自动令随机信标（random beacon）暂停工作,不允许任何一半网络继续运行。
Ouroboros Genesis ：Genesis 协议可以根据其如何选取区块链的规则实现概率性确定。具体规则是对于短距离攻击（最多 k 个区块,其中 k 是安全参数）,则采用最长链原则；而对于长程攻击（超过 k 个区块）,则采用充裕法则（plenitude rule）,也就是说在当前链发生分叉后即时查看时间段,然后选择密度较高的链。
Casper FFG ：Casper FFG 的目标是为基于链的系统提供绝对/经济上的确定性,委员会按权益加权获得 ⅔ 大多数投票后签署一个区块,便能达到确定性。Casper FFG 的这种构建方式,即使攻击者控制了底层区块链的提案机制,出现冲突的检查点也永远无法被最终确定。但是,FFG 提供了安全性并且提案机制提供了活跃度,因此攻击者可以通过延迟达成共识来阻止 Casper 确定未来的检查点。FFG 是优先考虑一致性的,因为它不允许在没有 ⅔ 验证者同意的情况下对检查点进行最终确定,否则确定无效。此外,FFG 还可以通过罚没机制来实现经济确定性。
Casper TFG ：TFG 通过具有不同容错阈值的验证者来实现绝对性确定。也就是说,协议是异步安全和拜占庭容错的,允许验证者具有不同的容错阈值。
撤销区块可能导致数百万美元的损失,或者影响到去中心化应用的基本运行。因此,对于构建强健的区块链平台以及如何选择开发应用程序的平台,确定性起着至关重要的作用。
致谢：特别感谢 Zubin Koticha 和 Aparna Krishnan,他们的讨论与反馈为这篇文章作出了巨大贡献。 内容来源：公众号-以太坊爱好者
原文链接: 
https://medium.com/mechanism-labs/finality-in-blockchain-consensus-d1f83c120a9a
作者: Alexis Gauba
翻译&校对: 杨哲 & Elisa
课程推荐

「深度学习福利」大神带你进阶工程师,立即查看>>>
项目组成
这个项目叫做LightDB
由三个部分构成
Lightdb.lib 是对rocksdb做了一层封装,主要的修改是追加了保存的数据类型,和表的概念
https://github.com/NewEconoLab/lightdb.lib
Lightdb.server 就是一个远程数据库啦,Lightdb的服务器版本
https://github.com/NewEconoLab/lightdb.server
Lightdb.SDK 是方便客户端接入LightdbServer 提供的,目前只提供了C#版本实现,后续还会提供Typescript版本实现,通讯协议比较简单,任意支持websocket的方案都可以连接。
https://github.com/NewEconoLab/lightdb.sdk
项目特点
要说项目特点的话,
一、追加了数据类型和表概念。
二、有服务器,采用websocket通讯,对js友好
三、数据的存储以taskblock为单位,方便数据库互相验证和同步
其实最重要的特点还有一个关于读的快照snapshot。快照的需求来源是数据处理的事务化,或者说一批操作的原子性要求。
传统数据库一定程度支持事务化,而KeyValue数据库这边支持事务化的程度就更差一些。
而NEO使用的嵌入式数据库,LevelDB因为采用LSM存储方式,提供读取的snapshot 非常容易,代价也小。
这也就造成了在NEO的实现中,存储部分对Snapshot的依赖非常强。
创立这个项目的初衷
有一部分是要改造NEO的存储部分为网络存储,并且可以用轻型节点直接找网络数据库去执行InvokeScript
也就是把Neo的一个节点一个进程的模式,改造为一个节点一个集群。
完成这个目标的基础,就是这个网络数据库需要一个类似的很低成本的读snapshot支持。
所以我选择了rocksdb作为这个基础,rocksdb是facebook 基于leveldb魔改的一个改进版本。
那么为什么要追加数据类型和表的概念？
因为leveldb使用中存储的东西都是byte[],而很多时候我们使用neo中得到的byte[] 都不知道是什么东西,要靠相应的约定。
我觉得这个很不方便,所以我们存储的单位不是byte[] 而是一个结构体 DBValue,他可以描述自己是什么数据类型,整数,string,byte[],bigint,小数,等等。
这个结构体里面还预留了给每一个值附加信息的功能,也记录了这个值最终修改的时间戳（存储高度）
至于表就更好理解了,这是使用leveldb的一个自然需求,keyvalue数据库是一个字典,可是我们存进去的东西,从逻辑上是分为几个字典的,交易字典,utxo字典,等等等。
我们只是把这个分字典的自然需求,在数据库层面直接提供了。
然后是网络层,选择了websocket作为通讯方法,完全是基于将来是网页的天下的考虑。因为存储这个功能被独立出来,甚至可以写一条链,他完全是在网页中运行的。
当然目前还没有想那么多,但可以预见到越来越多的业务会在网络中运行,因为这个数据库的出现,nel目前的至少50%的查询需求可以不通过后台服务器,js直接完成。
比如nep5资产的blanceof,比如交易UTXO数据的确认。
其三,数据库的存储模仿了区块链的结构,以taskblock为单位,首尾相接。毕竟一开始这个项目的名字就叫lightchain.
后来一想,这个名字有点烂大街了,数据库还是老老实实的叫DB吧
为什么要以taskblock为单位呢,因为便于同步。数据库读写分离是性能扩展的必然走向,而把每一个操作记录下来,从数据库只要从主数据库取得每一个block,自己执行一遍,就同步完了。
对了还有一点也很像NEO区块链,我们的写入权限控制不是用密码,而是用私钥,而且还是和NEO完全兼容的私钥
最后,还有一个很重要的功能,checkpoint,这也是rocksdb提供的礼物,可以快速的在本地产生一个新的数据库副本。这样我们做链上数据快照的手段就更多了,传统手段是用爬虫爬取要快照的数据,爬到指定高度,停。现在又多了一个手段,约定时间快照,到时间了,啪,一个checkpoint,整个数据库都备份下来了。
不过当数据量达到G的级别,这个checkpoint性能是怎样的,还是需要测试确认的
项目使用方法
一、开服务器
获取lightdb.server,生成
启动之前看一下config
Server_port 服务端口
Server_storage_path 数据库存储路径
Server_type 读写分离用,从机模式还没开发呢,只能Master
Storage_maindb_magic 提供一个魔法字串,好让这个库特立独行
会写入库中,数据库创建之后,改这个值就没意义了
Storage_maindb_firstwriter_address 提供一个NEO地址,他将成为第一个有写入权限的人,实际上还没开发追加写入人的功能,他就是唯一一个。
会写入库中,数据库创建之后,改这个值就没意义了
然后启动server,支持linux windows,在win10,unbutu,centos测试过,linux下需安装依赖库,参考facebook rocksdb项目的说明
https://github.com/facebook/rocksdb/blob/master/INSTALL.md
中的Supported platforms一节

如果路径里没有创建过数据库会新建,否则会打开
控制台目前只有db.state 和 db.block 两个功能
Db.block 会把block解析开,我们可以看到每个block都干了些啥,value都是DBvalue,用DBValue结构体去查看就能看到类型
二、客户端使用
首先引用lightdb.sdk,可以下源码,可以nuget
New一个client对象
注册,断线事件,然后Connect
如果连接成功,就OK
不需要登陆啥的,读随便,写的时候,需要你先签好名
Ping 与dbstate
所有的读操作都是通过snap来进行的
所以先要获取一个snapshot
然后就可以getblock
Getblockhash
Getvalue
client.Post_snapshot_getvalue(snapshotid, tableid, key);
要写数据就比较复杂了
首先创建个writetask对象,所有的写入,都通过writetask对象完成,
然后创建signdata对象,进行签名
然后将这两个东西post给服务器。有对应的私钥才能完成签名,成功写入数据。

NEOFANS：neofans.org
NEOFANS 微博：https://www.weibo.com/neofanscommunity
NEOFANS telegram群：https://t.me/NEOfansCN

「深度学习福利」大神带你进阶工程师,立即查看>>>
访问区块链会议并关注区块链新闻时,不可避免地,您会遇到Linux基金会的Hyperledger。理解像比特币、以太坊这样的加密货币还算相对容易的,Hyperledger却不然。但如果你多研究研究,你会发现一些令人兴奋的非货币、工业区块链的应用项目。
什么是Hyperledger？
让我们从Hyperledger不是什么开始。首先,它不是公司、不是加密货币、不是 区块链 。Hyperledger更像是开放式工业区块链开发的枢纽。Hyperledger网站上有解释：
“Hyperledger是一项旨在推动跨行业区块链技术的发展的开源项目。由Linux基金会在2015年12月主导发起该项目,成员包括金融,银行,物联网,供应链,制造和技术领域的领导者。”
Hyperledger不支持比特币或其他任何加密货币。但该平台对区块链技术感到非常兴奋。该网站称,因为网络本身,“有一项技术,承诺比区块链技术更广泛,更具根本性的革命。” 区块链有可能“构建新一代的交易应用程序,在其核心建立信任、责任和透明度的同时简化业务流程和法律约束。”
所以我们许下很多承诺- 我们有Hyperledger。有了它,Linux基金会旨在创建一个软件开发人员和公司协调构建区块链框架的环境。Linux基金会于2015年12月创建了该平台。2016年2月,它宣布了第一批创始成员,2016年3月又有10位成员加入。
今天,Hyperledger拥有超过100名令人印象深刻的成员名单。该清单涵盖了广泛的知名行业领导者。它包括空客和戴姆勒等移动技术巨头,IBM,富士通,SAP,华为,诺基亚,英特尔和三星等IT公司,德意志交易所,美国运通,摩根大通,BBVA,法国巴黎银行和富国银行等金融机构。像Blockstream,Netki,Lykke,Factom,bloq和Consensys这样的区块链创业公司。许多世界上最大的技术和金融公司在Hyperledger会见了一些最热门的区块链创业公司。
Hyperledger的“执行政府”都是各行各业的领军人物。这10多位高管大多数拥有数十年的开源经验以及与多个行业的紧密联系。您将找到Apache Foundation和W3C Consortium的领导者以及IBM的工程师等。Hyperledgers的一些成员,如Richard Brown和Tamas Blumer,已经与Blockchain合作多年。对于其成员,Hyperledger不仅提供技术知识和软件框架,还提供与行业和开发人员的各种联系。
在Hyperledger历史的早期阶段,必须有所舍弃。执行董事Brian Behlendorf被问到是否会有一个“Hyperledger币”——一个在Hyperledger区块链上运行的货币单位。Behlendorf回答说,Hyperledger项目本身永远不会建立自己的加密货币。
“你永远不会看到Hyperledger币,”他说,“通过不推货币,我们避免了必须保持全球货币一致的诸多政治挑战。”
这一决定坚定了Hyperledger的战略目标,即建立区块链技术的工业应用,并将其与通常从基于货币的区块链发展而来的致富计划完全分离。可能有点儿无聊,但对Hyperledger直面技术。
此外,“章程”概述了Hyperledger的目标,好比任务指南。据此,该平台旨在“创建企业级,开源分布式分类帐框架和代码库”,并创建、推广和维护开放式基础架构。
这种说法不知何故,还是有点儿含糊不清。它概述了某种程序,但没有回答关乎痛点的大问题：所有这些世界领先的公司和领导者在Hyperledger做了什么？他们推进了哪些项目？有谁参加？
项目
Hyperledger的“伞形策略”孵化并推广了一系列业务区块链技术、框架、库、接口和应用程序。目前,Hyperledger是以下项目的主持人：
1. Hyperledger Sawtooth：这是由英特尔开发的模块化区块链套件,它使用一种称为Proof of Elapsed Time（PoeT）的新共识算法。
2. Hyperledger Iroha：Iroha是几家日本公司的一个项目,旨在创建一个易于合并区块链框架的项目。
3. Hyperledger Fabric：这是IBM的项目。Fabric是一种插件,可以实现区块链技术,作为开发具有灵活权限的高级区块链程序的基础。
4. Hyperledger Burrow：该项目沿着以太坊的规范开发了一个有权限的智能合约机。
除了这些框架项目,Hyperledger还有几个工具项目,目的在于使区块链的访问和开发更容易,更有效。这是Cello,一种区块链即服务部署模型,Composer,一种用于构建区块链业务网络的工具,一种用于查看、查询和部署区块链上的事务和相关数据的资源管理器,以及Indy,一系列工具、库和其他基于区块链的数字身份组件。
Hyperledger显然参与了大量非货币区块链项目。我们仔细研究两个最突出的项目：Sawtooth和Fabric。这两个项目都是由大公司- 英特尔和IBM创建的- 并将Hyperledger作为开源代码提供。通过Hyperledger,公司继续推进他们的区块链项目,同时邀请其他人参与。
英特尔的Sawtooth
Sawtooth Lake是英特尔的模块化区块链套件。它是用Python编写的,专为从物联网到财务等许多领域的用例而设计。Sawtooth Lake的主要特征是它支持许可和无权限的应用和部署,并且它使用新开发的PoET的一致性算法。
PoET使用新的安全CPU指令,英特尔构建的新处理器中也常使用这种CPU。通过这些指令,PoET可确保安全随机地选择所谓的“领导者”。这可以与比特币采矿进行比较,其中矿工竞争一次性访问以编写区块链。除了比特币的证明算法,PoET不需要专门的挖掘硬件。
要成为领导者,每个“验证器” - 等同于节点或矿工- 需要使用安全CPU指令来请求等待时间。具有最短等待时间的验证器将被选为领导者。算法PoET的工作方式就像彩票一样,价格可以获得对区块链的写入权限。
除了加密货币之外,对领导者没有任何奖励。它只是运行软件的一部分。因此,没有像加密货币那样激烈的竞争。每个节点都可以使用它的CPU - 只要它是一个新的模型,并且可能来自英特尔- 就可以免费参与让领导选择。什么是比特币挖掘,只是Sawtooth Lake软件的非侵入性部分。
Sawtooth Lake的另一项创新是交易的建立和传播。客户端构建事务并将其提交给验证器。这包括他们在批处理中获得的事务并将它们完全提交。这是一个类似但不完全相同的过程,因为当加密货币“矿工”将交易包装到一个区块时,通过这种批处理,Sawtooth解决了安全验证相互依赖的问题。
迄今为止,Sawtooth已在多种应用中进行了测试。经过测试记录了从海洋到餐桌的海鲜之旅,使用物联网传感器,从渔民到超市,追踪整个供应链的所有权,拥有权和参数。买家可以访问整个海鲜活链的完整且非加密的记录。区块链越来越多地讨论供应链和产品历史中的这种用例。
Sawtooth也经过测试简化了转让债券的过程。开发人员创建了用于跟踪和转移债券的用户界面。有了这个,用户可以管理区块链上的整个债券组合。目前测试的Sawtooth的另一个用例是数字资产。开发人员构建了一个平台,用于管理Sawtooth区块链上的数字资产所有权,该平台可以管理大范围的数字资产。 应用程序之间的连接点Sawtooth似乎是构建在区块链中的任何类型的数字资产的市场,并且已经为用户提供了图形界面。

「深度学习福利」大神带你进阶工程师,立即查看>>>
于2018年11月21号到23号期间参加能源行业顶级盛会 - 联合国国际能源署MC IC1罗马会议


参加了Panel Discussion, 就以下3个topics分享了自己的观点： R&D project financing Innovative Strategy in R&D Top priority R&D topic
我强调了自己的观点,下一个区块链的热点是Data Storage和Data Security

第三天,还发表了关于Echoin 法国电力项目的主题演讲,共享了如何在微电网接入主网时,用区块链技术解决其中的能量确权问题。
感谢中国驻意大利大使馆对参会中国代表团的支持
感谢中科院王一波博士给我们搭建了通向能源顶级平台的桥梁

「深度学习福利」大神带你进阶工程师,立即查看>>>
web3j maven插件用于基于solidity智能合约文件创建java类。
用法
插件的基本配置将从 src/main/resources 获取solidity文件,并将java类生成到 src/main/java 文件夹中。 org.web3j web3j-maven-plugin 0.3.7
运行插件执行目标 generate-sources ： mvn web3j:generate-sources
配置
有几个变量用于选择solidity源文件,定义源目标路径或更改包名称。
outputDirectory 的配置优先于 sourceDestination 。
入门
创建一个标准的java maven项目。将以下 配置添加到 pom.xml 文件中： org.web3j web3j-maven-plugin 0.3.7 com.zuehlke.blockchain.model src/main/java/generated true java,bin src/main/resources **/*.sol src/java/generated src/bin/generated src/abi/generated
将你的Solidity合约文件添加到文件夹 src/main/resources 中。确保solidity文件以 .sol 结尾。
开始生成过程： > mvn web3j:generate-sources [INFO] --- web3j-maven-plugin:0.1.2:generate-sources (default-cli) @ hotel-showcase --- [INFO] process 'HotelShowCaseProxy.sol' [INFO] Built Class for contract 'HotelShowCaseProxy' [INFO] Built Class for contract 'HotelShowCaseV2' [INFO] Built Class for contract 'Owned' [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 4.681 s [INFO] Finished at: 2017-06-13T07:07:04+02:00 [INFO] Final Memory: 14M/187M [INFO] ------------------------------------------------------------------------ Process finished with exit code 0
你可以在目录 src/main/java/generated/ 中找到生成的java类。
下一步是与智能合约进行交互。请参阅 web3j主页中文版 的智能合约部署和交互。
有关多模块项目配置,请参阅@fcorneli的 帖子 。简而言之：要获取生成的java源文件,需要build-helper-maven-plugin配置。此外,多模块项目中需要 ${basedir} 前缀。
安利2个java以太坊、比特币区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。
汇智网原创翻译,转载请标明出处。这里是原文 web3j的maven插件

「深度学习福利」大神带你进阶工程师,立即查看>>>
对优质区块链开发人员的需求很大,这是有充分理由的。区块链和ICO领域在过去几年中爆炸式增长。越来越多的人试图进入并在该领域中扬名立万。但是,为了获得成功,他们拥有一支强大而健全的团队至关重要。区块链开发人员,更准确地说,以太坊开发人员是该团队中最关键的组成部分。
因此, 在本指南中,我们将使你的生活更轻松。我们将向你展示如何精确定位和从人群中筛选的优秀的人才。
在我们雇用以太坊开发者之前,重要的是我们要知道我们雇用的是哪类人。
怎么样才算是一个完美NB的以太坊开发者？
在以太坊开发者精湛的技能中,最重要的是要知道将最优秀的与其他人区分开的基本品质是什么？优秀的开发人员必须不仅仅是具有区块链编码技能的开发人员。我们并不是说只熟悉编码就没有价值,但是,如果你需要一个合适的开发人员来创建一个帝国。那么,你正在寻找的一些主要品质是什么？ 去中心化的坚定信念：这些人认为去中心化将挽救人类。传统公司不会雇佣这些人,因为他们相信社会,公司和政府等机构不应该去中心化。 掌握密码学：区块链开发人员需要掌握加密经济学。加密经济学,密码学和经济学分为两部分。这就是为什么伟大的以太坊开发人员应该对密码学有一种不懈的好奇心。 掌握经济学：加密经济学的后半部分是“经济学”,因此专业开发人员也应该具备经济和博弈论机制的良好知识。如果你正在创建区块链平台,则代码应确保所有参与者都受到经济激励。 极度好奇：为了拥有如此庞大的知识基础,这些人天生就非常好奇。这些人大多都是直到深夜还通过视频,论坛,维基来了解特定问题。
所以,现在我们知道我们正在寻找的那种人。这就是为什么说从头开始了解一些以太坊基础知识是有道理的。
我们为什么这样做？
因为每个以太坊开发者都应该完全熟悉这些概念。
1
什么是以太坊？
这是以太坊网站定义的方式： 以太坊是一个区中的平台,运行智能合约：完全按照程序方式运行的应用程序,没有任何停机,审查,欺诈或第三方干扰的可能性。这些应用程序运行在定制的区块链上,这是一个非常强大的共享的全局基础架构,可以转移价值并体现财产的所有权。
但简单来说,以太坊计划成为未来的终极软件平台。如果未来是去中心化的,并且dAPP变得司空见惯,那么以太坊必须成为它的前沿和中心。
虽然比特币是区块链技术的第一个应用,但它仍然只是一种货币。以太坊带来了区块链技术可能实现的全部应用范围。
正如以太坊联合创始人Gavin Wood博士所说： 比特币首先是一种货币;这是区块链的一个特殊应用。但是,它远非唯一的应用程序。举一个类似情况的过去例子,电子邮件是互联网的一种特殊用途,并且肯定有助于推广它,但还有很多其他的应用。
2
以太坊采矿如何工作？
截至目前,以太坊正在使用比特币正在使用的相同的工作量证明（Proof-of-Work）。然而,以太坊很快计划转向权益证明（Proof-of-stake）,他们将使用Casper协议来实现这一转变。
那么权益证明和工作量证明之间有什么区别？这实际上是你可以问人们你可能会面试的事情。了解工作量证明和权益证明的工作原理绝对至关重要。
**工作量证明：**这是大多数加密货币如以太坊和比特币迄今为止遵循的协议。这意味着矿工通过使用专用硬件通过“挖矿”来挖掘加密货币。
**权益证明：**该协议将使整个挖掘过程成为虚拟的。在这个系统中,我们有验证器而不是矿工。它的工作方式是,作为一个验证器,你首先必须把你的一些以太锁作为赌注。完成后,你将开始验证块,这基本上意味着如果你看到任何你认为可以附加到区块链的块,你可以通过下注来验证它。当块被追加时,你将获得与你投资的比例成比例的奖励。但是,如果你在错误或恶意区块上下注,你投入的股份将被剥夺。
为了实现“权益证明”,以太坊将使用Casper一致性算法。一开始,它将是一个混合风格的系统,其中大多数交易仍将是工作量证明,而每100个交易将成为权益证明。这样做意味着,它将提供真实世界在以太坊平台上来测试验证。但这对于以太坊意味着什么？这个协议的优点是什么？让我们来看看：
权益证明的优点 降低整体能源消耗和货币成本：世界范围比特币矿工每小时花费约50,000美元用电。那是每天120万美元,每月3600万美元,每年约4.5亿美元！只是把最重要的放在那些数字和浪费的电量上。通过使用“权益证明”,你将使整个过程完全虚拟化,并切断所有这些成本。 没有ASIC优势：由于整个过程将是虚拟的,因此不依赖于谁拥有更好的设备或ASIC（专用集成电路）。 使51％的攻击更难：51％的攻击发生在一群矿工获得超过世界散射能力的50％时。使用权益证明可以抵消这种攻击。 无恶意验证者：任何将资金锁定在区块链中的验证人都会确保他们不会向链中添加任何错误或恶意的区块,因为这意味着他们投入的全部股权将被剥夺。 块创建：更快地创建更新的块和整个过程。 可伸缩性：通过引入“分片”概念使区块链可扩展（稍后将详细介绍）。
尽管之前有过各种简单的权益证明实施,但Casper与其他方式的区别在于,它激励了诚实的矿工并惩罚了不诚实的矿工。如果你已经将你的赌注置于恶意区块上,那么赌注将被取走。它将惩罚任何不遵守规则的人。
这是Vitalik解释它的方式： 想象一下,100个人坐在圆桌旁。一个人有一堆文件,每个文件都有不同的交易历史。第一个参与者拿起一支笔并签一张,然后将其传递给下一个做出类似选择的人。如果每个参与者签署了大多数参与者最终签署的交易历史记录,则每个参与者只能获得1美元。如果你在一个页面上签名并稍后签署另外不该签的一页,那么你的房子就会被烧毁。然后他补充说,这可能是正确签署的好动力！
3
什么是智能合约？
智能合约是自动化合约。它们是自动执行的,并且在其代码上写入特定指令,这些指令在特定条件下执行。
你可以在我们的其他文章中了解有关智能合约的更多信息。
智能合约是以太坊生态系统中的任务完成的方式。当有人想要在以太坊完成特定任务时,他们会与一个或多个人签订智能合约。
智能合约是一系列指令,使用编程语言solidity编写,它基于IFTTT逻辑（即IF-THIS-THEN-THAT逻辑）工作。基本上,如果完成了第一组指令,则执行下一个函数,然后执行下一个函数并继续重复,直到合约结束。
理解这一点的最好方法是想象一台自动售货机。你采取的每个步骤都像下一步执行自身的触发器。它有点像多米诺骨牌效应。那么,让我们来看看在与自动售货机交互时你将采取的步骤： 第1步：你给自动售货机一些钱。 第2步：按下与所需产品对应的按钮。 第3步：该产品出来,你收起它。
现在看看所有这些步骤并考虑一下。如果前一个步骤没有执行,其他任何步骤都还可以工作吗？这些步骤中的每一步都与前一步骤直接相关。还有一个要考虑的因素,它是智能合约的一个组成部分。你可以看到,在与自动售货机的整个交互过程中,你（请求者）仅与机器（提供商）合作。绝对没有第三方参与。
那么,现在,如果它在以太坊网络中发生,那么这笔交易将如何？
假设你刚刚从以太坊网络中的自动售货机购买了一些东西,那么步骤将如何？ 第1步：你给自动售货机一些钱,这由以太坊网络中的所有节点记录,并且交易在分类帐中更新。 第2步：按下与你想要的产品对应的按钮,并在以太坊网络和分类帐中更新记录。 第3步：产品出来,你收集它,这将由所有节点和分类帐记录。
你通过智能合约进行的每笔交易都将由网络记录和更新。这样做是因为它让每个参与合约的人都对他们的行为负责。它通过使整个网络可以看到每个动作来消除人类的恶意。
好的,直到现在我们已经涵盖了以太坊是什么,什么是采矿,什么是智能合约。如果你的候选人不能令人满意地回答这些问题,那就让他们在那一瞬间离开。已经不值得你再花时间。
4
掌握智能合约代码
显然,这应该是所有伟大的开发人员的菜。你可以肯定地了解开发人员的专业知识的一种方法是让他们解释特定合约的工作原理。在这里,我们将向你展示两个solidity代码。你可以通过他们运行此代码并要求他们将其分解并向你解释每个步骤中发生的情况。
代码示例1
代码和解释来自toptal。 pragma solidity 0.4.18;import "./Vehicle.sol"; contract VehicleOwner {    address public owner;    mapping(bytes32 => address) public vehicles;    event NewVehicleAdded(address indexed newVehicle, uint256 timestamp);    function VehicleOwner() public {        owner = msg.sender;    }    /**    * @dev Throws if called by any account other than the owner.    */    modifier onlyOwner() {        require(msg.sender == owner);        _;    }    function createNewVehicle(string model, string make, bytes32 vin) public onlyOwner {        address newVehicle = new Vehicle(model, make, vin);        vehicles[vin] = newVehicle;        NewVehicleAdded(newVehicle, now);    } }
让我们一行一行地了解这些代码都干了些什么。
代码：pragma solidity 0.4.18;
分析：指定使用的编译器的版本。在这儿是0.4.18
代码：import“./Vehicle.sol”; *
分析：导入用于代表新车辆的智能合约。
代码：contract VehicleOwner {
分析：声明车主合约。
代码： address public owner; mapping(bytes32 => address) public vehicles;
分析：这是我们充实合约的地方。第一个变量调用所有者owner并表示创建VehicleOwner合约的任何给定实例的以太坊。
第二个称为vehicles车辆,将用于存储车主拥有的车辆清单,通过将其合约地址分配给提供的车辆识别号码。
代码： function VehicleOwner() public { owner = msg.sender; }
分析：看看该函数与合约的名称是什么？这是因为这个特定的函数是一个构造函数。它唯一的功能是将调用该函数的地址指定为合约所有者。
代码： modifier onlyOwner() {require(msg.sender == owner);_; }
分析：使用此函数修饰符确保只有合约所有者才能访问合约。
看到_？这产生了稍后应用修改器modifier的函数体。
代码： function createNewVehicle(string model, string make, bytes32 vin) public onlyOwner { address newVehicle = new Vehicle(model, make, vin); vehicles[vin] = newVehicle; NewVehicleAdded(newVehicle, now); }
分析：这在区块链上创建了一个新合约,这是一种新车辆的代表。车辆合约的构造函数接收三个属性：model,make和vin,后者可用于识别特定车辆。
创建新合约将返回其新分配的地址。在函数中,使用车辆的映射,我们将给定的vin绑定到该地址。最后,该函数广播一个新事件,传入地址和当前时间戳。
代码示例2 contract BasicIterator { address creator; // reserve one "address"-type spotuint8[10] integers; // reserve a chunk of storage for 10 8-bit unsigned integers in an arrayfunction BasicIterator(){ creator = msg.sender; uint8 x = 0;//Section 1: Assigning valueswhile(x < integers.length) { integers[x] = x;   x++; } }function getSum() constant returns (uint) { uint8 sum = 0; uint8 x = 0;//Section 2: Adding the integers in an array.while(x < integers.length) { sum = sum + integers[x]; x++; }return sum; }// Section 3: Killing the contractfunction kill(){if (msg.sender == creator) { suicide(creator); } } }
那么,让我们来分析吧。
第1节：赋值
在第一步中,我们赋值一个名为“integers”的数组,该数组接收10个8位无符号整数。我们这样做的方式是通过while循环。让我们来看看while循环中发生了什么。 while(x < integers.length) {integers[x] = x;x++; }
请记住,我们已经为整数x赋值“0”。while循环从0变为integers.length。Integers.length是一个返回数组最大容量的函数。因此,如果我们确定一个数组将有10个整数,arrayname.length将返回一个值10。在上面的循环中,x的值从0到9（<10）并将其自身的值赋给整数数组也是如此。因此,在循环结束时,“integers”将具有以下值：
0,1,2,3,4,5,6,7,8,9。
第2节：添加数组内容
在getSum()函数内部,我们将添加数组本身的内容。它的方式是通过重复上面相同的while循环并使用变量“sum”来添加数组的内容。
第3节：终止合约
此功能终止合约并将合约中的剩余资金发回给合约创建者。
因此,这应该可以让你更好地了解solidity合约看起来是什么样子的以及你应该从那里获得什么样的代码细分类型。
5 以太和gas有什么区别？
这是你的开发人员应该熟悉的另一个核心概念。
以太是生态系统中的主要标记。这是激励玩家完成智能合约的动力。
gas是满足特定合约所需的燃料量。
当有人提交智能合约时,它具有预先确定的gas价值。合约执行时,合约的每一步都需要一定量的气体来执行。
这可能导致两种情况： 所需的gas超过设定的极限。如果是这种情况,则合约状态将恢复到原始状态,并且所有气体都用完了。 所需gas小于设定的极限。如果是这种情况,那么合约就完成了,剩余的gas将交给合约制定者。
以下是显示Wei的平均gas价格的图表。
gas是以太坊的生命线。
以太坊的所有交易均由矿工验证。基本上,他们必须手动将每个交易放入他们为了验证交易而挖掘的块中。为了换取他们的服务,他们收取了一定的交易费用。
通常,优先考虑高gas费的智能合约,因为矿工有机会在那里收取更高的费用。与比特币相比,收取的费用只是象征性的。
此图表比较了比特币与以太坊的交易费用。
实际上,正如你所看到的,在0.01以太的此次交易中,仅收取0.00000000000002以太的gas作为交易费用<$0.000001。
所以,正如你所看到的,以太坊的矿工只收取非常象征性的交易费用。显然收取交易费是矿工的次要角色,他们的主要工作是......好吧......挖矿！
6
问题和解答
提炼所有这些知识,让我们对你可以提出的一些具体问题。
1.问题：合约构造函数是如何定义的？ 解答：构造函数被定义为一个函数,其名称与合约完全相同。
2.问题：在以太坊中记录的事件在哪里？它们的目的是什么？ 解答：日志是合约发出的事件。这些是其交易收据的一部分以及在以太坊虚拟机（EVM）上执行的LOG opcodes操作码的结果。这些事件主要用于与前端通信或作为廉价的数据存储。因为交易的返回值只是交易的hash,区块链需要一些时间来达成共识并验证交易,通过将它们挖掘到新块中。通过发出事件并使前端收听（观察）这些事件,实现了有效的通信。
3.问题：mappings映射是什么？ 解答：映射等同于其他编程语言中的字典或映射。它就是键值存储。
4.问题：修饰语purpose of modifiers的目的是什么？ 解答：顾名思义,他们修改使用它们的功能。但是,在执行函数之前必须满足修饰符的条件。如果不是,那么修饰符会抛出错误。
5.问题：以太坊库libraries是什么？ 解答：以太坊库有助于隔离整体逻辑。它们是一组使用以太坊虚拟机（EVM）在区块链上使用的软件包。所有库都可以在智能合约中部署和链接。它们可以通过DELEGATECALL调用。
6.问题：为什么在智能合约上调用方法需要花钱？ 解答：当调用方法时,它们会改变区块链的状态。由于操作需要gas,因此需要花钱。
哪里可以找到优秀的开发人员？
在像LinkedIn和谷歌这样的“传统地方”很难找到优秀的开发者。但是,Reddit,GitHub等是寻找这些开发人员的好地方。
另外,还有一件事。由于这是一个利基人才市场,你应该对他们可能在你的城市甚至你自己的国家的事实持开放态度。应该为远程工作做好准备,特别是如果你正在寻找优秀开发者。
这可能是一种痛苦,但这是“质量超过数量”的必须面对的情况之一。
7
结论
当你面试以太坊开发人员时,你必须记住一件事。他们没有必要彻底回答所有问题。重要的是他们的热情以及他们是否能够专门回答与他们的工作和角色有关的问题。
无论如何,本指南应该帮助你了解特别的区块链开发人员。最后一句忠告,请不要和开发人员的质量妥协。请记住,质量永远胜过数量。 内容来源：公众号-区块链兄弟
原文发布于:博客园 
作者: malii2
课程推荐

「深度学习福利」大神带你进阶工程师,立即查看>>>
0x00 前言
下拉最后看演示效果。项目 地址
本来这应该是一个很和谐的感恩节假期,本来我可以很悠闲的写完所有作业然后随便看点论文打发时间,本来可以很美好的,假装自己不是个程序员。然鹅,一切都因为一篇论文而起,那是篇今年（2018）顶会的论文,内容居然是以太访智能合约的逆向。于是好奇心就起来了,以太访有逆向工具了,为了追上历史的潮流,NEO是不是也应该有一个逆向工具呢？其实在几个月前我写合约的时候就有这种想NEO自己定义了一套指令集,想要通过这些指令去分析交易简直让人崩溃。于是,所以,因此,一股子冲动上来,我就开始作死的坑自己。
0x01 探索
假期有五天,我的第一天计划是用一天时间来研究这个逆向工具,有头绪就好,不着急动手。然后第二第三第四以及第五天就写作业啊,看论文啊之类的。于是第一天。
我在网上搜了很多,基本上针对以太访的合约逆向工具都是17年左右出来的。比较完整的是Porosity,也是号称第一个以太访反编译工具,于是我下载了这个家伙,然后把反编译之外的文件全部删掉。研究之后发现这个项目其实还是蛮原始的,跟我们熟悉的C#或者Java的反编译工具相比,这个Porosity能做的其实很有限,基本上属于一个辅助工具,毕竟这个工具的作者似乎是打CTF的,所以人家开发工具当然是最适合自己就好了。另外一个号称比较完整甚至号称可以反编译ETH/NEO/EOS/BTC的工具是OCTOPUS,于是我也跑去看了,但是感觉总体完成度不是很高,连指令解析都还处于TODO状态,于是提交了下自己在研究的时候发现的bug之后就转去找别的了。 虽然这两个项目对我的直接帮助并不大（可以抄代码）那种,但是研究完这两个项目我的冲动更强烈了。好奇心使我灭亡。
0x02 思考
网上搜了很多,也看了关于栈虚拟机分析的文章,但是依然感觉所有的信息在我的脑子里都是碎片化的,我不知道如何入手,完全没有头绪。
我起初的想法是,因为AVM是通过C#的字节码翻译过来的,如果我把这个对应着翻译回去,岂不是可以直接用C#的反编译工具,这简直是美滋滋。于是我开始研究李总的NEOVM和NEOCompiler源码。年初的时候,也就是过年那会,我其实研究过李总的这个虚拟机和编译器的源码,但是当时对NEO整体还不是很熟悉,啃这个源码就像嚼糠一样,含泪咽下去了,也消化不动。现在将近一年过去,中间又断断续续看过一些,现在重新看,感觉轻松了许多,至少每个文件干嘛的都还记得。研究Compiler的方法就是看源码和打Log,然后根据输出对应源码来理解逻辑,蛋是,很快我就发现这样很蛋疼,因为,Compiler在做转换的时候,一条C#指令码可能对应着多条NEO指令,同时多条C#指令也可能对应着相同的NEO指令。再加上C#本身的指令码晦涩程度远超NEO,于是我很快缴械投降放弃了Compiler。
编译的过程搞不定,至少还可以研究下执行的过程,这个虚拟机总是要对每一条指令进行解析的,如果我能搞懂所有的指令,那么岂不是就可以针对这些指令相应的生成高级语言代码！
0x03 起步
第一天的假期就这么过去了,我失去了很重要的一天,但是我想了想,剩下来还有四天,挤一挤还是可以完成原来的计划的。于是我决定第二天继续搞这个东东。
在第一天的夜里,我躺在床上的时候,突然就想到其实我完全可以不必这么纠结,我完全不需要做一个像C#反编译工具那么牛逼哄哄的工具出来,如果开发一个功能完整的工具有困难,那么我就从最简单的开始。于是我决定先不考虑函数调用,系统调用,合约调用等等复杂操作。从最简单的逻辑代码逆向开始。
于是第二天我终于开始敲代码了,我的第一步是把李总的对AVM解析的TS项目迁移到C#上来。至少让我的项目可以输出点东西。这个工作纯粹是搬砖,把李总的ts代码拿过来改成C#,然后加上文件读写和解析,到真正能运行的时候,宝贵的上午已经过去了。于是我又遇到了瓶颈。
如何使用这些SAM呢？我开始趴在桌子上抓头发,由于我本人没有反编译工具开发的经验,所以能凭借的只有大二学计组时学到的逆向和系统知识以及NEOVM的源码。所以我最后决定,把NEOVM整合到我的反编译工具里,具体来说,就是模拟合约执行的过程。
由于我在这个模拟的过程中需要定义新变量以及追踪变量在堆栈中的执行过程,所以我不能使用NEOVM本身自带的类型也好执行栈也好的所有整套逻辑。大刀阔斧的删掉所有我不能用的文件之后,NEOVM还剩下一个ExecuteEngine。
好吧,完美,于是我重新定义合约的方法类用来存储合约里的函数,重新定义执行栈的元素用来存储合约执行过程中对堆栈读写的变量。再然后就是对NEO的指令进行一对一的解析和翻译。
0x04 小成
这个时候其实已经第二天的夜里了,由于我在的城市夜里很不安全,我决定先回家。于是第三天,莫名的力量诱使着我：“只是稍微看一小会,稍微优化一点点,然后就开始做作业。”
为了研究NEO的指令,我首先写一个空的合约,编译之后记录SAM, 然后再定义一个简单变量并赋值,再记录SAM,如此反复,然后反复对比不同版本的合约和相应的SAM,再对照着NEOVM的解析代码来仔细研究每一个指令的执行原理。同理研究函数调用过程。
等到对这些指令大概熟悉之后,开始对每一个指令进行解析翻译。
由于在NEO中,每一个函数都是以指令RET作为结束标志符,而且这个指令不会在别的地方出现,因此我以RET为标记来获取每一个函数的指令并保存在NEOMethod对象中。函数的名字由sub_ 前缀加上函数首地址,Main函数总是在合约的第一个,所以很容易获取合约入口,Main函数将仍旧以Main命名。
函数调用的指令是CALL,后面跟着目标函数的地址偏移,因此只要计算出目标地址的位置,就可以直接获取到目标地址的名称。此处有个问题就是函数的参数以及返回值,这个问题我还没有想到好的解决方案。
在合约执行过程中,每一个会进入堆栈的变量都会有一个名字,变量起名的规则是由一个variable_count来记录当前函数的变量个数,然后在前面加上v_ 作为变量标记符。此外,由于有些变量可能只会用一次,我对每一个变量的引用次数进行记录,在合约解析完成之后,那些只用了一次的变量将会被移除。
系统调用是️虚拟机提供的那些接口,这些系统调用直接就是接口的名字,因此我们可以通过字符串匹配来知道合约在调用哪一个接口。在反编译工具中,我对NEOVM提供的每一个接口都进行了整理,记录了他们需要的参数数量以及输出的参数数量,因此当解析到SysCall的时候,就可以直接翻译为指定的系统调用并添加输入和输出。
其实以上已经是两天的工作量了,没错,五天的假期已经被我一时冲动消耗掉了四天。希望最后一天我能即写完作业又看得完文档还做的了ppt完得成实验。
项目地址： https://github.com/Liaojinghui/NEODecompiler
欢迎有兴趣的小伙伴和我一起完成这个项目。 最后是反编译的演示结果：
合约源码： public static void Main() { int a = 2; string aa="hello"; string bb = "world"; string cc = aa + bb; // uint b = Blockchain.GetHeight(); }
反编译结果： 00 static void Main(string[] args) { 01 Array v_array_0 = new Array(5); 04 byte[] v_array_1 = new byte[]("hello "); 11 v_array_0[0] = v_array_1; 12 byte[] v_array_2 = new byte[]("world"); 1e v_array_0[1] = v_array_2; 26 v_array_0[2] = 0; 27 Jump 49 2f v_array_1 = v_array_0[0]; 34 v_array_2 = v_array_0[1]; 35 v_array_1 = v_array_1 + v_array_2 // (hello world) 3c v_array_0[3] = v_array_1; 42 int v_int_0 = v_array_0[2]; 44 v_int_0 = 1 + v_int_0; 4b v_array_0[2] = v_int_0; 50 v_int_0 = v_array_0[2]; 52 bool v_bool_0 = v_int_0 < 10; 59 v_array_0[4] = v_bool_0; 5e v_bool_0 = v_array_0[4]; 5f Jump 27 } 00:PUSH5 01:NEWARRAY 02:TOALTSTACK 03:NOP 04:PUSHBYTES6[0x68656c6c6f20] (hello ) 0b:FROMALTSTACK 0c:DUP 0d:TOALTSTACK 0e:PUSH0(false) 0f:PUSH2 10:ROLL 11:SETITEM 12:PUSHBYTES5[0x776f726c64] (world) 18:FROMALTSTACK 19:DUP 1a:TOALTSTACK 1b:PUSH1(true) 1c:PUSH2 1d:ROLL 1e:SETITEM 1f:PUSH0(false) 20:FROMALTSTACK 21:DUP 22:TOALTSTACK 23:PUSH2 24:PUSH2 25:ROLL 26:SETITEM 27:JMP[37] 2a:NOP 2b:FROMALTSTACK 2c:DUP 2d:TOALTSTACK 2e:PUSH0(false) 2f:PICKITEM 30:FROMALTSTACK 31:DUP 32:TOALTSTACK 33:PUSH1(true) 34:PICKITEM 35:CAT 36:FROMALTSTACK 37:DUP 38:TOALTSTACK 39:PUSH3 3a:PUSH2 3b:ROLL 3c:SETITEM 3d:NOP 3e:FROMALTSTACK 3f:DUP 40:TOALTSTACK 41:PUSH2 42:PICKITEM 43:PUSH1(true) 44:ADD 45:FROMALTSTACK 46:DUP 47:TOALTSTACK 48:PUSH2 49:PUSH2 4a:ROLL 4b:SETITEM 4c:FROMALTSTACK 4d:DUP 4e:TOALTSTACK 4f:PUSH2 50:PICKITEM 51:PUSH10 52:LT 53:FROMALTSTACK 54:DUP 55:TOALTSTACK 56:PUSH4 57:PUSH2 58:ROLL 59:SETITEM 5a:FROMALTSTACK 5b:DUP 5c:TOALTSTACK 5d:PUSH4 5e:PICKITEM 5f:JMPIF[-53] 62:NOP 63:FROMALTSTACK 64:DROP 65:RET

「深度学习福利」大神带你进阶工程师,立即查看>>>
区块链是一个去中心化的系统,每个节点分布在全球各地,那么节点之间是如何自发地组成网络,又如何进行通信的？区块链中的p2p网络算法与bt下载中的p2p网络有什么区别？ 11月28日,第29期技术工坊邀请离子链首席架构师吴寿鹤为大家分享区块链中的P2P网络。
1
时间地点
**时间：**11月28日 18:30 -  21:00
地点 ：（上海徐汇）上海市市辖区徐汇区龙华中路596号A308室
线下分享+交流  9.8元/人
参会人员要求：
1） 技术背景人员,对区块链开发有兴趣；
2） 活动限额15人,报满截止。
2
活动流程
18:30-19:30  签到,自我介绍
19:30-20:30  区块链中的P2P网络
20:30-21:00  互动交流
3
分享主题及嘉宾
分享主题：区块链中的p2p网络
分享大纲：
1、p2p中的三层模型
2、DHT数据结构
3、DHT table更新流程
4、节点之间的加密通信
5、以太坊节点的通信协议
分享嘉宾：吴寿鹤
离子链首席架构师,区块链兄弟联合创始人,区块链技术&安全加密专家；HyperLedger核心开发人员；2014年开始从事区块链开发；参与出版了《区块链开发实战-以太坊关键技术原理分析》、《区块链开发实战-Hyperledger关键技术原理分析》等多本区块链书籍的编著。
4
报名方式
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>>
“以太坊是一个分布式的计算平台。它会生成一个名为Ether的加密货币。程序员可以在以太坊区块链上写下智能合约,这些以太坊智能合约会根据代码自动执行。”“智能合约是在以太坊虚拟机上运行的应用程序。这是一个分布的“世界计算机”,计算能力由所有以太坊节点提供。提供计算能力的任何节点都将以Ether数字货币作为资源支付。”以太坊和智能合约的概念大家已经很清楚了,但是更深入的问题还需要学习,比如以太坊的开发语言solidity到底有什么特点？交易数据里data字段的编码规则是怎样的？以太坊的数据结构、底层存储方式是什么？如何进行智能合约编译？等。 本期技术工坊以太零研发团队技术总监钟瑞仙老师将以具体的项目实践和使用场景为基础,带领大家探索以太坊智能合约的深度应用和底层实现 。
1
时间地点
**时间：**11月22日 19:00 -  21:30
地点 ：深圳市南山区宝深路科陆大厦A座 8层
线下分享+交流  9.8元/人
参会人员要求：
1） 技术背景人员,对区块链开发有兴趣；
2） 活动限额30人,报满截止。
3） 自带电脑
2
活动流程
19:00-20:00  签到,自我介绍
20:00-21:00  深度探索以太坊智能合约 
21:00-21:30  互动交流
3
分享主题及嘉宾
分享话题：深度探索以太坊智能合约
简介：以具体的项目实践和使用场景为基础,探索以太坊智能合约的深度应用和底层实现 。
大纲：
1）solidity中bool类型和byte32类型谁占用的内存空间更大？
2）交易数据里data字段的编码规则
3）以太坊账户在底层存储的数据结构
4）智能合约属性的底层存储方式
5）智能合约复杂数据类型的编码处理
6）预编译合约介绍及汇编调用方法
分享嘉宾：钟瑞仙
以太零研发团队技术总监
十余年编程开发和网络安全防御经验,从事游戏行业多年,以太坊早期开发者,专注以太坊底层实现和DAPP应用,现任以太零研发团队技术总监,实现了以太零公链的MPOS共识算法及零手续费的Power防御机制。
4
主办方及合作伙伴

5
报名方式
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>>
北京路演
布洛克科技报道
布洛克科技按：11月9日,Echoin能源公链生态私享交流酒会在北京成功举行。FBG资本、创世资本、国金投资、OK Blockchain Capital、Block VC、引力资本、JRR Crypto、 Achain、布洛克资本、镜湖资本、Hayek Capital（排名不分先后）,以及Echoin合作伙伴车主邦、Cybermiles均到场参与交流。

11月9日,Echoin能源公链生态私享交流酒会在北京成功举行。FBG资本、创世资本、国金投资、OK Blockchain Capital、Block VC、引力资本、JRR Crypto、 Achain、布洛克资本、镜湖资本、Hayek Capital（排名不分先后）,以及Echoin合作伙伴车主邦、Cybermiles均到场参与交流。
“能源互联网”是未来能源产业的趋势,Echoin面向能源生态经济是先行之师, Echoin能源公链深耕技术,扎根能源生态市场,结合车主邦线下覆盖的19万根充电桩与3000+加油站,车主邦庞大精准的用户基础为Echoin能源公链的冷启动提供了有效的保障。
另一重要战略合作伙伴——全球最大的电力提供商之一法国电力,在全球拥有4300万用户,电力网络线路绵延130余万公里,与Echoin能源公链达成了为期三期的主网微电网并网的解决方案,目前一期顺利完成,合作开发的APP等基础软件已经上线。
会后的晚宴时间,对于Echoin能源公链表现出兴趣的各资本方展开了热烈的讨论。在一片欢笑声中,首届Echoin私享项目交流酒会圆满落下帷幕。


创新永远是历史更迭变化的主旋律,Echoin团队不会忘记,在一年前团队初创之际,投资人的对Echoin能源公链的要求：“搭好公链、完备服务、切实落地。”
Echoin团队负责人说道：“我们希望Echoin能源公链未来不仅仅是为车主邦、法国电力这样的顶级能源供应商提供服务,我们希望,未来广阔的能源交易市场,都能够接入Echoin能源公链,实现能源互联共通。”在能源公链的技术道路上,Echoin正在一步一个脚印,以坚实的姿态稳步前行,让我们拭目以待。
一号财经
上海路演

「深度学习福利」大神带你进阶工程师,立即查看>>>
2017年是加密货币热潮令人难忘的一年。从那时起到现在世界没有任何改变,但今天我们对加密货币仍然很兴奋。乐观主义者认为,比特币将从根本上改变世界各地的支付,经济甚至政治。最乐观的支持者甚至开始抵押他们的房子以购买比特币。悲观主义者声称比特币是一个泡沫,不可避免地会遭遇崩盘。无论比特币发生什么,支持加密货币的技术仍将是真正的结构转型,可能会像20年前的互联网成为影响这个世界的发展一种方式。
每种加密货币都在某种技术下运作。将来哪一个会名列前茅？它们是否会共存并作为完全不同的系统运行？要回答这些问题,有必要深入研究这个问题。那么,Blockchain(区块链)和Tangle(纠缠)究竟是什么？
区块链是加密的分布式数据存储网络,其中信息被添加到区块链并存储在块中。简而言之,它是一个块链。所有块都相互链接。每个块包含多个交易。这些交易由块高标识,这使得查找和识别特定交易变得容易。它增加了安全性,因为为了更改特定交易,你还必须更改前面块中的信息。
在Tangle,有一个完全不同的场景。Tangle是IOTA开发人员的新概念。他们想要创建一个没有采矿,没有交易费用且速度快的解决方案。在Tangle中,交易相互关联,就像一个大的网络纠缠在一起。没有块的概念。该技术本身基于有向Acylic图。DAG是有向图,由有限数量的边和顶点组成。在这种架构中,你永远无法回到你前面的同一个顶点。在Tangle中,你无需等待块开采。交易几乎会实时进行验证,一次可以提供更快的交易速度和更多的交易。
像比特币,以太坊,莱特币等与区块链更相关,Tangle与IOTA相关联。IOTA的标语为 Next Generation Blockchain ,是日益拥挤的加密货币领域的最新竞争者之一。与微软,富士通和其他几家公司合作,IOTA认为自己是第一个由物联网提供支持的市场。
在比较Tangle和Blockchain时,有许多不同之处,因为它们是基于相同原理构建的两个完全独特的架构。

普通区块链无法调整为免费结算,因为费用被设计为对矿工的货币激励,从而作为对网络的保护。这很重要,因为应用领域（如比特币）通常位于金融系统中以取代货币（$,€）。很明显,比特币和几乎所有其他加密货币都没有以这种免费的方式运作。考虑到在不久的将来每天会有数十万nano-payments,这些区块链仅用于进行交易就将产生大量费用,而这些nano-payments通常成本甚至都低于要付的费用。
在这些术语中,在Tangle网络上运行的IOTA有更多的机会,因为当量子时代到来时,它在量子计算机环境中的可交易量,成本和安全性都更好。
你如何看待Tangle和Blockchain的未来？
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 Blockchain(区块链)和Tangle(纠缠)哪一个是未来？

「深度学习福利」大神带你进阶工程师,立即查看>>>
在比特币的简史中,它已经从一种不受管制的非法活动货币转变为一种合法便捷的全球商业促进者。当然,加密货币受到无数因素的影响,这些因素共同使其成为世界上最难以预测的货币之一。但是,尽管存在这种不确定性,每天仍有超过30万笔比特币交易正在发生,而且数字仍在增长。
今天,比特币显然远远超过八年前Satoshi Nakamoto所设想的点对点（p2p）现金系统。全球计算机网络每隔一分钟就会挖掘新的比特币,电子商务网站正在蓬勃发展,甚至像特斯拉和维珍银河这样的大型实体公司也开始接受比特币作为支付方式。
也就是说,比特币以及加密货币作为一个整体,相对仍处于采用的早期阶段,它正在不断进化。虽然加密货币有望成为未来的通用货币,但更有希望的趋势似乎是去中心化的应用程序（Dapps）。
随着加密货币在未来几年成为常态,专家们假设点对点应用程序将在用户基础上超越全球最大的软件公司,公用事业和网络公司的估值,因为它们具有出色的激励结构,透明度,弹性和灵活性,以及分布式的特性。
Dapps的出现
远见者描述了一个完全去中心化的世界,在这个世界中,管理数字网络的中央机构的是不存在的,并且每一点沟通或交易都直接发生在两方之间。理想情况下,这描绘了一个社会,其中在线应用程序,网站和实用程序不需要中介来运行,甚至创建系统的实体也不能控制用户信息。
当然,利用这一发人深省概念的第一项创新是比特币而且它是开源的,点对点的,加密存储记录——通常称为区块链。然而,开发人员开始掌握更大的图景并不需要很长时间。比特币模型让互联网用户可以完全控制他们如何交换金钱,而不仅仅是数字数据。互联网如何实现对数据交换的控制？你猜对了,通过与Dapps交互。
什么是Dapp？
去中心化应用程序是一种新型的基于互联网的软件程序,旨在以不受集中式机构控制的方式存在,就像加密货币一样。然而,虽然密码提供了一种去中心化的交换价值模式,但Dapps实现了超越货币交易的功能。
目前,存在许多去中心化的应用程序,虽然有些应用程序使用自己的区块链,但大多数已采用现有的区块链技术并将它们与自己的代币集成在一起。但是,无论哪种类型,只有符合以下条件,应用程序才会被视为Dapp。
1.完全自治
应用程序必须是开源的,这意味着任何一个实体都不能控制其大部分代币,数据和记录。此外,Dapp需要将其数据加密存储在去中心化的且可公共访问的区块链中,而不是集中式私有服务器以避免出现故障点。
2.代币生成
应用程序必须按照标准算法生成代币（称为App Coins）,如果可能,在其操作开始时分配其中一些代币。Dapps的设计使得指定的数字代币需要使用该应用程序,并且提供给用户的任何奖励仅通过代币完成。用于生成代币的算法充当应用程序用户的价值证明。
3.多数人管理
Dapp可以采用协议来响应建议的更改或改进以及市场反馈,但在进行任何更改之前,必须通过其用户的多数共识达成一致。如果不将建议的更改达成共识,任何人都无法更改应用程序的数据或记录。
比特币怎么作为Dapp
通过使用点对点分发,比特币已经证明自己是传统金融系统中许多问题的有效解决方案,包括买方/卖方验证,国际汇款和防止欺诈。
比特币被广泛认为具有向世界开放去中心化应用的可能性。它不仅是第一个加密货币,也是第一个Dapp。
作为一个去中心化的应用程序,比特币的所有资源都是开源的,这意味着任何实体（公司,组织或政府）都无法控制比特币。与使用加密货币相关的一切都是开放和公开的。因此,任何人都可以开采,存储和分发比特币。
此外,比特币模型使用标准算法生成token,即比特币,即哈希码工作证明（PoW）功能,除非得到其用户的多数共识的批准,否则无法更改。这些token是比特币运作所必需的,系统的任何贡献者（矿工）都会获得奖励。
比特币dapp革命
比特币已经存在了一段时间,但与所有Dapps一样,它仍处于早期开发阶段。Dapp领域作为一个整体有雄心勃勃的开发者有很多机会可以利用,而这种开发进步的速度证明去中心化的未来并不是遥遥无期。
现在,如果你愿意,你可以选择淡化去中心化应用程序的重要性,特别是考虑到许多人不知道（或关心）互联网如何工作这一事实,只要它有效。但是,以这种方式思考：我们每天最常使用的应用程序和网站完全由全球主要公司控制,这些公司的动态可能会在一夜之间发生变化。想象一下醒来发现你不能再在亚马逊上购物,因为Jeff在推特上把总统骂的太过分了,或不能登陆雅虎,因为它们的很多事情并没有与新老板谈妥。
去中心化应用程序开发将这种权力从公司转移到应用程序的用户,就像比特币从政府和金融机构取得货币控制权一样,并将其提供给加密货币的所有用户。
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 把比特币看作是Dapp怎么样？

「深度学习福利」大神带你进阶工程师,立即查看>>>
当把智能合约部署到Rinkeby Test Network时,需要获得测试以太币。其网络获取测试以太币的方法同Ropsten Test Network有些不同,本文详细讲解一下。
1
访问网站
访问rinkeby网络（ https://www.rinkeby.io/#faucet）,提示获取测试币需要有在Twitter、FaceBook、google+等上发布消息,并将消息的网址粘贴到上面截图的输入框中选个获取就可以。
如果你不能访问该网站和其中提及的社交网站,请选择科学上网吧,本文不再解释。
充值提示
2
在GOOGLE PLUS网站发布文章
1）访问 https://plus.google.com/,完成GOOGLE账号的注册或者登录。
访问网站
2）发布一篇文章,内容需要包含你期望充值的以太坊地址。
文章
3）公开分享后获取其文章地址
公开分享
其地址为： https://plus.google.com/104242392040236476231/posts/G2wnV7Saqqr
3
在rinkeby网站输入GOOGLE文章链接
在rinkeby充值栏输入GOOGLE地址,选择充值金额,例如3ETH / 8 hours,会有充值弹窗提示。
查询下MetaMask的账号,这个测试代币就到账了。
这个网站不允许一天内同一个社交账号多次申请测试代币,否则会有告警提示。
充值失败提示
至此,如何获得Rinkeby网络的测试以太币的方法讲解完毕。总体而言,不如ROPSTEN获取代币方便。 本文作者：HiBlock区块链技术布道群- 辉哥
原文发布于简书
加微信baobaotalk_com,加入技术布道群

「深度学习福利」大神带你进阶工程师,立即查看>>>
1
活动基本信息
1）主题： 【区块链技术工坊22期】BANCOR算法详解及代码实现
2）议题： BANCOR算法的特点和优劣势 BANCOR算法和举例 如何加入BANCOR.NETWORK交易所 如何开发自己的BANCOR去中心化交易平台？
3）嘉宾：
王登辉
创业股平台 CTO,尖晶技术赋能中心副总经理, HiBlock区块链社区上海合伙人,电子科技大学硕士毕业, 10年华为/中兴 产品.研发经验,深耕区块链应用。
4）活动定位
由HiBlock、创业股平台和兄弟区块链社群共同主办的区块链技术工坊,深度分享区块链知识,实现小会技术交友。区块链技术工坊坚持4F原则： Frency - 每周三晚上一次； Focus - 聚焦区块链技术分享； Fun - 20人以内会前做自我介绍,分享有深度的技术内容,技术交友； Feedback - 会后有活动总结和合影照片。
2
分享实录

目前小规模通证交易痛点： 数字货币市场形成长尾效应,缺乏流动性,无法形成成交。 交易所上币成本高,项目方容易被收割,新代币在交易所上币是需要一笔不小的启动费用的。 交易存在暗箱操作可能,用户容易被收割
没有对手风险,所有的交易都是人机交易,买家不需要去找卖家,卖家不需要去找买家,交易信息公开透明。 不同于中心化交易所的撮合定价,BANCOR协议的定价是根据真实供需公式定价公开透明可预测； 没有竞价这个环节,不依赖流动性。刷单,刷交易量,刷净流入,净流出等操作都是无意义的。
轻松创建 Token
Bancor 使创建数字资产变得更容易,解放用户生成 Token 的巨大潜力。这些token 还提供便宜的访问服务,这些服务之前都是很昂贵的,或者其他方式无法访问的。
模块化工具包
Bancor 协议建立了唯一的标准从而使多种应用场景变得可能。由于智能代币能够将其他智能代币作为储备,它们可以被用来作为新的金融,银行或其他货币解决方案的模块,这些模块能够向它们自己乃至整个生态系统传递价值。
嵌套估值
通过在储备中持有一个预先存在的代币,智能代币与相关资产有一个预先的估值。因此,由于与这些预先储备的代币的联系,智能代币的建立,或直接或间接的与更大的价值相连接（这些预先存在的代币所代表的价值）。生态系统的长期演变是开放的,对于 Bancor 协议来说,网络可能会设定它们对投机或波动性的偏好。
互联的框架
通过帮助一些非常小的实体和网络在无须牺牲个体独特性的前提下共享和交换资源,智能代币使它们连接成一个更大的网络。
连续流动性
用户总能通过智能合约在网络中直接购买或出售代币,即便市场中只有很少或者没有其他买家或卖家。因为价格会根据兑换规模进行调整,所以总可以使用特定价格来兑换代币。Bancor 协议有效地使得流动性与交易量脱钩。
没有内置手续费
默认情况下,智能代币不会对它们执行的兑换收取费用。用户承担的唯一费用是处理下层区块链易所需的费用（例如,以太坊的 gas）。虽然智能代币的发行者可能为通过他们的特定智能代币进行的兑换设定可选的使用费（称为捐赠）。
Bancor 协议不会为了获取运营利润而收取兑换费用,而是从代币网络的扩展以及用户数量的增长中获利。
可调整的价格敏感度
大量连接器余额和高权重的带来的影响,是使得智能代币价格对大宗交易导致的短期投机和价格波动更不敏感。例如,一个 CW 为 10%的智能代币,相当于交易所里一个占代币市值 10%的订单。这种灵敏度可以通过 CW 和连接器余额进行调整,以实现特定智能代币的预期配置。
没有价差
Bancor 公式在处理买单和卖单时使用同样的价格计算方法。这与传统交易所不同,传统交易所的买入价格总是低于卖出价格。买卖价差,即所谓的价差,是传统的做市商赚取利润的原因。如上所述,Bancor 协议不会为了运营而获得这种利润,另外为了鼓励采用该网络,可能会引入去中心化的价差,从而使所有参与者受益。
价格可预测
智能代币的价格算法是完全透明的,允许用户在执行兑换之前预先计算他们想要兑换的有效价格。这与传统的以订单为基础的交易所形成了鲜明对比,在传统交易所,大量订单可能导致价格不可预测地下滑至明显不同的水平。
兼容 ERC20
智能代币是与 ERC20 兼容的代币（尽管具备额外的功能）,它们与现有的代币应用程序（如钱包或 DApp）无缝集成,因为它们符合流行的 ERC20 代币标准。此外,任何现有的 ERC20 标准代币都可以通过带有连接器的智能代币连接到Bancor 网络,这使得 Bancor 协议向后兼容现有的 ERC20 代币。
单点失效 对于 Bancor 协议建立的去中心化交易所,都是用代币合约来处理交易。虽然说明面上是去中心化交易所,但是需要在合约中设立超级管理员权限。当有账户存在超级管理员权限时,整个代币生态极容易发生单点失效。超级管理员权限是把双刃剑。在 Bancor 事件中,黑客利用了管理员权限盗取代币,而项目方也正利用了管理员权限来降低损失。不过我们认为,开发者依然可以通过良好的代码设计来降低代币和协议合约对管理员的依赖。 牺牲交易深度 Bancor 协议的问题是价格曲线调节参数完全受项目方控制,参与而且鼓励价格投机,越早买入的人越容易获利。买盘能够推高价格,同时买盘也会降低价格,一旦曲线上升停滞容易发生「踩踏」造成较大的波动。所谓牺牲深度带来流动性。 参数被操控问题 Bancor 算法根据参数 CW 的不同,以及构造关系不同,会产生不同的数学图形,或杠杆效果。比如常见的四类图形,如 3.2.2 节 4 张图所示。市场对价格变化的预期几乎完全基于 CW,因为它决定了价格曲线。那么如果项目中途改变 CW 参数呢？RAM 和 FIBOS 项目都发生过这一的情况,只不过一个是简单粗暴,一个是有其他参数配合的「合理解释」的。这类风险也是目前 Bancor 协议投资者面临的最大风险。

BANCOR的基本计算公式
计算公式涉及多个参数,解释如下： Token的供应量【Smart Token's Supply】,简称Supply； Token的价格【Smart Token's Price 】,简称Price； Token的总市值【Smart Token's Total Value】,简称TotalValue； 储备金余额【Connector Balance】,简称Balance； 储备金固定比率【Connector Weight】,简称CW。
计算公式如下： CW = Balance / TotalValue = Connector Balance / Smart Token's Value; TotalValue = Price * Supply = Smart Token's Price * Smart Token's Supply ; Price = Balance /（Supply * CW）= Connector Balance / (Smart Token's Supply * Connector Weight)
举例：若当前AToken的发行量为1000,报价为0.5个ETH兑换1个AToken,那么AToken的总价值为500个ETH,但是储备金余额可能并没有500个ETH,比如为250个ETH,那么CW则为0.5（50%）。

Token买入计算公式： Token_Return = Supply *（（1 + ETH_Paid / Balance）^ CW - 1）
举例：若当前AToken的发行量为1000,储备金余额为250个ETH,CW为0.5,那么当前的报价则为0.5个ETH兑换1个AToken；现在Bob想花750个ETH购买AToken,带入公式：Token_Return = 1000 *（（1 + 750 / 250）^ 0.5 - 1）= 1000
即Bob花了750个ETH购买了1000个AToken,本次购买的平均价格为0.75个ETH兑换1个AToken,比初始报价已经高了许多。Bob的购买行为推高了AToken的报价。若Bob接着购买同样数量的AToken,则需要付出更多的ETH代价,每一笔购买都会继续推高AToken的报价。
Token卖出计算公式： ETH_Return = Balance *（1 - （1 - Token_Paid / Supply）^ （1 / CW））
举例：在Bob的那笔交易完成后,AToken的发行总量为2000个,储备金余额为1000个ETH,CW维持不变、仍然为0.5,那么通过公式可以计算当前的报价为1个ETH兑换1个AToken；现在Alice想卖掉1000个AToken,带入公式：ETH_Return = 1000 *（1 - （1 - 1000 / 2000）^ （1 /0.5））= 750
即Alice 卖掉了1000个AToken,获得了750个ETH,本次购买的平均价格为0.75个ETH兑换1个AToken。因为Bob的购买行为推高了AToken的报价,而Alice是在Bob的购买行为之后卖掉了AToken,所以Alice卖到了相对较高的价位。假如没有Bob的购买行为,回到AToken的供应量为1000的那个时候,Alice卖掉全部的AToken,也只能获得250个ETH。

网址： https://www.bancor.network/communities/5a174bc0171b0100018276b3/currency

核心点为需要存入10万美元等值的BNT智能代币。

1000个CLOB可以兑换多少个TKN1？ SmartTokenAmount = SmartTokenTokenSupply *（（1 + ConnectorToken / ConnectorTokenBalance）^ CW - 1）�= 1000 * (( 1 + 1000 / 90000 )^ 0.9 - 1 )�=?9.99446694706181297191051400502(个TNK1)

9.994466947个TKN1可以兑换多少个ETH呢？
connectorTokenAmount = ConnectorTokenBalance *（1 - （1 - SmartTokenAmount / SmartTokenTokenSupply）^ （1 / CW） ） connectorTokenAmount = 10 * （1 - （1 - （9.994466947 / (1000 + 9.994466947)))^ （1 / 0.1） ）�= 10 * （1 - （1 - （9.994466947 / (1000 + 9.994466947)))^ （1 / 0.1） ）�= 10 * （1 - （1 - （0.00989556603929837667128805564395))^ （1 / 0.1） ）�= 10 * （1 - （1 - （0.00989556603929837667128805564395))^ （1 / 0.1） ）�= 10 * （1 - 0.99010443396070162332871194435605 ^ 10 ）�= 10 * (1 - 0.90533655025365121589722721359431)�=?0.94663449746348784102772786405694(个ETH) 兑换结论：1000个CLB可以兑换0.946个ETH 按照假设的市价,两者的价值均为1000元左右,符合期望。
省略运行部分。
参考记录文章： BANCOR学习：如何开发自己的BANCOR去中心化交易平台？ 【白皮书】 Bancor协议：通过智能合约为加密货币提供持续流动性 (附PDF下载) 【易错概念】 以实例形式深入浅出讲透BANCOR算法 基于以太坊的交易所BANCOR算法实现-转换算法框架 如何从BANCOR交易所兑换ENJIN通证： https://www.jianshu.com/p/617103393dc6
本次活动照片：
本文作者：HiBlock区块链技术布道群- 辉哥
原文发布于简书
整理：Ella
加微信baobaotalk_com,加入技术布道群
下期活动预告：

「深度学习福利」大神带你进阶工程师,立即查看>>>
1
摘要
在以太坊上,代码即法律,交易即金钱。每一笔智能合约的运行,都要根据复杂度消耗一笔GAS费(ETH)。那么,智能合约solidity语言的编写,不仅要考虑安全,也要考虑语言的优化,以便高效便宜了。
本文将从以下一些方面分析如何节约GAS的编程总结：
1）如何在REMIX编译器上分析GAS/GAS LIMIT等信息 2） 如何优化节省GAS费用的方法 创建合约优化 存储优化 变量排序优化 交易输入数据优化 转账优化 部署合约优化 调用合约函数的成本优化
2
如何在REMIX编译器上分析GAS/GAS LIMIT等信息
如果你想了解以太坊的账户、交易、Gas和Gas Limit等基本概念信息,可以阅读文章《 以太坊的账户、交易、Gas和Gas Limit 》。
如果你不了解以太坊智能合约语言solidity编译IDE环境REMIX,可以阅读文章《 Solidity语言编辑器REMIX指导大 全》。
本章节聚焦在如何通过REMIX编译器查看GAS/GAS LIMIT等信息。
2.1 简单智能合约样例
以太坊指令执行主要依靠GAS。当你执行智能合约时,它会消耗GAS。所以,如果你正在运行一个智能合约,那么每一条指令都要花费一定数量的GAS费。这有两个因素,即您发送的GAS数量和总区块GAS上限（a total block gas limit）。
举例来说,一个简单的智能合约,有一个保存无符号整数256值的函数。 合约代码如下： pragma solidity ^0.4.19; contract A {    uint b;    function saveB(uint _b) public {        b = _b;    } }
如果你将此合约复制并粘贴到Remix（ http://remix.ethereum.org/）中,则可以运行此合约。通过MIST或来自网站的MetaMask与此合同进行交互的方式类似。
让我们运行saveB（5）并查看日志窗口中发生的情况：
这儿有3个我们感兴趣的值: GAS总量( "gas limit")： 3,000,000 交易费用 ("transaction cost"): 41642 gas 执行费用( "execution cost"): 20178 gas.
2.2 发送的GAS总量(Gas limit)
这儿显示的"Gas limit"是发送的GAS总量,Value是发给目标地址的ETH值。这2处的值可以被发送交易的用户修改。
2.3 交易成本（Transaction Cost）
交易成本,在Remix中显示,是实际交易成本加上执行成本的混合。我认为,这儿看起来有点误导。
如果您使用数据字段发送交易,那么交易包含一个基本成本和每个字节的附加成本（GAS计价）。看看以太坊黄皮书（ https://github.com/riversyang/ethereum_yellowpaper）的附录列出了每种的GAS费用：
一起来看看41642的交易成本是如何结合在一起的。这是Remix在交易中自动发送的数据字段：
input_remix
这儿是 Data-Field: > 0x348218ec0000000000000000000000000000000000000000000000000000000000000005
数据字段是散列函数签名的前4个字节和32字节填充参数的组合。我们快速手动计算。
函数签名是saveB(uint256),如果我们用SHA3-256（或Keccak-256）散列函数,那么我们得到：348218ec5e13d72ab0b6b9db1556cba7b0b97f5626b126d748db81c97e97e43d
如果我们取前4个字节（提醒：1个字节= 8位= 2个十六进制字符.1个十六进制字符= 4 bit = 0-15 = 0000到1111 = 0x0到0xF）,然后我们得到348218ec。让我们0x在前面添加,我们得到0x348218ec。参数是一个256位的无符号整数,即32个字节。这意味着它将整数“5”填充到32个字节,换句话说,它将在数字前面添加63个零： 0000000000000000000000000000000000000000000000000000000000000005。
从以太坊黄皮书上可以获得参考： 每笔交易都有21000 GAS支付 为交易的每个非零字节数据或代码支付68 GAS 为交易的每个零字节数据或代码支付4  GAS
计算一下： 348218ec 是4个字节的数据,显然是非零的。 0000000000000000000000000000000000000000000000000000000000000005是31个字节的零数据和1个字节的非零数据的混合。
这使得总共5个字节的非零数据和31个字节的零数据。 (5 non-zero-bytes * 68 gas) + (31 zero-bytes * 4 gas) = 340 + 124 = 464   gas
对于我们的输入数据,我们必须支付464 GAS。除此之外,我们还要支付 21000 GAS,这是每笔交易支付的。因此总共需要21464用于交易。 让我们看看是否会增加。
Remix称“交易成本”为41642  gas,“执行成本”为 20178  gas。而在Remix中,“交易成本”实际上是交易成本加执行成本的总和。因此,如果我们从交易成本中减去执行成本,我们应该得到21464 gas。
41642 (交易成本”) - 20178 (执行成本) = 21464   gas
剩下的结果21464   gas为数据交易成本,同上计算公式。
2.4 执行成本(Execution Cost)
执行成本有点难以计算,因为发生了很多事情,辉哥试着告诉你合同执行时到底发生了什么。
让我们深入了解实际的事务并打开调试器。这可以通过单击事务旁边的“调试”按钮来完成。
可以打开指令折叠菜单和单步调试菜单。你将看到每一条指令以及每个指令在该特定步骤中花费的GAS费用。
这里看到的是所有以太坊汇编指令。因此,我们知道Solidity可以归结为EVM Assembly。这是矿工实际执行的智能合约运行看起来的实际情况。来看看前两个指令：
PUSH1 60 PUSH1 40
这意味着除了将值60和40推入堆栈之外别无其他。显然还有很多事情要做,你可以通过在单步调试器中移动蓝色滑块来完成它们的工作。
根据以太坊黄皮书将每个指令所需的确切气体量汇总在一起,以便将值5写入存储： GAS Instruction 3   000 PUSH1 60 3   002 PUSH1 40 12  004 MSTORE 3   005 PUSH1 04 2   007 CALLDATASIZE 3   008 LT 3   009 PUSH1 3f 10  011 JUMPI 3   012 PUSH1 00 3   014 CALLDATALOAD 3   015 PUSH29 0100000000000000000000000000000000000000000000000000000000 3   045 SWAP1 5   046 DIV 3   047 PUSH4 ffffffff 3   052 AND 3   053 DUP1 3   054 PUSH4 348218ec 3   059 EQ 3   060 PUSH1 44 10  062 JUMPI 1   068 JUMPDEST 2   069 CALLVALUE 3   070 ISZERO 3   071 PUSH1 4e 10  073 JUMPI 3   074 PUSH1 00 3   076 DUP1 1   078 JUMPDEST 3   079 PUSH1 62 3   081 PUSH1 04 3   083 DUP1 3   084 DUP1 3   085 CALLDATALOAD 3   086 SWAP1 3   087 PUSH1 20 3   089 ADD 3   090 SWAP1 3   091 SWAP2 3   092 SWAP1 2   093 POP 2   094 POP 3   095 PUSH1 64 8   097 JUMP 1   100 JUMPDEST 3   101 DUP1 3   102 PUSH1 00 3   104 DUP2 3   105 SWAP1 20000   106 SSTORE 2   107 POP 2   108 POP 8   109 JUMP 1   098 JUMPDEST 0   099 STOP
合计为20178 GAS费。
2.5 GAS上限(Gas Limit)
所以,以太坊区块链上的每一条指令都会消耗一些GAS。如果你要将值写入存储,则需要花费很多。如果你只是使用堆栈,它的成本会低一些。但基本上所有关于EVM的指令都需要GAS。这意味着智能合约只能做有限的事情,直到发送的GAS用完为止。在样例这种情况下,我们发送了300万 GAS费。
当您返回REMIX的单步调试器,点击第一步时,您会看到每个步骤剩余多少GAS。辉哥在第一步打开它：
它已经从我们发送的300万（从3,000,000 - 21464 = 2,978,536）中扣除的交易成本开始。（说明：21464是之前2.3章节执行的数据执行成本。）
一旦此计数器达到零,那么合约执行将立即停止,所有存储的值将被回滚,你将获得“Out of Gas”异常告警。
2.6 区块GAS上限(Block Gas Limit)
除了通过交易设置的气Gas Limit外,还有一个所谓的“区块上限”。这是你可以发送的最大GAS量。目前,在Main-Net,该值大概为8M左右。
2.7 GAS退款(Gas Refund)
Gas Limit有一个好处：你不必自己计算它。如果你向合约发送8M的GAS,它耗尽41642 GAS,可以退还其余部分。因此,发送远远超过必要的GAS总会节省下来的,其余的将自动退还到你的账号地址。
2.8 GAS价格(Gas Price)
GAS价格决定了交易在能否被包含在下一个被挖出的区块中。
当你发送交易时,你可以激励矿工接下来处理您的交易。这种激励就是GAS PRICE。矿工一旦挖出新区块,也会将交易纳入该区块。哪些交易被纳入下一个区块是由矿工确定的 - 但他很可能将GAS PRICE从高到低排序。
假设有15笔未完成的交易,但只有12笔交易可以进入下一个区块。5个20 Gwei,5个15 Gwei和5个 5Gwei的GAS PRICE。矿工很可能按此顺序选择交易：5 * 20 + 5 * 15 + 2 * 5 Gwei并将它们合并到下一个挖掘区块中。
因此,GAS Limit基本上决定了以太坊虚拟机可以执行的指令数量,而GAS Price决定了矿工选择此交易的可能性。
大多数钱包将标准GAS Price设定为20Gwei左右（0.00000002 ETH）。如果您正在执行上述合约,那么您将支付约60-70美分（美元分）,当前汇率为1 ETH = 800美元。所以它根本不便宜。
幸运的是,在网络拥塞期间,您只需要更高的GAS PRICE,那是因为许多人尝试同时发送交易。如果网络没有拥挤,那么您不需要支付这么多GAS。EthGasStation网站（ https://ethgasstation.info）评估目前的交易价格为4 Gwei足够 。所以,凭借这个小功能,只需要4 Gwei的GAS,它将是16美分左右,而不是65美分。一个巨大的差异。
3
如何优化节省GAS费用的方法
GAS消耗可参考以下两个表： 表格1 表2
下面提供一下优化GAS消耗的方法。
3.1 创建合约
创建合约对应CREATE和CODECOPY这两条指令。在合约中创建另一个空合约消耗42,901个GAS（总共64,173个GAS）。如果直接部署空白合约,共有68,653个GAS。
如果包含实施,可能会有数十万甚至数百万的GAS。它应该是所有指令中最昂贵的。如果创建多个合约实例,则GAS消耗可能很大。
建议： 避免将合约用作数据存储。
不好的代码实现： contract User {    uint256 public amount;   bool public isAdmin;   function User(uint256 _amount, bool _isAdmin) {     amount = _amount;     isAdmin = _isAdmin;   }  }
好的代码实现： contract MyContract {  mapping(address => uint256) amount;  mapping(address => bool) isAdmin; }
另一种OK的代码实现： contract MyContract {   struct {    uint256 amount;     bool isAdmin;  } mapping(address => User) users; }
3.2 存储
对应于SSTORE指令。存储新数据需要20,000 GAS。修改数据需要5000 GAS。一个例外是将非零变量更改为零。我们稍后会讨论这个问题。
建议： 避免重复写入,最好一次在最后尽可能多地写入到存储变量。
不好的代码样例： uint256 public count; // ... for (uint256 i = 0; i < 10; ++i) {   // ...    ++count; }
好的代码样例： for (uint256 i = 0; i < 10; ++i) {   // ... } count += 10;
3.3 变量排序对GAS的影响
你可能不知道变量声明的顺序也会影响Gas的消耗。
由于EVM操作都是以32字节为单位执行的,因此编译器将尝试将变量打包成32字节集进行访问,以减少访问时间。
但是,编译器不够智能,无法自动优化变量分组。它将静态大小的变量分组为32个字节的组。例如： contract MyContract {   uint64 public a;   uint64 public b;   uint64 public c;   uint64 public d; function test() {     a = 1;     b = 2;     c = 3;     d = 4;   }  }
执行test()时,看起来已经存储了四个变量。由于这四个变量之和恰好是32个字节,因此实际执行了一个SSTORE。这只需要20,000 GAS。
再看下一个例子： contract MyContract {    uint64 public a;   uint64 public b;   byte e;   uint64 public c;   uint64 public d; function test() {     a = 1;     b = 2;     c = 3;     d = 4;   }  }
中间插入了另一个变数,结果造成a,b,e和c会被分为一组,d独立为一组。同样的test()造成两次写入,消耗40000 Gas。
最后再看一个例子： contract MyContract {   uint64 public a;   uint64 public b;   uint64 public c;   uint64 public d; function test() {     a = 1;     b = 2;     // ... do something     c = 3;     d = 4;   }  }
**这与第一个例子的区别在于：**在存储a和b之后,完成了其他事情,最后存储了c和d。结果这次将导致两次写入。因为当执行“执行某事”时,编译器确定打包操作已结束,然后发送写入。但是,由于第二次写入是同一组数据,因此认为它是被修改的。将消耗总共25,000个气体。
建议：
根据上述原则,我们可以很容易地知道如何处理它。 正确的排序和分组 将数据大小分组为32个字节,并将通常同时更新的变量放在一起。
不好的代码例子： contract MyContract {  uint128 public hp;  uint128 public maxHp;  uint32 level;  uint128 public mp;  uint128 public maxMp; }
好的例子： contract MyContract {  uint128 public hp;  uint128 public mp;  uint128 public maxHp;  uint128 public maxMp;  uint32 level; }
这里我们假设hp和mp更频繁地更新,并且maxHp和maxMp更频繁地一起更新。 尽量一次访问
不好的代码例子： function test() {    hp = 1;     // ... do something    mp = 2;  } 好的例子： function test() {     // ... do something    hp = 1;    mp = 2;  }
这个规则在struct上是一样的。
3.4 交易输入数据
合约交易的基本气体是21,000。输入数据为每字节68个GAS,如果字节为0x00则为4个GAS。
例如,如果数据为0x0dbe671f,则气体为68 * 4 = 272; 如果是0x0000001f,它是68 * 1 + 4 * 3 = 80。
由于所有参数都是32字节,因此当参数为零时,气体消耗最小。它将是32 * 4 = 128。最大值如下： n * 68 +（32-n）* 4 的字节数 （n：参数）
例如,32字节输入参数的最大GAS为2,176 （3268 = 2176）。输入参数为地址,地址是20个字节,因此它是1,408 （2068+（32-20）*4 = 1408）。
建议：  可以通过更改排序来节省GAS消耗。
例如EtherScan有下一段交易记录： Function: trade(address tokenGet, uint256 amountGet, address tokenGive, uint256 amountGive, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount) *** MethodID: 0x0a19b14a [0]:0000000000000000000000000000000000000000000000000000000000000000 [1]:000000000000000000000000000000000000000000000000006a94d74f430000 [2]:000000000000000000000000a92f038e486768447291ec7277fff094421cbe1c [3]:0000000000000000000000000000000000000000000000000000000005f5e100 [4]:000000000000000000000000000000000000000000000000000000000024cd39 [5]:00000000000000000000000000000000000000000000000000000000e053cefa [6]:000000000000000000000000a11654ff00ed063c77ae35be6c1a95b91ad9586e [7]:000000000000000000000000000000000000000000000000000000000000001c [8]:caa3a70dd8ab2ea89736d7c12c6a8508f59b68590016ed99b40af0bcc2de8dee [9]:26e2347abfba108444811ae5e6ead79c7bd0434cf680aa3102596f1ab855c571 [10]:000000000000000000000000000000000000000000000000000221b262dd8000
所有参数都是256位,无论类型是byte32,address还是uint8。所以左边的大多数参数都有大量的“0”是未使用的位。很容易想到使用这些“空间”。
例如可以把tokenGive的高位字节用于存放下面吗一些变量,把命名改为uint256 tokenSellWithData。 nonce  - > 40位 takerFee  - > 16位 makerFee  - > 16位 uint256 joyPrice  - > 28位 isBuy  - > 4位（实际上,1位就足够了。只是为了方便呈现文档）
假如上面变量的值分别为： nonce: 0181bfeb takerFee: 0014 makerFee: 000a joyPrice: 0000000 isBuy: 1
那么tokenSellWithData的存储可能如：
更多优化参考文章《[Solidity] Compress input in smart contract》。
3.5 转账
Call, send 和transfer 函数对应于CALL指令。基本消耗是7,400 GAS。事实上,消费将近7,600 GAS。值得注意的是,如果转账到一个从未见过的地址,将额外增加25,000个GAS。
没有额外的消耗样例: function withdraw（uint256 amount）{   msg.sender.transfer（amount）;  }
可能会有额外的消耗样例（receiver参数未被使用,多余参数）： function withdrawTo(uint256 amount, address receiver) {  receiver.transfer(amount); }
3.6 其他命令
3.6.1 ecrecover
对应CALL指令。此功能将消耗3700 GAS。
3.6.2调用外部合约
调用外部合约执行EXTCODESIZE和CALL指令。基本消耗1400 GAS。除非必要,否则不建议拆分多个合同。可以使用多个继承来管理代码。
3.6.3事件
对应于LOG1指令。没有参数的事件是750 GAS。理论上每个附加参数将增加256个GAS,但事实上,它会更多。
3.6.4哈希
你可以使用智能合约中的几个内置哈希函数：keccak256,sha256和ripemd160。参数越多,消耗的气体越多。耗气量：ripemd160> sha256> keccak256。因此,如果没有其他目的,建议使用keccak256函数。
3.7 部署合约优化
大部分的优化在编译时候已经完成了。 问题：部署合同中是否包含注释,是否会增加部署气体？ 回答：不,在编译期间删除了执行时不需要的所有内容。其中包括注释,变量名和类型名称。
并且可以在此处文章（ https://solidity.readthedocs.io/en/latest/miscellaneous.html#internals-the-optimizer）找到优化程序的详细信息。
另一种通过删除无用代码来减小大小的方法。例如： 1 function p1 ( uint x ){  2    if ( x > 5) 3     if ( x*x < 20) 4        XXX }
在上面的代码中,第3行和第4行永远不会执行,并且可以避免这些类型的无用代码仔细通过合同逻辑,这将减少智能合约的大小。
3.8 调用合约函数的成本优化
当调用合约额的功能时,为了执行功能,它需要GAS。因此,优化使用较少GAS的功能非常重要。在考虑每个合约时时,可以采用多种不同的方式。这里有一些可能在执行过程中节省GAS的方法。
3.8.1  减少昂贵的操作
昂贵的操作是指一些需要更多GAS值的操作码,例如SSTORE。以下是一些减少昂贵操作的方法。
A）使用短路规则 （ https://solidity.readthedocs.io/en/develop/types.html#booleans） 操作符 || 和&&适用常见的短路规则。这意味着在表达式f（x）|| g（y）中,如果f（x）的计算结果为真,即使它有副作用,也不会评估g（y）。
因此,如果逻辑操作包括昂贵的操作和低成本操作,那么以昂贵的操作可以短路的方式安排将在一些执行中减少GAS。
如果f（x）是便宜的并且g（y）是昂贵的,逻辑运算代码（便宜的放在前面）： OR ： f(x) || g(y) AND： f(x) && g(y)
如果短路,将节省更多的气体。 f(x)与g(y)安排AND操作相比,如果返回错误的概率要高得多,f(x) && g(y)可能会导致通过短路节省更多的气体。 f(x)与g(y)安排OR运算相比,如果返回真值的概率要高得多,f(x) || g(y)可能会导致通过短路节省更多气体。
B）循环中昂贵的操作
不好的代码,例如： uint sum = 0;  function p3 ( uint x ){      for ( uint i = 0 ; i < x ; i++)         sum += i; }
在上面的代码中,由于sum每次在循环内读取和写入存储变量,所以在每次迭代时都会发生昂贵的存储操作。这可以通过引入如下的局部变量来节省GAS来避免。
好的代码,例如： uint sum = 0;  function p3 ( uint x ){     uint temp = 0;      for ( uint i = 0 ; i < x ; i++)         temp += i; }     sum += temp;
3.8.2 其他循环相关模式
循环组合,不好的代码样例： function p5 ( uint x ){     uint m = 0;     uint v = 0;     for ( uint i = 0 ; i < x ; i++) //loop-1         m += i;     for ( uint j = 0 ; j < x ; j++) /loop-2         v -= j; }
loop-1和loop-2可以组合,可以节省燃气。
好的代码样例： function p5 ( uint x ){    uint m = 0;    uint v = 0;     for ( uint i = 0 ; i < x ; i++) //loop-1       m += i;       v -= j; }
3.8.3  使用固定大小的字节数组 可以使用一个字节数组作为byte [],但它在传入调用时浪费了大量空间,每个元素31个字节。最好使用bytes。 根据经验,对任意长度的原始字节数据使用 bytes标识符,对任意长度的字符串（UTF-8）数据使用 string标识符。如果您可以将长度限制为特定的字节数,请始终使用bytes1到bytes32之一,因为它们要便宜得多。
具有固定长度总是节省GAS。也请参考这个问题（ https://ethereum.stackexchange.com/questions/11556/use-string-type-or-bytes32）描述。
3.8.4 删除无用的代码可以在执行时节省GAS
如前面在合同部署中所解释的那样删除无用的代码即使在执行函数时也会节省GAS。
3.8.5 在实现功能时不使用库对于简单的使用来说更便宜。
调用库以获得简单的用法可能代价高昂。如果功能在合同中实现简单且可行,因为它避免了调用库的步骤。两种功能的执行成本仍然相同。
4
参考
参考
（1）区块链系列十九：Gas优化： https://magicly.me/blockchain-19-solidity-gas-optimization
（2）How to write an optimized (gas-cost) smart contract?： https://ethereum.stackexchange.com/questions/28813/how-to-write-an-optimized-gas-cost-smart-contract
（3）[Solidity] Optimize Smart Contract Gas Usage： https://medium.com/joyso/solidity-save-gas-in-smart-contract-3d9f20626ea4
（4）What exactly is the Gas Limit and the Gas Price in Ethereum： https://vomtom.at/what-exactly-is-the-gas-limit-and-the-gas-price-in-ethereum/
（5） 以太坊的账户、交易、Gas和Gas Limit的概念 本文作者：HiBlock区块链技术布道群- 辉哥
原文发布于简书
加微信baobaotalk_com,加入技术布道群

「深度学习福利」大神带你进阶工程师,立即查看>>>
本文我们将弄清楚什么是EOS代币以及如何自己创建和部署EOS代币。
与以太坊相反,EOS带有即插即用的代币智能合约。以太坊拥有ERC20智能合约,EOS拥有 eosio.token 智能合约。 Eosio.token 智能合约允许你通过提供最大代币供应数量和代币的书面定义,通过向帐户发放代币以及在帐户之间转移代币来创建你自己的代币。EOS区块链上的EOS代币使用相同的智能合约签发。 cleos --url https://api.main.alohaeos.com:443 get currency stats eosio.token EOS { "EOS": { "supply": "1003605574.9616 EOS", "max_supply": "10000000000.0000 EOS", "issuer": "eosio" } }
url 参数指定你连接的哪一个节点。你可以在官方网站上查看更多提供API的节点。
安装Cleos
Cleos是一个命令行工具,它与nodeos公开的REST API进行交互。我们需要cleos来运行所有命令来与EOS区块链进行交互。你可以使用Docker,AWS Image或编译源代码来安装cleos。安装的最终结果必须在你的终端中是可用的。 cleos ERROR: RequiredError: Subcommand required Command Line Interface to EOSIO Client Usage: cleos [OPTIONS] SUBCOMMAND Options: -h,--help Print this help message and exit -u,--url TEXT=http://localhost:8888/ the http/https URL where nodeos is running --wallet-url TEXT=http://localhost:8900/ the http/https URL where keosd is running -r,--header pass specific HTTP header; repeat this option to pass multiple headers -n,--no-verify don't verify peer certificate when using HTTPS -v,--verbose output verbose actions on error --print-request print HTTP request to STDERR --print-response print HTTP response to STDERR Subcommands: version Retrieve version information create Create various items, on and off the blockchain get Retrieve various items and information from the blockchain set Set or update blockchain state transfer Transfer EOS from account to account net Interact with local p2p network connections wallet Interact with local wallet sign Sign a transaction push Push arbitrary transactions to the blockchain multisig Multisig contract commands system Send eosio.system contract action to the blockchain.
创建钱包
钱包是存储可能与一个或多个帐户的权限相关联密钥的客户端。理想情况下,钱包具有受高熵密码保护的锁定（加密）和解锁（解密）状态。EOSIO/eos存储库捆绑了一个名为cleos的命令行界面客户端,它与一个名为keosd的lite客户端连接在一起,它们展示了这种模式。
让我们创建一个名为“treasure”的东西。 cleos wallet create --name treasure Creating wallet: treasure Save password to use in the future to unlock this wallet. Without password imported keys will not be retrievable. "PW5J2DTM7kpPaihUH35pLTJrvhjgZ11SY4FqxYbo6geWvEH4SNvMC"
你必须将密码保存在安全的地方,因为如果它丢失了,则无法恢复钱包内的所有密钥。
现在我们需要为所有者和活动权限生成两对密钥。之后,我们将它们导入我们的钱包。 cleos create key #owner Private key: 5HsrZsLeUoDvBCFT2JSvgg3KrfwE7BXAJkUBSwnTwX27Cgabumj Public key: EOS8VMwRNWWHwov4vyzJiq9uTEyzcny8QKXv7CJxGQAwjSTncyv51 cleos create key #active Private key: 5JtrJNbJPfzm8XPMddANGYT9yzaqo8gwTEpmSrgQNhtoPXL9Ynd Public key: EOS8CCRKHAbhBim6LimdvhhzhEYiKNnLRhuMD1Zqx5Cut52moBRmH cleos wallet import 5HsrZsLeUoDvBCFT2JSvgg3KrfwE7BXAJkUBSwnTwX27Cgabumj --name treasure #owner imported private key for: EOS8VMwRNWWHwov4vyzJiq9uTEyzcny8QKXv7CJxGQAwjSTncyv51 cleos wallet import 5JtrJNbJPfzm8XPMddANGYT9yzaqo8gwTEpmSrgQNhtoPXL9Ynd --name treasure #owner imported private key for: EOS8CCRKHAbhBim6LimdvhhzhEYiKNnLRhuMD1Zqx5Cut52moBRmH
创建帐号
要在EOS区块链中执行任何操作,你需要拥有一个帐户。
帐户是存储在区块链中的我们可以看明白的名称。它可以由一个人或一些人拥有,具体取决于权限配置。需要一个帐户来将交易转移或推送到区块链。
帐户本质上是一些公共或私有密钥,是一个唯一的名称。密钥存放在钱包中。帐户存储在EOS区块链中。
在本地创建帐户很容易,你只需运行 cleos create account 命令,因为你拥有默认的 eosio 帐户,这在Mainnet上显然不是这样。要在Mainnet上创建帐户,你需要已经拥有它的人的帮助,例如 zeos 或 eos-account-creator ,这需要花钱。此外,你只能创建12个符号的帐户,并且仅包含a-z小写,1-5个数字。在我看来,这是非常严格的限制。要获得名称较短的帐户,你必须进行竞价。考虑到（双关的语意）你可以转售EOS帐户,抢注量是非常巨大的。考虑到所有这些,我们将使用Testnet来节省金钱和时间。
EOS Jungle Tesnet在尽可能模拟主网。转到 jungle.cryptolions.io 并点击 Create Account 链接。它会询问你的帐户名称和两个密钥。使用之前生成的公钥。
确认后账号会被建好。 cleos --url https://jungle.eosio.cr:443 get account ylvdeveloper permissions: owner 1: 1 EOS8VMwRNWWHwov4vyzJiq9uTEyzcny8QKXv7CJxGQAwjSTncyv51 active 1: 1 EOS8CCRKHAbhBim6LimdvhhzhEYiKNnLRhuMD1Zqx5Cut52moBRmH memory: quota: 161.4 KiB used: 3.365 KiB net bandwidth: staked: 100.0000 EOS (total stake delegated from account to self) delegated: 0.0000 EOS (total staked delegated to account from others) used: 0 bytes available: 19.12 MiB limit: 19.12 MiB cpu bandwidth: staked: 100.0000 EOS (total stake delegated from account to self) delegated: 0.0000 EOS (total staked delegated to account from others) used: 0 us available: 3.826 sec limit: 3.826 sec producers:
现在我们需要为我们的帐户购买一些RAM,因为我们要发布我们的智能合约。在EOS区块链中,RAM市场上有鲸鱼玩公牛,这是另一个有钱的人投机机会。使用EOS Jungle Testnet Faucet将一些EOS代币放入你的帐户。
之后运行 cleos system buyram 命令购买带有EOS代币的RAM。 cleos --url https://jungle.eosio.cr:443 system buyram ylvdeveloper ylvdeveloper "10 EOS" 3481816ms thread-0 main.cpp:429 create_action ] result: {"binargs":"7055a5516d9576f47055a5516d9576f4a08601000000000004454f5300000000"} arg: {"code":"eosio","action":"buyram","args":{"payer":"ylvdeveloper","receiver":"ylvdeveloper","quant":"10.0000 EOS"}} executed transaction: 8eb30f6cfced6845e02b134946c7b6d623558f0c1a5ceff135b7e98007da692f 128 bytes 5094 us # eosio <= eosio::buyram {"payer":"ylvdeveloper","receiver":"ylvdeveloper","quant":"10.0000 EOS"} # eosio.token <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"} # ylvdeveloper <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"} # eosio.ram <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ram","quantity":"9.9500 EOS","memo":"buy ram"} # eosio.token <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"} # ylvdeveloper <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"} # eosio.ramfee <= eosio.token::transfer {"from":"ylvdeveloper","to":"eosio.ramfee","quantity":"0.0500 EOS","memo":"ram fee"} warning: transaction executed locally, but may not be confirmed by the network yet
创建合约
首先,我们必须将我们的合约上传到区块链。Cleos命令 set contract 通过以下位置参数执行： * account — the account to publish a contract for. * contract-dir — contract directory. * wast-file — the file containing the contract WAST or WASM. * abi-file — the ABI of the contract.
如你所见,我们需要指定 wast 和 abi 文件。如果你通过源代码构建EOS,可以在 ./build/contracts/eosio.token/ 文件夹中找到它们。为方便起见,我上传了他们两个 wast / abi 。 我们用自己的帐户和文件调用 set contract 命令。因为我们的wast/abi文件与目录名称是相同,所以我们可以跳过这些参数。 cleos --url https://jungle.eosio.cr:443 set contract ylvdeveloper ./contracts/eosio.token Reading WAST/WASM from ./contracts/eosio.token/eosio.token.wasm... Using already assembled WASM... Publishing contract... executed transaction: 3fa704e4c1c72050e61882460bf0acd3b200df087d86a157d3d60ec1c439ba65 8104 bytes 3178 us # eosio <= eosio::setcode {"account":"ylvdeveloper","vmtype":0,"vmversion":0,"code":"0061736d01000000017e1560037f7e7f0060057f7... # eosio <= eosio::setabi {"account":"ylvdeveloper","abi":"0e656f73696f3a3a6162692f312e30010c6163636f756e745f6e616d65046e616d6... warning: transaction executed locally, but may not be confirmed by the network yet
让我们检查代码是否已使用 get code ylvdeveloper 命令上传。 cleos --url https://jungle.eosio.cr:443 get code ylvdeveloper code hash: 641f336aa1d08526201599c3c0ddb7a646e5ac8f9fd2493f56414d0422a0f957
创建代币
最后,我们可以创建和发布我们的令牌。我们将使用 cleos push action 命令利用我们的智能合约的创建和发布,该命令采用以下参数： * contract — the account providing the contract to execute. * action — the action to execute on the contract. * data — the arguments to the contract.
让我们创建YLV代币并发出一些代币。 cleos --url https://jungle.eosio.cr:443 push action ylvdeveloper transfer '{"from":"ylvdeveloper", "to":"ylvio", "quantity":"100.00 YLV", "memo":"gift"}' -p ylvdeveloper executed transaction: 32abee7e426d9e5653f67a7b492c17ca62aeeef97ff1a86037f58f2dd1459452 136 bytes 1639 us # ylvdeveloper <= ylvdeveloper::transfer {"from":"ylvdeveloper","to":"ylvio","quantity":"100.00 YLV","memo":"gift"} # ylvio <= ylvdeveloper::transfer {"from":"ylvdeveloper","to":"ylvio","quantity":"100.00 YLV","memo":"gift"}
检查下余额： cleos --url https://jungle.eosio.cr:443 get table ylvdeveloper ylvdeveloper accounts { "rows": [{ "balance": "900.00 YLV" } ], "more": false } Bytezilla:build iYalovoy$ cleos --url https://jungle.eosio.cr:443 get table ylvdeveloper ylvio accounts { "rows": [{ "balance": "100.00 YLV" } ], "more": false }
按预期完成了我们的工作,很完美。
总结下
我们从安装 cleos 和了解 eosio.token 智能合约再到拥有我们自己的代币并将代币转移到其他帐户的全部过程。我们使用 EOS Jungle Testnet 完成了所有这一切,它几乎与Mainnet相同。相同的步骤适用于Mainnet,你只需使用不同的API节点并为你的帐户和RAM支付相应的费用。 EOS代币是一个智能合约。 Cleos 是用于与钱包和节点交互的命令行实用程序。 EOS Jungle Testnet 可用于开发。 你可以使用 eosio.token 智能合约创建,发布和发送你自己的代币。
分享一个相关的交互式在线编程实战教程：
EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。
汇智网原创翻译,转载请标明出处。这里是原文 如何创建和部署自己的EOS代币

「深度学习福利」大神带你进阶工程师,立即查看>>>
2009年中本聪发表论文《比特币-一种点对点的电子现金系统》之后比特币横空出世,比特币诞生至今的9年时间币价增长了200万倍,2016年至今区块链行业也产生了爆炸式的增长,越来越多的人开始关注区块链行业,想要深入了解区块链,中本聪当年的论文是不可错过的重要资料,区块链行业至今的很多重要创新都源于这篇论文,对该论文的研究,有助于我们更快的了解比特币,了解区块链。

中本聪论文中,比特币首先解决了交易中交易信任,隐私保护和交易欺诈等问题,其次以低成本的运营方式,对于运营参与者给予合理的回报,最终形成一套去中心化的自运行的金融系统。首创了交易哈希值,工作量证明,时间戳等区块链关键技术,日后被区块链其他项目沿用至今。以下内容是关于中本聪论文的解读：

一、交易的问题
1.交易信任
交易中最核心的问题是信任问题。
在传统的商业中是靠可信的第三方中介来解决的,比如淘宝购物依靠支付宝解决信任问题,金融借贷通过银行解决信任问题。

而比特币通过交易双方的公钥和私钥确定交易者的身份,并首创了公开广播的形式来解决信任问题。系统授予并记录交易双方唯一的交易序列,之后进行全网的广播,被整个系统中的所有参与者见证。

2.交易欺诈
传统商业中,银行作为可信的第三方中介服务于各种交易中,但常常因为支付和结算的时间差,遇到欺诈的问题。比如,空头支票,假支票等问题。为了解决交易欺诈,银行等传统机构花费了大量的成本来解决该问题,比如先对单在付款,比如延长付款期限,比如使用高科技手段来认证交易者身份等等。

交易欺诈的问题在比特币网络中同样可能存在,即使进行全网的广播,也可能会出现A转账到B之后,在交易未结束前把同样一笔资金在转账给C的问题,中本聪在论文中提出了时间戳的概念,每一笔交易的随机散列加密数据+时间戳确定了交易的唯一性,全网广播之后一笔笔交易就形成了一个链条式的账本,之前的交易无法更改,从而杜绝了交易欺诈的问题。

3.隐私保护

交易中的双方的公钥是匿名的,网络中的参与者被公告的信息是：某个人将一定数量的货币支付给了另外一个人,但是难以将该交易同某个特定的人联系在一起,也就是说,全网中没有人知道交易双方究竟是谁。和股票交易类似,股票买卖者的交易数据是公开的,比如在什么时间某一股票被买卖了多少数量,而买卖的身份信息是隐匿的,即我们并不知道谁参与了交易。

二、系统的运营
1.系统成本
传统商业中,银行系统的维护需要大量的人力物力成本,比如办公场地,人员工资,安保成本,网络系统等等。

比特币设计时,中本聪设想了一个不需要中心化维护的互联网系统,也就不需要组织结构,不需要固定的人员工资的系统。而系统运营人员的成本又通过系统自运营中产生的奖励完成,从而实现了系统的自动运行。从经济学的角度,这是最低程度消耗资源,最低成本的运营方式。

2.系统的自运行
开发者和矿工作是比特币系统的核心,比特币系统的开发在中本聪消失前基本完成,在此之后系统的演进工作都是社区在中本聪开发的基础上进行的修补。

而比特币系统运营中最关键的铸币和记账工作是通过矿工完成的,矿工通过铸币和记账获得相应的奖励来保证矿工有足够的工作积极性。

对于铸币奖励,论文中是这样定义的：“每个区块的第一笔交易进行特殊化处理,该交易产生一枚由该区块创造者拥有的新的电子货币。这样就增加了节点支持该网络的激励,并在没有中央集权机构发行货币的情况下, 提供了一种将电子货币分配到流通领域的一种方法 ”

记账奖励的来源则是交易费（transaction fees）。论文中的定义：“如果某笔交易的输出值小于输入值,那么差额就是交易费,该交易费将被增加到该区块的激励中。只要既定数量的电子货币已经进入流通,那么激励机制就可以逐渐转换为完全依靠交易费,那么本货币系统就能够免于通货膨胀”

三、划时代的创新
1.去中心化
完全通过点对点技术实现的电子现金系统,基于密码学原理而不基于信用,它使得在线支付能够直接由一方发起并支付给另外一方,任何达成一致的双方,能够直接进行支付, 而不需要第三方中介的参与,也不依赖任何中心化的组织就可以自动运行。

2.交易验证
一枚电子货币（an electronic coin）是这样的一串数字签名： 每一位所有者通过对前一次交易和下一位拥有者的公钥(Public key)签署一个随机散列的数字签名,并将这个签名附加在这枚电子货币的末尾,电子货币就发送给了下一位所有者。而收款人通过对签名进行检验,就能够验证该链条的所有者。

在电子系统中排除第三方中介机构,那么交易信息就应当被公开宣布（publicly announced）1,我们需要整个系统内的所有参与者,都有唯一公认的历史交易序列。收款人需要确保在交易期间绝大多数的节点都认同该交易是首次出现。

每个交易中的每个时间戳应当将前一个时间戳纳入其随机散列值中,每一个随后的时间戳都对之前的一个时间戳进行增强(reinforcing),这样就形成了一个链条（Chain）。 交易验证使用数字签名+全网广播+时间戳完美的解决了交易中的信任问题。

3.工作量证明（Proof-of-Work）
在进行随机散列运算时,工作量证明机制引入了对某一个特定值的扫描工作,比方说SHA-256下,随机散列值以一个或多个0开始。那么随着0的数目的上升,找到这个解所需要的工作量将呈指数增长,但是检验结果仅需要一次随机散列运算。

我们在区块中补增一个随机数(Nonce),这个随机数要使得该给定区块的随机散列值出现了所需的那么多个0。 我们通过反复尝试来找到这个随机数,找到为止。 这样我们就构建了一个工作量证明机制。只要该CPU耗费的工作量能够满足该工作量证明机制,那么除非重新完成相当的工作量, 该区块的信息就不可更改。由于之后的区块是链接在该区块之后的,所以想要更改该区块中的信息,就还需要重新完成之后所有区块的全部工作量。

工作量证明的几个好处：
1）公平有效的分配区块奖励
矿工之间的竞争是通过完成随机散列运算的次数完成保证了公平有效,谁在整个区块链中的工作量更多,谁获得的区块奖励就更多。

2）保证了区块链数据难以篡改
代表诚实节点的最长的链包含了最大的工作量,如果想要对业已出现的区块进行修改,攻击者必须重新完成该区块的工作量外加该区块之后所有区块的工作量,并最终赶上和超越诚实节点的工作量。工作量最多的链,一定是数据最完整的链,一定是代表了全网用户利益的链。

3）控制发币速度
硬件的运算速度在高速增长,且节点参与网络的程度会有所起伏。为了解决这个问题,工作量证明的难度(the proof-of-work difficulty)将采用移动平均目标的方法来确定,即令难度指向令每小时生成区块的速度为某一预设的平均数。如果区块生成的速度过快,那么难度就会提高工作量来证明自己在铸币和记账中的工作量

4.系统激励
把传统的消耗资源挖矿的方式应用到比特币系统中,比特币系统的挖矿消耗的资源是CPU的运算时间和电力资源。

对于矿工的激励是发掘出新区块奖励的比特币,在所有比特币挖掘完毕之后,比特币系统的高额手续费成为矿工持续工作的动力。

四、遗留的问题
比特币系统诞生已经9年了,现在来看当初关于系统设计的论文,也不得不赞叹该系统设计超越时代的先进与严谨,比特币从最初的试验品,到小范围应用,到现在成为市值600亿美元的准商用系统,经历了无数次考验。

但是比特币作为一个金融系统运营至今,随着越来越多的人使用,比特币网络拥塞的问题也越来越严重,扩容之争给比特币的未来蒙上了一团迷雾；算力集中于几大矿池也让比特币网络越来越中心化；币价上涨导致的算力的暴涨问题,让挖矿耗费的电力资源越来越多；早期参与者的持币成本和现在及未来参与者的持币成本的巨大差异导致的贫富不均等等问题,在未来都需要比特币的持有者,比特币网络的使用者,比特币系统的开发者,矿工们共同去解决。

五、总结
随着互联网的发展,全球经济格局已经从线下实体经济越来越多的转变为互联网虚拟经济。过去主要的财富来源是物质资产,比如房地产,矿产资源,实物商品,现在的主要财富来源则是知识,信息和金融,实体经济中创造的财富也在逐渐向互联网转移,比特币系统创造的代币作为区块链应用的核心,承载着区块链项目的价值,也提供了实体经济中创造的财富向互联网转移的机会。

也许正如之前老猫说过的：区块链的世界,一切才刚刚开始。

阅读原文

「深度学习福利」大神带你进阶工程师,立即查看>>>
这一系列文章将围绕以太坊的二层扩容框架,介绍其基本运行原理,具体操作细节,安全性讨论以及未来研究方向等。本篇文章主要介绍在 Plasma 框架下的项目 Plasma Cash。
深入理解Plasma（1）：Plasma 框架
深入理解Plasma（2）：Plasma 细节剖析
深入理解Plasma（3）：Plasma MVP
在 上一篇文章中 我们已经理解了 Plasma 的最小实现 Plasma MVP 如何使用 UTXO 模型实现 Plasma 链下扩容的核心思想。但由于 Plasma MVP 本身过于简单,并不能用于实际的生产环境中。2018 年 3 月,在巴黎举行的以太坊开发者大会上,Vitalik 发布了 Plasma Cash 模型[1],可以视为对 Plasma MVP 的改进。Plasma Cash 与 Plasma MVP 的主要区别是每次存款操作都会产生一个唯一的 coin ID 对应转移到侧链上的资产,并使用一种称为稀疏梅克尔树（Sparse Merkle Tree）的数据结构存储交易历史。由此带来的好处是用户不需要关注子链上的每个动态,只需要关注跟自己的 token 有关的动态。在下文中将介绍具体细节。
1
存款（Deposits）
Plasma Cash 中的每次存款操作都会对应产生一个 NFT（non-fungible token）[2]。NFT 可以简单理解为“不可互换的 token”,即每个 token 都是独一无二的,由唯一的 ID 标记。以太坊官方为 NFT 提供了 ERC721 标准[3],在之前火爆到阻塞以太坊的 CryptoKitties 就是由 ERC721 合约实现的。
在 Plasma Cash 中,当用户向 Plasma 合约发送存款交易时,合约会生成一个与存款等值的 token,并给这个 token 分配一个唯一的 ID。如果一个用户分别执行两次存款操作,且每次存款都是 5 ETH,那么他将得到相等价值的两个完全不同的 token。和 Plasma MVP 一样,每次存款操作都会使得 Plasma 合约产生一个只包含这个存款交易的区块。
2
Plasma Cash 区块
Plasma Cash 中的每个 token 都被分配唯一的 ID,因此可以按 ID 的顺序存储每个 token 的交易历史。Plasma Cash 的区块按 token ID 的顺序给每个 token 分配了一个插槽（slot）,每个插槽会记录这个 token 是否被交易的信息。例如在下图（来源[4]）的区块中,包含 4 个 token,id 分别是 #1,#2,#3,#4。其中 #1,#2,#3 被标记为没有被花费,而 #4 由用户 A 发送给用户 B。
从上面这个例子中我们可以看到,每个插槽记录了其所对应的 token 在当前区块中的交易状态,所有存储了某个 token 的交易状态的区块按时间顺序连在一起就构成了这个 token 的全部交易历史。每当一个 token 被分配了一个 id,之后的所有交易状态都会被保存在每个区块相同的插槽中,也不会被其它 token 取代。因此,用户只需要关注每个区块中存储属于自己的 token 的状态,完全不用关心别的插槽存储的内容。
3
交易与验证
由于 Plasma Cash 中的节点只追踪属于自己的 token 的交易历史,因此当有交易发生时,token 的发送者要向接收者提供关于这个 token 所有的交易历史（从存款交易开始）以便接收者验证。从下图（来源[4]）的例子中可以看到 4 个区块中所记录的 4 个 token 的交易历史。
截止到区块 #4,可以看到token #1 和 token #3 始终没有被交易。token #2 在区块 #2 被 E 发送给了 F,在区块 #4 被 F 发送给了 G,在其它区块没有发生交易,token #2 的最终所有权归 G。token #4 在区块 #1 被 A 发送给了 B,在区块 #3 被 B 发送给了 C,在其它区块没有发生交易,token #4 的最终所有权归 C。F 为了向 G 证明 token #2 的合法性,需要向 G 提供 token #2 在前 4 个区块中的所有交易历史,也就是说不仅需要包括区块 #2 中 E => F 的交易证明、区块 #4中 F => G 的交易证明,还要包括在区块 #1 和 #3 中没有被交易的证明。到这里可能感觉有点奇怪,为什么还要包括没有被交易的证明？这是为了防止双花,因为 G 并不知道在区块 #1 和 #3 中 token #2 是否被交易给了其它人。假如 F 在区块 #3 中将 token #2 发送给了 H,并且对 G 隐瞒了这个交易,那么发生在区块 #4 中的 F => G 就是非法（双花）的。因此,在 Plasma Cash 中,完整且合法的交易历史是一个 token 被安全交易的前提。
4
稀疏梅克尔树（Sparse Merkle Tree）
在上文中我们已经了解到一个交易的成功的前提是需要发送方提供关于一个 token 的完整交易历史。完整的交易历史既包括这个 token 在哪些区块被交易的信息,也包括这个 token 在哪些区块没有被交易的信息。我们都知道,在区块链中,使用梅克尔树（Merkle Tree,MT）构造梅克尔证明（Merkel Proof, MP）可以在 O(logN)的时间复杂度验证一个交易是否存在一个区块中。但想要证明一个交易没有存在一个区块中,使用标准的梅克尔树却没那么容易。因此,Plasma Cash 中使用了一种称为稀疏梅克尔树（Sparse Merkle Tree,SMT）的数据结构存储交易数据,能够在O(logN)的时间复杂度验证一个交易不存在。
SMT 实际上一点都不复杂,它的叶子节点是按数据集中的元素序号顺序排列的。如果某个叶子节点对应的元素为空,那么该叶子节点将存储一个特定的值（例如 0 的哈希值）。一个简单的 SMT 示例如下图（来源[5]）所示。
扩展到 Plasma Cash 中,SMT 的叶子节点对应了区块中给每个 token 分配的插槽,按照每个 token 的 ID 排序。每个叶子节点存储对应的 token 的交易信息,如果 token 在这个区块中没有被交易,则相应的叶子节点存储的值为 null。
以上图为例,如果需要证明交易 A 存在,就像在标准的 MT 中一样,需要构造 MP：H(null) 和 H(H(null) + H(D))。如果需要证明 B 不存在,同样很简单,我们已经知道 B 的位置是第二个叶子节点,如果 B 不存在,那么该节点存储的值应该为 null。因此就像在标准的 MT 中证明存在的 MP 一样,只不过需要加上 H(null) 作为 MP 的一部分,即 MP：H(null)、H(A)和 H(H(null)+H(D))。
5
取款/退出（Withdrawl/Exit）
Plasma Cash 中的取款操作在流程上跟 Plasma MVP 大体相同,都要从提交取款申请开始,经历争议期之后才能完成。由于 Plasma Cash 中采用的数据结构不同,在取款时需要提交的 token 所有权证明不同,因此当争议发生时需要提交的争议证明也不同。
提交取款申请
在向 Plasma 合约提交关于某个 token 的取款申请时,需要提供关于这个 token 最近的两次交易证明。例如,在上图中,假如 G 想要取走 token #2 到主链,那么他需要提交关于 F => G 以及 E => F 的 Merkle Proof。
提交争议
取款者在提交了取款申请之后同样需要支付一定的保证金,并等待一段时间的争议期。在这期间如果有其它节点提交了有效的争议证明,那么取款者不但无法完成取款操作,也会损失全部或部分的保证金。
目前 Plasma Cash 支持三种争议证明,分别应对三种不同的攻击场景（具体会在后文分析）： **已花费证明。**如果能证明正在取款的 token 已经被花费,那么取款立即被取消； **双花证明。**如果能证明取款申请中提供的两次交易证明中间还有别的交易,即发生了双花,那么取款立即被取消； **非法交易历史证明。**用户还可以对正在取款的 token 的其它交易历史提出争议。这种争议不会立刻阻断取款,而是强制取款者提交其它交易证明来反驳争议,如果没有在规定时间内反驳,则取款被取消。
6
攻击场景
在这一节将讨论已有的 3 种攻击场景以及如何构造争议分别应对这些攻击[6]。在这里假设 Plasma Cash 中存在不可信的 operator 接收所有的交易并构造区块。
发送交易后立即退出
如下图（来源[7]）所示,假设攻击者 Alice 向 Bob 发送了一个 token A,且 Bob 已经验证了 A 的交易历史没有问题,交易在区块 N+X 得到确认。在这之后,Alice 立即提交取款申请,企图将 token A 取回主链,并提交 A 在区块 N 以及之前的交易证明。为了应对这种情况,Bob 必须及时发现 Alice 的取款行为,并且在争议期结束前提交在区块 N+X 中 token A 被 Alice 发送给 Bob 的证明。这里需要注意的是,如果 Bob 在区块 N+Y 将 token A 发送给 Charlie 的交易是不能被当做争议证明的,只有最接近被争议的交易的下一个交易证明有效。
双花攻击
双花攻击需要 operator 配合,将含有已经被花费的 token 的交易打包入下一个区块中。如下图所示（来源[7]）,攻击者 Alice 和 Charlie 是同谋,Alice 向 Bob 发送一个 token A 在区块 N+X 被确认,之后 Alice 又将 token A 发送给 Charlie,并在区块 N+Y 被确认。这时在主链看来,Bob 和 Charlie 都是 token A 的合法拥有者。接下来,Charlie 立即提交取款申请,企图取走 token A。Bob 为了防止自己的 token 被盗,可以在争议期内提交在区块 N+X 被确认的交易,表明自己在 Charlie 之前已经拥有了 token A。
取款包含非法交易历史
这种攻击需要联合比较多的同谋者。如下图所示,Alice 在区块 N 拥有 token A。Bob 联合 operator、Charlie 以及 Dylan 企图盗走 Alice 的 token。首先,operator 伪造 Alice 将 token A 发送给 Bob 的交易,并在区块 N+X 得到确认,之后 Bob 将 token 发送给 Charlie,在区块 N+Y 确认。同样地,Charlie 接着将 token 发送给 Dylan,在区块 N+Z 确认。这是,Dylan 提出取款申请,企图取走 token A。Dylan 用于取款申请的两个交易证明 Charlie => Dylan 和 Bob => Charlie 都是合法的,但 token A 的交易历史中有一部分是伪造的。Alice 为了证明自己是 token A 的最新合法拥有者,可以提出争议,要求 Dylan 提供 Alice => Bob 的交易证明,同时 Alice 需要提交一部分保证金（否则任何人都可以随便提出争议）。Dylan 必须在一定的时间内提供合法的交易证明,否则取款失效。
7
相关项目
相关项目： Talk is cheap, show me your code.
目前已经有许多机构和公司已经实现了 Plasma Cash,但实现的语言和细节有所不同： Loom Network [8] Omisego [9] Wolk [10] Lucidity [11]
8
总结
本篇介绍了 Plasma 框架下的基于 NFT 的项目 Plasma Cash。Plasma Cash 给每个新转移的 token 分配一个唯一的 token ID,并且用稀疏梅克尔树存储交易,使得用户可以只关注跟自己的 token 有关的动态,而不需要关注其它 token。Plasma Cash 可以被看作 Plasma 逐渐迈向成熟的一步,已经有很多公司使用 Plasma Cash 搭建自己的平台和应用,例如 Loomnetwork 公司搭建了自己的 Plasma Cash 子链并且编写了 SDK 支撑开发者在上面开发新的应用。然而 Plasma Cash 本身仍然存在较多的问题,例如 token 无法被分隔合并、需要提交的证明过长等。在接下来的文章中还会继续跟进 Plasma 最新的进展。
9
相关资源
相关资源 https://ethresear.ch/t/plasma-cash-plasma-with-much-less-per-user-data-checking/1298 https://en.wikipedia.org/wiki/Non-fungible_token http://erc721.org/ https://github.com/ethsociety/learn-plasma https://medium.com/@kelvinfichter/whats-a-sparse-merkle-tree-acda70aeb837 https://karl.tech/plasma-cash-simple-spec/ https://github.com/loomnetwork/plasma-paper/blob/master/plasma_cash.pdf https://github.com/loomnetwork/plasma-cash https://github.com/omisego/plasma-cash https://github.com/wolkdb/deepblockchains/tree/master/Plasmacash https://github.com/luciditytech/lucidity-plasma-cash 内容首发：Github 原文作者：盖盖

「深度学习福利」大神带你进阶工程师,立即查看>>> 本文节选自：《Tendermint: Byzantine Fault Tolerance in the Age of Blockchains》
原文作者： Ethan Buchman
译者： 饶云坤
校对： 傅晓波
译者注：
Tendermint是一个分布式系统状态复制引擎,用于在多台机器安全一致地复制一个应用。所谓安全性,指的是即使有多达1/3的机器出现任意故障的情况下, Tendermint仍然能够正常工作。所谓一致性,指的是每一个正常工作的机器都会有着同样的交易日志,计算相同的状态。安全一致的复制是分布式系统中一个基本原则问题,它在各种应用程序（从货币到选举,到基础设施规划等）中的广泛应用的容错能力方面承担了极其重要的作用。
Tendermint被设计成易于使用、易于理解,且性能优异,适用于广泛的分布式应用。

分布式共识系统成为现代互联网基础设施中的一个关键组件,正助力于每一个主要的互联网应用。本章节内容介绍了必要的背景材料来理解和探讨这些系统。

复制状态机（Replicated State Machine）
最常见的用来研究和实施分布式共识（distributed consensus）的范例的是复制状态机的范例,其中,一个确定的状态机在数个进程（processes）之间被复制,这样不管部分进程是否失败,这些进程看上去像单个状态机。状态机有一些列输入驱动,这些输入被称作交易（transactions）,每一个交易根据其是否有效,可能引起一个状态迁移并返回一个结果。更正式的,交易为数据库上的原子操作（atomic operation）,意味着其要么完成要么根本就没有发生,不能返回一个中间状态（ intermediate state）。状态交易逻辑（state transition logic）由状态机的状态转移函数决定,这个函数映射了一个交易和目前的状态到一个新的状态和一个返回值。状态转移函数有时也被称为应用逻辑（application logic）。
订购交易（order the transactions）并且将相应的交易日志（ transaction log ）复制到每一个进程是共识协议的责任。使用一个确定的（deterministic）状态转移函数意味着在给定同样的交易日志的情况下,每一个进程将计算出相同的结果。
复制状态机架构如图2.1所示。
图2.1
图2.1 一个复制状态机在多个机器之间复制了一个交易日志和结果状态。交易从客户端接受,运行了共识协议,在交易日志中订购（ordered）,最后执行得到最新状态。在图中,每一个菱形代表了单个机器,其中,虚线代表机器间的通讯用来承载进行订购交易（ ordering transactions）的共识协议。
Tendermint的目标是创建一个通用目的,高性能,安全和健壮的复制状态机。

不同时性（Asynchrony）
容错复制状态机（fault-tolerant replicated state machine）的目的是在对上层提供服务的时候,协调网络中的计算机的同步,不管是否存在故障节点。
保持同步意味着成功复制交易日志；提供一个有用的服务意味着在处理新交易的时候保持状态机的可用性。传统上系统的这些方面被各自成为安全性（safety）和可用性（liveness）。通俗地,安全性意味着没有任何坏的事情发生；可用性意味着好的事情最终发生。安全违规（ violation of safety）意味着存在两个或者更多的有效的,竞争的交易日志。可用性违规（violating liveness ）意味着一个无法响应的网络。
通过接受所有的交易可以很容易来满足可用性。通过不接受任何交易可以很容易来满足安全性。因此,状态机复制算法可以被看作在两者之间的一个平衡。一般地,进程在提交一个新的交易在之前,需要对来自于其他进程的信息设立一个阈值。在同步的环境中,我们对网络消息的最大延迟或者处理器时钟的最大速度作出假设,通过轮流坐庄来提议新的交易,进行大多数投票表决,如果提议者在同步假设的区间内并没有产生任何提议,则跳过（skip）提议者的这一回合。
在一个异步的环境中,没有关于网络延迟或者处理器速度的保证的假设,权衡将变得更为困难。事实上,所谓的FLP不可能性结果（FLP impossibility result）证明了在确定的异步进程（单个进程可能会崩溃）之间的分布式共识的不可能性。该证明意味着,因为进程可能失败,存在协议的有效执行,但进程恰好在某一时间崩溃这样就阻止了共识。因此,我们对共识没有任何保证。
一般地,协议中的同步是通过管理某些交易时用到的超时（timeouts）来进行的。在异步环境中,消息能够被任意延迟,依赖同步来确保安全性的话可能导致交易日志的分叉。依赖同步来保证系统的可用性能够引起共识的宕机,并且服务无法响应。前者通常被看作更为严重,因为调解冲突日志可能是一个令人生畏或者不可能的任务。
实际上,仅当消息延迟能够被良好的定义和控制的时候,同步解决方案才会被使用,例如在一架飞机上的控制器之间,或者利用同步的原子时钟的数据中心之间。因此,尽管存在很多高效的同步解决方案,计算机网络的一般化的不可靠性（general unreliability）太大以至于不能实际投入使用而不显著增加额外的成本。
根本上有两种途径来克服FLP不可能性结果。第一个是采用更强的同步假设-甚至相当弱的假设也是足够的,例如,那个唯一的最终崩溃的进程被怀疑崩溃了,正确的进程不受影响。一般地,这个方法利用leaders,其扮演了一个特别的协作的角色,并且在超时并被认为发生故障了以后可以被跳过。实际上,这样的领导选取机制成功运转起来很难。
第二种克服FLP的方法是使用非确定性的-包含随机化元素,这样达成共识的可能性接近为1。尽管第二种方法更智能并且某些高级加密技术近些年来取得了速度上的提高,依赖随机化的方法通常更慢。

广播和共识
为了让一个进程复制状态到其它进程上,它必须有基本通讯原语的权限来允许其传播或者传递信息。一个最有用的原语是可靠广播（reliable broadcast）。可靠广播（RBC）是一个广播原语满足如下特性,对消息m,有：
有效性（validity） - 如果一个正确的进程广播m,它最终成功传达了m
一致性（agreement） - 如果一个正确的进程成功传达了m,所有最终所有的进程成功传达m
完整性（integrity） - m只传递一次,并且是以广播的形式被发送者发送出去
本质上,可靠广播使得消息最终到达所有的进程一次。
另外,更有用的原语是原子广播（ atomic broadcast（ABC））,其满足可靠广播（RBC）和另外的一个属性：
总的顺序（total order） - 如果正确的进程p和q分别传递出m和m',p传达m在m'之前,那么q传达m在m'之前
原子广播是一个可靠的广播,其中值(values)以相同的顺序被发送到每个机器上。注意到这实际上复制交易日志的问题。通俗地讲,该问题可以被称作共识,共识原语的标准定义满足以下条件：
终止性 - 每个正确的进程最终能做出决定
完整性 - 每个正确的进程最多只做出决定一次
一致性 - 如果一个进程做出了v1的决定, 并且另外一个进程做出了v2的决定,那么v1=v2
有效性 - 如果一个正确的进程做出了v的决定,至少一个进程提议了v
直观地,共识和原子广播看上去十分类似,主要的差异在于,原子广播本身作为一个协议是连续的,然而共识期望终止。这就是说,每一个可以精简为另一个。共识可以被精简为原子广播通过决定第一个原子广播的值。原子广播可以精简为共识,通过依次运行许多共识协议的实例,然而存在一些微妙的考量,特别是在处理拜占庭故障方面。一个完整的参数空间的关于原子广播精简为共识的描述仍然是一个开放的研究话题。
历史上,尽管大多数用例实际上需要原子广播,采用的最为广泛的算法是称作Paxos的共识算法,在90年代介绍并且证明该算法正确性的是Leslie Lamport。Paxos同时赋予和困惑了共识科学,一方面提供了第一个真实世界的,实用的,容错的共识算法,另一方面又难于理解和解释。算法的具体实现使用了其专门的技术来从Paxos建立原子广播,使得这个生态难于操纵,理解和利用。不幸的是,几乎没有任何工作使得提高该框架更容易理解,尽管有尝试来描绘解决方案中的各种困难。
在2013年,Ongaro和 Ousterhout发表了Raft,一个状态机复制算法,其主要的设计动机是可理解性。与其从一个共识算法开始,并且尝试建立原子广播,Raft的设计首先考虑的是交易日志,寻求正交组件,其组合在一起来提供最终的原子广播,尽管其不是被这样描述的。
Paxos是工业领域的主要共识算法,在工业领域像亚马逊,谷歌和其他扩建了高可用性全球互联网服务的公司。Paxos 共识位于应用程序栈的底部,提供了资源管理和分配的一致接口,操作在一个更慢的时标相比于其他面对用户的高可用性应用程序。
Raft登场以来得到了广泛的采用,特别是在开源社区,其具有多个主流语言的实现,并且在多数项目中作为其主干。
Raft与Paxos在设计方面主要的不同是先聚焦于交易日志,而不是单个值,特别是允许一个leader持续提交交易直到其卸任,这时领导选举开始生效。在某种程度上,这类似于在区块链中采用的方法,尽管其主要优势是能够容忍不同种类故障。

拜占庭容错（Byzantine Fault Tolerance）
区块链通过在共享数据库上责任的去中心化,减少了对手方风险,因此被称为“信任机器”。比特币由其具有的抵抗任何攻击和恶意行为的能力而著称。传统地,容忍恶意行为的共识协议被称为拜占庭容错共识协议（Byzantine Fault Tolerant ）。术语“拜占庭”被使用,源于拜占庭将军们面对的类似问题,这些将军们尝试相互协调来攻击罗马,使用唯一的信使,其中一个将军可能是叛徒。
在一个崩溃故障中,一个进程可能宕机。在一个拜占庭故障中,故障节点能做任何事情。崩溃的故障更容易处理,因为没有进程会对其他进程说谎。只存在崩溃故障的系统可以通过简单的多数决定规则（ majority rule）来操作,因此通常能够同时容忍近一半的系统故障。如果系统能够容忍失败的数量是f,这样系统必须至少有2f+1个进程。
拜占庭故障复杂一些。在一个具有2f+1进程的系统中,如果f是拜占庭,这些拜占庭节点可以协作来说任何事情对另外f+1的进程。例如,我们尝试取得单比特共识,并且f=1,所以我们有N=3个进程,A,B,C,其中C是拜占庭,如图2.2所示。C可以告诉A这个值是0,告诉B这个值是1。如果A同意它是0,B同意它是1,那么他们都将认为他们获得了大多数,提交,这样就违反了安全条件。因此,拜占庭系统能够容忍的故障上限小于非拜占庭系统。
图2.2
图2.2 一个拜占庭进程C,告诉A一件事,告诉B另外一件,致使他们得出关于网络的不同的结论。这里。简单的大多数投票导致了安全违规,源于单个拜占庭进程。
事实上,可以证明拜占庭故障的上限为f在1999年,Castro 和 Liskov 发表了实用拜占庭容错（Practical Byzantine Fault Tolerance）,提供了第一个优化的适用于实际的拜占庭容错算法。其为工业系统中拜占庭容错的实用性设定了一个新的先例,每秒可以处理成千上万比交易。除此之外,拜占庭容错仍然是被人认为是昂贵的,大部分时间是不必要的,并且最流行的实现很难建立在其上面。因此,尽管学术对其兴趣日增,包括大量提高了的变种,但在实施和配置方面并没有太多进展。进一步,如果网络中超过1/3的节点是拜占庭,PBFT将不能提供任何保证。

密码学,信任和经济学
根本上说,容错这个问题起源于缺乏信任 - 不知道一些进程将如何表现（behave）。正式地,信任需要从理论上被定义成一种信息,其作为一种减少世界模型熵的手段-信任某个人就是乐观地减少这个人对于这个世界的不确定性,使得可以把注意力放在更高阶的组织层面上。
密码学原语从根本上与信任问题相关,主要被定义为允许熵大量减少的机制-成功认证一个密码学函数把一个可能结果的分布坍缩成一个点,或者在一些例子中一些少量的结果。
它是做所周知的有着更好制度信任的文明,例如法治具有更高的生产率和更充满生气的经济。结果产生了一个直观的感觉,能够更多的信任相互作用,减少可能结果的空间,其需要被主动建模,使其更容易协调。不幸的是,评价现代机构的信誉越来越困难,因为他们的复杂度在近些年增加了很多,增加了可能性,其声称的确定性是幻觉。
幸运的是,密码学形成了社会中心的信任体系的基础,奇迹大地提高了人类在全球范围内协作的能力,由于减少了欺骗和无责任行动的风险。比较有趣的是密码学原语在BFT算法中的重要性,为了认证和散播不确定性。
最有趣的是,经济机制也能当作减少熵的一种方式,迄今为止经济代理可以被激励-更有可能被用来执行一个特定的行为。比特币深入的洞察是密码原语可以与经济激励结合起来有效减少公共共识网络的熵来取得状态安全复制。
更正式的信任的信息理论根基,密码学,共识和经济学和他们之间的关系的调查将会在以后的工作中展开。

区块链
区块链的核心是一个关于拜占庭容错原子广播的聚焦完整性的方法。例如,比特币区块链结合了经济学和密码学随机化来提供一个强的概率保证,保证安全违规不会发生,给定了一个弱同步假设,即区块间的通讯比产生哈希碰撞更迅速。实际上,然而,众所周知,比特币的安全保证容易受到各种狡猾（subtle）的攻击。
区块链从两个关键的优化中得到它的名字,其利用这两个优化解决了原子化广播的问题。第一个是交易以块为单位进行分组来分摊高提交延迟（在10min量级）。第二个优化是通过加密哈希把区块链接起来成为一个不可篡改的链,这样就很容易验证历史记录。两个优化都相对于原始的BFT-ABC的有所提高,前者提高了性能,后者提高了容错。
经过这几年的发展,使用哈希链接交易块并以原子广播发送出去已经成为公共的区块链共识算法。据作者所知,Tendermint是第一个这样的提议,升级了知名的80年代的BFT算法,成为了自成体系的共识算法。Tendermint被IBM跟进,IBM升级PBFT到区块链,JP摩根升级了一个Raft的BFT版本。

过程演算
各个部分同时执行的分布式系统,因难以设计、构建和调试而饱受诟病。它们更难以正式验证,因为大多数技术的形式验证,以及实际上非常基础的计算机科学,都是通过推算得到的,因此很难正式验证。
过程演算是一种为并发计算提供了有条理的基础原理的模型系列。最通常的演算方法,Communicating Sequential Processes（CSP）构成了许多现代编程语言的理论基础。比如Go语言,在设计中包含了并发原语。
我们可以使用一个正式的逻辑来表达一个过程可能满足的属性。举例来说,模态Hennessy–Milner逻辑可以表示,在某些或所有形式的动作发生后,一个进程将满足其他一些逻辑表达式。通过将更复杂的运算方法添加到逻辑中,可以建立正式的系统,可以很容易地描述分布式系统的重要属性,比如安全性、可用性和本地化等。通过π-calculus编写的系统可以被正式验证,以满足使用模型检查软件的相关属性。
当我们使用π-calculus来详细说明Tendermint算法时,我们会使用相关的正式逻辑,以及相应的属性验证,以备将来的工作。

Tendermint的需求
比特币及其衍生物的成功,特别是以太坊和他们的关于安全,自治,分布式,对任意代码的容错执行的前景引起了事实上每一个主要的金融机构的兴趣。特别地,出现了对两种种区块链技术：一方面是公链,被亲切地称为Big Dad公链（Big Bad Public Blockchains）,其协议被内建经济激励通过原生货币（native currency）的方式所支配。另一方面是所谓的私有链,更准确的被称为“联盟链”（ consortia blockchains）,通过哈希树的使用,数字签名,p2p网络和加强的问责制,其对传统共识和拜占庭算法有一定的提高。
就像现代社会的基础设施持续的去中心化或者正如商业的跨组织本质,对透明,问责和高性能的拜占庭系统的需求越来越多,这个系统支持的应用程序从财政到域名注册到电子投票和与治理的高级机制协作和未来的演进。Tendermint这个解决方案对联盟或者跨组织逻辑进行了优化,但是足够灵活来容纳任何人,从私有企业到全球货币,并且性能足够高来与主要的,非拜占庭容错的,共识解决方案竞争例如 etcd, consul, and zookeeper,于此同时提供了更强的恢复性,安全保证,对应用开发者的灵活性。

「深度学习福利」大神带你进阶工程师,立即查看>>>
上一篇文章 以太坊（Ethereum）与以太（Ether） 中,你应该很好地理解以太坊是如何构建以太坊应用程序网络的,这些应用程序需要一个名为Ether的加密货币来运行。现在是时候引入一个更深层的概念——Token通证也称为代币。在以太坊上构建的许多dApp都有自己的加密货币或 Token 。为了与dApp交互,用户需要购买dApp自身的Token通证（代币）。一般而言,通证（代币）表示给定生态系统中的特定事物。这可能是经济价值,股息,股权,投票权......现实中的具体事物。重要的是要理解Token即通证（代币）不仅限于一个特定的角色；它可以在其自身的生态系统中履行各种不同的角色。
既然我们有以太,那为什么还需要Token？
在了解了以太以及它在以太坊网络中如何运作之后,我们要问的一个自然问题是,为什么我们不使用Ether来支付这些dApp中的每笔交易？为什么我们需要自己的货币？对此的答案非常简单,因为在现实世界中有很多地方我们也使用代币而非传统货币。
一个最简单的示例就是娱乐场所常见的街机游戏。
如果你想在街机游戏中玩游戏,你必须先将钱存入投币机或者找服务员换成街机代币。一旦你有了代币,那么你就可以玩游戏了。
不同类型的Token
以太坊生态系统正在迅速发展,变化和扩大。一分钟就可能出现了新的创新。将来会有各种基于区块链的Token通证（代币）。但是现在,我们将讨论三种基于区块链的通证（代币）： Usage tokens：使用某种服务时所需的代币。 Work tokens：一种代币,使用户有权为DAO做贡献并以工作成果交换的方式获得收益 Security tokens：一种为外部交易资产服务的代币,代表系统中的价值。  
Usage tokens
这些Token代币的功能就像它们各自的dApp中的货币一样。这通常是Token的最简单和直接的应用。这些代币具有货币价值；但是,他们在特定网络中没有任何形式的权利或特权。简而言之,将Token视为金钱。使用Token有时也称为“medium-of-exchange”代币。
示例：Golem,0x,Civic,Raiden,Basic Attention Token等。
Work tokens
工作通证使用户有权为组织贡献工作以帮助其发挥作用。在此模型中,用户（或服务提供商）使用网络的本身通证来获得为网络执行工作的权利。关于工作通证模型的一个很酷的事情是,随着对服务的需求的增长,更多的收入将流向服务提供商。鉴于固定的通证供应,服务提供商将合理地为每个通证提供更多的权利,以获得不断增长的现金流的一部分。我们将深入研究bonding,计算估值以及网络激励的概念。在此阶段要理解的重要事项是工作通证授予对网络的访问权限并提供现金流量的潜力,条件是使用通证交付工作。
示例：Augur,Keep,Truebit,Gems等。
Security tokens
证券代币,也称为代币化证券或投资代币,是符合美国证券交易委员会规定的金融证券。虽然不会涉及法规和合规性,但要理解的简单事项是这些代币为代币持有者提供了一系列财务权利。
这些财务权利的例子包括股权,股息,利润分享,投票权等。简单地说,这些代币代表对相关资产的权利,例如房地产,现金流或持股。使证券代币如此透明（并且可能具有革命性）的原因在于,权利被写入智能合约中,并且代币在区块链驱动的交易所上交易。
把它们整理一下
虽然在这里引入了许多关于Token通证或代币的新概念,重要的是要记住在以太坊上构建的dApp,它们就像街机游戏。使用它们,与它们交互,甚至与它们一起玩都要从拥有Token通证或代币开始。随着生态系统的成熟,开发人员将尝试并继续提出的各种想法,并以此为基础上进行构建。随着时间的推移,我们肯定会发现新的和创造性的方法来捕捉各种网络原生Token通证或代币的价值,继续增强用户体验并使某种新的事物成为可能。
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 以太坊Token通证或者代币的作用

「深度学习福利」大神带你进阶工程师,立即查看>>>
客观的来说,以太坊与以太这两个概念很容易混淆。
当我们听到以太坊 Ethereum 这个词时,我们通常会将它与加密货币（比如比特币）联系起来。虽然这个定义并不完全错误。但重要的是要理解以太坊不仅仅是一个简单的加密货币,它实际上是一个基于区块链技术的开放式软件平台,使开发人员能够使用智能合约构建和部署去中心化的应用程序。
但是,为以太坊网络提供支撑动力的加密货币称为以太 Ether 。这正是Coinbase等许多交易所的卖点。
以太坊如何工作
以太坊区块链的功能类似于比特币区块链：一个由计算机组成的网络运行软件,通过称为挖矿的多数共识算法来验证交易。挖矿由运行这些验证交易的计算机所有者提供支持。
比特币矿工通过得到比特币来获得资金补偿。
以太坊矿工通过在以太网中获得以太得到补偿。
Ether以太是一种可编程货币
单纯的将以太称为数字货币可能会产生一些误导,因为实际上它更像是一种数字商品。
就像你需要汽油来为你的车辆加油一样,你需要Ether以太才能在以太坊区块链上运行应用程序。这里以太为智能合约提供支持（例如通过设置租金进行支付才能观看的视频）以及运行 DApps ,在ICO期间生成通证,促进以太坊区块链上的交易,以及进行款项支付。这就是为什么以太坊（或以太）也可以被称为可编程货币。
以太既是商品也是货币
说以太更像是商品而不是货币的原因在于,适用于石油和天然气等商品的供需经济学原理中的基本原则也同样适用于以太。油是有价值的,因为它为我们日常生活中使用的许多东西提供动力,它可以为我们取暖的锅炉或者为我们的发动机提供动力。
现在越多人开始使用基于以太坊的应用程序,对Ether以太的需求也就越高,这将增加其价值。
由于以太是很有用的,可交换的和可转让的,很多的商家也就开始接受它作为货币,这时就体现出了它的货币属性。
把它们整理一下 以太坊是平台,以太像是为平台提供动力的燃料。 以太被用来买卖,而以太坊不能。 Ethererum以太坊上有各种各样的应用程序。 Ether在以太坊区块链上只有一个 application=enable 操作。
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 以太坊（Ethereum）与以太（Ether）

「深度学习福利」大神带你进阶工程师,立即查看>>> 原文题目： 《Tendermint: Byzantine Fault Tolerance in the Age of Blockchains》
原文作者： Ethan Buchman
翻译： 饶云坤
校对： 傅晓波
本文为节选
以下为正文：

本章阐述Tendermint共识算法和用于原子广播（ atomic broadcast）的相关区块链。拜占庭容错共识问题将被详细讨论,并且Tendermint共识的一个正式说明将以π-calculus的形式给出。Tendermint区块链已经被非正式地证明为满足原子广播。将来我们将以进程演进的方式来描述完整的区块链协议,并证明相关特性。

Tendermint综述
Tendermint是区块链范式中的一个安全的状态机复制算法。其算法形态为BFT-ABC,并且附加责任制,便于验证拜占庭节点的不诚实行为。
Tendermint算法给每个区块赋予一个增量索引或者高度（height）,在某一高度中只存在一个有效的区块,区块链从高度为0的创世纪块开始,由一个验证者集合投票产生下一个区块,其中每一个验证者由各自的公钥标识。每一个验证者需要维护一份完整的复制状态的拷贝。在投票产生某一高度的区块的过程中,在正式提交（commit）某一高度的区块之前,至少需要经过一轮（round）投票（vote）来达成共识。每一轮都会通过round robin的方法产生一个提议者（proposer）,该提议者在当轮以广播的形式提出一个提议（proposal）,提议经过验证者的集体投票,来决定是否最终提交该区块或者进入下一轮。在提议的区块真正被提交（commit）之前,验证者们需要进行两轮投票（pre-vote & pre-commit）, 通过一个简单的锁机制用来阻止少于总数1/3的拜占庭节点攻击。由于Tendermint网络的不同时性（asynchrony）,当拜占庭节点超过总数的1/3,网络存在瘫痪的可能性。
注意到,tendermint的多轮投票机制的核心是共识算法。每一个区块包含一些元数据（metadata）,称作区块头（header）。区块头里包含本区块的高度,提议时间,本区块所有交易的梅克尔根哈希值。

共识
共识算法可以大致分为以下几部分：
• 提议（Proposals） ：在每一轮（round）中,新区块的提议者必须是有效的,并且告诉（gossiped）其他验证者。如果在一定时间内没有收到当轮提议（proposal）,当前提议者将被后面的提议者接替。
• 投票（Votes） ：两阶段的投票基于优化的拜占庭容错。它们分别被称作预投票（pre-vote）和预提交（pre-commit）。对于同一个区块同一轮如果存在超过2/3的预提交（pre-commit）则对应产生一个提交(commit)。
• 锁(Locks) ：在拜占庭节点数少于节点总数的1/3的情况下,Tendermint中的锁机制可以确保没有两个验证者在同一高度提交（commit）了两个不同的区块。锁机制确保了在当前高度验证者的下一轮预投票或者预提交依赖于这一轮的预投票或者预提交。
为了应对单个拜占庭故障节点,Tendermint网络至少需要包括4个验证者。每个验证者拥有一对非对称密钥,其中私钥用来进行数字签名,公钥用来标识自己的身份ID。验证者们从公共的初始状态开始,初始状态包含了一份验证者列表。所有的提议和投票都需要各自的私钥签名,便于其他验证者进行公钥验证。
验证人在发起提议（proposal）步骤之后,当且仅当收到其它验证人超过三分之二（+2/3）的投票后才会进一步推进流程。虚线箭头表示进入下一个区块高度共识流程的原子广播。
共识开始于第0轮,第一个提议者（proposer）是区块链头里验证者列表里的第一个验证者。每一轮最终要么完成了一个提交（commit）,要么直接进入当前高度的下一轮,每一轮都会产生一个新的提议者。
与其他选举（leader election ）算法不同,Tendermint每一轮都会产生一个新的提议者(proposer),验证者投票决定是否进入下一轮,这与接受提议的流程类似。
每轮的开始对同步有弱的依赖性。每一轮开始期间,存在一个用来计时的本地同步时钟,如果验证者在TimeoutPropose时间内没有收到提议,验证者将参与投票来决定是否跳过当前提交者。TimeoutPropose会随着轮数的增加而增加。
每轮收到提议以后,进入完全异步模式。之后验证者的每一个网络决定需要得到2/3验证者以上的同意。这样降低了对同步时钟的依赖或者网络的延迟。但是这也意味着如果得不到1/3以上验证者的响应,整个网络将瘫痪。
简言之,每轮,开始提议弱同步,之后投票完全异步。
为了增强Tendermint共识网络的安全性,引入了少量的锁定规则（locking rules）来迫使验证者自证其投票的合法性。尽管我们不需要实时广播他们的合法证明,但是我们确实期望验证者们保存相关数据。这样当网络被拜占庭故障节点瘫痪时,其可以存留为相关证据。这个问责机制确保在网络故障（例如PBFT）的时候Tendermint具有一个更健壮的担保（guarantees）。
验证者使用一组不同的消息（messages）来管理区块链,应用程序状态,p2p网络和共识。其中,核心的共识算法包含两类消息：
ProposalMsg: 对应某一高度及某一轮数的区块的提议（proposal）,该提议已经由提议者签名
VoteMsg: 对某一提议的签名投票

一、提议
每轮开始于一个提议（proposal）,提议者从内存池（Mempool）选取一批交易进而构成了一个区块,该区块随后被嵌套在ProposalMsg中,最后提议者广播（broadcast）ProposalMsg。如果这个提议者是拜占庭节点,他可能向不同的验证者广播不同的ProposalMsg。
提议者通过一个简单并且相对固定的的roubd robin轮流坐庄,所以每一轮只有一个有效且被所有验证者公认的提议者。如果验证者收到了之前更低轮次的提议或者提议来自于非法的提议者,该提议将被拒绝。
提议者的轮流坐庄对于拜占庭容错是必要的。比如,对于raft算法,如果选举出来的leader是拜占庭,并且leader与其他节点网络连接状态良好,该leader可以完全控制整个网络,网络节点的安全和正常运转将无从得到保障。Tendermint通过投票和锁的机制（voting and locking mechanisms ）确保了系统的安全性。如果一个提议者在限定时间内没有处理任何交易,排在其后的提议者将会接替他。更有趣的是验证者能通过治理模块投票来移出或者替换拜占庭验证者。

二、投票
一旦验证者从网络中收到了一份完整的提议（proposal ）,他对该提议进行预投票（pre-vote）签名,并且广播到网络中。如果验证者在ProposalTimeout时间内没有接收到一个有效的提议,其对该提议的预投票为空（nil）。
在存在拜占庭节点的异步环境中,单阶投票,即每个验证者对每个提议只投一次,不能足以确保整个系统的安全。本质上,因为验证者可能做出一些不诚实的行为,并且消息的到达时间没有任何保障,一个不诚实的验证者可以与其他验证者进行协作来提交（commit）一个区块,然而其他没有看到这个提交区块的验证者进入了新的一轮,并提交（commit）了一个不同的区块。
一个单阶的投票允许验证者互相沟通他们知道的关于该提议的信息。但是为了容忍拜占庭故障,他们也需要互相告诉对方他们自己了解到的其他验证者声称了解到的关于该提交的信息。换句话说,二阶段提交确保了足够的验证者见证了第一阶段的结果。
对于某个区块的非空预投票是为网络提交（commit）区块已做好准备的投票。空预投票是为网络直接进入下一轮的投票。在理想的一轮中,超过2/3的验证者为该提议进行了预投票。在任意一轮中,区块具有的超过2/3的预投票被称作一个波尔卡（polka）。超过2/3的空预投票成为空波尔卡（nil-polka）。
当一个验证者收到了一个波尔卡（polka）,他接受到了一个信号,即网络准备提交该区块,作为一个验证者签名并且广播预提交（pre-commit）的背书。有时,由于网络的不同时性,验证者可能没有收到对应的波尔卡或者波尔卡根本就不存在。在这种情况下,验证者没有对应的波尔卡为这个预提交背书,此时预提交为空。也就是说,在没有收到波尔卡背书的情况下,签名一个预提交被看作是一个恶意行为。
预提交（pre-commit）是关于提交(commit)一个块的投票。空预提交则投票进入到下一轮。如果验证者收到2/3以上验证者的预提交,则其在本地提交该块,计算结果状态,并移动到下一高度的第0轮。如果验证者接收到超过2/3的空预提交,则投票进入下一轮。

三、锁
多轮投票的安全问题是棘手的,必须避免同一高度不同轮数分别提交两个不同区块的情形。在Tendermint中,这个问题可以通过锁机制（locking mechanism）得到解决。锁机制的大致定位在波尔卡附近。本质上,预提交必须有一个波尔卡为其背书,验证者被锁定在其最近预提交（pre-commit）的区块上。
锁定规则：
· 预投票锁 （Prevote-the-Lock）：验证者只能预投票(pre-vote)他们被锁定的区块。这样就阻止验证者在上一轮中预提交(pre-commit)一个区块,之后又预投票了下一轮的另一个区块。
· 波尔卡解锁 （Unlock-on-Polka ）：验证者只有在看到更高一轮（相对于其当前被锁定区块的轮数）的波尔卡之后才能释放该锁。这样就允许验证者解锁,如果他们预提交了某个区块,但是这个区块网络的剩余节点不想提交,这样就保护了整个网络的运转,并且这样做并没有损害网络安全性。
简单来说,验证者可以被看作锁在任意高度-1轮的nil-block上,所以波尔卡解锁意味着验证者不能预提交一个新高度的区块直到他们看见一个波尔卡。
这些规则可以以例子的形式被更直观的理解。考虑4个验证者,A,B,C,D,假设有一个第R轮关于blockX的提议。现在假设blockX已经有一个波尔卡,但是A看不见它,预提交（pre-commit）为空,然而其他人对blockX进行了预提交。进一步假设只有D看见了所有的预提交,然而其他人并没有看见D的预提交（他们只看见他们的预提交和A的空预提交）。D现在将要提交（commit）这个区块,然而其他人进入到R+1轮。由于任何验证者都可能是新的提议者,如果他们提议并投票了一个新的区块blockY,他们可能提交这个区块。可是D已经提交了bockX,因此损害了系统的安全性。注意,这里并没有任何拜占庭行为,仅仅是不同时性。
（为了便于读者理解,译者补充此表格,下同）
锁定解决了这个问题通过强迫验证者粘附在他们预提交（pre-commit）的区块上,因为其他的验证者可能居于这个预提交进行了提交（如上例中的D）。本质上,在任何一个节点一旦存在超过2/3预提交（pre-commit）,整个网络被锁定在这个区块上,也就是说在下一轮中无法产生一个不同块的波尔卡。这是预投票锁的直接动机。
当然这里必须有相应的解锁方式。假设在某一轮中,A和B预提交（pre-commit）了blockX,与此同时C和D的预提交为空。因此所有的验证者进入到下一轮,预提议(pre-vote）blockY。假设A是拜占庭,为blockY也进行了预投票（不考虑其被锁在blockX上）,导致了一个波尔卡。假设B并没有看见这个波尔卡,预提交为空,此时A下线,C,D预提交bolckY。他们进入到下一轮,但是B仍然被锁定在blockX上,C和D被锁定在blockY上。这时因为A下线了,他们将永远得不到一个波尔卡。因此即使在拜占庭节点少于1/3的情况下,这里网络的正常运转仍然受到了影响。

解锁的条件是1个波尔卡。一旦B看见了blockY的波尔卡（用来为C和D的关于blockY的预提交背书）,他应当能够解锁并预提交（pre-commit）blockY。这是波尔卡解锁的动机,其允许验证者在看见更高轮数波尔卡的时候解锁并且提交对应的新区块。

区块链
Tendermint对交易按批或块进行处理。区块之间通过加密哈哈希算法链成一个完整的区块链。区块链包括经过排序的交易日志和验证者提交的相关证据。

一、为什么是区块？
共识算法一次提交若干个交易（transactions）。正如在第二章提到的那样。从分批原子广播（batched atomic broadcast）的角度来看待这个问题,对应两个主要的优化,其给了我们更多的吞吐量和容错能力：
· 带宽优化 ：因为每一次提交(commit)需要验证者之间的两轮通讯,以块为单位交易的批处理,平摊了提交的成本在该区块中的所有交易上。
· 完整性优化 ：区块的哈希链形成了一个不可篡改的数据结构,跟git仓库很像,具备历史任意点的子状态认证检查的能力。
区块也引起了另外一个效应,看上去更微妙,但是可能更重要。他们增加了单个交易的最小延迟到区块的最小延迟,对于Tendermint来说在数百毫秒到数秒量级。传统的序列化数据库系统提供了提交延迟在毫秒到数百毫秒量级。他们的低延迟是因为这些数据库不是拜占庭容错的,只需要一轮通讯而不是两轮和来自于1/2而不是2/3节点的响应。然而,与其他具有快速提交时间（commit times）的选举算法不同,Tendermint提供了一个更常规的脉冲（pulse ）,在节点故障和网络不同时方面对整个网络的状态具有更好的响应度。
脉冲在通讯自治系统一致性方面的角色现在并不明朗,但是由此引发的延迟在金融市场中是具有前景的。

二、区块的结构
区块的目的是打包一批交易,并且链接到前面一个块。链接包含两种形式：前面一个区块的哈希和前面区块的预提交的集合,其也被称作LastCommit。因此一个区块由三部分构成：区块头,交易列表和Lastcommit。

安全性
这里我们简要的证明一下Tendermint满足原子广播。原子广播被定义为满足以下条件：
· 有效性（validity） - 如果一个正确的进程广播m,它最终成功传达了m
· 一致性（agreement） - 如果一个正确的进程成功传达了m,所有最终所有的进程成功传达m
· 完整性（integrity） - m只传递一次,并且是以广播的形式被发送者发送出去
· 总的顺序（total order） - 如果正确的进程p和q分别传递出m和m',p传达m在m'之前,那么q传达m在m'之前
注意到, 如果把m看作一个区块,Tendermint并不满足有效性,因为并不能保证提议的区块最会会被提交,因为验证者可能进入到新的一轮,并提交一个不同的区块。
如果我们把m看作某一区块里的一批交易,那么我们能够满足有效性通过验证者重新提议同一批交易直至交易最终被提交。
为了满足完整性的第一部分,我们必须引入额外的规则来禁止一个合法的验证者提议或者预提交一个区块,其中这个区块包含的这批交易已经被提交过。幸运的是,交易可以被梅克尔根索引,在提议和预提交以前可以进行相关的查找来滤除已经提交的交易。
或者我们可以把m当成一个交易（transaction）,通过引入内存池的持久属性,可以满足有效性,即,交易可以驻留在内存池中直到它被提交。然而为了满足完整性的第一部分,我们必须依赖应用程序状态（application state）来制定一些针对交易的规则,这样一个给定的交易只能进行一次。例如,可以通过基于账户的序列号,正如在以太坊中的那样。或者保存一份未使用资源的列表,每一个资源只能被使用一次,正如在比特币中使用的那样。因为有多种方法,Tendermint本身并不保证消息只传达一次,但是允许应用开发者来指定相关特性。完整性的第二部分显而易见,因为只有正确的提议者提议的区块中的交易才能被提交。
为了证明Tendermint满足“总的顺序”,我们引入了一个新的特性,状态机安全性（state machine safety）,并且可以证明满足状态机安全性的协议必定满足“一致性”和“总的顺序”。所谓的状态机安全是指如果一个正确的验证者在高度H提交了一个区块,没有其他的验证者在同一高度提交一个不同的区块。考虑到所有的消息最终被接收,这个立刻暗示了一致性,因为如果一个正确的验证者在高度H提交了一个区块B,包含了交易m,所有其他的正确的验证者不能提交其他的区块,因此最终提交了区块B,传达了消息m。
现在,我们需要证明状态机安全满足“总的顺序”,并且Tendermint满足状态机安全。为了证明前者,考虑两个消息m和m'分别由验证者p和q发出。状态机安全确保p发出消息m在高度Hm当且仅当q发出消息m在高度Hm,并且p发出消息m'在高度Hm'当且仅当q发出消息m'在高度Hm'。不失一般性,因为高度是严格递增的,假设Hm最后,为了证明当拜占庭节点少于1/3的时候,Tendermint满足状态机安全,我们采用反证法。假设Tendermint并不满足状态机安全,允许在某一高度提交多个区块。那么我们可以证明至少需要1/3的拜占庭节点,与假设矛盾。
考虑一个有效的验证者在高度H和轮数R提交了一个区块B。提交一个区块意味着验证者在第R轮收到了关于区块B的超过2/3的预提交。假设另一个区块C在高度H提交。我们有两个选项：要么在第R轮提交要么在S轮提交（S>R）。
如果区块C在第R轮提交,那么超过2/3的验证者必须为该区块预提交,那么意味着至少1/3的验证者在第R轮同时对区块B和C进行了预提交,那么显然这些同时节点是拜占庭节点。假设区块C在S轮提交。因为超过2/3对B区块进行了预提交,他们在S轮也将被锁定在区块B上,因此他们必须对B进行预投票。为了对区块C进行预提交,他们必须接收到关于区块C的波尔卡,因此需要关于区块C的超过2/3的预投票。然而,超过2/3的验证者已经被锁定在区块B上。节点为了收到区块C的波尔卡至少需要网络中1/3的验证者违背锁机制,这部分节点显然是拜占庭节点。因此,为了违背状态机安全,至少需要1/3的拜占庭验证者。即若网络中的拜占庭节点少于总数的1/3,Tendermint满足状态机安全性。
综上,Tendermint满足原子广播。
在未来的工作中,我们会提供关于Tendermint的安全性的更正式的证明。

责任制
一个具有问责制的拜占庭容错算法能够在存在安全隐患时标识所有的拜占庭验证者。传统的拜占庭容错算法并没与这个特性,对应地也没有任何相应的保证。当然,问责制仅能适用在拜占庭节点在1/3到2/3的情况。如果超过2/3的节点是拜占庭,他们能够完全占据协议,此时无法保证一个合法的验证者可以收到任何拜占庭节点违法的证据。
进一步,问责制是在异步网络环境下最终性的尽力而为,在这样的网络环境中着安全问题,关键消息（critical messages）的延迟使得在探测到安全问题以后才可能发现拜占庭验证者。事实上,如果正确的进程（correct processes）可以接受拜占庭行为的相关证据（evidence）,但是在他们能够通讯之前不可逆地失败了（fail irreversibly）,可能使得问责制永久失效（ Permanently compromised）,尽管实际上这种情形可以通过高级备份策略来克服。
通过枚举安全问题的各种隐患,拜占庭验证者是可以识别的,这样协议是具有问责制的。与其它竞选相关的协议相比,Tendermint的简洁给予了其更简单的分析方法。
在Tendermint存在两类安全隐患,每一种都是可问责的。第一种,拜占庭提议者在单轮中产生两个冲突的提议,并且拜占庭验证者同时对这两个提议进行投票（vote）。第二种,一些验证者在单轮已经提交（commit）之后,拜占庭验证者违反锁机制（locking rules）,致使其他验证者在随后的轮数提交一个不同的区块。注意到,若拜占庭验证者少于2/3,只通过违反解锁机制的方法是无法引发安全性问题的,同时超过1/3的节点必须违背波尔卡锁机制,因为每一个提交（commot）需要有一个波尔卡为其背书。
在存在提议或者投票冲突的情况下,同时接受冲突的提议或者投票,可以根据这些提议或投票的签名来辨别这些拜占庭节点。
在违反锁定机制(locking rules)的情况下,伴随着相应的安全性问题,有效的验证者必须广播在当前高度看到的所有投票,这样证据可以被收集起来。少于2/3的正确验证者在所有导致两个区块被同时提交的投票中集体隐匿。此时在这些投票中,如果没有1/3或者更多的验证者签名冲突的投票,那么存在1/3或者更多的验证者违反了锁定机制。
如果预投票（ pre-vote ）或者预提交（ pre-commit）影响了一个提交,它一定会被一个合法的验证者看见。因此,通过搜集所有的投票,通过匹配每一个预投票和最近的预提交,可以探测到违反锁机制的行为（violations of Prevotethe-Lock ）。
类似的,通过匹配预提交（pre-commit ）和为其背书的波卡尔卡（polka）,可以探测到违反解锁机制的行为（violations of Unlock-on-Polka ）。注意到这就意味着如果拜占庭验证者可以在看见波尔卡之前预提交（pre-commit）,并且如果相应的波尔卡最终发生的话,拜占庭验证者将逃脱责任制。然而,如果每一个预提交有波尔卡背书的话,这些安全隐患就不存在。
目前的设计提供了问责制,伴随着后危机广播协议（post-crisis broadcast protocol）,但是其能够用来提高实时的问责制。也就是说,一旦提交被改变,相应的预提交,为预提交背书的预投都会发生改变,这样一直回退到创世纪块。通过上面的方式,如果发生安全问题,没有背书的投票可以立即被探测到。

故障和可用性
作为一个拜占庭共识容错算法,Tendermint可以容忍拜占庭故障节点到（但不包括）节点总数的1/3。这就意味着节点可能会崩溃,发送不同和冲突的消息到不同的节点,拒绝中继消息或者表现异常,安全或者运转存在问题。
协议中有两个地方我们可以通过使用本地时钟的超时特性,为不同时性做一些优化：在接收到2/3或者更多预投票（pre-votes）之后（不针对单个区块或者nil）和在收到2/3或更多预提交（pre-commit）以后（不针对单个区块或者nil）。在每一中情形中,我们可以睡眠一段时间用来给延迟的投票一个被接受的机会,因此减少在新的一轮没有提交区块的可能性。时钟不需要在验证者之间同步,因为验证者在观测到2/3或更多的投票时会重置各自的时间。
如果1/3或者更多的验证者崩溃,网络瘫痪,因为任何共识进展需要2/3以上验证者的投票。网络仍然可以读取数据,但是没有新的区块的提交。只要验证者重新上线,他们能够从之前的投票状态开始。共识状态机应该配置一个预写式日志（write-ahead log）,这样重新上线的的验证者可以快速回退到之前机器崩溃时的位置,确保没有违反规则。
如果1/3或者更多的验证者是拜占庭,他们能够以多种方式损害系统的安全性。例如,在同一轮提交两个块,并且投票提交这两个区块或者通过通过违反锁定机制在同一高度不同轮提交两个不同的区块。在每一种情形中,有清晰的证据显示哪些验证者是拜占庭节点。在第一个例子中,他们在同一轮签名两个不同的提议,违反规则。在第二个例子中,他们锁定在r-1轮在第r轮提交了一个不同的区块,违反了锁定机制。
当使用经济和治理组件来激励和管理共识,这些额外的责任制保证是具有决定性的。

结论
Tendermint本身是弱同步,拜占庭容错,状态机复制协议,拥有优化的拜占庭容错和额外的责任制来保证当超过拜占庭容错假设上限时的情形。协议采用round robin的提议者产生方法,用同样的机制跳过一个提议者。多轮投票之间的安全性通过锁机制得到了保障。

本章是关于协议的表述,存在许多有待进一步讨论的重要细节,例如块之间有效的通讯（efficient gossiping of blocks）,缓存交易,验证者集合的改变和应用逻辑的接口。这些重要的话题将在随后的章节得到进一步的解释。

「深度学习福利」大神带你进阶工程师,立即查看>>>
2天培训  16个课时
探寻技术原理,精通以太坊智能合约开发
以太坊智能合约是现在应用的最广泛的区块链应用开发方式,HiBlock区块链社区针对以太坊智能合约的学习特别推出2天闭门研修班,通过2天16个课时,学习掌握以太坊智能合约从基础入门到开发实践。
1月19-20日,由HiBlock区块链社区发起人Bob Jiang老师以及以太坊专家杨镇老师联合授课。 本次课程从以太坊智能合约基础讲起,覆盖2个区块链应用的动手实践以及区块链投票、拍卖、在线支付等智能合约实例的讲解,在2天时间里由浅入深掌握区块链智能合约开发。
1
时间地点
**开课时间：**1月19日-1月20日 （每天9:00-17:00）
**开课地点：**北京市朝阳区富华大厦D-4B
**报名费用：**原价2800元/人, 限时优惠价1800元/人
（ 注 ：本课程招生名额有限,一旦报名不接受因学员自身原因产生的退款,报名请准时到场。）
学员自带电脑
可加微信咨询,微信号：EF0815。好友申请输入：线下培训
2
课程内容
1月19日：掌握以太坊：实践驱动智能合约学习
内容简介：
第一天共计8个课时（45分钟/课时）,BoB Jiang老师对区块链相关概念进行介绍,帮助学习者掌握以太坊基础概念及智能合约Dapp开发,并介绍Solidity语言基础。通过6个课时进行2个具体项目的动手实践,在开发过程中掌握智能合约开发技巧,主讲教练将全程指导每一位学员真正开发出可落地的区块链应用。
1月20日：精通以太坊：原理驱动智能合约实践
内容简介：
杨老师基于对以太坊黄皮书（技术文档）的精湛了解,通过8个课时（45分钟/课时）向学习者完整介绍以太坊协议的实现原理及协议细节,在1天时间内对以太坊黄皮书进行精简解读,并利用2个课时帮助开发者掌握智能合约开发语言Solidity语言的重要特性,结合投票、拍卖、安全付款、微支付通道等实例让学习者从原理上掌握以太坊技术。
3
课程收益
1、建立区块链技术认知,形成开发者学习体系；
2、掌握区块链Dapp开发,动手实践区块链应用；
3、认知以太坊技术原理,学习以太坊编写语言；
4、高阶以太坊技术应用,了解微支付系统实例。
4
主讲教练
主讲教练：BoB Jiang
HiBlock区块链社区（hiblock.one）发起人,中国北方的第一位CST（Certified Scrum Trainer）,国内的敏捷（Agile）大咖；敏捷变革中心（Center for Agile Transformation）合伙人,敏捷一千零一夜社区合伙人,敏捷之旅核心组织者,《Scrum精髓》译者。
主讲教练：杨镇
资深软件工程师、架构师；区块链技术布道者；有 17 年的软件行业从业经验。
2017年开始参与以太坊技术社区贡献；独立中译了以太坊 Homestead 官方文档；对以太坊黄皮书中文版进行了独立校订和增补更新；独立中译了以太坊分片技术说明；是 Solidity 官方文档中译项目的贡献者、校订人和项目管理员。
感谢 彪洋科技 提供场地赞助。
5
报名方式
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>> 平时交易的时候,交易员喜欢盯着盘面数据,why？原因是,关心行情的异动,找个机器人帮你盯着是个很好的办法。 言归正传,在商品期货交易策略中 经常看到 不同品种的 组合对冲策略,比如 焦煤、铁矿石 和 螺纹钢 对冲, 这种跨品种对冲策略是不是也能用到数字货币交易中呢？ 不过风险依然是不容忽视的,那么最简单的就是 回测一下 大致验证一下策略思路是否可行。

1.前提条件
我们选用价格差相对合适的 比特币（BTC） 、以太坊（ETH） 作为对冲 品种。

2.策略描述
我们在 BTC/ETH 比例小的时候 空ETH多BTC , 在比例大的时候 平仓, 可以使用SMA指标来进行择时。

3.策略地址 ： https://www.botvs.com/strategy/48536 使用了 “画线类库” 、 “ 数字货币交易类库” 这两个模板（可复用的模块代码）
4.DEMO 很方便的把想法画在了图表上, 其实还有很多地方要优化,这里只是抛个砖,探讨思路方法,接下来准备 优化 扩展 看看是否靠谱可行。

抛砖引玉般的DEMO ( JS 语言 基于发明者平台) /*exchanges A : BTC B : ETH */ var RateUpDateTime = new Date().getTime() var UpDateCyc = 60 * 60 * 1000 var SumInCyc = 0 var AddCounts = 1 var RateArray = [] var BTC_hold_amount = 0 var ETH_hold_amount = 0 var IDLE = 0 var PLUS = 1 var STATE = IDLE var fee_btc = { buy : 0.2, // 0.2 % , 千分之四 sell : 0.2 } var fee_eth = { buy : 0.2, sell : 0.2 } var ModeStr = ["BOLL", "SMA"][Mode] function CalcPriceForNoFee(price, fee, type){ if(type == "buy"){ return price * (1 - fee / 100) }else if(type == "sell"){ return price * (1 + fee / 100) } } function loop(nowTime){ var depthA = exchanges[0].GetDepth() var depthB = exchanges[1].GetDepth() var sma120 = null var sma10 = null var boll = null if(!depthA || !depthB || depthA.Asks.length == 0 || depthA.Bids.length == 0 || depthB.Asks.length == 0 || depthB.Bids.length == 0){ return } var Rate = CalcPriceForNoFee((depthA.Bids[0].Price + depthA.Asks[0].Price) / 2, 0.2, "buy") / CalcPriceForNoFee((depthB.Bids[0].Price + depthB.Asks[0].Price) / 2, 0.2, "sell") if(nowTime - RateUpDateTime > UpDateCyc){ RateArray.push(Rate) $.PlotLine("avgRate", RateArray[RateArray.length - 2], RateUpDateTime) if(RateArray.length > 60){ if(ModeStr == "SMA"){ sma120 = talib.SMA(RateArray, 60) sma10 = talib.SMA(RateArray, 10) $.PlotLine("sma120", sma120[sma120.length - 2], RateUpDateTime) $.PlotLine("sma10", sma10[sma10.length - 2], RateUpDateTime) }else if(ModeStr == "BOLL"){ boll = TA.BOLL(RateArray, 20, 2.5) $.PlotLine("up", boll[0][boll[0].length - 2], RateUpDateTime) $.PlotLine("down", boll[2][boll[2].length - 2], RateUpDateTime) } } RateUpDateTime += UpDateCyc SumInCyc = 0 AddCounts = 1 }else{ SumInCyc += Rate AddCounts++ RateArray[RateArray.length - 1] = (SumInCyc / AddCounts) $.PlotLine("avgRate", RateArray[RateArray.length - 1], RateUpDateTime) if(RateArray.length > 60){ if(ModeStr == "SMA"){ sma120 = talib.SMA(RateArray, 60) sma10 = talib.SMA(RateArray, 10) $.PlotLine("sma120", sma120[sma120.length - 1], RateUpDateTime) $.PlotLine("sma10", sma10[sma10.length - 1], RateUpDateTime) }else if(ModeStr == "BOLL"){ boll = TA.BOLL(RateArray, 20, 2.5) $.PlotLine("up", boll[0][boll[0].length - 1], RateUpDateTime) $.PlotLine("down", boll[2][boll[2].length - 1], RateUpDateTime) } } } if(ModeStr == "SMA"){ if(STATE == IDLE && (sma120 && sma10) && sma120[sma120.length - 2] > sma10[sma10.length - 2] && sma120[sma120.length - 1] < sma10[sma10.length - 1]){ // PLUS var SellInfo = $.Sell(exchanges[1], 5) var sumMoney = SellInfo.price * SellInfo.amount var amount = _N(sumMoney / depthA.Asks[0].Price, 2) var BuyInfo = $.Buy(exchanges[0], amount) ETH_hold_amount = SellInfo.amount BTC_hold_amount = amount STATE = PLUS // throw "stop" // ceshi } if(STATE == PLUS && (sma120 && sma10) && sma120[sma120.length - 2] < sma10[sma10.length - 2] && sma120[sma120.length - 1] > sma10[sma10.length - 1]){ // COVER var BuyInfo = $.Buy(exchanges[1], ETH_hold_amount) var SellInfo = $.Sell(exchanges[0], BTC_hold_amount) ETH_hold_amount = 0 BTC_hold_amount = 0 STATE = IDLE Log(exchanges[0].GetAccount(), exchanges[1].GetAccount()) } } } function main() { var AccountA = exchanges[0].GetAccount() var AccountB = exchanges[1].GetAccount() Log("AccountA:", AccountA, "AccountB:", AccountB) while(true){ var beginTime = new Date().getTime() loop(beginTime) Sleep(500) } }

阅读原文

「深度学习福利」大神带你进阶工程师,立即查看>>>
区块链的火热就不用说了,回看一下Vinay Gupta 2015年发表的文章《内容可编程的区块链：以太坊的未来》,感受一下先行者的思想。
到本文结束时,你将了解一般的区块链（特别是下一代区块链平台——以太坊）,这足以确定它们对你未来生活的意义。
天网
以太坊带有强烈的情感冲击。有人将它与天网（SkyNet）进行了比较,后者是电影终结者中的分布式人工智能系统。有些人曾经说,整件事情就是一个白日梦。但该网络已经持续了几个月,并没有表现出敌意的自我意识或完全要崩溃的迹象。
但是,如果你不是非常关注技术,或者是在不同领域的技术人员,很容易盯着所有这些东西然后想“我会稍后再琢磨这个问题”或者决定忽略它,直到卫报做了一个很好的功能（什么功能你可以看这个文章： Imogen Heap：音乐界的救星？ ）。
但是,事实上,至少对于人们只是为了日常生活而产生的那些影响,理解以太坊,区块链,比特币和其他所有内容并不困难。即使是想要清楚细节的程序员也可以很容易地得到一个足够好的模型。区块链解释器通常专注于一些非常机敏的低级细节,如挖掘,但这些东西确实无法帮助人们（除了实施者）了解正在发生的事情。相反,让我们来看看区块链如何去适应关于计算机是如何影响社会的更一般的故事吧。
通常情况下,为了理解现在,我们必须回顾历史：区块链是该剧的第三幕,我们也还只是在第三幕的开头。所以我们必须回放一下。
SQL：昨天最好的主意
实际上区块链的故事开始于20世纪70年代,我们知道当时它的数据库这样创建的：关系模型,SQL,旋转磁带驱动器的大机架等等。如果你想象中的是大型的白色房间里有昂贵的米色巨石,戴着领带的男人们看着它们,那么你就是历史的见证。在大型机时代,大型组织为IBM和其他大型数据库支付了大笔资金,并将所有最宝贵的数据资产放在这些系统中如机构资料存储和客户关系。为运行网络的绝大多数内容,管理系统提供支持的SQL语言最初是磁带驱动器的命令语言。固定字段长度,有点像tweets上的140个字符限制,最初用于让人不耐烦的程序以超高速快进磁带去获知位置,以便将磁带头准确地放在下一条记录开始的地方。这一切都在我出生的时候进行。这是历史,但它还不是古老的历史。
在更高级,更语义化的层面上,我们如何看待现实世界的微妙扭曲：在数据库中难以表现的东西变得轮番贬值和更加迷恋物化。多年过去了,人们通过知识管理,语义网络和许多其他抽象来努力将现实世界变成数据库。其实并非一切都合适,但无论如何我们都在使用这些工具。在数据库中不完全适应的东西都被边缘化了,当然生活还在继续。有一段时间,技术逆流将暂停,并试图推翻数据库的暴政,但总体趋势却很坚定：如果它不适合数据库,它就不存在。
你可能不认为这是个数据库世界,但你生活在其中。每当你看到一个带有正方形的纸质表格,每个方框一个内容时,你就会与数据库进行交互。每当你使用一个网站时,就会有一个潜伏在表面之下的数据库（或者更可能是一大堆的数据库）。亚马逊,Facebook,所有它们这些网站,都是数据库。每当客户服务助理耸耸肩说“电脑系统说不行”或者组织部门有些变态,以不灵活的方式行事时,可能存在一个数据库,其中有一个有限的,严格的现实视图,而且修复软件使组织更加智能化的成本太高。我们生活在这些盒子里,它像氧气一样普遍,而且像穿孔卡一样灵活。
文件和互联网
第二幕是Tim Berners-Lee的到来和互联网的出现。互联网实际上是在他到来之前开始的。在20世纪80年代末和90年代初期,我们认真对待计算机网络。像Telnet,Gopher,Usenet和Email本身这样的协议为早期互联网的提供了用户接口,但直到20世纪90年代我们才开始大规模采用联网计算机,逐渐引导我们在Google Docs上输入想要的,并在网络浏览器中阅读它。这个加入“.”的过程,“网络就是计算机”正如Sun Microsystems所说的那样,发展很快。在20世纪90年代早期,已经存在大量的机器,但它们基本上是独立的设备,或者连接到大学校园里的几百台机器,而没有太多进入外部世界的窗口。在任何地方软件和硬件建立网络,无论是私有网络还是互联网,需要很长时间才能创建,然后像野火一样慢慢传播。小块松散地连接起来,然后紧紧地耦合到我们今天所知的互联网中。随着网络变得越来越智能,硬件越来越小,越来越便宜,我们仍然在掀起技术浪潮,并开始有像“物联网”这样的名字出现在我们的灯泡之类的东西上。
官僚机构
但数据库和网络人们从未真正学会过。机房中的大型机和无数的小型个人电脑散落在互联网上,就像蜘蛛网上的露水一样,找不到一个能让它们顺利互操作的通用世界模型。与单个数据库交互非常简单：你每天使用的表单和Web应用程序。但困难的问题是为了我们的利益,让数据库无形地协同工作,或让数据库与我们自己的笔记本电脑上运行的进程平滑地进行交互。
这些技术问题通常被官僚机构掩盖,但我们每一天都会经历这些问题。这是就是你的魔鬼般的工作,让两个大型组织代表和你一起工作,而在内心深处,这其实是一个软件问题。也许你希望你的汽车保险公司获得有关你的汽车被侵犯时警方的报告。很可能你必须以打印输出的形式从一个数据库中获取数据,然后自己将它们邮件给保险公司,因为它们的系统中没有真正可用的连接接口。除了填写表格的愚蠢过程之外,你无法在笔记本电脑中完成这件事。没有使用真正的计算机做事的意识,只是将计算机滥用为昂贵的纸张模拟器。虽然理论上信息可以在你允许的情况下从一个数据库流向另一个数据库,但实际上连接数据库的技术成本很高,而你的计算机也不会存储你的数据,因此它无法为你完成所有这些工作。相反,它只是你填写表格的机器。为什么我们如此糟糕地利用这些机器的潜力呢？
数据哲学
答案一如既往地在我们自己的脑海里。关于计算机系统世界几乎不可能翻译。人为因素即产生软件的心态也并不适合。每个企业都以自己的形象构建自己的计算机系统,这些系统不关心的某些东西其实有时候是至关重要的,这不是偶然的,而事实也并不容易在它们之间流动。当我们需要从一个模型转换到另一个模型时,只是将人类行为置于过程中,我们又回到了反映纸质形式而非真正数字化合作的过程。结果是同在一个世界,我们的系统却分的七七八八的,从来没有在同一页面上,我们在平常生活中需要的东西似乎不断的落在系统间的裂缝中,每一个过程都需要填写同样该死的名字和地址数据,一天二十次,如果你搬家,会更常见。你有多久因为他们知道你住在哪里而经常从亚马逊却不是一些更专业的商店购物了？
还有很多其他因素可以保持我们计算机的理论潜力与我们日常使用技术的不断加速变化,以及编写软件的费用之间的差距。但最终都归结为心态。虽然它看起来像只是一和零,但软件“建筑师”正在围绕预算摆动,你可以用它来建造一座摩天大楼,而改成一个类似的其他项目,就像拆一个半成品建筑一样。排成行的昂贵的工程师需要舍弃数月（或数年）的工作,这样即使软件不能用,世界也会继续前进。只是每件事情总是感觉有点支离破碎罢了。
我们一遍又一遍地回顾纸张时代的纸张和隐含的信息,原因是我们还无法正确使用软件,而这个问题的核心是我们在20世纪90年代成功地将计算机联网,但我们可能从未弄清楚如何真正的将数据库联网,让他们一起工作。
那人们如何尝试让他们的网络和数据库顺利地协同工作,有三种经典模型。
第一方法：多元化的同步模型
第一种方法是直接将机器连接在一起,并随时计算出lumps。你可以使用机器A,通过网络将其连接到机器B,然后通过线路触发事务。理论上,机器B捕获它们,将它们写入自己的数据库,并且工作很好。在实践中,这里存在一些问题。
认识论问题非常严重。通常在我们的组织中部署的数据库存储一些事实信息。如果数据库说库存水平是31个单位,这对整个组织来说都是事实信息,除了那些下到货架并计算它们的人,发现实际计数是29,并将其作为数据库放入纠正也就盘点的时候才会发现问题。数据库有时是制度造成的一个现实反应。
但是当数据离开一个数据库并流入另一个数据库时,它会越过组织的边界。对于组织A,数据库A的内容在操作上是现实的,除非另有证明,否则为真。但对于组织B来说,是一种状态反应。比如如何考虑一个订单：订单是一个请求,但直到付款完成并不会发生退款之后才会成为一个确认的事实。一家公司可能认为订单已经发生,但这是对其他人的意图揣测,直到现金支付（或比特币）才会消除所有疑虑。到那时前,“订单错误”的信号可以重置整个流程。订单作为一个假设的存在,直到现金支付后才从它所存在的指定缓冲区中清除并将其牢固地置于过去已发生的事实记录中即此订单已存在,已发货,已被接受,我们已获得付款。
但在此之前,订单其实只是一种猜测。
对于从一个组织流向另一个组织的新描述的简单请求的意义转变,从意图清除到事实的记录,并不是我们通常会仔细考虑的事情。但是,当我们开始考虑世界上有多少我们的生活,运行在像这样工作的系统：食品供应链,电网,税收,教育,医疗系统时,很奇怪的这些系统我们不会经常关注到。
事实上,我们只在出现问题时才会注意到它们。
对等连接的第二个问题是每个对等连接的绝对不稳定性。软件在一端或另一端稍有变化,并引入了错误。在传输数据之前可能无法看到的细微错误已深入到组织B的内部记录中。典型的实例：订单总是在12槽位记录,并作为一个盒子处理。但出于某种原因,有一天,订单被记录在槽位13时,而在组织B的某个地方,库存处理电子表格崩溃了。没有办法运送1.083个盒子和机器也会停止工作。
另一个因素加剧了这种不稳定性：需要将一个组织的哲学假设,实际上是企业认识论,转化为另一个组织的私人内部语言。假设我们正在讨论将酒店和汽车租赁作为单一行动进行预订：酒店希望用信用卡号码区分客户,但汽车租赁办公室希望用驾驶执照。一个可笑的小错误导致客户会被误认,因为客户被错误地要求用他们的驾驶执照号码来确认酒店房间预订,但是当客户回读他们的信用卡详细信息时,所有人都知道是“计算机系统错误”,计算机现在想要的是别的东西。
如果你认为这是一个愚蠢的例子,火星气候轨道器在1999年被NASA丢失,因为一个团队使用英寸,而另一个团队使用厘米。这些事总是可能会出错。
但是,通过两个商业组织之间的链接,人们不能简单地认为是另一个人的源代码中找出错误。每当两个组织会面并希望后端连接自动化时,所有这些问题都必须手工完成。这很困难,而且价格昂贵且容易出错,实际上很多公司通常会使用传真机。这很荒谬,但这就是今天世界真正运作的方式。
当然,有人试图澄清这一混乱,引入标准和代码可重用性,以帮助简化这些操作并使业务互操作性成为现实。你可以选择EDI,XMI-EDI,JSON,SOAP,XML-RPC,JSON-RPC,WSDL等标准来协助你的集成过程。
毋庸置疑,有这么多标准的原因正是因为它们都没有正常的满足所有工作。
最后,存在扩展协作的问题。假设我们两个人已经支付了协作的前期成本并实现了无缝的技术合作,现在第三个合作伙伴加入了我们。然后是第四,第五。通过五个合作伙伴,我们有13个连接需要进行调试。六,七......十分之一连接调试是45。每个新合作伙伴加入我们的网络时,合作成本一直在上升,结果就只能是小型合作,这些合作不能无限增长。
请记住,这不仅仅是一个抽象的问题,这是银行业,这是金融,医药,电网,食品供应和政府的具体问题。
我们的电脑世界很杂乱。
集中和辐射：一个新方法
这个窘境的一个常见答案是不再编写各种软件而是直接连接一个复杂的对等实现上（良好,二次）,并简单地让某人负责。这个问题基本上有两种方法。
首先,我们选择一个组织,VISA是典型的,所有人都同意我们将使用他们的标准接口连接到VISA。每个组织只需要一个连接器,VISA从顶部获得1％的折扣,并确保一切正常。
这种方法存在一些问题,但它们可以用“自然垄断”这一术语来概括。作为其他人的枢纽或平台的业务实际上是为任何在这种方式中取得现有地位的人开动了印钞机。这个地位可以赋予与监管机构谈判的政治权力及确定服务条款的形式,并且可能已经开始将建立形成中立支柱的所有安排迅速变成了一个全能的庞然大物。最后导致客户没有这个简单的庞然大物就不能做生意。
这种模式在不同行业中一次又一次地在复杂性和规模的不同层面上再次出现,从铁路到光纤以及机场的跑道分配再到金融机构的流动性管理。
在数据库环境中,存在一个微妙的问题形式：平台经济学。如果“集中辐射”模型是每个人运行Oracle或Windows服务器或其他一些这样的系统,然后依赖这些盒子完美地连接到彼此的话,我们就拥有也有相同的基本经济的主张,因为它们像是克隆的豌豆一样,然后要成为网络的一员,你为了会员特权依靠中间人,他们收取任何认为有必要的费用,这种类似税收一样的费用会伪装成技术成本。
VISA获得了这个世界游戏交易中相当大的比例1％或更多。如果你想知道区块链业务的经济优势可能是什么,那么只需考虑这个数字有多大就好。
协议,如果你能找到它们
该协议是终极“独角兽”。它成立两年后成为一家价值10亿美元的公司,但这个想法非常好,让人们不再争论如何做事,只是继续讨论如何做好他们自己。
互联网上有少数这样的东西：Tim Berners Lee先生的HTTP和HTML标准就像魔术一样,虽然当时他只是点燃了火种,无数的技术专家给了我们现在所知道的和喜爱的奇妙又复杂的世界。SMTP,POP和IMAP为我们的电子邮件提供支持。BGP对我们的大型路由器进行了整理。还有几十个,它们越来越深奥,运行着我们拥有的大部分开放系统。
关于像Gchat或Slack这样工具的一个常见抱怨是他们做的工作具有非常好的开放协议（IRC或XMPP）,但实际上并不能提供这些协议。结果是无法在Slack和IRC或Skype或其他任何系统之间进行互操作,原因是提供强大系统性能的黑客可能会攻击网关。结果是技术生态系统退化为一系列由不同公司拥有的花园围墙,并持续的影响市场。
想象一下,如果WikiPedia是一个难以从其用户群中获利并让其投资者退回资金的项目,那么它现在会有多大吸引力。
但是当协议开始有效时,所创造的是巨大的真正财富,而不是金钱,是实际财富,因为世界通过恰当合作得到各种改善。当然,SOAP和JSON-RPC以及其他所有人都希望支持协议,甚至是变成协议本身,但是每个努力领域的语义定义往往会产生一种固有的复杂性,这种复杂性会导致回到集中辐射模型或其他模型。
区块链是第四种方式？
你听说过人们谈论比特币。酒吧里的传教士们绝对会说世界会发生一些根本性的变化,抛出“互联网中央银行”和讨论民族国家结束等术语。在播客上穿着鲜艳的女性谈论着惊人的未来潜力。但究竟是什么呢？什么是技术,能把政治和未来潜力分开？
它下面的内容是通过打印出大量纸张并随身携带来实现数据库同步的替代方案。让我们暂时来看看纸币现金：我从一家银行到另一家银行拿走一沓纸,价值从一个银行账户,通过一个计算机系统,转移到另一个银行账户。计算机再一次作为纸张模拟器。比特币简单地采用基于纸张的流程,即现金的基本表达,并用数字系统取代：数字现金货币。从这个意义上说,你似乎可以看到比特币只是另一种纸张模拟器,但事实并非如此。
比特币将该文件从该系统中取出,并用比特币网络中所有计算机之间的稳定协议（“共识”）替换它,该协议涉及交易中涉及的所有账户的当前价值。它采用了真正的协议式解决方案：没有中间人提取租金,也没有来自无数不同连接器的指数级别的系统复杂性。区块链体系结构本质上是一种协议,它可以像轮辐一样工作,但是没有中心可信赖的第三方可能选择提取租金的责任。这真是一件好事。该系统具有一些神奇的属性,最终在所有节点上达成一致的数据,这超出了纸张和数据库之外的范围。我们称之为“分布式共识”,但这只是一种奇特的方式,表示每个人最终都同意事实真相（在你的银行余额中,在你的合同中）。
这是一件大事。
事实上,它打破了将计算机连接在一起做事的40年经验。作为一项基本技术,区块链是全新的。在这个技术分支中,真正的新想法可以带来数十亿美元,并为数十年的行业定下方向。它们很少见。
比特币允许你将价值从一个账户转移到另一个账户,而无需移动现金或通过银行用于改组电汇传输流程,因为底层数据库技术是新的,现代的和更好的,通过更好的技术提供更好的服务。就像现金一样,它是匿名和分散的,比特币采取一些货币政策并发行现金本身：一个“去中心化的银行。”如果你愿意,它就是互联网的中央银行。
一旦你认为现金是一种特殊的形式,而现金交易就像纸张在数据库中移动一样,很容易看明白比特币。
可以毫不夸张地说,比特币在我们数据库技术极限造成40年深坑的出路探索上已经说明了这一点。能否在财政层面实现真正的变革还有待观察。
好的,那么以太坊呢？
以太坊采用这种“超越纸张的比喻”的方法让数据库比比特币更进一步协同工作。以太坊不是替换现金,而是提出了一种新模式,第四种方式。你将数据推送到以太坊,它永久地绑定在公共存储中（“区块链”）。所有需要访问这些信息的组织,从你的堂兄到政府,都可以看到它。以太坊寻求替换所有其他你需要填写表格的地方,让计算机一起工作。起初这看起来有点奇怪。毕竟,你不希望你的健康记录存在于这样的系统中。这是对的,你不用担心。如果你要在线存储健康记录,则需要使用额外的加密层来保护它们,以确保无法私自读取它们,无论如何我们应该这样做。对私人数据应用进行适当的加密其实并不常见,这就是为什么你一直听到这些巨大的黑客攻击和泄密的原因。
那么你喜欢什么样的公共数据呢？让我们从一些显而易见的事情开始：你自己的域名,你拥有的企业的域名,人们需要知道你的企业拥有该域名,而不是其他人拥有。这种独特的名称系统是我们如何在整个互联网上导航：这是我们在永久公共数据库中想要的一个明确的例子。我们也喜欢它,如果政府没有继续编辑这些公共记录并根据当地法律将域名移到离线状态,如果互联网是一种全球性的公共产品,那么让政府不断通过审查他们所做的事情来找漏洞是令人讨厌的。谁都不喜欢。
众筹可以作为试验平台
另一个很好的例子是项目众筹,就像KickStarter,IndieGoGo等一样。在这些系统中,有人将项目放在网上并收集资金,并且公开记录了已经投入了多少资金。如果超过一定数量,该项目就会上线,我们希望他们记录他们所做的事情花了多少钱,这是一个非常重要的步骤：我们希望他们对所投入的资金负责,如果资金不足,我们希望他们原路返回。我们拥有全球公益,组织人和资助项目的能力。透明度确实有帮助,所以这是区块链应用的自然场景。
因此,让我们更详细地考虑众筹案例。从某种意义上说,为众筹项目提供资金是一个简单的合约：
如果账户余额超过10000美元,那么为项目提供资金,如果我捐款超过50美元,请寄给我一件T恤。否则,退还所有的钱。
表达为伪代码,可能是：
如果你将此简单协议表示为实际详细代码,则会得到类似的结果。这是智能合约的一个简单示例,智能合约是以太坊系统最强大的方面之一。
众筹可能使我们能够获得深度技术情报支持的风险资本,并投资以创造真正的政治变革。比如说,如果Elon Musk能够获得所有相信他正在做的事情的人的资本储备,那么在未来的火星城项目上出售（比如说）股票,这对人类的未来是好还是坏？
建立实现这种大规模集体行动的机制可能对我们的未来至关重要。
智能合约
所有这些花哨梦想的实施层都非常简单：智能合约设想采用某些简单的纸质协议并将其表示为软件。你不能轻易想象画房子,“房子画得好吗？”,这不是电脑可以做的事情,但对于主要涉及数字产品的合约,想想手机合约或机票或类似产品,依靠计算机提供服务或向你发送电子机票,软件几乎在所有情况下都能很好地代表这些合约。偶尔会出现问题,英语中的所有法律术语都会被激活,而且一名人工法官会参与诉讼,但这确实是一个非常罕见的例外。我们主要处理网站,并向系统中的人员展示帮助我们（如航空公司门员）证明我们已完成与计算机的交易,例如向他们展示我们的登机牌。我们通过填写一些表格来开展我们的业务,计算机出去为我们排序,除非出现问题,否则不需要人工。
为了使这一切成为可能,提供这些服务的公司维持着自己的技术基础设施,网络公司的资金支付工程师队伍和和服务器群以及围绕这些资产的物理安全需要。你可以从那些为你设置电子商务网站或其他简单案例的人那里购买现成的服务,但基本上达到这种复杂性是大公司的领域,因为在你有一个计算机系统付费和提供服务之前你需要所有的管理费用和技术技能。
它只是硬件就很昂贵。如果你要创建银行或新航空公司,软件是你预算中非常重要的一部分,聘请技术团队是挑战的重要组成部分。
智能合约和世界计算机
所以以太坊提供的是一个“智能合约平台”,它需要将大量昂贵,困难的事务自动化。现在还处于初期阶段,所以我们不能做所有事情,但即使从世界上第一个普遍可用的智能合约平台的第一个版本开始,我们也看到了惊人的功能。
那么智能合约平台如何运作？就像比特币一样,很多很多人都运行这个软件,然后得到一些代币（以太）来做这件事。网络中的这些计算机一起工作并共享一个称为区块链的公共数据库。比特币的区块链存储金融交易。以太坊的区块链存储智能合约。你不需要在数据中心租用空间并雇用一大堆系统管理员。相反,你使用共享的全局资源,“世界计算机”以及你放入系统的资源将转移给计算机构成此全局资源的人员。该制度公平公正。
以太坊是开源软件,以太坊团队维护它（越来越多地得到许多独立贡献者和其他公司的帮助。）大多数网络运行在由类似团队生产和维护的开源软件上：我们知道开源软件是生产和维护全球基础设施的好方法。这确保了没有集中的机构可以利用其市场力量来做一些事情,例如提高交易费用以获取巨额利润：开源软件（以及自由软件）帮助保持这些全球公共产品的免费和适合每个人。
在以太坊平台上运行的智能合约本身是用简单的语言编写的：对于程序员来说并不难学。有一个学习曲线,但它与专业工作人员每隔几年做的事情没有什么不同。智能合约通常很短：500行就是很长的了。但是因为它们利用了密码学和区块链的巨大力量,因为它们跨组织和个体之间运行,即使是相对较短的程序也有巨大的力量。
那么世界计算机是什么意思呢？从本质上讲,以太坊模拟了一台完美的机器,由于物理定律,它本质上永远不会存在,但可以通过足够大的计算机网络进行模拟。网络的大小并不是为了生产最快的计算机（尽管可能会在稍后的区块链扩展中出现）,而是生产一台可以从任何地方随处访问的通用计算机,并且（关键！）它总能给每个人带来相同的结果。它是一个存储答案的全球资源,不能被破坏,拒绝或审查。
我们认为这是一件大事。
智能合约可以存储谁拥有什么的记录。它可以存储承诺支付,并承诺在没有中间人或让人们面临欺诈风险的情况下交付。它可以根据过去很久的指示自动转移资金,如遗嘱或期货合约。对于纯数字资产,没有“交易对手风险”,因为要转移的价值在创建时可以锁定在合约中,并在满足条件和条款时自动释放：如果合约清楚,则欺诈是不可能的,因为该计划实际上对所涉及的资产有实际控制权,而不像ATM机或汽车租赁代理那样需要值得信赖的中间人。
这个系统在全球范围内运行,有数十台,最终成千上万台计算机分担工作量,更重要的是,备份了谁承诺向谁提供的文化记忆。是的,欺诈仍然是可能的,在数字的边缘,但许多种类的彻头彻尾的土匪可能会简单地消亡：例如,你可以检查区块链并查明房屋是否已售出两次。谁真的在布鲁克林拥有这座桥？如果此贷款违约会发生什么？在一个共享的全局区块链中,就像水晶一样清晰。无论如何,这就是计划。
民主化进入最先进的技术
所有这些都可能充分利用现代技术的力量,并将其交给程序员,他们的工作环境并不比编写网站复杂得多。这些简单的程序运行在极其强大的共享全局基础架构上,可以移动价值并代表财产的所有权。这会创建市场,域名注册表以及我们目前尚未理解的许多其他内容,因为它们尚未构建。当网络被发明以便于发布文档供其他人看时,没有人会猜到它会彻底改变它触及的每个行业,并通过社交网络,交友网站和在线教育改变人们的个人生活。没有人会猜到亚马逊有朝一日会比沃尔玛更大。我们无法确定智能合约的去向,但很难不去看网络和梦想。
虽然需要大量深奥的计算机科学来创建一个编程环境,让相对普通的网络技能在一个安全的全球生态系统中的财产中移动,但这项工作已经完成。虽然以太坊还不是一个计划中的结果,但这主要是文档,培训和技术生态系统逐渐成熟的问题。这些语言写得很好：调试器需要更多时间。但是,编写自己的智能合约基础架构的令人发指的复杂性已经消失：智能合约本身比现代JavaScript更简单,并且没有任何网络程序员会害怕。结果是我们希望这些工具能够在不久的将来,到处是因为人们开始想要新的服务,而团队则需要提供这些服务。
未来？
我很兴奋,因为我们不知道我们创造了什么,更重要的是,你和你的朋友将用它创造什么。我认为像“比特币2.0”和“Web 3.0”这样的术语是不合适的,这将是一个新事物,新的思想和新文化嵌入在一个新的软件平台中。每一个新媒体都改变了这个信息：博客带来了长篇回写,然后推特创造了一个环境,在这里,简洁不仅是智慧的灵魂,也是必要的。现在,我们可以将简单的协议表示为言论自由,作为一个想法的出版,以及谁知道这导致了什么。
Ethereum Frontier是第一步：它是程序员构建你可以通过Web浏览器或手机应用程序访问的服务的平台。稍后我们将发布以太网Metropolis,这将是一个类似于程序的网络浏览器,目前称为Mist,它采用了以太坊固有的所有安全性和加密技术,并将其与任何人都可以使用的用户界面很好地打包在一起。最近发布的Mist展示了一个安全的钱包,这只是一个开始。Mist提供的安全性远远强于当前的电子商务系统和手机应用程序。从中期来看,合约生产系统将是独立的,因此几乎任何人都可以下载“分布式应用程序构建器”并加载它们的内容和想法并上传它,对于简单的事情,不需要代码,但是将提供网络的全部潜在能力。按照安装向导的思路,但不是设置打印机,而是为贷款配置智能合约的条款：多少钱,多长时间,还款率。单击“确定”批准！
如果这听起来不可能,欢迎接受我们的挑战：技术已经远远领先于我们解释或传播技术的能力！
世界超级计算机？
我们还没有完成创新。在一段时间内,我们谈论一两年,以太坊Serenity将把网络提升到一个全新的水平。现在,向以太坊网络添加更多计算机使其更安全,但速度更快。我们使用Ether来管理网络的有限速度,这是一个优先考虑网络等的代币。在Serenity系统中,向网络添加更多计算机使其更快,这最终将使我们能够构建真正具有互联网规模的系统：数亿台计算机一起工作,共同完成我们需要完成的工作。今天我们可能猜测蛋白质折叠或基因组学或人工智能,但是谁会说这些精彩软件会有什么用途。
我希望这个关于以太坊生态系统的非技术性入门有用,一旦我们有一个用户友好版本的系统可用于一般用途,你就会第一个知道！
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 内容可编程的区块链：以太坊的未来

「深度学习福利」大神带你进阶工程师,立即查看>>>
今天我将向你展示如何在以太坊区块链上开发你自己的加密货币并将其出售！我将向你展示如何使用以太坊智能合约逐步创建自己的ERC-20代币和众筹销售,如何测试智能合约,如何将智能合约部署到以太坊区块链,以及如何构建ICO网站部署到网络上。我还将解释ERC-20代币是什么,以太坊代币如何工作,初始代币产品（ICO）如何工作。
什么是ERC-20代币？
以太坊区块链允许你创建自己的加密货币或代币,可以通过以太币（以太坊区块链的本地加密货币）购买。ERC-20只是一个标准,它指定了这些代币的行为方式,因此它们与加密货币交换等其他平台兼容。
那怎么做呢？让我们先来看看以太坊区块链的工作原理。
以太坊是像比特币一样的区块链。与比特币一样,以太坊也会跟踪拥有Ether的用户余额,以太坊的原生加密货币。与比特币不同,以太坊也是一个平台,允许你创建自己的代币而无需创建新的区块链。
你可以使用智能合约创建以太坊代币。ERC-20是一个标准,用于指定此代币智能合约应如何工作。
让我们用一个例子来理解ERC-20代币智能合约的工作原理。假设我们想要创建一个名为“My Token”的代币,其符号为“MTK”,并且存在100,000,000个这样的代币。
首先,代币智能合约跟踪一些基本代币属性。例如,它记录名称“My Token”,你在加密货币交换中看到的符号,以及存在多少总代币。
它还跟踪谁拥有“My Token”和多少。
ERC-20代币可以作为付款从一个帐户转移到另一个帐户,就像任何其他加密货币一样。
它们也可以在众筹销售中购买,如ICO,我们将在下一节中进行讨论。
它们也可以在加密货币交易所买卖。
ICO如何运作
ERC-20代币可以以多种方式分发。一种流行的方法是举行目标人群促销或初始代币发行（ICO）。众筹销售是公司通过创建自己的ERC-20代币来为其业务筹集资金的一种方式,该代币可以由以太币的投资者购买。
每当发生众筹销售时,公司就会以投资者支付的以太币形式获得流动资金,并持有在众筹销售中出售的预留金额的ERC-20代币。
为了参与众筹销售,投资者必须使用帐户连接到Etherum区块链。此帐户有一个可以存储以太币的钱包地址,以及在众筹销售中购买的ERC-20代币。
投资者必须访问与智能合约谈话的众筹销售网站。智能合约管理众筹销售如何运作的所有规则。
每当投资者在众筹销售网站上购买代币时,他们就会将以太币从他们的钱包发送到智能合约,而智能合约会立即将购买的代币分发到他们的钱包中。
智能合约在众筹销售中设定代币的价格并控制众筹销售的行为方式。
众筹销售可以采取各种形状和大小。它们可以具有多个层级或阶段,例如Pre ICO,ICO和ICO Bonus阶段。这些层中的每一层都可以在不同的时间点发生并且可以表现不同。
他们还可以使用白名单来限制哪些投资者可以购买代币。
他们还可以拥有预定数量的代币,这些代币不会在众筹销售中出售。这些储备通常留给每个公司的特定成员,如创始人和顾问。这些储备可以是固定数量的代币或百分比。
每当众筹销售结束时,它可以由管理员最终确定。每当发生这种情况时,所有预留的代币都将分发到相应的帐户,众筹销售将正式结束。
ERC-20代币的工作原理
正如我之前解释的那样,ERC-20代币是使用以太坊智能合约创建的。什么是智能合约？
以太坊允许开发人员使用智能合约编写在区块链上运行的应用程序,这些应用程序封装了这些应用程序的所有业务逻辑。它们使我们能够读取和写入区块链的数据,以及执行代码。智能合约使用名为Solidity的编程语言编写,看起来很像Javascript。它是一种完整的编程语言,它允许我们执行Javascript所能提供的许多相同类型的事情,但由于它的用例,它的行为有点不同,我们将在本教程中看到。
对于ERC-20代币,智能合约管理有关代币如何工作的所有行为,并跟踪代币所有权和帐户余额。
ERC-20是关于如何构建以太坊代币的API规范。它是一种社区采用的标准,允许在各种用例中支持代币。我们希望构建一个符合此标准的代币,以便广泛接受。如果我们没有这样的标准,我们可以有无尽的方式来创建代币,它们可能彼此不兼容！
使用ERC-20标准可确保代币符合以下用例（以及更多）： 电子钱包转帐 - 将代币从一个帐户发送到另一个帐户 在加密货币交易所买卖 在众筹销售（ICO）中购买代币,就像我们将在本教程中演示一样
ERC-20规范基本上规定了智能合约必须响应的接口。它规定了智能合约的结构和智能合约必须具备的功能类型。它还提供了一些很好的建议功能,但最终是可选的。它规定了我们的代币必须具有的某些事件,例如 transfer 事件。请注意,智能合约可以发出消费者可以订阅的事件,并且使用此标准,我们可以订阅告诉我们何时销售代币的事件。
以下是ERC-20标准指定的 transfer 函数的示例实现。它是智能合约所要求的,并且管理某人如何将钱包中的ERC-20代币发送到另一个钱包。 contract ERC20Token { // ... function transfer(address _to, uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[_to] += _value; Transfer(msg.sender, _to, _value); return true; } // ... }
该函数通过以下方式实现ERC-20标准： 该功能存在。 它接受正确的参数。 如果用户没有足够的代币进行支付,即余额不足,则失败。 它将余额从发件人的帐户转移到收款人的帐户。 它会触发 sell 事件。 它返回正确的值,例如 true 。
如果所有这些还没有完全有意义,请不要担心。你可以直接在 以太坊改进提案 github存储库中阅读有关 ERC-20令牌标准 的更多信息。这是围绕以太坊标准进行的所有社区讨论的地方。我强烈建议将该存储库加入书签并阅读提交内容,因为这是你可以观看以太坊技术实时增长和变化的地方！
我也推荐这篇 维基百科文章 。
我们要建立的网站
我们将建立一个ICO网站,与区块链上的众筹销售智能合约进行对话。这个客户端网站将有一个表格,用户可以在众筹销售中购买令牌。它将显示众筹销售的进度,例如用户购买了多少令牌,所有用户购买了多少令牌,以及众筹销售中可用的令牌总数。它还会在“你的帐户”下显示我们与区块链相关联的帐户。
安装依赖项
为了构建我们的ERC-20令牌和销售,我们首先需要一些依赖。
节点包管理器（NPM）
我们需要的第一个依赖是节点包管理器,或NPM,它与Node.js一起提供。你可以通过你的终端并输入以下内容来查看你是否已安装节点： $ node -v
Truffle框架
下一个依赖是Truffle Framework,它允许我们在以太坊区块链上构建去中心化的应用程序。它提供了一套工具,允许我们使用Solidity编程语言编写智能合约。它还使我们能够测试我们的智能合约并将其部署到区块链。它还为我们提供了开发客户端应用程序的地方。
你可以在命令行中使用NPM安装Truffle,如下所示： $ npm install -g truffle
Ganache
下一个依赖项是Ganache,一个本地内存区块链。你可以通过从Truffle Framework网站下载来安装Ganache。它将为我们提供10个外部帐户,其中包含我们当地以太坊区块链的地址。每个帐户预装100个测试Ether。
Metamask
下一个依赖项是Google Chrome的Metamask扩展。为了使用区块链,我们必须连接它（记住,我说块链是一个网络）。我们必须安装一个特殊的浏览器扩展才能使用以太坊区块链。这就是Metamask的用武之地。我们将能够通过我们的个人账户连接到我们当地的以太坊区块链,并与我们的智能合约进行交互。
我们将在本教程中使用Metamask chrome扩展,因此如果你还没有安装google chrome浏览器,则还需要安装它。要安装Metamask,请在Google Chrome网上应用店中搜索Metamask Chrome插件。安装完成后,请确保在扩展列表中选中它。安装后,你会在Chrome浏览器的右上角看到狐狸图标。
语法高亮显示
依赖项是可选的,但建议使用。我建议为Solidity编程语言安装语法高亮显示。大多数文本编辑器和IDE都没有开箱即用的Solidity语法高亮显示,因此你必须安装一个软件包才能支持此功能。我正在使用Sublime Text,我已经下载了“Ethereum”软件包,它为Solidity提供了很好的语法高亮显示。
ERC-20令牌智能合约
现在我们已经安装了依赖项,让我们开始构建我们的ERC-20令牌！这是完整的ERC-20令牌智能合约Solidity代码： pragma solidity ^0.4.2; contract DappToken { string public name = "DApp Token"; string public symbol = "DAPP"; string public standard = "DApp Token v1.0"; uint256 public totalSupply; event Transfer( address indexed _from, address indexed _to, uint256 _value ); event Approval( address indexed _owner, address indexed _spender, uint256 _value ); mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; function DappToken (uint256 _initialSupply) public { balanceOf[msg.sender] = _initialSupply; totalSupply = _initialSupply; } function transfer(address _to, uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; balanceOf[_to] += _value; Transfer(msg.sender, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= balanceOf[_from]); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] -= _value; balanceOf[_to] += _value; allowance[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } }
让我们来看看这个智能合约的功能,以及它如何实现ERC-20标准： 它存储代币名称 string public name =“DApp Token”。 它存储用于加密货币交换的代币符号 string public symbol =“DAPP” 。 它存储了 uint256 public totalSupply 公共代币总供应量。 它使用Solidity映射来存储拥有代币映射 mapping(address => uint256) public balanceOf 的每个帐户的余额。 它实现了一个 transfer 函数,允许用户将代币发送到另一个帐户。 它实现了一个允许其他帐户使用代币的 approve 函数,例如加密货币交换。这会更新 allowance 映射,以查看帐户可以支出的金额。 它实现了 transferFrom ,允许其他帐户转移令牌。
你还可以阅读此智能合约的测试,以了解有关其工作原理的更多信息。这些测试确保这种智能合约的行为符合我们的预期。这是一个完整的测试套件,可以检查智能合约的所有行为： var DappToken = artifacts.require("./DappToken.sol"); contract('DappToken', function(accounts) { var tokenInstance; it('initializes the contract with the correct values', function() { return DappToken.deployed().then(function(instance) { tokenInstance = instance; return tokenInstance.name(); }).then(function(name) { assert.equal(name, 'DApp Token', 'has the correct name'); return tokenInstance.symbol(); }).then(function(symbol) { assert.equal(symbol, 'DAPP', 'has the correct symbol'); return tokenInstance.standard(); }).then(function(standard) { assert.equal(standard, 'DApp Token v1.0', 'has the correct standard'); }); }) it('allocates the initial supply upon deployment', function() { return DappToken.deployed().then(function(instance) { tokenInstance = instance; return tokenInstance.totalSupply(); }).then(function(totalSupply) { assert.equal(totalSupply.toNumber(), 1000000, 'sets the total supply to 1,000,000'); return tokenInstance.balanceOf(accounts[0]); }).then(function(adminBalance) { assert.equal(adminBalance.toNumber(), 1000000, 'it allocates the initial supply to the admin account'); }); }); it('transfers token ownership', function() { return DappToken.deployed().then(function(instance) { tokenInstance = instance; // Test `require` statement first by transferring something larger than the sender's balance return tokenInstance.transfer.call(accounts[1], 99999999999999999999999); }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert') >= 0, 'error message must contain revert'); return tokenInstance.transfer.call(accounts[1], 250000, { from: accounts[0] }); }).then(function(success) { assert.equal(success, true, 'it returns true'); return tokenInstance.transfer(accounts[1], 250000, { from: accounts[0] }); }).then(function(receipt) { assert.equal(receipt.logs.length, 1, 'triggers one event'); assert.equal(receipt.logs[0].event, 'Transfer', 'should be the "Transfer" event'); assert.equal(receipt.logs[0].args._from, accounts[0], 'logs the account the tokens are transferred from'); assert.equal(receipt.logs[0].args._to, accounts[1], 'logs the account the tokens are transferred to'); assert.equal(receipt.logs[0].args._value, 250000, 'logs the transfer amount'); return tokenInstance.balanceOf(accounts[1]); }).then(function(balance) { assert.equal(balance.toNumber(), 250000, 'adds the amount to the receiving account'); return tokenInstance.balanceOf(accounts[0]); }).then(function(balance) { assert.equal(balance.toNumber(), 750000, 'deducts the amount from the sending account'); }); }); it('approves tokens for delegated transfer', function() { return DappToken.deployed().then(function(instance) { tokenInstance = instance; return tokenInstance.approve.call(accounts[1], 100); }).then(function(success) { assert.equal(success, true, 'it returns true'); return tokenInstance.approve(accounts[1], 100, { from: accounts[0] }); }).then(function(receipt) { assert.equal(receipt.logs.length, 1, 'triggers one event'); assert.equal(receipt.logs[0].event, 'Approval', 'should be the "Approval" event'); assert.equal(receipt.logs[0].args._owner, accounts[0], 'logs the account the tokens are authorized by'); assert.equal(receipt.logs[0].args._spender, accounts[1], 'logs the account the tokens are authorized to'); assert.equal(receipt.logs[0].args._value, 100, 'logs the transfer amount'); return tokenInstance.allowance(accounts[0], accounts[1]); }).then(function(allowance) { assert.equal(allowance.toNumber(), 100, 'stores the allowance for delegated trasnfer'); }); }); it('handles delegated token transfers', function() { return DappToken.deployed().then(function(instance) { tokenInstance = instance; fromAccount = accounts[2]; toAccount = accounts[3]; spendingAccount = accounts[4]; // Transfer some tokens to fromAccount return tokenInstance.transfer(fromAccount, 100, { from: accounts[0] }); }).then(function(receipt) { // Approve spendingAccount to spend 10 tokens form fromAccount return tokenInstance.approve(spendingAccount, 10, { from: fromAccount }); }).then(function(receipt) { // Try transferring something larger than the sender's balance return tokenInstance.transferFrom(fromAccount, toAccount, 9999, { from: spendingAccount }); }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert') >= 0, 'cannot transfer value larger than balance'); // Try transferring something larger than the approved amount return tokenInstance.transferFrom(fromAccount, toAccount, 20, { from: spendingAccount }); }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert') >= 0, 'cannot transfer value larger than approved amount'); return tokenInstance.transferFrom.call(fromAccount, toAccount, 10, { from: spendingAccount }); }).then(function(success) { assert.equal(success, true); return tokenInstance.transferFrom(fromAccount, toAccount, 10, { from: spendingAccount }); }).then(function(receipt) { assert.equal(receipt.logs.length, 1, 'triggers one event'); assert.equal(receipt.logs[0].event, 'Transfer', 'should be the "Transfer" event'); assert.equal(receipt.logs[0].args._from, fromAccount, 'logs the account the tokens are transferred from'); assert.equal(receipt.logs[0].args._to, toAccount, 'logs the account the tokens are transferred to'); assert.equal(receipt.logs[0].args._value, 10, 'logs the transfer amount'); return tokenInstance.balanceOf(fromAccount); }).then(function(balance) { assert.equal(balance.toNumber(), 90, 'deducts the amount from the sending account'); return tokenInstance.balanceOf(toAccount); }).then(function(balance) { assert.equal(balance.toNumber(), 10, 'adds the amount from the receiving account'); return tokenInstance.allowance(fromAccount, spendingAccount); }).then(function(allowance) { assert.equal(allowance.toNumber(), 0, 'deducts the amount from the allowance'); }); }); });
你可以使用truffle从命令行运行测试,如下所示： $ truffle test
众筹销售智能合约
现在我们可以建立一个众筹销售智能合约,允许投资者在最初的代币产品（ICO）中购买代币。这是完整的众筹销售智能合约Solidity代码： pragma solidity ^0.4.2; import "./DappToken.sol"; contract DappTokenSale { address admin; DappToken public tokenContract; uint256 public tokenPrice; uint256 public tokensSold; event Sell(address _buyer, uint256 _amount); function DappTokenSale(DappToken _tokenContract, uint256 _tokenPrice) public { admin = msg.sender; tokenContract = _tokenContract; tokenPrice = _tokenPrice; } function multiply(uint x, uint y) internal pure returns (uint z) { require(y == 0 || (z = x * y) / y == x); } function buyTokens(uint256 _numberOfTokens) public payable { require(msg.value == multiply(_numberOfTokens, tokenPrice)); require(tokenContract.balanceOf(this) >= _numberOfTokens); require(tokenContract.transfer(msg.sender, _numberOfTokens)); tokensSold += _numberOfTokens; Sell(msg.sender, _numberOfTokens); } function endSale() public { require(msg.sender == admin); require(tokenContract.transfer(admin, tokenContract.balanceOf(this))); // Just transfer the balance to the admin admin.transfer(address(this).balance); } }
让我们来看看这个智能合约的功能,以及它如何进行众筹销售： 它存储众筹销售 address admin 的地址管理员帐户。 它引用了ERC-20代币智能合约 DappToken public tokenContract 。 它存储代币价格 uint256 public tokenPrice 。 它存储了代币销售的数量 uint256 public tokensSold 。 它实现了一个 sell 事件,以便消费者可以在出售代币时收到通知。 它实现了 buyTokens 函数,允许用户在众筹销售中购买代币。 它实现了一个 endSale 函数,允许管理员结束众筹销售并收集销售期间筹集的以太币。 var DappToken = artifacts.require('./DappToken.sol'); var DappTokenSale = artifacts.require('./DappTokenSale.sol'); contract('DappTokenSale', function(accounts) { var tokenInstance; var tokenSaleInstance; var admin = accounts[0]; var buyer = accounts[1]; var tokenPrice = 1000000000000000; // in wei var tokensAvailable = 750000; var numberOfTokens; it('initializes the contract with the correct values', function() { return DappTokenSale.deployed().then(function(instance) { tokenSaleInstance = instance; return tokenSaleInstance.address }).then(function(address) { assert.notEqual(address, 0x0, 'has contract address'); return tokenSaleInstance.tokenContract(); }).then(function(address) { assert.notEqual(address, 0x0, 'has token contract address'); return tokenSaleInstance.tokenPrice(); }).then(function(price) { assert.equal(price, tokenPrice, 'token price is correct'); }); }); it('facilitates token buying', function() { return DappToken.deployed().then(function(instance) { // Grab token instance first tokenInstance = instance; return DappTokenSale.deployed(); }).then(function(instance) { // Then grab token sale instance tokenSaleInstance = instance; // Provision 75% of all tokens to the token sale return tokenInstance.transfer(tokenSaleInstance.address, tokensAvailable, { from: admin }) }).then(function(receipt) { numberOfTokens = 10; return tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: numberOfTokens * tokenPrice }) }).then(function(receipt) { assert.equal(receipt.logs.length, 1, 'triggers one event'); assert.equal(receipt.logs[0].event, 'Sell', 'should be the "Sell" event'); assert.equal(receipt.logs[0].args._buyer, buyer, 'logs the account that purchased the tokens'); assert.equal(receipt.logs[0].args._amount, numberOfTokens, 'logs the number of tokens purchased'); return tokenSaleInstance.tokensSold(); }).then(function(amount) { assert.equal(amount.toNumber(), numberOfTokens, 'increments the number of tokens sold'); return tokenInstance.balanceOf(buyer); }).then(function(balance) { assert.equal(balance.toNumber(), numberOfTokens); return tokenInstance.balanceOf(tokenSaleInstance.address); }).then(function(balance) { assert.equal(balance.toNumber(), tokensAvailable - numberOfTokens); // Try to buy tokens different from the ether value return tokenSaleInstance.buyTokens(numberOfTokens, { from: buyer, value: 1 }); }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert') >= 0, 'msg.value must equal number of tokens in wei'); return tokenSaleInstance.buyTokens(800000, { from: buyer, value: numberOfTokens * tokenPrice }) }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert') >= 0, 'cannot purchase more tokens than available'); }); }); it('ends token sale', function() { return DappToken.deployed().then(function(instance) { // Grab token instance first tokenInstance = instance; return DappTokenSale.deployed(); }).then(function(instance) { // Then grab token sale instance tokenSaleInstance = instance; // Try to end sale from account other than the admin return tokenSaleInstance.endSale({ from: buyer }); }).then(assert.fail).catch(function(error) { assert(error.message.indexOf('revert' >= 0, 'must be admin to end sale')); // End sale as admin return tokenSaleInstance.endSale({ from: admin }); }).then(function(receipt) { return tokenInstance.balanceOf(admin); }).then(function(balance) { assert.equal(balance.toNumber(), 999990, 'returns all unsold dapp tokens to admin'); // Check that the contract has no balance balance = web3.eth.getBalance(tokenSaleInstance.address) assert.equal(balance.toNumber(), 0); }); }); });
恭喜！你已成功学习了如何在以太坊上建立了ERC-20代币和众筹销售智能合约！
======================================================================
分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程： java以太坊开发教程 ,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。 python以太坊 ,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。 php以太坊 ,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。 以太坊入门教程 ,主要介绍智能合约与dapp应用开发,适合入门。 以太坊开发进阶教程 ,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。 C#以太坊 ,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。 EOS教程 ,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。 java比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。 php比特币开发教程 ,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。 tendermint区块链开发详解 ,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。
汇智网原创翻译,转载请标明出处。这里是原文 在以太坊开发自己的加密货币

「深度学习福利」大神带你进阶工程师,立即查看>>>
【好消息!】HiBlock区块链技术工坊已经成功举办了26期,其中北京1期,西安1期,成都2期,上海22期。经常有社区的小伙伴问定期举办技术工坊的除了上海以外,其他城市有没有？现在 区块链技术工坊来到了深圳 ,由登链学院与HiBlock共同组织,活动得到小牛新能源的赞助支持,计划每周四晚和大家一起探讨区块链技术。
11月15日,深圳技术工坊第1期（总第27期） 深圳市南山区宝深路科陆大厦A座 8层进行,由 Tiny熊老师进行以《如何开发一款以太坊钱包》为主题的分享 ,1小时分享后与参会者进行深入的区块链技术讨论。
1
时间地点
**时间：**11月15日 19:00 -  21:30
地点 ：深圳市南山区宝深路科陆大厦A座 8层
线下分享+交流  9.8元/人
参会人员要求：
1） 技术背景人员,对区块链开发有兴趣；
2） 活动限额30人,报满截止。
3） 自带电脑
2
活动流程
19:00-20:00  签到,自我介绍
20:00-21:00  如何开发一款以太坊钱包
21:00-21:30  互动交流
3
分享主题及嘉宾
分享主题：如何开发一款以太坊钱包
区块链技术与其他软件开发技术有什么不同？学习区块链技术要从哪里开始？
经常会有人问这个问题,从目前的实用角度来说,区块链技术应用离不开TOKEN、数字钱包、智能合约等场景,因此学习区块链技术可以从以太坊钱包开发入手。
分享大纲：
1. 使用密码学上随机数生成私钥；
2. 如何通过私钥推导出地址；
3. 什么是HD钱包（分层确定性钱包）；
4. 助记词如何产生,作用是什么？
5. 如何安全的保存私钥,以及导入保存的私钥；
6. 如何测量gasLimit及设定gasPrice;
7. 如何发送签名交易;
8. 如何发送Token;
分享嘉宾：熊丽兵（Tiny熊）
登链学院创始人,以太坊布道者
北京航空航天大学硕士,先后就职于创新工场及猎豹移动,全面负责数款千万级用户开发及管理工作。区块链知名技术博客《深入浅出区块链（learnblockchain.cn）》首席作者,图书《精通以太坊智能合约开发》作者,CSDN博客专家。
4
主办方
5
报名方式
识别下图二维码或点击“ 阅读原文 ”即可报名参加。

「深度学习福利」大神带你进阶工程师,立即查看>>>
比原项目仓库：
Github地址： https://github.com/Bytom/bytom
Gitee地址： https://gitee.com/BytomBlockchain/bytom
很多了解比原链的都知道,比原链是专注信息和数字资产在链上交互和流转的公链项目,信息上链不是比原链核心能力,所以并没有在钱包端做一个功能入口,但是比原链提供了相关的接口可以将一些信息写到链上去。 那如何实现信息上链呢？使用特殊的Retire操作,这个操作可以进行销毁资产的操作,但因为其可以附带信息,所以就可以实现信息上链的功能。
请往下看,也用postman请求演示,然后用golang写了一个接口的demo, 在用golang代码实现之前,我们先要做一些准备工作。 首先确保自己在本地已经搭建好了比原的节点,如果你还没有搭建好节点,请参考开发文档： https://docs.bytom.io/mydoc_build_environment.cn.html 确保自己账户是有足够BTM测试币,如果没有可以去比原链水龙头领取BTM测试币,领取地址：
http://test.blockmeta.com/faucet.php 发行自己的资产,参考： http://8btc.com/forum.php?mod=viewthread&tid=242940&extra= 信息上链的本质就是其实就是创建并发送一笔交易,我们都知道通过api发起交易主要有三个步骤,先 build → sign → submit,分别对应的api是 build-transaction、sign-transaction、submit-transaction。用postman请求过程如下：
请求build-transaction接口:
请求参数： { "base_transaction": null, "actions": [{ "account_id": "0KTCS3R5G0A02", "amount": 10000000, "asset_id": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "type": "spend_account" }, { "account_id": "0KTCS3R5G0A02", "amount": 100, "asset_id": "608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd", "type": "spend_account" }, { "account_id": "0KTCS3R5G0A02", "amount": 100, "asset_id": "608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd", "arbitrary": "77656c636f6d65efbc8ce6aca2e8bf8ee69da5e588b0e58e9fe5ad90e4b896e7958c", "type": "retire" }], "ttl": 0, "time_range": 1521625823 }
请求sign-transaction接口：
请求参数： { "password": "huangxinglong123", "transaction": { "allow_additional_actions": false, "local": true, "raw_transaction": "0701dfd5c8d505020160015e560352e415b41be7648b2241ffdabf56259bc618525f62ac123dce32002110f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0989fe3020001160014adb6632c5b10c6d5b6f97b8d1250f6e409e11c0101000161015f560352e415b41be7648b2241ffdabf56259bc618525f62ac123dce32002110f0608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd9cc5b191f3190101160014dcfd9b78c24260823e318153665d511d6c4ecb1b010003013dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0ebbcde02011600147a9baebd37dba3f14960624ed8e6ca3cc9d5f73800013e608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cdb8c4b191f31901160014f0370fdf7a7bec7b34cc62fd5291071a3dc3d9b0000147608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd6401246a2277656c636f6d65efbc8ce6aca2e8bf8ee69da5e588b0e58e9fe5ad90e4b896e7958c00", "signing_instructions": [{ "position": 0, "witness_components": [{ "keys": [{ "derivation_path": [ "0000002c", "00000099", "0100000000000000", "0100000000000000", "4600000000000000" ], "xpub": "1c03161a08a4dbb7df153815a28f733fec1ac7579f954c4834e5ce9f0ad8deb260ecb2066a8623b69aa936f5798f4dcb9572bc476f2c8171953ce054d58a759f" }], "quorum": 1, "signatures": null, "type": "raw_tx_signature" }, { "type": "data", "value": "4f089176a5bca95ec9227b8a87dfec947c59453805bf46d3f5a18f8032255b5a" }] }, { "position": 1, "witness_components": [{ "keys": [{ "derivation_path": [ "0000002c", "00000099", "0100000000000000", "0100000000000000", "4700000000000000" ], "xpub": "1c03161a08a4dbb7df153815a28f733fec1ac7579f954c4834e5ce9f0ad8deb260ecb2066a8623b69aa936f5798f4dcb9572bc476f2c8171953ce054d58a759f" }], "quorum": 1, "signatures": null, "type": "raw_tx_signature" }, { "type": "data", "value": "67512f9250f559699e32c72c8af29096b1556af145f6ecc0c306e6acc88bbfaa" }] }] } }
请求submit-transaction接口：
请求参数： { "raw_transaction": "0701dfd5c8d505020160015e560352e415b41be7648b2241ffdabf56259bc618525f62ac123dce32002110f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0989fe3020001160014adb6632c5b10c6d5b6f97b8d1250f6e409e11c01630240c7004022db674ff2961b540d4edab846d550429ae9a92311ba375a4f452331422961fdcde3bf79631755dd12df409e24a849158d4aeab919cab81520fb7d1e02204f089176a5bca95ec9227b8a87dfec947c59453805bf46d3f5a18f8032255b5a0161015f560352e415b41be7648b2241ffdabf56259bc618525f62ac123dce32002110f0608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd9cc5b191f3190101160014dcfd9b78c24260823e318153665d511d6c4ecb1b6302406b75ef5a9decfa31d4f5ae06e0fb14ca507ba4a03715874d1d831516945121573b9b858e4d7527d209c1f89f74e0aa4c4e38afd098cbadaff31b9107167099012067512f9250f559699e32c72c8af29096b1556af145f6ecc0c306e6acc88bbfaa03013dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0ebbcde02011600147a9baebd37dba3f14960624ed8e6ca3cc9d5f73800013e608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cdb8c4b191f31901160014f0370fdf7a7bec7b34cc62fd5291071a3dc3d9b0000147608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd6401246a2277656c636f6d65efbc8ce6aca2e8bf8ee69da5e588b0e58e9fe5ad90e4b896e7958c00" }
响应参数： { "status": "success", "data": { "tx_id": "5ef27b930646d468bbb436d3406972ff201aa63702518f777e31dd6a2147dddc" } }
​
用上面返回的tx_id去比原的浏览器中去查看交易详情,就可以查看到我们上传的数据
参考代码： package main import ( "bytes" "encoding/json" "fmt" "io/ioutil" "net/http" ) //build-transaction params //https://bytom.github.io/mydoc_RPC_call.cn.html#build-transaction type BytomAccount struct { AccountId string `json:"account_id"` Amount int `json:"amount"` AssetId string `json:"asset_id"` //Arbitrary string `json:"arbitrary"` Type string `json:"type"` } type BytomAccount1 struct { AccountId string `json:"account_id"` Amount int `json:"amount"` AssetId string `json:"asset_id"` Arbitrary string `json:"arbitrary"` Type string `json:"type"` } type BaseTransaction struct{} type TransactionParams struct { BaseTransaction *BaseTransaction `json:"base_transaction"` Actions []interface{} `json:"actions"` Ttl int `json:"ttl"` TimeRange int `json:"time_range"` } //sign-transaction params //https://bytom.github.io/mydoc_RPC_call.cn.html#build-transaction type Transaction struct { } type SignParams struct { Password string `json:"password"` Transaction Transaction `json:"transaction"` } //submit-transaction //https://bytom.github.io/mydoc_RPC_call.cn.html#build-transaction type SubmitParams struct { RawTransaction string `json:"raw_transaction"` } type SubmitResponse struct { TxId string `json:"tx_id"` } func main() { account1, account2, account3 := BytomAccount{}, BytomAccount{}, BytomAccount1{} account1.AccountId = "0KTCS3R5G0A02" account1.Amount = 10000000 account1.AssetId = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" account1.Type = "spend_account" account2.AccountId = "0KTCS3R5G0A02" account2.Amount = 100 account2.AssetId = "608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd" account2.Type = "spend_account" account3.AccountId = "0KTCS3R5G0A02" account3.Amount = 100 account3.AssetId = "608037f96e8d1613d900c67a0730cc90e2a03311fb7d091588f7eb551a6103cd" account3.Arbitrary = "77656c636f6d65efbc8ce6aca2e8bf8ee69da5e588b0e58e9fe5ad90e4b896e7958c" account3.Type = "retire" //var array var actions []interface{} //append three params array_actions := append(actions, account1, account2, account3) transaction_params := &TransactionParams{} transaction_params.Actions = array_actions transaction_params.Ttl = 0 transaction_params.TimeRange = 1521625823 //本地测试网节点 //build-transaction port := "http://127.0.0.1:9888/build-transaction" value, err := SendTransactionRetire(transaction_params, port) if err != nil { fmt.Println("err:", err) } fmt.Println("build-transaction接口返回的参数:", value) //sign-transaction //........... //submit-transaction //........... } //send post request func SendTransactionRetire(params *TransactionParams, port string) (v interface{}, err error) { //以本地测试网节点连接 ParamsStr, err := json.Marshal(params) if err != nil { return nil, err } jsonStr := bytes.NewBuffer(ParamsStr) fmt.Println(jsonStr) req, err := http.NewRequest("POST", port, jsonStr) req.Header.Set("Content-Type", "application/json") req.Header.Add("Accept", "application/json") client := &http.Client{} resp, err := client.Do(req) if err != nil { panic(err) } defer resp.Body.Close() var bodyBytes []byte if resp.StatusCode == 200 { bodyBytes, err = ioutil.ReadAll(resp.Body) if err != nil { return nil, err } } return string(bodyBytes), nil }
上面的代码只是build-transaction一个步骤,另外sign-transaction和submit-transaction请求需要自己去组织参数进行请求。请求完submit-transaction 获得返回的交易hash,去区块链浏览器上查看自己的上链信息,区块链浏览器地址： http://52.82.46.157:8082/。
好了,通过以上的4个步骤,我们就可以借助比原链实现信息上链。如果你有什么疑问或者不明白,请在我们的社区联系我们, https://github.com/Bytom/bytom。

「深度学习福利」大神带你进阶工程师,立即查看>>>
身在区块链行业,最近这几个月有一种尘归尘土归土的感觉,随着大众对区块链热度的下降,对于区块链技术圈来说,倒是一件好事。
回归区块链技术本源,不可篡改的技术特性有了越来越多的应用场景,就像几年前的人工智能、大数据一样,真正的技术人才仍然千金难求。
对于数百万的软件开发从业者来说,掌握一些区块链技术,会打开新的技术视角,带来更多技术解决方案,而在区块链技术入门上,钱包开发和智能合约是两个既基础,又重要的,但又相对简单的区块链知识。
11月24日,HiBlock区块链社区在西安发起一场“破冰区块链技术”的沙龙活动 ,邀请胡键和鲍帅两位老师分别从以太坊钱包开发和编写安全的solidity智能合约两个话题分享区块链技术入门方式。此外,还有冯宇老师带来技术视频制作小技巧。
1
时间地点
主题：破冰区块链技术,从钱包和智能合约开发入门区块链
**时间：**11月24日 13:30-17:30
地址 ： 西安市高新区沣惠南路36号橡树街区B-10101,哈希屋 （32路;35路;184路;260路;261路;261路区间;280路;324路;411路;高新1号线;高新4号线;高新9号线;高新草堂专线到科技六路中段下车）
本次活动 免费 参加,点击" 阅读原文 "即可报名
2
分享内容
话题1：使用Angular开发以太坊钱包
钱包是区块链应用的必备组件之一,对于任何意图入门区块链开发的开发者来讲,钱包开发是一个不错的开始。本次分享将结合Angualr和以太坊来展示一个入门级钱包的开发过程,通过这次分享,参会者将会了解到Angular的基本构成、以太坊的基本知识,以及以太坊Dapp开发的一般过程。对于像了解区块链相关知识的开发者而言,是一堂不容错过的入门课。
分享嘉宾：胡键
入行超过15年,CSM/架构师/创业者,先后就职于中兴和SAP,现专注于工业物联网、大数据处理和区块链。具有丰富的产品研发和项目管理经验,擅长围绕工业设备构建物联网端到端解决方案,对海量设备接入、数据存储和数据分析有深刻见解。他同时还热衷于参与技术社区,在多个社区会议上进行过分享,作为HiBlock社区合伙人在西安组织了多场区块链技术活动。在业余时间,他还会参与开源软件的开发和布道（Grails、Vert.x和以太坊）,并贡献了基于vert.x的API网关dgate。他的简书博客（ https://www.jianshu.com/u/3ff936a6e22c）记录了他关于技术和创业的思考。
话题2：如何编写安全的solidity智能合约
智能合约是企业在使用区块链技术进行应用落地时候的关键路径, 和传统的互联网技术不同, 区块链上的智能合约一旦写定上链就无法再更改。这既是区块链技术的特点, 也是对区块链上业务安全运营的挑战。本期嘉宾将为大家分享如何编写安全的Solidity智能合约, 从而帮助业务开发者在编码阶段提升智能合约的安全性和功能准确性, 做到防患于未然。
分享嘉宾：鲍帅
西安好码安全信息科技有限公司CEO, 毕业于西安交通大学, 曾在IBM中国开发实验室、华为公有云从事商业智能和云计算相关的研发工作。在云计算、分布式系统、区块链技术、商业智能等领域具有多年实战经验。
话题3：技术视频制作小技巧
对于技术人员可能会遇到需要制作视频教程布道的需求。那么制作视频教程需要有哪些要注意的呢？应该如何制作出容量又小,画质又好的优质视频教程呢？本次将分享我制作视频教程的一些经验。
分享嘉宾：冯宇
毕业于西安电子科技大学网络工程专业,从事多年DevOps工作,在西安开源社区线下活动中有多次个人session。热爱开源技术,国内早期Docker,SaltStack等技术工具推广者,《精通SaltStack》一书合作译者,《ELKStack中文指南》内容协助者。SaltStack, Grails, Dgate, Jenkins, sdkman, screenFetch等多个项目的代码贡献者,此外,还有多个pull request被上游合并。
3
流程安排
13:30-14:00 签到
14:00-14:05 开场及主办方介绍
14:05-15:05 胡键： 使用Angular开发以太坊钱包
15:15-16:15 鲍帅 ：如何编写安全的solidity智能合约
16:25-17:25 冯宇： 技术视频制作小技巧
17:25-17:30 合影
4
主办方
HiBlock  秉承开放、协作、透明、链接、分享的价值观,致力打造一个专注于区块链的开发者社区,我们不仅在开发者中宣传推广区块链,还会帮助开发者真正掌握区块链技术和应用。我们有线上活动（如一起译文档、一起学以太坊、一起学EOS等）,有培训课程（提供专业的区块链技术培训  http://hiblock.net/topics/node16）、也有线下沙龙聚会（全国各城进行线下交流）。
详情参考：
https://github.com/HiBlock/hiblock/tree/master/meetup
联合主办
一杯咖啡读懂区块链~~
哈希屋Hahs House是西安区块链爱好者的聚集地,一个以咖啡厅为载体,集合区块链领域多方资源的线上线下生态。致力于普及传播加密货币、区块链知识、历史、文化、技术、应用,以极客元素及国际化为特色,内有矿机博物馆,韭菜庄园,区块链书籍、精品白皮书,区块链周边产品等,同时提供区块链主题元素饮品、甜点。配套培训教室、多媒体会议室、2000平米的专业展厅,以及500平米区块链企业众创空间。
5
合作伙伴
6
报名流程
扫描二维码或点击“ 阅读原文 ”即可报名

「深度学习福利」大神带你进阶工程师,立即查看>>>
今天我们先在windows系统上学习入门以太坊。

首先,我们先要下载以太坊钱包,https://ethfans.org/wikis/Home 在这个网站上下载官方钱包镜像,这几个都可以下载下来,他们各有优势和用处（具体的由于篇幅先不赘述）但今天Ethereum Wallet和Geth的一定要先下载下来。注意,最好选择个空间大一点的盘,因为日后在公有链上同步区块需要不小的存储,也是时候把你们电脑里的小片片清理一下了。

接下来就到正题操作了,我们需要创建一个json文件,如果对这个文件不熟悉的小伙伴,可以先创建一个txt文档,然后在文件内输入如下代码。 { "config": { "chainId": 10, "homesteadBlock": 0, "eip155Block": 0, "eip158Block": 0 }, "alloc" : {}, "coinbase" : "0x0000000000000000000000000000000000000000", "difficulty" : "0x02000000", "extraData" : "", "gasLimit" : "0x2fefd8", "nonce" : "0x0000000000000042", "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash" : "0x00000000000000000000000000000000000000000000000000000000000 00000", "timestamp" : "0x00" }

不想动手的小伙伴直接复制即可,里面的各个参数先不做过多解释,我们只需要知道这是配置挖矿用的一些参数就行了。然后我们将文件保存在Geth目录下面,Geth目录下应该有个geth.exe程序）使用txt文档的小伙伴记得把txt的拓展名改成json。然后打开我们的cmd终端,注意不是tmd终端,切换到Geth文件所在目录,（假如文件在e盘,输入e：+回车,cd Geth+回车）然后输入命令： geth --datadir "%cd%\chain" init genesis.json

然后回车会出现如下东东:

这是初始化创世块。接着输入命令： geth -datadir "%cd%\chain" --nodiscover console

然后回车出现如下东东:

这时候就启动了私有链节点,也打开了geth控制台。接下来,我们打开Ethereun Wallet.exe程序,但出现如下画面时。

点击LAUNCH APPLICATION进入私有链网络,这时候,如果大家第一次进入的话,是没有账户的,我们需要回到我们刚才的geth控制台,输入如下命令创建账户：personal.newAccount()然后会让你输入两次密码,接下来会就会创建一个新账户了,如下图所示:
接下来就是愉快挖矿装逼的环节了,输入命令miner.start()你就会发现系统开始咔咔的为你搬砖了,等过了一段时间之后,再输入命令eth.getBalance(eth.accounts[0])如果其输出结果不为零,那么就说明你挖到以太币了,钱包的余额也会显示。想要停止挖矿的话,输入命令miner.stop()就可以了。

原文链接： https://quant.la/Article/View/580/