区块链分享ppt,区块链ppt,区块链入门ppt

团队区块链分享ppt

可做为初步入门分享ppt

目录如下:

比特币
以太坊
区块链
币圈
韭菜圈
链圈
预测
机会

 

水平有限,中间如果有问题,可以随时交流

原版ppt会有备注和动画演示效果

原版下载:https://pan.baidu.com/s/1eUhIdxS

如果有问题,可以加上图的微信,验证备注:区块链分享ppt

区块链九大公链

1. 以太坊

https://www.ethereum.org/

以太坊中文白皮书
https://github.com/ethereum/wiki/wiki/%5B%E4%B8%AD%E6%96%87%5D-%E4%BB%A5%E5%A4%AA%E5%9D%8A%E7%99%BD%E7%9A%AE%E4%B9%A6

创始人:Vitalik Buterin

ICO众筹:2014

简介:以太坊(英语:Ethereum)是一个开源的有智能合约功能的公共区块链平台。通过其专用加密货币以太币(Ether,又称“以太币”)提供去中心化的虚拟机(称为“以太虚拟机”Ethereum Virtual Machine)来处理点对点合约。

应用:

支付系统 比特币的主要使用案例同样能够应用到以太坊网络。以太币(以太坊网络的加密货币)被用作货币或者价值存储方式方面存在着很多争论,但是,以太币暂时可以并且也正在积极被用于价值转移。使用以太币的支付可以通过节点/矿工网络进行验证,并被写入不可变更账本,就像比特币区块链那样。

黄金投资Digix团队已经为所有人设计了一种用于在以太坊区块链上以代币化形式购买黄金的方法。问问自己,如何轻松(廉价的)可以买到价值500美元的黄金?通过Digix你可以立即将法定货币(以太坊)转变成黄金代币,这种代币与新加坡金库通过加密的形式相连并获得其支持。任何时候(甚至是在Digix破产的情况下)用户都能够使用代币进行赎回换取实体黄金。无经纪人,无银行,无损耗存储,几乎零手续费,直接且安全。除此之外不只是黄金,还可以是其他贵金属,珠宝,石油,橘子等。

众筹Kickstarter, Indiegogo和其他的一些组织机构在过去几年一直主导者众筹领域。例如,如果一家创业公司有了新想法并设定了众筹目标,如果众筹成功,Kickstarter将收取5%的费用,剩下的交给创业公司。然而,在以太坊区块链上,如果创业公司众筹成功,智能合约就会自动将资金转移给创业公司,并且不收取费用。

公司财务在今年5月初,DAO启动了史上最大规模的众筹项目。从本质上讲,The DAO是一种去中心化风险投资资金,依赖于集体智慧投票系统来做出投资决定。这是一次革命性试验,令所有人都毫无防备,尤其是监管机构。该项目的法律意义仍在制定,但是如果成功的话,你将会看到一些由区块链代码而不是CEO和董事会来管理的公司。这种概念咋一看实在令人难以相信。我期待在未来几个月里,我们会听到更多关于这个实验的信息。

物联网 物联网可能会成为一个数万亿美元的大市场。Stephan Tual, Simon Jentzsch和Christoph Jentzsch旨在通过slock.it抢占部分市场份额。Slock是一家雄心勃勃的创业公司,正在建设连接区块链与现实世界的桥梁。通过使用以太坊计算机(Ethereum Cumputer),所有的资产(自行车,公寓,汽车等)能够被数字化锁定或者解锁,然后通过出租,将这些资产变成收入。就像以太坊众筹消除Kickstarter费用那样,Slock同样存在消除AirBaB费用的潜在可能。

预测市场 预测市场为市场交易人/投机者提供了一种方法,用于押注某一事件的二元结果。Augur和Gnosis正是预测市场(如PredictIt)的去中心化版本。他们最终如何决定处理这个问题将会不仅对他们的APP的成功至关重要,同样会成为区块链技术的标志,因为将从现实世界获得的信息可靠且可信地放入区块链中并不是一种简单的事情。如果成功,我们将能够看到一种新的集体智慧管理类型,这种类型一直被认为会有很多有用的应用。

网页托管 根据我的理解,去中心化网页托管意味着一个网页被托管给所有人,这就意味着这个网页可能会被DDoS攻击或者被政府审查。所以我们所拥有的就是一个潜在的无审查的互联网。例如,在这个互联网内放入一些去中心化扑克牌,然后你就拥有了一种在线赌博形式,并且政府难以禁止。简单且具有颠覆性。

社交网络你曾经被你最喜爱的论坛管理员审查过吗?Akasha的团队正在利用一种评级系统来研究将在线社区进行去中心化。通过由智能合约所管理的开源代码和规则,未来将可以彻底消除审查丑闻的出现。

能源转移TransActive Grid项目是能源公司LO3与ConsenSys合作进行的项目,允许所有的居民自动地转移或者出售剩余的可再生能源给自己的邻居。这种使用案例为所有拥有太阳能板的社区提供了更加高效和便宜的能源使用。

婚姻契约/遗嘱使你的婚姻正式化并放在区块链上。同样,一个简单的智能合约能够在你死后将资产转移给你的近亲。不过此举目前并没有法律支持,不过将来有一天也许能够实现。

去中心化加密货币交易所EtherEx是一个去中心化加密货币交易所。更多是在金融市场上。

供应链管理ConsenSys公司有一些有关整个供应链被颠覆的成熟时机的有趣想法。

金融市场区块链的最明显的使用案例之一就使金融市场。猖獗的欺骗行为,欺诈和操纵市场都会被区块链所颠覆。不过让我们面对现实,银行、政府以及那些掌权的人将可能永远不会让这种事情发生。如果金融市场应用了区块链技术,那么很可能是私有区块链。然而,对那些梦想家来说,UBS在去年的年度以太坊会议上展示了债券能够在区块链上进行转移。

选举可证明的公正的选举。每一个人都有一次投票计划,仅有一次。没有人会被审查或者被禁止参与投票。据说,乌克兰将进行尝试这种投票方式。

房地产有人说,房地产行业已经到来被区块链颠覆的时机。我不知道有多少人知道Rex,这个团队正在这方面进行研究。

点评:以太坊受比特币启发后提出, 作为区块链项目的鼻祖 ,虽然命途多舛经历多次分叉,但截至2017年5月,以太币是市值第二高的加密货币,仅次于比特币。在本轮ico热潮中以太坊成为了所有项目的中介,其他区块链公链或多或少都会和它有所关联,被称作为区块链之母一点也不过分。

2 小蚁(NEO)

https://neo.org/

小蚁白皮书:https://github.com/neo-project/neo/wiki/%E7%99%BD%E7%9A%AE%E4%B9%A6-1.1

2014.6 小蚁 正式立项,接受种子轮投资 2015.6在GitHub上建立antshares 项目,并实时开源

2015.10小蚁 ICO一期众筹2100BTC,巴比特资讯、比特时代全程进行报道

2016.10小蚁 区块链,主网正式启动上线!

2017.6NEW 小蚁 品牌战略发布会, 小蚁 更名为NEO

创始人:达叔(达鸿飞)

简介:NEO区块链通过将点对点网络、拜占庭容错、数字证书、智能合约、超导交易、跨链互操作协议等一系列技术相结合,让你快速、高效、安全、合法地管理你的智能资产。

点评:作为国内第一条原创公链,最近改名为NEO的小蚁任重道远。NEO确实是想搞事情也有能力搞事情,从它的白皮书和应用简介看,主创的文笔流畅思路清晰,应用层也有各类应用出现,但是对于NEO作为第一条公链,希望它的功能不要被泛区块链化,它可以走得更好,更远,而不仅仅是把它作为一个概念应用,找优秀的程序员加诸代码。加油。

3.
量子链

https://qtum.org/zh/

白皮书:http://qtum.org/uploads/files/17dc8a787ca852e62076481096240e1e.pdf

创始人:帅初

简介:创造简单实用的去中心化 应用可以在移动设备上运行,兼容目前的主流区块链生态系统

点评:在上面提供的白皮书和官网中,可以了解到官方端提供的所有信息。外界对于这条公链其实是褒贬不一。这里也不进行决断,代币没有发行前,任何愿景也都是画饼。希望量子链的团队能够利用好这波牛市,去研发出真技术回馈现在的市值。实力可以让喷子闭嘴,也是给信任你的忠粉的反馈。现在的量子是资本运作和营销一流,PPT做得也还不错其他得一切需要等待时间去见证。

4.
元界

http://mvs.live/

白皮书:http://mvs.live/attachment/Metaverse-White-Paper(draft)-EN.pdf

创始人:初夏虎

点评:对于元界项目本身,可能币圈里的人对初夏虎会更加了解,因为确实会来事,会搞事,技术先不说它做得怎么样,但是热度至少是搞起来了,基于平台也有自己的社区和衍生的应用,但是更希望它的愿景可以被技术实现,免得很多时候限于夸夸其谈,钱到位办实事是最当紧的。

5.
比原链

https://bytom.io/

白皮书

经济:https://bytom.io/BytomWhitePaperV1.0_Economic.pdf

技术:https://bytom.io/BytomWhitePaperV1.0.pdf

简介:Bytom Blockchain Protocol(简称比原链:Bytom)是一种多元比特资产的交互协议,运行在比原链区块链上的不同形态的、异构的比特资产(原生的数字货币、数字资产)和原子资产(有传统物理世界对应物的权证、权益、股息、债券、情报资讯、预测信息等)可以通过该协议进行登记、交换、对赌、和基于合约的更具复杂性的交互操作。连通原子世界与比特世界,促进资产在两个世界间的交互和流转。比原链采用三层架构:应用层、合约层、数据层,应用层对移动终端等多终端友好,方便开发者便捷的开发出资产管理应用;合约层采用创世合约和控制合约进行资产的发行和管理,在底层支持扩展的UTXO模型BUTXO,对虚拟机做了优化,采用自省机制以防止图灵完备中的死锁状态;数据层使用分布式账本技术,实现资产的发行、花费、交换等操作,共识机制采用对人工智能ASIC芯片友好型POW算法,在哈希过程中引入矩阵和卷积计算,使得矿机在闲置或被淘汰后,可用于AI硬件加速服务,从而产生额外的社会效益

主要创新

(1)与比特币UTXO的设计兼容

比原链由三层组成:数据交易及传输层、合约层、资产交互层。资产交互层通过调用合约来对资产进行操作,其中在在数据交易及传输层,兼容比特币的UTXO模型和交易数据结构,以实现高速并发和可控匿名。

(2)通用地址格式

比原链钱包的设计中将引入BIP32,BIP43,BIP44 理念,用 Hierarchical Deterministic Wallets (or “HDWallets”)提供对多币种、多账户、多地址、多密钥的支持。BIP44提供了一种5层路径建议:(1)确定路径规则;(2)币种;(3)账户;(4)找零;(5)地址索引。用户只需要保存一个主私钥,就能控制所有币种、所有账户的资产钱包。BIP44对找零机制提供了很好的支持,用户只要不用同一地址多次收款,就可以避免同一私钥多次签名,从而规避私钥暴露的风险。

(3)支持国密标准

比原链的资产控制和操作中涉及到私钥、公钥、地址体系。传统的比特币代码实现中基于椭圆曲线函数加密ECDSA和SHA256散列。在比原链中将进一步支持 国密SM2椭圆曲线公钥密码算法 和 SM3密码杂凑算法 。在实现同样的计算复杂度时,SM2在私钥的处理速度上远快于RSA、DSA算法,加密效率更高。SM3算法的压缩函数与SHA-256的压缩函数具有相似的结构,但是SM3算法的设计更加复杂,比如压缩函数的每一轮都使用2个消息字。

(4)资产命名采用ODIN标识

链上资产的命名采用ODIN(Open Data Index Name)开放数据索引命名标准,利用区块链透明可信、不可篡改特性,保障资产的全网、全链唯一性。与其它基于区块链的标识解决方案不同的是,ODIN基于比特币区块链,支持扩展多级标识引入其它区块链(公有链、联盟链、私有链),不是以抢注字符串的方式,而是用区块记录位置作为标识名称。

(5)人工智能ASIC芯片友好型POW算法

采用对人工智能ASIC芯片友好型POW算法,使得矿机在闲置或被淘汰后,可用于AI加速服务。

如果我们在挖矿的哈希过程中引入矩阵运算与卷积运算,使得矿机对人工智能ASIC相对于GPU、CPU更友好,那么,区块链共识所需要的计算量同样可以应用于AI硬件加速服务,从而产生较大的社会效益:一方面,矿机市场会刺激人工智能市场,扩大对深度学习ASIC芯片的需求,正如目前显卡友好型PoW区块链,对显卡市场的促进作用;另一方面,被淘汰或闲置的矿机可应用于AI硬件加速服务,节省挖矿成本,形成双赢局面。

(6)使用侧链支持跨链资产交易及分红

为对其他链上资产进行操作,在比原链上开发者可以创建一种小型版本的X链(其他链)中继器XRelay,比原链上的Dapp开发者可以从智能合约向X链中继器进行API调用,来验证X链网络活动,实现跨链通信。继而在合约中完成交易和分红操作。

(7)类“隔离见证”设计

(8)增强的交易灵活性

4 应用场景

4.1 场景一 收益权资产管理

比原链可以用于收益类众筹项目的管理。区块链公开透明的特性,消除了众筹发起、投资以及后续资金使用过程中的信息不对称,降低了人们的信任成本。基于比原链提供的可编程接口,可以在众筹资产发行时内置智能合约,真正做到资金的专款专用,让投资人没有后顾之忧。智能合约还可以保证:如果你没有达成预定的目标,资金可以自动退回到支持者的账户。这些都不需要第三方背书和担保,不需要给第三方支付佣金。

4.2 场景二 非上市公司股权管理

比原链还适用于私募基金管理。私募基金管理人使用比原链发行私募基金,在智能合约中制定基金的资产审计、投资人回馈规则、回购规则、交易规则等,将使得整个管理严格执行,公开透明。基金份额变得更易转让和交易,投资人可以放心的购买长期股权投资基金,而无需担心不时之需,通过比原链的交易转让系统,可以随时将基金溢价或折价转让。

4.3 场景三 证券化资产管理

通过比原链管理证券化资产,可极大的提高ABS资产运作的效率、安全性和可追溯性,实现交易数据的安全存储,保证信息不可伪造和篡改,并自动执行智能合约。ABS交易过程中所有市场参与者,通过分布式账本和共识机制保持资产登记与交易信息的同步,有效解决了机构间费时费力的对账清算问题。

点评:比原链是基于巴比特社区所产生的产品,巴比特是国内最早做区块链论坛和资讯的公司,从早期的讨论比特币的论坛,现在成为一个发布各类区块链信息的平台。另外一方面,比原链的发行平台币众筹是国内最早的ico平台。之前在币众筹也发行过巴比特自己社区股,盈利势头一直保持优秀势头。比原也是业内把经济和技术白皮书单独列项的公司。唯一的忧虑是20亿的代币数量对于一个初成长的货币来说是一个巨大的量,虽然从某种角度讲,让更多的人有了参与机会,但是在ico热度下滑的时候发行巨量代币还值得时间商榷, 不过截止发文时,因为在做社区时候的行业积淀,以及和业内各大交易所的良好关系,产品已经在多个交易平台上线代币。

6 COSMOS

https://cosmos.network/

白皮书:https://cosmos.network/whitepaper

简介:建立一个分布式账本网络,解决加密货币和区块链社区长期存在的问题。宇宙网络由许多独立的、平行的区块链组成,这些区块被称为“区域”,每个区域都由经典的拜占庭式容错(BFT)协商一致协议(如“ErisDB”所使用的平台)所驱动。

有些区域作为中心与其他区域,允许多个区域通过共享中心进行互操作。

该架构是比特币侧链概念的一个更通用的应用,使用经典的BFT和风险验证算法,而不是工作证明。

创新:

Cosmos hub通过新的IBC(跨区块链通信)协议连接到区域,并记录每个区域内的令牌总数。

因为所有的区域间令牌传输都经过了宇宙集线器,你可以快速而安全地将令牌从一个区域转移到另一个区域,而不需要在区域之间进行液体交换或受信任的第三方。

只要每个区域都说IBC,宇宙中心就可以连接到许多不同的区域。

因此,Cosmos可以支持多种货币和脚本语言,比如比特币、Ethereum、ZeroCash、CryptoNote等。

7 Polkadot

https://polkadot.io/

白皮书:

项目创新构想:现有的区块链架构都存在诸多问题,不仅仅是从实用性角度所说的扩展性(extensibilty)和伸缩性(scalability)的问题。我们认为,问题源于把共识架构中两个很重要的部分:一致性(canonicality)和有效性(validity)绑定得太紧密了。这篇文章介绍了一种异构的多链架构,能从本质上把两者拆开。

为了分离这两者,且能保持最小化的绝对安全性(security)和传输性(transport)等基本功能,我们将介绍一种原生的支持内核可扩展(core extensibilty)的可行性方法。对于可伸缩性(scalability)的问题,我们通过对这两个问题分而治之的思路解决,通过非信任节点的激励机制,弱化他们的内生绑定关系。

本架构的异构本质,支持众多高度差异化的共识系统在非信任(trustless)、完全去中心化的联邦内交互操作,允许去信任(trust-free)地相互访问各区块链。

我们提出一种方式,支持向后兼容一个或多个现有的网络,比如以太坊等。我们相信这个系统能够提供一种有用的底层组件,能够实用性地支持全球商业级别的可伸缩性(scalability)和隐私性(privacy)

点评:这是一个国外的项目,在国内显得颇为神秘低调,但是区块链底层技术开发者对这家公司却褒大于贬,主创成员的以太坊主要代码贡献者的身份也是这个项目值得期待的原因之一,不过没有落地之前,所有事情谁知道呢?

8 IPFS

https://ipfs.io/

白皮书:

简介:每个文件和它内部的所有块都有一个称为加密散列的独特的指纹。IPFS消除了网络中的重复,并跟踪每个文件的版本历史。每个网络节点只存储它感兴趣的内容,以及一些索引信息,这些信息可以帮助确定谁在存储什么。在查找文件时,您要求网络找到存储在一个惟一散列背后的内容的节点。每个文件都可以通过一个名为IPFS的分散命名系统来找到人类可读的名字。

点评:IPFS项目运行其实偏慢,一开始募集资金的设置了一定门槛,它的目的是想开创互联网3.0时代,但是现在它所做的一些工作或者说现阶段的技术感觉会让互联网更复杂。互联网本身的需求就是特定或随机在面对互联网的时候,它这样就像搞了很多个功能性极强的app,而且会时不时让你进入它的模式节奏。它的想法真的很好建立一个超大的自由连接的局域网,但是距离提出到现在已经两年时间了,没有巨大的技术突破。
9 EOS

https://eos.io/

Eos白皮书::

https://github.com/EOSIO/Documentation/blob/master/TechnicalWhitePaper.md

创始团队: BM 李笑来 沈波

简介: Eos是一个区块链操作系统,它提供了数据库,账号许可,调度,认证和互联网应用通信,提高智能商业开发效率,它使用了并行计算使得把区块链拓展到百万用户和每秒百万次交易成为一种可能。

代币发放模式:EOS代币分配在341天的时间内完全在以太坊区块链上运行。在此期间,EOS总共将分配10亿个ERC-20兼容代币。其中2亿个代币,即EOS代币总量的20%,将在前五天内分配,另外还有7亿个EOS代币将在接下来每23小时以200万增量的形式分配。最后,剩下的1亿,即EOS代币总量的10%,将留给block.one—— http://EOS.IO软件的开发者,这些代币在整个分配期间都不能在以太坊网络上进行交易或转移。EOS代币分配类似于一种拍卖,每个人的价格都相同,该价格等于所有人愿意并能够在给定时间内支付的最高价格。在最初5天和每23小时的分配期结束时,数量已经设定好的EOS代币将根据在这些阶段筹集的以太币(“ETH”)的总量按照比例分配给所有授权购买者。

简介:EOS项目在github的代码其实在一些技术者眼里觉得是非常一般甚至是个骗局,尤其是它ico一年的模式,然后又传出创始人在吸收eth后在国外交易所套现和用这些ICO其他项目,不过如果该项目基于对标eth的基础上,这步棋实际上下的还是不错的。另外一方面,白皮书中规划,以及愿景如果都得以实现,它的市值成为区块链市场前三或许也是可能出现的。不过现在来看业内对于它的评价还是贬大于褒,一方面可能会基于仇富心理,自己被割,说实话如果自己赚到钱,再烂的项目很多国人也不会放个屁的,另一方面,是来自技术从业人员的质疑,因为它的代码真的是迷之代码,好在借助自身强大的资源,以及自身的云币交易平台,没有形成破发,现在价格在10-11区间稳定住了。

然后看它的原则,其实是很具有去中心化意味的,但如果把它换成一个非区块链项目这些原则可不可以被替代。也希望EOS的团队手里的资源可以利用到极致,为了区块链而区块链其实是很难达到技术革新和去中心化。

原文:http://8btc.com/thread-66296-1-1.html

区块链数字货币,区块链虚拟货币,区块链币种有哪些

BTC币
LTC币
ETH币
ETC币
BCH币
XRP币
XEM币
XLM币
IOTA币
1ST币
AAC币
ACE币
ACT币
AIDOC币
AMM币
ARK币
AST币
ATL币
AVT币
BCD币
BCX币
BNT币
BRD币
BT1币
BT2币
BTG币
BTM币
CAG币
CAN币
CMT币
CTR币
CVC币
DASH币
DAT币
DENT币
DGB币
DGD币
DNA币
DNT币
DPY币
EDO币
ELF币
ENG币
EOS币
ETF币
EVX币
F4SBTC币
FAIR币
FUN币
GAS币
GNT币
GNX币
HMC币
HOT币
HSR币
ICN币
ICX币
INS币
INT币
IOST币
IPC币
ITC币
KCASH币
KEY币
KNC币
LA币
LEND币
LEV币
LIGHT币
LINK币
LRC币
MAG币
MANA币
MCO币
MDA币
MDT币
MKR币
MOF币
MOT币
MTH币
MTL币
NANO币
NAS币
NEO币
NGC币
NULS币
OAX币
OF币
OMG币
OST币
PAY币
POE币
PPT币
PRA币
PST币
PYN币
QTUM币
QUN币
QVT币
RCN币
RCT币
RDN币
READ币
REF币
REQ币
RNT币
SALT币
SAN币
SBTC币
SHOW币
SMT币
SNC币
SNGLS币
SNM币
SNT币
SOC币
SPF币
SSC币
STC币
STORJ币
SUB币
SWFTC币
TCT币
THETA币
TIO币
TNB币
TOPC币
TRUE币
TRX币
UBTC币
UGC币
UKG币
USDT币
UTK币
VEE币
VIB币
VIU币
WBTC币
WRC币
WTC币
XMR币
XUC币
YEE币
YOYO币
ZEC币
ZEN币
ZIP币
ZRX币

以太坊,以太币,token,AXCD,以太钱包

我在以太坊发了一个token

谁要想,给我以太钱包地址,免费赠送10个token

 

合约地址:0x8419bf9bAb3455756118Cb35709260B17C32F451

Token名:AXCD

长度:18

 

继续阅读以太坊,以太币,token,AXCD,以太钱包

Etheteum wallet 账本结构解析和源码分析

第一部分 看看geth客户端的整体结构
创建私链的时候已经指定所有的信息都放在private-geth目录下,现在是已经有过挖矿的目录。

当时我们把创世文件genesis.json放在该目录下了、

root@i-5tthrr8u:/home/ubuntu/private-geth# ll
total 16
drwxr-xr-x 3 root   root   4096 Jul  2 17:02 ./
drwxr-xr-x 6 ubuntu ubuntu 4096 Jul  4 14:07 ../
drwx------ 5 root   root   4096 Jul  2 17:41 data/
-rw-r--r-- 1 root   root    529 Jul  2 16:29 genesis.json

进入真正的存放数据的目录private-geth/data/00
geth中保存的是区块链的相关数据
keystore中保存的是该链条中的用户信息

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00# ll
total 20
drwx------ 4 root root 4096 Jul  2 17:23 ./
drwx------ 5 root root 4096 Jul  2 17:41 ../
drwxr-xr-x 5 root root 4096 Jul  2 17:02 geth/
-rw------- 1 root root 1391 Jul  2 17:58 history
drwx------ 2 root root 4096 Jul  2 17:10 keystore/

之前我们这个节点已经创建了两个账户,现在我们可以看到keystore里面有两个账户信息的文件

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/keystore# ll
total 16
drwx------ 2 root root 4096 Jul  2 17:10 ./
drwx------ 4 root root 4096 Jul  2 17:23 ../
-rw------- 1 root root  491 Jul  2 17:02 UTC--2017-07-02T09-02-56.470592674Z--28b769b3b9109afd1e9e50a9312c5a3bfae8a699
-rw------- 1 root root  491 Jul  2 17:10 UTC--2017-07-02T09-10-28.087401309Z--b4e2e2514eae3684157bf34a0cee2c07c431cf92

每个账户都由一对钥匙定义,一个私钥和一个公钥。 账户以地址为索引,地址由公钥衍生而来,取公钥的最后 20个字节。每对私钥 /地址都编码在一个钥匙文件里。钥匙文件是JSON文本文件,可以用任何文本编辑器打开和浏览。钥匙文件的关键部分,账户私钥,通常用你创建帐户时设置的密码进行加密。钥匙文件的文件名格式为UTC。账号列出时是按字母顺序排列,但是由于时间戳格式,实际上它是按创建顺序排列。如果把秘钥丢了钥匙文件可以在以太坊节点数据目录的keystore子目录下找到,接下来我们进入一个keystore目录文件看看他的信息:

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/keystore# vim UTC--2017-07-02T09-02-56.470592674Z--28b769b3b9109afd1e9e50a9312c5a3bfae8a699 

{"address":"28b769b3b9109afd1e9e50a9312c5a3bfae8a699",
"crypto":{
"cipher":"aes-128-ctr",
"ciphertext":"89ce1513b4b5a325735891b559c361ce696bb2c173a7a1b290549e79dad8f847",
"cipherparams":{"iv":"982c86418fae2dd39e04d1e51528cffa"},
"kdf":"scrypt",
"kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"4227384ea0e3d15af1bac190f7e01d392543d0a5ca1ec931c1d340f87845f771"},
"mac":"46cffc6e4f57fa27b69e53dc4ae43a03ce1b93f24c132aa4655f53ddf215f112"},
"id":"e516b9d4-2161-4648-b3db-fc2ef1c3739c",
"version":3
}

警告:记住密码并”备份钥匙文件”。为了从账号发送交易,包括发送以太币,你必须同时有钥匙文件和密码。确保钥匙文件有个备份并牢记密码,尽可能安全地存储它们。这里没有逃亡路径,如果钥匙文件丢失或忘记密码,就会丢失所有的以太币。没有密码不可能进入账号,也没有忘记密码选项。所以一定不要忘记密码。

接下来进入geth可以看到chaindata,lightchaindata,nodes目录

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/geth# ll
total 24
drwxr-xr-x 5 root root 4096 Jul  2 17:02 ./
drwx------ 4 root root 4096 Jul  2 17:23 ../
drwxr-xr-x 2 root root 4096 Jul  4 14:12 chaindata/
drwxr-xr-x 2 root root 4096 Jul  2 17:02 lightchaindata/
-rw-r--r-- 1 root root    0 Jul  2 17:02 LOCK
-rw------- 1 root root   64 Jul  2 17:02 nodekey
drwxr-xr-x 2 root root 4096 Jul  4 15:55 nodes/

进入nodes(我们这条私链有三个节点,所以这里有三个ldb文件)

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/geth/nodes# ll
total 5316
drwxr-xr-x 2 root root    4096 Jul  4 15:55 ./
drwxr-xr-x 5 root root    4096 Jul  2 17:02 ../
-rw-r--r-- 1 root root  405250 Jul  4 15:57 000033.log
-rw-r--r-- 1 root root 2132979 Jul  4 15:55 000035.ldb
-rw-r--r-- 1 root root 2131238 Jul  4 15:55 000036.ldb
-rw-r--r-- 1 root root  739354 Jul  4 15:55 000037.ldb
-rw-r--r-- 1 root root      16 Jul  4 14:12 CURRENT
-rw-r--r-- 1 root root       0 Jul  2 17:02 LOCK
-rw-r--r-- 1 root root    8187 Jul  4 15:55 LOG
-rw-r--r-- 1 root root    4557 Jul  4 15:55 MANIFEST-000013

进入chaindata,区块链最后的本地存储都是以ldb文件的形势(但这里是不是应该每个区块一个ldb文件呢?)

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/geth/chaindata# ll
total 52
drwxr-xr-x 2 root root  4096 Jul  5 09:51 ./
drwxr-xr-x 5 root root  4096 Jul  2 17:02 ../
-rw-r--r-- 1 root root  5288 Jul  2 17:56 000008.ldb
-rw-r--r-- 1 root root 11681 Jul  4 14:12 000009.ldb
-rw-r--r-- 1 root root  8921 Jul  4 14:13 000010.log
-rw-r--r-- 1 root root    16 Jul  4 14:12 CURRENT
-rw-r--r-- 1 root root     0 Jul  2 17:02 LOCK
-rw-r--r-- 1 root root  2807 Jul  4 14:12 LOG
-rw-r--r-- 1 root root   346 Jul  4 14:12 MANIFEST-000011

进入Lightchaindata

root@i-5tthrr8u:/home/ubuntu/private-geth/data/00/geth/lightchaindata# ll
total 24
drwxr-xr-x 2 root root 4096 Jul  2 17:02 ./
drwxr-xr-x 5 root root 4096 Jul  2 17:02 ../
-rw-r--r-- 1 root root 1237 Jul  2 17:02 000001.log
-rw-r--r-- 1 root root   16 Jul  2 17:02 CURRENT
-rw-r--r-- 1 root root    0 Jul  2 17:02 LOCK
-rw-r--r-- 1 root root  358 Jul  2 17:02 LOG
-rw-r--r-- 1 root root   54 Jul  2 17:02 MANIFEST-000000

第二部分 看看源码的结构

1 Core/types/block.go
首先看到的是一个区块的结构

// Block represents an entire block in the Ethereum blockchain.

type Block struct {
    header       *Header
    uncles       []*Header
    transactions Transactions

    // caches    hashsize字段是cache之用,避免多次 hash/sign导致性能损失
    hash atomic.Value
    size atomic.Value

    // Td is used by package core to store the total difficulty
    // of the chain up to and including the block.挖矿难度
    td *big.Int

    // These fields are used by package eth to track
    // inter-peer block relay.
    ReceivedAt   time.Time
    ReceivedFrom interface{}
}
这是一个区块体的结构,区块体是动态的存储数据的,主要包含了交易列表和uncle列表
// Body is a simple (mutable, non-safe) data container for storing and moving
// a block's data contents (transactions and uncles) together.
type Body struct {
    Transactions []*Transaction
    Uncles       []*Header
}
区块头的结构体,里面的参数我们都很熟悉就不解释了
// Header represents a block header in the Ethereum blockchain.
type Header struct {
    ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"`
    UncleHash   common.Hash    `json:"sha3Uncles"       gencodec:"required"`
    Coinbase    common.Address `json:"miner"            gencodec:"required"`
    Root        common.Hash    `json:"stateRoot"        gencodec:"required"`
    TxHash      common.Hash    `json:"transactionsRoot" gencodec:"required"`
    ReceiptHash common.Hash    `json:"receiptsRoot"     gencodec:"required"`
    Bloom       Bloom          `json:"logsBloom"        gencodec:"required"`
    Difficulty  *big.Int       `json:"difficulty"       gencodec:"required"`
    Number      *big.Int       `json:"number"           gencodec:"required"`
    GasLimit    *big.Int       `json:"gasLimit"         gencodec:"required"`
    GasUsed     *big.Int       `json:"gasUsed"          gencodec:"required"`
    Time        *big.Int       `json:"timestamp"        gencodec:"required"`
    Extra       []byte         `json:"extraData"        gencodec:"required"`
    MixDigest   common.Hash    `json:"mixHash"          gencodec:"required"`
    Nonce       BlockNonce     `json:"nonce"            gencodec:"required"`
}

2 这是一个交易的结构体
Core/types/transaction.go

1ContractTransaction的区别在于:Recipient == nil ; 2. Transaction能以RLP算法进行Encode和Decode; 3. hash/size/from字段是cache之用,避免多次 hash/sign导致性能损失;
type Transaction struct {
    data txdata
    // caches
    hash atomic.Value
    size atomic.Value
    from atomic.Value
}

type txdata struct {
    AccountNonce uint64          `json:"nonce"    gencodec:"required"`
    Price        *big.Int        `json:"gasPrice" gencodec:"required"`
    GasLimit     *big.Int        `json:"gas"      gencodec:"required"`
    Recipient    *common.Address `json:"to"       rlp:"nil"` // nil means contract creation
    Amount       *big.Int        `json:"value"    gencodec:"required"`
    Payload      []byte          `json:"input"    gencodec:"required"`

    // Signature values 签名
    V *big.Int `json:"v" gencodec:"required"`
    R *big.Int `json:"r" gencodec:"required"`
    S *big.Int `json:"s" gencodec:"required"`

    // This is only used when marshaling to JSON.
    Hash *common.Hash `json:"hash" rlp:"-"`
}

3 Receiptroot我们刚刚在区块头有看到,那他具体包含的是什么呢?它是一个交易的结果,主要包括了poststate,交易所花费的gas,bloom和logs


// Receipt represents the results of a transaction.
type Receipt struct {
    // Consensus fields
    PostState         []byte   `json:"root"              gencodec:"required"`
    CumulativeGasUsed *big.Int `json:"cumulativeGasUsed" gencodec:"required"`
    Bloom             Bloom    `json:"logsBloom"         gencodec:"required"`
    Logs              []*Log   `json:"logs"              gencodec:"required"`

    // Implementation fields (don't reorder!)
    TxHash          common.Hash    `json:"transactionHash" gencodec:"required"`
    ContractAddress common.Address `json:"contractAddress"`
    GasUsed         *big.Int       `json:"gasUsed" gencodec:"required"`
}

4 一个个交易被打包到区块上面,那区块又是怎么变成去快链的呢?
Core/blockchain.go

// BlockChain represents the canonical chain given a database with a genesis block. The Blockchain manages chain imports, reverts, chain reorganisations.
// Importing blocks in to the block chain happens according to the set of rules defined by the two stage Validator. (需要两个阶段的验证)Processing of blocks is done using the Processor which processes the included transaction.(第一阶段交易的验证) The validation of the state is done in the second part of the Validator.(第二阶段state的验证) Failing results in aborting of the import.
// The BlockChain also helps in returning blocks from **any** chain included in the database as well as blocks that represents the canonical chain. It's important to note that GetBlock can return any block and does not need to be included in the canonical one where as GetBlockByNumber always represents the canonical chain.


type BlockChain struct {
    config *params.ChainConfig // chain & network configuration

    hc           *HeaderChain
    chainDb      **ethdb**.Database 本地数据库
    eventMux     *event.TypeMux
    genesisBlock *types.Block

    mu      sync.RWMutex // global mutex for locking chain operations
    chainmu sync.RWMutex // blockchain insertion lock
    procmu  sync.RWMutex // block processor lock

    checkpoint       int          // checkpoint counts towards the new checkpoint
    currentBlock     *types.Block // Current head of the block chain
    currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!)

    stateCache   *state.StateDB // State database to reuse between imports (contains state cache)
    bodyCache    *lru.Cache     // Cache for the most recent block bodies
    bodyRLPCache *lru.Cache     // Cache for the most recent block bodies in RLP encoded format
    blockCache   *lru.Cache     // Cache for the most recent entire blocks
    futureBlocks *lru.Cache     // future blocks are blocks added for later processing

    quit    chan struct{} // blockchain quit channel
    running int32         // running must be called atomically
    // procInterrupt must be atomically called
    procInterrupt int32          // interrupt signaler for block processing
    wg            sync.WaitGroup // chain processing wait group for shutting down

    engine    consensus.Engine
    processor Processor // block processor interface
    validator Validator // block and state validator interface
    vmConfig  vm.Config

    badBlocks *lru.Cache // Bad block cache
}

注意:1. BlockChain无结构化查询需求,仅Hash查询, Key/Value数据库最方便; 2. 低层用LevelDB存储,性能好

5 stateDB用来存储世界状态
Core/state/statedb.go

// StateDBs within the ethereum protocol are used to store anything
// within the merkle trie. StateDBs take care of caching and storing
// nested states. It's the general query interface to retrieve:
// * Contracts
// * Accounts
type StateDB struct {
    db            ethdb.Database //本地数据库
    trie          *trie.SecureTrie
    pastTries     []*trie.SecureTrie
    codeSizeCache *lru.Cache

    // This map holds 'live' objects, which will get modified while processing a state transition.
    stateObjects           map[common.Address]*stateObject
    stateObjectsDirty      map[common.Address]struct{}
    stateObjectsDestructed map[common.Address]struct{}

    // The refund counter, also used by state transitioning.
    refund *big.Int

    thash, bhash common.Hash
    txIndex      int
    logs         map[common.Hash][]*types.Log
    logSize      uint

    preimages map[common.Hash][]byte

    // Journal of state modifications. This is the backbone of
    // Snapshot and RevertToSnapshot.
    journal        journal
    validRevisions []revision
    nextRevisionId int

    lock sync.Mutex
}

注意:1. StateDB完整记录Transaction的执行情况; 2. StateDB的重点是StateObjects; 3. StateDB中的 stateObjects,Account的Address为 key,记录其Balance、nonce、code、codeHash ,以及tire中的 {string:Hash}等信息;

那我们接下来看看stateObject结构体
Core/state/state_object.go

// stateObject represents an Ethereum account which is being modified.
//
// The usage pattern is as follows:
// First you need to obtain a state object.
// Account values can be accessed and modified through the object.
// Finally, call CommitTrie to write the modified storage trie into a database.
type stateObject struct {
    address common.Address // Ethereum address of this account
    data    Account
    db      *StateDB

    // DB error.
    // State objects are used by the consensus core and VM which are
    // unable to deal with database-level errors. Any error that occurs
    // during a database read is memoized here and will eventually be returned
    // by StateDB.Commit.
    dbErr error

    // Write caches.
    trie *trie.SecureTrie // storage trie, which becomes non-nil on first access
    code Code             // contract bytecode, which gets set when code is loaded

    cachedStorage Storage // Storage entry cache to avoid duplicate reads
    dirtyStorage  Storage // Storage entries that need to be flushed to disk

    // Cache flags.
    // When an object is marked suicided it will be delete from the trie
    // during the "update" phase of the state transition.
    dirtyCode bool // true if the code was updated
    suicided  bool
    touched   bool
    deleted   bool
    onDirty   func(addr common.Address) // Callback method to mark a state object newly dirty
}

再看看state的一个接口,可以查看账户的余额,nonce,代码和storage

// ChainStateReader wraps access to the state trie of the canonical blockchain. Note that implementations of the interface may be unable to return state values for old blocks.
// In many cases, using CallContract can be preferable to reading raw contract storage.

type ChainStateReader interface {
    BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error)
    StorageAt(ctx context.Context, account common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error)
    CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
    NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
}

所有的结构凑明朗了,那具体的验证过程是怎么样的呢
Core/state_processor.go
Core/state_transition.go
Core/block_validator.go

StateProcessor 1. 调用StateTransition,验证(执行)Transaction; 2. 计算Gas、Recipt、Uncle Reward

// StateProcessor is a basic Processor, which takes care of transitioning
// state from one point to another.
//
// StateProcessor implements Processor.
type StateProcessor struct {
    config *params.ChainConfig // Chain configuration options
    bc     *BlockChain         // Canonical block chain
    engine consensus.Engine    // Consensus engine used for block rewards
}

StateTransition
1. 验证(执行)Transaction;
3. 扣除transaction.data.payload计算数据所需要消耗的gas;
4. 在vm中执行code(生成contract or 执行contract);vm执 行过程中,其gas会被自动消耗。如果gas不足,vm会自 选退出;
5. 将多余的gas退回到sender.balance中;
6. 将消耗的gas换成balance加到当前env.Coinbase()中;

/*
The State Transitioning Model

A state transition is a change made when a transaction is applied to the current world state
The state transitioning model does all all the necessary work to work out a valid new state root.

1) Nonce handling
2) Pre pay gas
3) Create a new state object if the recipient is \0*32
4) Value transfer
== If contract creation ==
  4a) Attempt to run transaction data
  4b) If valid, use result as code for the new state object
== end ==
5) Run Script section
6) Derive new state root
*/
type StateTransition struct {
    gp         *GasPool
    msg        Message
    gas        uint64
    gasPrice   *big.Int
    initialGas *big.Int
    value      *big.Int
    data       []byte
    state      vm.StateDB

    evm *vm.EVM
}

BlockValidator
1. 验证UsedGas
2. 验证Bloom
3. 验证receiptSha
4. 验证stateDB.IntermediateRoot

// BlockValidator is responsible for validating block headers, uncles and
// processed state.
//
// BlockValidator implements Validator.
type BlockValidator struct {
    config *params.ChainConfig // Chain configuration options
    bc     *BlockChain         // Canonical block chain
    engine consensus.Engine    // Consensus engine used for validating
}

 

可以注意到刚才的state和block都是写进db数据库的,那我们看一下leveldb数据库结构

type LDBDatabase struct {
    fn string      // filename for reporting
    db *leveldb.DB // LevelDB instance

    getTimer       gometrics.Timer // Timer for measuring the database get request counts and latencies
    putTimer       gometrics.Timer // Timer for measuring the database put request counts and latencies
    delTimer       gometrics.Timer // Timer for measuring the database delete request counts and latencies
    missMeter      gometrics.Meter // Meter for measuring the missed database get requests
    readMeter      gometrics.Meter // Meter for measuring the database get request data usage
    writeMeter     gometrics.Meter // Meter for measuring the database put request data usage
    compTimeMeter  gometrics.Meter // Meter for measuring the total time spent in database compaction
    compReadMeter  gometrics.Meter // Meter for measuring the data read during compaction
    compWriteMeter gometrics.Meter // Meter for measuring the data written during compaction

    quitLock sync.Mutex      // Mutex protecting the quit channel access
    quitChan chan chan error // Quit channel to stop the metrics collection before closing the database

    log log.Logger // Contextual logger tracking the database path
}
type Database interface {
    Put(key []byte, value []byte) error
    Get(key []byte) ([]byte, error)
    Delete(key []byte) error
    Close()
    NewBatch() Batch
}

 

原文:http://blog.csdn.net/ddffr/article/details/74389051

区块链技术与身份识别(认证)进行结合

在今天的世界,没有身份就无法拥有银行账户,无法获得社会福利,无法形式受教育的权利,更不谈参与政治生活。同样,一个区块链上如果用户只有拥有匿名的地址而无法证明自己的真实身份,那么其应用场景必然变得狭窄。

ShoCard是一个将实体身份证件的数据指纹保存在区块链上的服务。用户用手机扫描自己的身份证件,ShoCard应用会把证件信息加密后保存在用户本地,把数据指纹保存到区块链。区块链上的数据指纹受一个私钥控制,只有持有私钥的用户自己才有权修改,ShoCard亦无权修改。同时,为了防范用户盗用他人身份证件扫描上传,ShoCard还允许银行等机构对用户的身份进行背书,确保真实性。

OneName则提供了另一种身份服务。任何比特币的用户都可以把自己的比特币地址和自己的姓名、Twitter、Facebook等账号绑定起来。相当于为每个社交账户提供了一个公开的比特币地址和进行数字签名的能力。

一个叫Bitnation的项目,则更为激进。用户在其官网上通过区块链登记成为bitnation的“公民”,并获得Bitnation“世界公民身份证”。然后凭此身份,获得Bitnation自我认可的各种公民服务。

与此相比,爱沙尼亚政府推出的“电子公民”计划可谓真正的接地气。2014年10月,其宣布向全世界开放“电子公民”身份认证服务。任何人只需要在其政府官网填写简单的信息,并用信用卡缴纳50欧元的申请费即可成为爱沙尼亚的电子公民。电子公民可以(1)线上登记注册并管理一间基于欧盟商业法律体系的欧盟企业;(2)获得爱沙尼亚政府认许的数字签名、认证与加密文件的网络服务;(3)在线开立爱沙尼亚的数位银行帐户;(4)使用全球跨境支付服务。《区块链:从数字货币到信用社会》(中信出版社)

作者:blockchain
链接:https://www.zhihu.com/question/42877886/answer/119517918
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

Solidity编程 一 之智能合约的介绍

写在前面:

最新在学习以太坊相关的东西,Solidity是基础,所以对 http://solidity.readthedocs.io/en/latest/installing-solidity.html 里的文章进行了翻译。争取这篇文档都能完成翻译。由于自己的英语水平有限,如果在翻译的过程中有什么错误的,请留言,非常感谢!

1. 一个智能合约的例子

   我们从一个基础的solidity例子开始。开始的时候,你可能看不懂每一行具体的意思,但是没关系,我们会在后续的讲解中介绍每一个细节

pragma solidity ^0.4.0;
 
contract SimpleStorage {
    uint storedData;
 
    function set(uint x) {
        storedData = x;
    }
 
    function get() constant returns (uint) {
        return storedData;
    }
}

第一行告诉该合约用的是0.4.0版本的solidity编写,并且这些代码具有向上兼容性。保证不会在不同solidity编译版本下编译会出现不同的行为。

  从Solidity角度来看,合约就是存在于以太坊区块链中的一个特定地址中的代码和数据集合。uint storedData 声明了一个类型为 uint(256位的无符号整型)的变量,变量名称为 storedData。你可以把它想象为数据库中的一个字段,该字段是可以被数据库中的方法进行查询,修改。在以太坊中,这个字段是属于一个合约字段。在这个例子中,该变量可以通过提供的get,set方法进行获取或是修改。Solidity中,访问一个变量是不需要通过this来引用的。

  这个合约很简单,只是允许以太坊上的任何人来存储一个数据到某个节点,同时把这个操作发布到以太坊中,当然,以太坊上的其他节点同样可以通过调用set方法来修改你已经存储好的值。虽然有被修改,但是对该值操作的任何历史记录都是保存在以太坊中的。不用担心你的存储记录或是修改记录会丢失。后面我们会将到如何对合约进行限制,只允许你一个人修改这个数据

2. 子货币例子

  下面的例子将实现一个简单的加密货币例子。无中生币不在是梦想,当然只有合约的创建人才有这个特权。此外,任何人只要有一个以太坊密钥对就可以进行货币交易,根本不需要注册用户名和密码。

pragma solidity ^0.4.0;
 
contract Coin {
 
    //public关键字可以让外部访问该变量
    address public minter;
    mapping (address => uint) public balances;
 
    //事件可以让轻客户端快速的响应变化
    event Sent(address from, address to, uint amount);
 
    // 构造方法
    function Coin() {
        minter = msg.sender;
    }
 
    function mint(address receiver, uint amount) {
        if (msg.sender != minter) return;
        balances[receiver] += amount;
    }
 
    function send(address receiver, uint amount) {
        if (balances[msg.sender] < amount) return;
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        Sent(msg.sender, receiver, amount);
    }
}

 

这个合约引入了一些新的概念,让我们一个个都过一遍。

  address public minter; 

   声明了一个public,类型为address的状态变量。Address类型是一个160位的值,不允许任何的算术操作。它适合于存储合约地址或是其他人的密钥对。Public关键字会自动产生用于外部访问该变量值的方法。如果不声明public,其他的合约是无法访问该变量的。自动产生的方法类似于:

   function minter() returns (address) { return minter; }

   当然如果你增加了一个和上面完全一样的方法是没有任何作用的,我们需要变量和产生的方法名完全一致。这块其实编译器会帮助我们完成,不需要我们自己动手编写,我们只要知道这个概念就可以。

  mapping (address => uint) public balances;

   还是创建了一个公有状态变量,这是一个比address更复杂的数据类型,类似java里的Map<address,uint>,它描述了一个地址和一个uinit数据类型的map关系。Mappings的关系可以看成是一个hash表,所有可能的key都对应了一个0的值。当然在map里不存在只有key值或是只有value值的情况。所以我们需要记住添加了一个什么样的map关系或是像这个例子一样,如何使用它。因为这是个public变量,所以系统会自动为它生成一个get方法,类似于:

   function balances(address _account) returns (uint) {

        return balances[_account];

    }

  通过上面的方法我们可以很容易的查询一个账号的余额。

  event Sent(address from, address to, uint amount);

   这一行创建了一个名为event 的事件。该事件会在该示例的最后一行被触发。用户或是server应用可以花很低的代价(后面会讲代价是什么)来监听事件的触发。一旦这个事件被触发了,监听者接收到三个参数:from, to,amount.也是说从哪个账号,到哪个账号,金额是多少。通过这三个参数可以很容易追踪到具体的交易。为了监听这个事件,我们需要使用如下代码:

1
2
3
4
5
6
7
8
9
10
Coin.Sent().watch({}, '', function(error, result) {
    if (!error) {
        console.log("Coin transfer: " + result.args.amount +
            " coins were sent from " + result.args.from +
            " to " + result.args.to + ".");
        console.log("Balances now:\n" +
            "Sender: " + Coin.balances.call(result.args.from) +
            "Receiver: " + Coin.balances.call(result.args.to));
    }
})

注意用户是如何调用系统自动生成的balances方法

   Coin方法是构造方法,是在合约产生的时候系统会调用,而且之后不允许被调用。Msg(以及tx和block)是一个全局变量,保存了可以被区块链访问的一些属性。它持久化了创建合约的节点的地址。 Msg.sender是值该方法调用者的地址。

最后,真正完成合约功能的,并且被其他用户调用的是 mint和send方法。如果mint是被不是创建该合约的账号调用,不会起任何作用。但是,send可以被任何账号(必须有以太币的账号)调用并发送以太币给另外一个账号。注意,如果你用合约发送以太币到另外一个账号,通过区块链浏览器查看是查看不到任何变化的,因为发送以太币的过程和金额的变化都被存储在了特殊的以太币合约里。而不是体现在账号上。通过使用事件,可以很容易的创建一个区块链浏览器,用来查看交易和账号余额。

3. 区块链基础

 

   对于编程者来说,区块链不是一个很难理解的概念。因为最难懂的那部分(包括挖矿,哈希,椭圆加密,p2p网络)都只是提供了一系列的特性和约束。一旦你知道了这些特性和约束,你不必去理解这些特性或是约束背后的实现原理。

  交易

     区块链是全局共享,交易数据库。这就意味着任何人只要参与到这个网络中就可以访问到这个数据库。如果你要修改数据库中的数据,你需要创建一个被其他所有在这个网络里的人所认可的交易。交易说明对数据的修改要么没有任何进行要么就完全完成,不会出现部分完成,部分未完成的情况。而且一旦交易完成,被记录在数据库中,谁也无法修改这个交易。

     举个例子,想象在一个电子货币里,用表列举出所有账号余额。当进行一个账号和另外一个账号进行交易,交易数据库要确保交易金额要从交易发送方减去,并且在交易接收方增加同样的交易金额。如果交易过程中出现了任何原因导致交易失败,交易发送方增加金额的行为失败,那接收方的金额也不应该发生变化。

     而且发送方都会对发起的交易进行签名加密。这直接地保证了数据库只能被指定的修改所修改。在电子货币的例子中,简单的检查能够确保只有持有这个账号的秘钥者才能对金额进行转移。

  区块

     在比特币术语中,一个比较难理解的是 “双花攻击”问题:当网络中的两笔交易想同时清空同一个账号的余额会发生什么?一个冲突?

     理论上,你不需要去关心这种情况。系统会为你选择一个交易,这些交易会绑定在一个叫做 “区块”里,然后这些交易被执行并且分发到所有参与的节点。如果两笔交易相互冲突,后面执行的交易会被拒绝,不会成为区块的一部分。

      每一个区块都会及时的用线性组织起来,这就是区块链的最初来源。每一个区块都在一个固定时间加入到区块链中,对于以太坊来说,间隔为17秒。作为“序列化选择机制”(被称做挖矿)的一部分,可能会发生区块反复回滚情况,但是这种情况只是出现在区块链的末端。越多的区块被加入到末端,回滚操作就会越少。所以你的交易可能被回滚或是从区块链上被删除,但是你只要等的时间越长,这种情况发生的就会越少。

4.  以太坊虚拟机

  概述

     以太坊虚拟机(EVM)是以太网上智能合约的运行环境。这不仅仅是个沙盒,更确实的是一个完全独立的环境,也就是说代码运行在EVM里是没有网络,文件系统或是其他进程的。智能合约甚至被限制访问其他的智能合约

  账号 

     在以太坊中有两种账号共享地址空间:外部账号和合约账号。外部账号是由公钥和私钥控制的(如人),合约账号是由账号存储的代码所控制。

外部账号的地址是由公钥决定的,而合约地址是在智能合约被创建的时候决定的(这个地址由创建者的地址和发送方发送过来的交易数字衍生而来,这个数字通常被叫做“nonce”)

    不管是否账号存有代码(合约账号存储了代码,而外部账号没有),对于EVM来说这两种账号是相等的。

每一个账号都有持久化存储一个key和value长度都为256位字的键值对,被称为“storage”

而且,在以太坊中,每个账号都有一个余额(确切的是用“Wei”来作为基本单位)  ,该余额可以被发送方发送过来带有以太币的交易所更改。

  交易 

   交易是一个账号和另外一个账号之间的信息交换。它包含了二进制数据(消费数据)和以太数据。如果目标账号包含了代码,这个代码一旦被执行,那么它的消费数据就会作为一个输入数据。如果目标账号是一个0账号(地址为0的账号),交易会生成一个新的合约。这个合约的地址不为0,但是是来源于发送方,之后这个账号的交易数据会被发送。这个合约消费会被编译为EVM的二进制代码,并执行。这次的执行会被作为这个合约的代码持久化。这就是说:为了创建一个合约,你不需要发送真正的代码到这个合约上,事实上是代码的返回作为合约代码。

  Gas

      以太坊上的每笔进行一笔交易都会被收取一定数量的Gas.这是为了限制交易的数量,同时对每一笔交易的进行支付额外费用。当EVM执行一个交易,交易发起方就会根据定义的规则消耗对应的Gas。

  交易的创造者定义了的Gas 价格。所以交易发起方每次需要支付 gas_price * gas 。如果有gas在执行后有剩余,会以同样的方法返回给交易发起方。

  如果gas在任何时候消耗完,out-of-gas 异常会被抛出,那当前的这边交易所执行的后的状态全部会被回滚到初始状态。

  存储,主存和栈

       每个账号都有持久化的内存空间叫做存储. 存储是一个key和value长度都为256位的key-value键值对。从一个合约里列举存储是不大可能的。读取存储里的内容是需要一定的代价的,修改storage里的内容代价则会更大。一个合约只能读取或是修改自己的存储内容。

  第二内存区域叫做主存。系统会为每个消息的调用分配一个新的,被清空的主存空间。主存是线性并且以字节粒度寻址。读的粒度为32字节(256位),写可以是1个字节(8位)或是32个字节(256字节)。当访问一个字(256位)内存时,主存会按照字的大小来扩展。主存扩展时候,消耗Gas也必须要支付,主存的开销会随着其增长而增大(指数增长)。

      EVM不是一个基于寄存器,而是基于栈的。所以所有的计算都是在栈中执行。最大的size为1024个元素,每个元素为256位的字。栈的访问限于顶端,按照如下方式:允许拷贝最上面的16个元素中的一个到栈顶或是栈顶和它下面的16个元素中的一个进行交换。所有其他操作会从栈中取出两个(有可能是1个,多个,取决于操作)元素,把操作结果在放回栈中。当然也有可能把栈中元素放入到存储或是主存中,但是不可能在没有移除上层元素的时候,随意访问下层元素。

  指令集

    为了避免错误的实现而导致的一致性问题,EVM的指令集保留最小集合。所有的指令操作都是基于256位的字。包含有常用的算术,位操作,逻辑操作和比较操作。条件跳转或是非条件跳转都是允许的。而且合约可以访问当前区块的相关属性比如编号和时间戳。

  消息调用

        合约可以通过消息调用来实现调用其他合约或是发送以太币到非合约账号。消息调用和交易类似,他们都有一个源,一个目标,数据负载,以太币,gas和返回的数据。事实上,每个交易都包含有一个顶层消息调用,这个顶层消息可以依次创建更多的消息调用。

       一个合约可以定义内部消息调用需要消耗多少gas,多少gas需要被保留。如果在内部消息调用中出现out-of-gas异常,合约会被通知,会在栈里用一个错误值来标记。这种情况只是这次调用的gas被消耗完。在Solidity,这种情况下调用合约会引起一个人为异常,这种异常会抛出栈的信息。

      上面提到,调用合约会被分配到一个新的,并且是清空的主存,并能访问调用的负载。调用负载时被称为calldata的一个独立区域。调用结束后,返回一个存储在调用主存空间里的数据。这个存储空间是被调用者预先分配好的。调用限制的深度为1024.对于更加复杂的操作,我们更倾向于使用循环而不是递归。

  代理调用/ 代码调用和库

    存在一种特殊的消息调用,叫做代理调用。除了目标地址的代码在调用方的上下文中被执行,而且msg.sender和msg.value不会改变他们的值,其他都和消息调用一样。这就意味着合约可以在运行时动态的加载其他地址的代码。存储,当前地址,余额都和调用合约有关系。只有代码是从被调用方中获取。这就使得我们可以在Solidity中使用库。比如为了实现复杂的数据结构,可重用的代码可以应用于合约存储中。

  日志

   我们可以把数据存储在一个特殊索引的数据结构中。这个结构映射到区块层面的各个地方。为了实现这个事件,在Solidity把这个特性称为日志。合约在被创建出来后是不可以访问日志数据的。但是他们可以从区块链外面有效的访问这些数据。因为日志的部分数据是存储在bloom filters上。我们可以用有效并且安全加密的方式来查询这些数据。即使不用下载整个区块链数据(轻客户端)也能找到这些日志

  创建

   合约可以通过特殊的指令来创建其他合约。这些创建调用指令和普通的消息调用唯一区别是:负载数据被执行,结果作为代码被存储,调用者在栈里收到了新合约的地址。

  自毁

    从区块链中移除代码的唯一方法是合约在它的地址上执行了selfdestruct操作。这个账号下剩余的以太币会发送给指定的目标,存储和代码从栈中删除。

作者: shaotine

出处: http://www.cnblogs.com/StephenWu/

区块链学堂(第四课):以太坊Geth基本命令

进入Geth 命令行模式

在上一篇文章中,我们说到,我们可以用下面命令,建立一个新的私有链

geth --datadir "./" --nodiscover console 2>>geth.log

进入命令行模式,其中参数

  • –datadir 代表文件夹地址,
  • –nodiscover 代表该链条不希望被其他节点发现,
  • console >> geth.log 代表将控制台输出到文件geth.log中去

当然从命令行模式退出,也很简单,只要打入exit, 即可退出

Geth命令行中的Eth.accounts

我们在命令行输入 eth.accounts 可以看到当前该区块链中共有几个账号,以及每个账号的公钥地址。

p1

这里就要说到以太坊的账户体系了,

在以太坊系统中,状态是由被称为“账户”(每个账户由一个20字节的地址)的对象和在两个账户之间转移价值和信息的状态转换构成的。以太坊的账户包含四个部分:

  • 随机数,用于确定每笔交易只能被处理一次的计数器
  • 账户目前的以太币余额
  • 账户的合约代码,如果有的话
  • 账户的存储(默认为空)

简单地说,每一个以太坊账户都有一对公钥和私钥组成。

  • 公钥我们可以理解为就是账户地址,任何其他账户都可以访问该地址
  • 私钥可以理解为一段加密过的密码,这一对公钥和私钥共同组成一个唯一标示的以太坊账户。

例如在上节我们建立的第一个以太坊账户 eth.accounts[0] 中,地址 0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f 就是公钥,而对密码加密而成的,就是私钥。

如何新增账户

我们可以输入命令 personal.newAccount("123") 来新建一个账户,(注意123可以修改为任何别的密码)

p2

这个时候我们可以看到除了第一个账户0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f之外,还新增了另一个账户 0xb8b12a801b610176935a15321f77b48dd5c0c448, 此时输入eth.accounts, 就可以很轻松的看到有两个账户的公钥地址。

如何获取账户的以太币余额

在上一章中我们说过,当以太坊的私链在挖矿时候,所挖到的以太币都会存入第一个以太坊账户中,即eth.accounts[0] 中,而eth.accounts[1]默认是不会有以太币的。这个时候我们可以用下面的命令来查看eth.accounts[0] 中的以太币余额。

eth.getBalance("0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f")
eth.getBalance("0xb8b12a801b610176935a15321f77b48dd5c0c448")
  • 其中0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f是第一个账户的地址,
  • 0xb8b12a801b610176935a15321f77b48dd5c0c448 是第二个账户的地址 结果如下: p11

从上我们可以看得很清楚,挖矿得来的以太币都进了第一个账户,同时每个账户的公钥是该账户的核心。通过公钥我么可以对该账户的以太币进行增删改查各种操作

如何在两个账户之间进行以太币转换

前面说过每个账户的公钥(地址)是一切以太坊账户操作的核心,但地址字符串太长,我们用acc0/acc1 分别代表accounts[0]和[1],另外设置要转移0.01个以太币

> acc0 = eth.accounts[0]
"0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f"
> acc1 = eth.accounts[1]
"0xb8b12a801b610176935a15321f77b48dd5c0c448"
> amount = web3.toWei(0.01)
"10000000000000000"

这个时候我们可以使用eth.sendTransaction来将0.01个以太币从acc0转移到acc1中。

> eth.sendTransaction({from: acc0, to: acc1, value: amount})

结果如下:

这个是以太坊的一个保护机制,每隔一段时间账户就会自动锁定,这个时候任何以太币在账户之间的转换都会被拒绝,除非把该账户解锁.

这个时候我们就需要执行 personal.unlockAccount(acc0) 并输入密码来解锁acc0才可。

> personal.unlockAccount(acc0)
Unlock account 0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f
Passphrase: 
true
>

这个时候我们重新执行命令eth.sendTransaction({from: acc0, to: acc1, value: amount}), 结果如下:

> eth.sendTransaction({from: acc0, to: acc1, value: amount})
"0xeea74dd5ff3f1287614d52ebb674edb93e8c5e51e4296835044d3d858d3d9f10"
> eth.getBalance(acc1)
10000000000000000
>

我们可以看到这个时候acc1有了数值10000000000000000, 而不再是之前的0了。但我们明明要给0.01ether币的,为何数值会如此大呢? 其实是对的,我们只要输入命令web3.fromWei(10000000000000000,"ether") 就可以知道了。

> web3.fromWei(10000000000000000,"ether")
"0.01"

为什么呢,这个就涉及到以太坊的基本单位了,我们下章讲解.

———————————————————————————-

Ether币的基本单位

Ether币最小的单位是Wei,也是命令行默认的单位, 然后每1000个进一个单位,依次是

  • kwei (1000 Wei)
  • mwei (1000 KWei)
  • gwei (1000 mwei)
  • szabo (1000 gwei)
  • finney (1000 szabo)
  • ether (1000 finney)

简单地说就是就是1 以太币 = 1000000000000000000 Wei (这就是上一站章中为何我们转移0.01个以太币,结果却显示很长的原因)

如何进行ether 和 Wei之间的转换

Ether–> Wei:web3.toWei

> web3.toWei(1)
"1000000000000000000"
> web3.toWei(1.3423423)
"1342342300000000000"
> web3.toWei(0.00034)
"340000000000000"
>

Wei –> Ether: web3.fromWei

> web3.fromWei(10000000000000000)
"0.01"
> web3.fromWei(1000000000000000000)
"1"
>

一个以太币各单位之间的转换工具

http://ether.fund/tool/converter

使用很简单,输入各种单位,就可以自动得到各种转换结果,例如输入0.01ether 可以得到多少Wei, 多少finney等。

p4

开始挖矿 & 停止挖矿

> miner.start() //开始挖矿
true
> miner.stop() //停止挖矿
true
>

部署合约

注意合约部署的时候,以太坊的私有链必须处在挖矿进行的状态,否则合约部署将不会生效

  • 我们在命令行中,首先unlock(eth.accounts[0]),因为部署合约需要消耗gas,也就是以太币。而之前说过由于保护机制,不解锁账户,是不会允许任何以太币流出的。
> personal.unlockAccount(acc0)
Unlock account 0xbcf5b841303bc08026ce2d3b8f83498ffe42c12f
Passphrase: 
true
>
  • 然后我们复制黏贴下面代码到geth 命令行中。
var a_demotypesContract = web3.eth.contract([{"constant":false,"inputs":[{"name":"a","type":"uint256"}],"name":"f","outputs":[{"name":"b","type":"uint256"}],"payable":false,"type":"function"}]);
var a_demotypes = a_demotypesContract.new(
   {
     from: web3.eth.accounts[0], 
     data: '0x6060604052341561000c57fe5b5b60ab8061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063b3de648b14603a575bfe5b3415604157fe5b60556004808035906020019091905050606b565b6040518082815260200191505060405180910390f35b600060006008830290508091505b509190505600a165627a7a7230582010decdc0b0a43b565814fe904eae2544665457d6353c7d906fc2c43c81c867e40029', 
     gas: '4700000'
   }, function (e, contract){
    console.log(e, contract);
    if (typeof contract.address !== 'undefined') {
         console.log('Contract mined! address: ' + contract.address + ' transactionHash: ' + contract.transactionHash);
    }
 })

结果如下图:

p5

等待片刻,会发现合约被部署到挖矿挖出来的区块中了, 按下回车代表成功

p6

此时输入合约部署的实例a_demotypes, 可以看到a_demotypes的详情。

> a_demotypes
{
  abi: [{
      constant: false,
      inputs: [{...}],
      name: "f",
      outputs: [{...}],
      payable: false,
      type: "function"
  }],
  address: "0x54ed7a5f5a63ddada3bfe83b3e632adabaa5fc2f",
  transactionHash: "0x69cde62bcd6458e14f40497f4840f422911d63f5dea2b3a9833e6810db64a1c9",
  allEvents: function(),
  f: function()
}
>

也可以调用a_demotypes的方法f, 输入任何数字,会返回8*n,如输入100,返回800,输入125,返回1000

> a_demotypes.f.call(100)
800
> a_demotypes.f.call(125)
1000
由此可见该合约在我们的私有链上部署成功!