以太坊 订阅
以太坊(英文Ethereum)是一个开源的有智能合约功能的公共区块链平台,通过其专用加密货币以太币(Ether,简称“ETH”)提供去中心化的以太虚拟机(Ethereum Virtual Machine)来处理点对点合约。以太坊的概念首次在2013至2014年间由程序员Vitalik Buterin受比特币启发后提出,大意为“下一代加密货币与去中心化应用平台”,在2014年通过ICO众筹开始得以发展。截至2018年2月,以太币是市值第二高的加密货币,仅次于比特币。 展开全文
以太坊(英文Ethereum)是一个开源的有智能合约功能的公共区块链平台,通过其专用加密货币以太币(Ether,简称“ETH”)提供去中心化的以太虚拟机(Ethereum Virtual Machine)来处理点对点合约。以太坊的概念首次在2013至2014年间由程序员Vitalik Buterin受比特币启发后提出,大意为“下一代加密货币与去中心化应用平台”,在2014年通过ICO众筹开始得以发展。截至2018年2月,以太币是市值第二高的加密货币,仅次于比特币。
信息
创始人
杰弗里•维尔克
外文名
Ethereum
中文名
以太坊
属    性
平台
以太坊产生背景
比特币开创了去中心化密码货币的先河,五年多的时间充分 检验了区块链技术的可行性和安全性。比特币的区块链事实上是一套分布式的数据库,如果再在其中加进一个符号——比特币,并规定一套协议使得这个符号可以在数据库上安全地转移,并且无需信任第三方,这些特征的组合完美地构造了一个货币传输体系——比特币网络。然而比特币并不完美,其中协议的扩展性是一项不足,例如比特币网络里只有一种符号——比特币,用户无法自定义另外的符号,这些符号可以是代表公司的股票,或者是债务凭证等,这就损失了一些功能。另外,比特币协议里使用了一套基于堆栈的脚本语言,这语言虽然具有一定灵活性,使得像多重签名这样的功能得以实现,然而却不足以构建更高级的应用,例如去中心化交易所等。以太坊从设计上就是为了解决比特币扩展性不足的问题。
收起全文
精华内容
参与话题
问答
  • 以太坊:选择以太坊客户端

    万次阅读 2019-05-09 17:09:13
    选择以太坊客户端 There are many Ethereum clients to choose from. We recommend different clients depending on whether you are developing or deploying. When developing Ganache We recommendGanache, a...

    选择以太坊客户端

    There are many Ethereum clients to choose from. We recommend different clients depending on whether you are developing or deploying.

    When developing

    Ganache

    We recommend Ganache, a personal blockchain for Ethereum development that runs on your desktop. Part of the Truffle Suite, Ganache simplifies dapp development by placing your contracts and transactions front and center. Using Ganache you can quickly see how your application affects the blockchain, and introspect details like your accounts, balances, contract creations and gas costs. You can also fine tune Ganache’s advanced mining controls to better suit your needs. Ganache is available for Windows, Mac and Linux, and you can download it here.

    Ganache, when launched, runs on http://127.0.0.1:7545. It will display the first 10 accounts and the mnemonic used to create those accounts. (Read more about account mnemonics.) The mnemonic will persist across restarts of Ganache, though it can be changed to be randomly generated. You can also input your own.

    **Warning**: Do not use this mnemonic on the main Ethereum network (mainnet).

    Truffle Develop

    We also recommend using Truffle Develop, a development blockchain built directly into Truffle. Truffle Develop helps you set up an integrated blockchain environment with a single command, no installation required. Run Truffle Develop by typing the following into a terminal:

    truffle develop
    

    This will run the client on http://127.0.0.1:9545. It will display the first 10 accounts and the mnemonic used to create those accounts. (Read more about account mnemonics.) When you run truffle develop for the first time it will generate a random mnemonic that will persist for you and you alone.

    **Warning**: Do not use this mnemonic on the main Ethereum network (mainnet). If you send ETH to any account generated from this mnemonic, you will lose it all!

    Once launched, Truffle Develop will provide you with a console you can use to run all available Truffle commands. These commands are input by omitting the truffle prefix. So, for example, to compile your smart contracts, instead of typing truffle compile, you need to only type compile.

    To read more about interacting with the console, please see the Using the Console section.

    Ganache CLI

    Ganache also has a command-line interface for those who aren’t working from a graphical environment. Great for automated testing and continuous integration environments, Ganache CLI runs headless and can be configured to serve all your development needs. Ganache CLI processes transactions instantly instead of waiting for the default block time, so you can test that your code works quickly. It also tells you immediately when your smart contracts run into errors, and integrates directly with Truffle to reduce test runtime up to 90% compared to other clients. Learn more about Ganache CLI.

    Deploying to live networks

    There are many official and unofficial Ethereum clients available for you to use. The following is a short list:

    These are full client implementations that include mining, networking, blocks and transaction processing. You should use these clients after you’ve sufficiently tested your dapp with Ganache or Truffle Develop and you’re ready to deploy to your desired Ethereum network.

    Deploying to private networks

    Private networks utilize the same technology as with live networks, but with a different configuration. So you can configure any of the Ethereum clients mentioned above to run a private network, and deploy to it in exactly the same way.

    Next  Previous

    展开全文
  • 课程介绍: 比特币提供了区块链技术应用的原型,但是比特币系统的初衷只是...本套视频我们还会学习如何搭建以太坊私链、如何开发以太坊钱包,如何发行ERC20标准的Token,以及以太坊开发集成环境truffle的用法。
  • 【课程简介】本套以太坊课程,对以太坊基础理论知识和架构做了系统的梳理和深入的阐述,并对solidity和DApp的开发做了系统讲解,另外还对以太坊白皮书、黄皮书做了介绍;为有志于学习区块链技术、了解以太坊底层架构...
  • 本文主要记录了基于以太坊智能合约发行以太坊代币过程。

    基于以太坊智能合约发行以太坊代币



    编写智能合约

    pragma solidity ^0.4.16;
    
    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
    
    contract WPHCoin {
        // Public variables of the token
        string public name;
        string public symbol;
        uint8 public decimals = 18;
        // 18 decimals is the strongly suggested default, avoid changing it
        uint256 public totalSupply;
    
        // This creates an array with all balances
        mapping (address => uint256) public balanceOf;
        mapping (address => mapping (address => uint256)) public allowance;
    
        // This generates a public event on the blockchain that will notify clients
        event Transfer(address indexed from, address indexed to, uint256 value);
        
        // This generates a public event on the blockchain that will notify clients
        event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
        // This notifies clients about the amount burnt
        event Burn(address indexed from, uint256 value);
    
        /**
         * Constructor function
         *
         * Initializes contract with initial supply tokens to the creator of the contract
         */
        function TokenERC20(
            uint256 initialSupply,
            string tokenName,
            string tokenSymbol
        ) public {
            totalSupply = 5000000000000000000000;  
            balanceOf[msg.sender] = totalSupply; 
            name = "WPHCoin";
            symbol = "WPH";
        }
    
        /**
         * Internal transfer, only can be called by this contract
         */
        function _transfer(address _from, address _to, uint _value) internal {
            // Prevent transfer to 0x0 address. Use burn() instead
            require(_to != 0x0);
            // Check if the sender has enough
            require(balanceOf[_from] >= _value);
            // Check for overflows
            require(balanceOf[_to] + _value >= balanceOf[_to]);
            // Save this for an assertion in the future
            uint previousBalances = balanceOf[_from] + balanceOf[_to];
            // Subtract from the sender
            balanceOf[_from] -= _value;
            // Add the same to the recipient
            balanceOf[_to] += _value;
            emit Transfer(_from, _to, _value);
            // Asserts are used to use static analysis to find bugs in your code. They should never fail
            assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
        }
    
        /**
         * Transfer tokens
         *
         * Send `_value` tokens to `_to` from your account
         *
         * @param _to The address of the recipient
         * @param _value the amount to send
         */
        function transfer(address _to, uint256 _value) public returns (bool success) {
            _transfer(msg.sender, _to, _value);
            return true;
        }
    
        /**
         * Transfer tokens from other address
         *
         * Send `_value` tokens to `_to` on behalf of `_from`
         *
         * @param _from The address of the sender
         * @param _to The address of the recipient
         * @param _value the amount to send
         */
        function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
            require(_value <= allowance[_from][msg.sender]);     // Check allowance
            allowance[_from][msg.sender] -= _value;
            _transfer(_from, _to, _value);
            return true;
        }
    
        /**
         * Set allowance for other address
         *
         * Allows `_spender` to spend no more than `_value` tokens on your behalf
         *
         * @param _spender The address authorized to spend
         * @param _value the max amount they can spend
         */
        function approve(address _spender, uint256 _value) public
            returns (bool success) {
            allowance[msg.sender][_spender] = _value;
            emit Approval(msg.sender, _spender, _value);
            return true;
        }
    
        /**
         * Set allowance for other address and notify
         *
         * Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
         *
         * @param _spender The address authorized to spend
         * @param _value the max amount they can spend
         * @param _extraData some extra information to send to the approved contract
         */
        function approveAndCall(address _spender, uint256 _value, bytes _extraData)
            public
            returns (bool success) {
            tokenRecipient spender = tokenRecipient(_spender);
            if (approve(_spender, _value)) {
                spender.receiveApproval(msg.sender, _value, this, _extraData);
                return true;
            }
        }
    
        /**
         * Destroy tokens
         *
         * Remove `_value` tokens from the system irreversibly
         *
         * @param _value the amount of money to burn
         */
        function burn(uint256 _value) public returns (bool success) {
            require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
            balanceOf[msg.sender] -= _value;            // Subtract from the sender
            totalSupply -= _value;                      // Updates totalSupply
            emit Burn(msg.sender, _value);
            return true;
        }
    
        /**
         * Destroy tokens from other account
         *
         * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
         *
         * @param _from the address of the sender
         * @param _value the amount of money to burn
         */
        function burnFrom(address _from, uint256 _value) public returns (bool success) {
            require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
            require(_value <= allowance[_from][msg.sender]);    // Check allowance
            balanceOf[_from] -= _value;                         // Subtract from the targeted balance
            allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
            totalSupply -= _value;                              // Update totalSupply
            emit Burn(_from, _value);
            return true;
        }
    }
    

    在这里插入图片描述
    在这里插入图片描述

    name : 代币名称
    symbol: 代币符号
    decimals: 代币小数点位数,代币的最小单位, 18表示我们可以拥有 .0000000000000000001单位个代币。
    totalSupply: 发行代币总量。



    编译智能合约

    前往 以太坊官方智能合约编码器
    新编码器地址:https://remix.ethereum.org
    旧编码器地址:https://ethereum.github.io/browser-solidity

    新编码器编码方法:

    • 将编写好的智能合约放入sol文件中。

    在这里插入图片描述

    • 按照下图顺序点击编译

    在这里插入图片描述
    其中第二步Compiler的版本选择0.4.25+commit.8f1就不会报错。

    在这里插入图片描述
    老编码器编码方法:

    • 选好版本

    在这里插入图片描述

    • 提交

    在这里插入图片描述

    • 付钱
      在这里插入图片描述
      在这里插入图片描述


    验证智能合约

    以太区块链网站
    在这里插入图片描述

    在这里插入图片描述
    提交信息验证成功后,记录ABI值
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述



    将代币加入钱包

    前往 MyEtherWallet钱包网页
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述



    转出代币

    在这里插入图片描述
    在这里插入图片描述
    右下角
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述



    展开全文
  • 新世界大门 当你打开数字货币新世界大门时,你需要学会一项在这世界生存的技能,如何妥善的备份你的钱包。 ... 这么理所当然的功能,在新世界中,你再也见不着踪影。...这是你看到数字货币诸多不方便的一面,也是它令人...

    新世界大门

    当你打开数字货币新世界大门时,你需要学会一项在这世界生存的技能, 如何妥善的备份你的钱包 。

    在过去的世界中,当你把密码弄丢时,你仅需要向服务商提交忘记密码的申请,稍过一会,你就会收到一封邮件,拿起键盘,输入你的新密码。这过程就像魔法一样,你重新获得账户的支配权。

    这么理所当然的功能,在新世界中,你再也见不着踪影。

    这是你看到数字货币诸多不方便的一面,也是它令人着迷的另一面。因为这是人类历史上,第一次通过技术彻底、纯粹地保障「私有财产神圣不可侵犯」。而这一切,都建立在你如何妥善地保管你的私钥的基础上。

    私钥,即财富。

    钱包生成机制

    在数字货币世界中,你的钱包由私钥,公钥构成。在学会保管钱包前,你需要明白私钥与公钥的生成机制: 非对称加密算法。

    在 1976 年以前,所有的加密方式都是同一种模式:
    1. 甲方选择一种加密规则,对信息进行加密;
    2. 乙方使用同一种规则,对信息进行解谜;

    由于加密与解密皆为同一种规则,被称为「对称加密算法」。此加密算法的最大弱点就是甲乙双方都需要了解解密规则,而保存和传递解密规则的过程存在极高的安全风险。

    直到 1977 年,Ron Rivest、Adi Shamir 和 Leonard Adleman 设计了一种非对称加密算法,此算法以他们三人名字命名,被称为「RSA 算法」。

    以上图为例,解释非对称加密模式的流程:
    1. Bob 与 Alice 通过非对称算法生成各自的私钥和公钥(公钥可以通过私钥推导);
    2. Bob 想给 Alice 发送一份加密信息;
    3. Bob 用 Alice 的公钥对信息进行加密;
    4. 加密的信息仅能通过 Alice 的私钥解密;

    当前数字货币(比特币、以太币等)采用的是「椭圆曲线算法」,椭圆曲线算法同样也是非对称算法,相比起 RSA 算法有更多的优势,比如安全性能高、计算量小、存储空间占用小、带宽要求低等。

    每一个钱包账户包含一份密钥对,即私钥与公钥。私钥(k)是一个数字,通常是随机选出的。有了私钥,我们就可以使用椭圆曲线乘法这个单向加密函数生成一个公钥(K)。有了公钥(K),我们就可以使用一个单向加密哈希函数生成该账户地址(A)。

    当你发生交易时,每笔交易都需要一个有效的签名才会被存储在区块链。只有有效的私钥才能产生有效的数字签名,因此拥有钱包账户的私钥就拥有了该账户的支配权。

    钱包形态

    在了解钱包的生成机制后,我们很快就明白一点,我们备份钱包,就是备份私钥,但因保管方式不同,所表现的形态也不一样。

    目前常见的私钥形态:
    1. Private Key
    2. Keystore && Password
    3. Mnemonic Seed

    Private Key

    Private Key 就是一份随机生成的 256 位二进制数字,你甚至可以用硬币、铅笔和纸来随机生成你的私钥:掷硬币 256 次,用纸和笔记录正反面并转换为 0 和 1,随机得到的 256 位二进制数字可作为私钥。这 256 位二进制数字,就是私钥原始的状态。

    Keystore && Password

    在以太坊官方钱包中,私钥与公钥将会以加密(创建钱包时设置的密码,请务必记住!)的方式保存为一份 JSON 文件,存储在 /Users/yourname/Library/Ethereum/keystore 中。 这份 JSON 文件就是 keystore,所以你需要同时备份 keystore 和对应的 password。

    Mnemonic code

    Mnemonic code 由 BIP 39 提案提出,目的是通过随机生成 12 ~ 24 个容易记住的单词,单词序列通过 PBKDF2 与 HMAC-SHA512 函数创建出随机种子,该种子通过 BIP-0032 提案的方式生成确定性钱包。

    BIP 39 定义助记码创建过程如下:
    1. 创造一个 128 到 256 位的随机顺序(熵)。 
    2. 提出 SHA256 哈希前几位,就可以创造一个随机序列的校验和。 
    3. 把校验和加在随机顺序的后面。 
    4. 把顺序分解成 11 位的不同集合,并用这些集合去和一个预先已经定义的 2048个单词字典做对应。 
    5. 生成一个 12 至 24 个单词的助记码。

    所以当你记住 12 ~ 24 个助记码后,就相当于记住私钥。助记码要比私钥更方便记忆和保管。目前支持助记码的钱包有 imToken 和 jaxx 。

    钱包备份方式

    因为钱包的形态多样(本质一样),所以备份的方式也同样多点,但最终的目的: 防盗,防丢,分散风险 。

    • 防盗:分离备份,假如 keystore 或密码被盗,但对应的密码 和 keystore 依然安全;

    • 防丢:多处备份,降低丢失所有对应的 keystore && password 、助记码、私钥等等风险;

    • 分散风险:将资金适当分散,降低损失程度,同时采取多重签名方式,提取超过限制金额,需要多把私钥授权;

    下面为大家介绍常见的备份方式:
    1. 多处和分离备份 keystore && password
    2. 纸钱包
    3. 脑钱包
    4. 多重签名

    多处和分离备份 keystore && password

    1. 打开以太坊官方钱包,在菜单栏中选择 ACCOUNTS -> BACKUP -> ACCOUNTS,你会看到一个 keystore 文件夹,在里面保存你创建过的钱包账户,以 UTC--2016-08-16....... 格式命名的 JSON 文件,这就是你的 keystore 文件。
    2. 将 keystore 文件放置多处安全的位置,如离线的 USB 以及你信任的云存储服务商。
    3. keystone 对应的 password,你应该采用强密码,同样多处且与 keystore 分离备份。

    纸钱包备份

    纸钱包实质就是将 keystore 或 私钥以纸质化形式保存,一般为二维码形式。

    你可以通过命令行的方式

    cat /Users/yourname/Library/Ethereum/keystore/<key_file> | qrencode -o keystore.png

    也可以到 MyEtherWallet: Open Source JavaScript Client-Side Ether Wallet 离线提交你的 keystore 或 私钥,就可以直接打印对应的二维码纸钱包。

    脑钱包

    我们所说的脑钱包并不是由用户自身输入自定义的词句生成私钥(因为这并不安全),而是通过 BIP 39 提案的方式生成足够随机的,可记忆的助记码。这是一个方案,但不是一个非常好的方案,因为人类的大脑并不总是靠谱。

    多重签名

    多重签名是一个不错的选择,它的优势是当你需要提取超过限制的金额时,需要多把私钥同时授权,同时提升防盗,防丢的安全性。

    在以太坊官方钱包中,你可以在 Wallet Contracts 下方中选择 Add Wallet Contract,前提是你用来创建 Wallet Contract 的 account 有不少于 0.02 ETH,足以支付交易所需的费用。

    当你选择 MULTISIGNATURE WALLET CONTRACT ,将会看到如下提示:

    “This is a joint account controlled by X owners. You can send up to Y ether per day. Any transaction over that daily limit requires the confirmation of Z owners.”

    X 代表此钱包合约由多少账户控制
    Y 代表在单个账户授权情况下,每日可提款的上限
    Z 代表突破提款上限,需要多少账户授权

    默认我们采取 X = 3 ,Z =2 的方式,钱包合约由三个账户管理,需突破取款上限需要两个账户同时授权。

    采取多重签名的机制后,你可以多处且分离的方式保管你的 keystore 和 password,提升防盗,防丢的安全性。

    关于更多多重签名的详情可看官方文档: Account Management — Ethereal Homestead 0.1 documentation

    结语

    不管你用任何方式备份钱包,达到 防盗,防丢,分散风险 的目的即可。

    参考:

    展开全文
  • 编者注:我们翻译和出版与密码学货币的私钥、地址和...2. 公钥和用来接收转账的地址都是由私钥使用单向的数学运算推导出来的,如果不信任现有的工具,你完全可以自己使用这些数学运算来生成地址;同时,公开地址不...

    编者注:我们翻译和出版与密码学货币的私钥、地址和钱包有关的内容,无非希望传达清楚几个要点:1. 密码学货币不同于传统的银行,你有很多工具可以生成一把私钥来持有密码学货币,既不需要向银行申请,也不需要给谁报备,没有任何人能阻止你拥有自己的私钥和钱包;2. 公钥和用来接收转账的地址都是由私钥使用单向的数学运算推导出来的,如果不信任现有的工具,你完全可以自己使用这些数学运算来生成地址;同时,公开地址不会产生安全问题,因为地址无法反推出公钥,也无法反推出私钥;3. 使用第三方提供的服务时,弄清楚服务的性质,不要向任何人暴露自己的私钥,并且定期备份。

    1

    在本系列文章的第一篇中,我们得到了如下的比特币私钥:

    60cf347dbc59d31c1358c8e5cf5e45b822ab85b79cb32a9f3d98184779a9efc2

    编者注:这里没有写出私钥的生成过程。简单来说,私钥就是一串随机的十六进制字符串,为了安全(私钥不暴露、不被他人重现出来),这串随机数的生成环境应尽可能满足随机性、不可预测性、不可重现性。所以,不要自己写一串数字来当私钥,因为你自以为的“随机”往往并不怎么随机,很不安全。(理论上来说你确实可以自己连抛 256 次硬币产生符合长度要求(64 位)的随机数,但还是很不推荐。)

    在本文中,我们会演示使用这个私钥来获得公开地址,以及与该私钥对应的以太坊钱包地址。

    通过私钥来获得比特币钱包地址的具体流程有些复杂,因此我们会描述简化后的版本。我们需要使用一个哈希函数去获得公钥,还需要使用另一个函数去获得地址。

    现在,让我们开始吧。

    公钥

    这部分内容和之前讨论比特币的文章中所说的相同,所以如果你已经读完了,那么就可以跳过(除非你想要复习一下)。

    首先,我们需要在私钥上使用 ECDSA,即椭圆曲线数字签名算法。椭圆曲线是通过 y² = x³ + ax + b 公式得出的,其中 a 和 b 可以自定义。椭圆曲线家族有很多知名并且广泛应用的案例。比特币使用了 secp256k1 曲线,关于椭圆曲线密码学,如果你想了解更多,可以参考此文章

    以太坊使用了同样的椭圆曲线,secp256k1,因此对于比特币和以太坊来说,获得公钥的流程是相同的。

    对私钥作了 ECDSA 运算之后,我们得到了 64 字节的整数,这是由两个 32 字节的整数串联组成,代表了椭圆曲线上某个点的 X 值和 Y 值。

    在 Python 程序中,代码显示如下:

    private_key_bytes = codecs.decode(private_key, ‘hex’)
    # Get ECDSA public key
    key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, ‘hex’)

    注意:从上面的代码可以看出,我使用了 ecdsa 模块并通过编码器解码了私钥。这样写更多是因为 Python 的关系,而与算法本身无关,为免误解,让我来好好解释一下。

    Python 语言中,至少有两种数据类型可以保存私钥和公钥:“str”和“bytes”。前者对应的是 string(字符串),后者则是 byte array(数值)。Python 语言中的密码学运算只能对“bytes”类操作,将 byte 型数据作为输入,并且将输出作为结果。

    但是,这里面有个小问题:作为字符串的“4f3c”和作为 byte array 的 4f3c 是不等同的,string 等于 byte array 和两个元素 O< 的结合。codecs.decode 方法就是将字符串转换为 byte array。本文中使用的密码学操作都要进行这一步骤。

    钱包地址

    一旦获得公钥,我们就可以计算出钱包地址,和比特币不同,以太坊在主网和所有测试网都有相同的地址。当用户发起转账和签名的时候,他们需要选择相应的网络。

    为了通过公钥得出地址,我们需要做的就是在公钥上应用 Keccak-256 加密算法,然后拿出结果的后 20 个字节,这样就可以了。整个过程不需要其他的哈希函数,无需 Base58 编码,也不用其他任何转换,你唯一需要做的事情就是在地址的开头添加“0x”。

    Python代码如下:

    public_key_bytes = codecs.decode(public_key, ‘hex’)
    keccak_hash = keccak.new(digest_bits=256)
    keccak_hash.update(public_key_bytes)
    keccak_digest = keccak_hash.hexdigest()
    # Take the last 20 bytes
    wallet_len = 40
    wallet = ‘0x’ + keccak_digest[-wallet_len:]

    校验和(checksum)

    Now, as you may remember, Bitcoin creates the checksum by hashing the public key and taking the first 4 bytes of the result. This is true for all Bitcoin addresses, so you can’t get the valid address without adding the checksum bytes.

    我们都知道,比特币是对公钥使用哈希算法,然后取结果的前 4 个数字,以此创建校验和。这对于所有比特币地址来说都是适用的,因此在没有添加 checksum 字节之前,用户无法获得有效地址。

    编者注:校验和(checksum)是一种较为简单的验证数据完整性的方法,具体方法有很多种,比如说对一段数据逐次取 4 个比特,把取出的数全部加起来,最后得到一个 4 个比特的值作为校验和。如果两段数据不一样,产生的校验和有极大概率是不一样的。跟哈希函数的原理有相似之处,但够不上密码学哈希函数那样的强度。)

    例:

    MD5(cvsoiu687y0adbfiq7et5tgho0) = a277a316d38c21786eac518b83af898f

    MD5(wysoiu687y0adbfiq7et5tgho0) = becd314fb8d277cfe20aaadc2b52c177

    在以太坊中,产生地址的流程与此并不相同。最初的时候,以太坊中没有校验和这样的机制来验证秘钥的完整性。但是在 2016 年,Vitalik Buterin 引进了 checksum 机制,现在已经被钱包提供商和交易所使用。

    在以太坊钱包地址上添加 checksum 使得我们可以通过大小写来校验地址的有效性。

    首先,你需要获得地址的 Keccak-256 哈希值。注意,将地址放入哈希函数的时候不可以添加 0x 部分。

    其次,你需要迭代初始地址的字符,如果哈希值中的第 i 个字节(byte)大于或者等于 8,那么你要将地址中的第 i 个字符变为大写,否则就还是保持小写。

    最后,你需要把 0x 添加到结果的开头。如果忽略大小写,那么校验和地址与初始地址是相同的。但是,这种使用大写字母的做法让人们可以随时随地检查地址是否有效。你可以通过这个网页找到有效验证 checksum 的算法。

    通过 checksum 验证方法,我们可以得到下面的结论:

    “平均来看每个地址有 15 个校验位,并且随机得出的错误地址能够偶然通过检验的概率为 0.0247%。”

    下面是将 checksum 添加到以太坊地址的代码:

    checksum = ‘0x’
    # Remove ‘0x’ from the address
    address = address[2:]
    address_byte_array = address.encode(‘utf-8’)
    keccak_hash = keccak.new(digest_bits=256)
    keccak_hash.update(address_byte_array)
    keccak_digest = keccak_hash.hexdigest()
    for i in range(len(address)):
        address_char = address[i]
        keccak_char = keccak_digest[i]
        if int(keccak_char, 16) >= 8:
            checksum += address_char.upper()
        else:
            checksum += str(address_char)

    结论

    如文中所述,和比特币相比,创建以太坊地址要容易地多。我们需要做的事情就是用私钥在 ECDSA 上找出公钥,然后使用 Keccak-256 算法,并以最终哈希值的后 20 个字节作为地址。

    2

    如果你想使用这些代码,我已经把它们发布到这个 GitHub repository 上了.

    编者注:如上图所示,以太坊的公钥和地址都由私钥生成,并且其生成所需的数学运算都是完全公开的。


    原文链接: https://medium.freecodecamp.org/how-to-create-an-ethereum-wallet-address-from-a-private-key-ae72b0eee27b
    作者: Timur Badretdinov

    展开全文
  • 3.4 以太坊以太坊架构详解

    千次阅读 2018-11-20 14:11:17
    1.以太坊总体架构  以太坊详细架构  账户设计  外部账户:一般意义上的账户 合约账户:它是一种可编程的账户,合约存在以太坊的区块链上,它是代码和数据的集合。合约受代码控制并由外部所有账户激活 ...
  • 以太坊java版本demo及以太坊白皮书 以太坊java版本demo及以太坊白皮书
  • 使用以太坊可以在多种不同的终端环境中使用,例如你可以在Geth终端(go语言所写)中使用以太坊,也可以在Parity终端(rust所写)、aleth终端(c++写)中使用。本文介绍ubuntu下的Geth终端环境的搭建,Geth终端环境的...
  • 什么是以太坊API?区块链开发人员在开发以太坊应用时,除了使用自己搭建的节点,也可以利用第三方提供的以太坊api。Tokenview提供的以太坊API获取以太坊区块信息,进行广播交易,查询地址和交易详情。虽然以太坊节点...
  • 以太坊智能合约项目实战

    万人学习 2019-01-15 13:51:27
    通过这个课程的学习,我们可以了解以太坊发展的轨迹,学会洞察智能合约的漏洞,学会如何发币以及具备一定的智能合约开发技能,让学习者在区块链的大潮中立于不败之地。 本科主要介绍5个智能合约项目,包括1.奖金...
  • 以太坊产生的背景  现象:以太坊创始人看到了比特币区块链技术上的缺陷,希望能够让区块链技术可以应用在加密货币之外的领域。 愿景:以太坊希望成为像TCP/IP协议这样的标准,能让以太坊区块链协议内置编程语言...
  • 以太坊简介

    万次阅读 2019-05-18 08:15:08
    以太坊的概念建立区块链和密码学货币之上,不熟悉区块链和比特币的读者可以先去看看《比特币的简介》和《区块链技术的简介》。本文假定读者对比特币的运行已有一定了解。 以太坊是什么哟? 以太坊是运行在计算机...

空空如也

1 2 3 4 5 ... 20
收藏数 22,925
精华内容 9,170
关键字:

以太坊