精华内容
下载资源
问答
  • 以太坊智能合约

    2018-04-09 14:38:26
    以太坊开发第二篇,以太坊智能合约开发。后续发行自己的代币
  • 以太坊智能合约安全检查清单:Knownsec 404团队的以太坊智能合约安全检查清单
  • 以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子以太坊智能合约例子
  • NMR:以太坊以太坊智能合约
  • 该存储库包含Knowledge上使用的所有以太坊智能合约。 松露是我们的开发,测试和部署框架。 OpenZeppelin是我们用于在以太坊上编写安全的智能合约的实体库。 我们遵循和。 知识代币销售 知识令牌销售于2018年1月15...
  • 以太坊智能合约开发第二篇:理解以太坊相关概念 以太坊智能合约开发第二篇:理解以太坊相关概念
  • 本文主要记录了基于以太坊智能合约发行以太坊代币过程。

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



    编写智能合约

    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钱包网页
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述



    转出代币

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

    在这里插入图片描述



    展开全文
  • 文章目录初探以太访智能合约remix小demo以太坊核心概念交易/事务( Transaction )区块参考 初探以太访智能合约 remix小demo https://remix.ethereum.org 目前尝试 Solidity 编程的最好方式是使用 Remixo Remix 是一...

    一、初探以太访智能合约

    1. remix小demo

    https://remix.ethereum.org

    Remix,Remix是以太坊官方开源的Solidity在线集成开发环境,可以使用Solidity语言在网页内完成 以太坊智能合约的在线开发、在线编译、在线测试、在线部署、在线调试与在线交互, 非常适合Solidity智能合约的学习与原型快速开发。

    目前尝试 Solidity 编程的最好方式是使用 Remixo Remix 是一个基于浏览器的 Solidity IDE , 它集成了 Solidity 编译器、运行环境 ,以及调试和发布工具。
    使用浏览器打开网址 https://remix.ethereum.org

    官方demo

    // SPDX-License-Identifier: GPL-3.0
    
    pragma solidity >=0.7.0 <0.8.0;
    
    /**
     * @title Storage
     * @dev Store & retrieve value in a variable
     */
    contract Storage {
    
        uint256 number;
    
        /**
         * @dev Store value in variable
         * @param num value to store
         */
        function store(uint256 num) public {
            number = num;
        }
    
        /**
         * @dev Return value 
         * @return value of 'number'
         */
        function retrieve() public view returns (uint256){
            return number;
        }
    }
    

    合约代码分析

    • pragma
      关键字 pragma 用来告诉编译器如何编译这段代码,〈表示这里需要 Solidity>=0.7.0 <0.8.0 版本)

    • contract Storage
      这行代码定义 了一个合约 , 合约 的名字为 Storage ( 这和在其他语言如 JavaScript 及 Python 中定义一个类很相似,只不过 class 关键字变成了 contract )。
      一个合约通常由一组代码(合约的函数)和数据(合约的状态)组成。一个合
      约被存储在 以太坊 区块链上 , 对应一个特殊地址 。

    • uint256 number;
      **这行代码声 明了 一个变量,在智能合约中称为“状态变量 ”。**这个状态变量名 为 number, 类型为 uint (一个 256 位的无符号整数) ,可以把它理解为数
      据库里面的一个存储单元 。

    • 修改变量 number 的值

          function store(uint256 num) public {
              number = num;
          }
      

      上面的代码定义了 一个函数 store() 。在 Solidity 中通过 function 关键字来定义
      函数,并且函数的可见性修饰符要写在函数名字及参数之后( 这和大部分常见
      语言不一样),这里 store()函数的作用是修改变量 number 的值。

    • 读取变量的值

          function retrieve() public view returns (uint256){
              return number;
          }
      

      上面的代码定义了 一个函数 retrieve(), 用来读取变量 number的值。这个函
      数通过 returns 来指定返回值 。 returns 返回值要放在所有函数修饰符之后 、 函数
      体之前 。

    和大多数语言有点不一样,函数在访问状态变量时,不需要像其他语言那样添加前缀 this 。
    所有的标识符如合约名称 、 函数名称 、 变量名称等都只能使用 ASCII 字符集里的字符,但是在字符串变量中可以存储 UTF-8 编码的数据。

    2. 写智能合约用的编程语言

    用Solidity就好。 要写智能合约有好几种语言可选:有点类似Javascript的Solidity, 文件扩展名是.sol. 和Python接近的Serpent, 文件名以.se结尾。还有类似Lisp的LLL。Serpent曾经流行过一段时间,但现在最流行而且最稳定的要算是Solidity了,因此用Solidity就好。

    当Solidity合约编译好并且发送到网络上之后,你可以使用以太坊的web3.js JavaScript API来调用它,构建能与之交互的web应用。

    二、以太坊核心概念

    1. 交易/事务( Transaction )

    注 : 英文 Transaction,大多数场合翻译为“交易”,当表示数据库特性时翻译为“事务”。

    区块链是全球共享的事务性数据库 。 全球共享意味着参与这个网络的每一个人都可以读取其中的记录 。 如果想修改这个数据库中的内容,就必须创建一个得到其他所有人确认的事务, 事务意味着要做的修改(假如想同时修改两个值)只能被完全应用或者一点都没有应用 。

    举个例子,想象一张表 , 里面列 出 了某个电子货币所有账户的余额。当从一个账户到另 一个账户的转账请求发生时,这个数据库的事务特性确保从一个账户中减掉的金额会被加到另 一个账户上。如果因为某种原因 , 往目标账户上增加金额的操作无法进行,那么原账户中 的金额也不会发生任何变化 。

    2. 区块

    一个区块就是若干交易 的集合,它会被标记上时间戳和前一个区块的 Hash标识 。区块在经过哈希运算后生成一份工作量证明 , 从而验证区块中的交易。有效的区块经过全网络的共识之后会被追加到区块链中。

    这些块按时间形成了 一个线性序列,这正是区块链这个词的来源。区块 以一定的时 间间隔被添加到链上。对于 以太坊,这个间隔大约是 17 秒 。

    作为“顺序选择机制”(也就是挖矿)的 一部分,可能有时会发生区块被回滚的情况,但通常仅在链的“末端”。 在末端增加的块越多,其发生回滚的概率越小 。因此交易被回滚甚至从区块链中抹除也是可能的,但交易发生后等待的时间越长, 这种情况发生的概率就越小 。

    3. 共识协议:工作量证明( PoW)

    在工作量证明系统中,创建区块的过程被称为“挖矿”。 矿工( Miner )是
    网络中挖区块的节点。
    任何人都可以成为网络中的矿工 。 每一个矿工都各自解决数学难题,其中第一个解决难题的矿工是胜利者 , 其得到的回报是 5 个以太 币和该区块中全部交易的交易费 。 如果某个矿工的处理器比网络中的其他节点更强大,则并不意味着这个矿工总会成功,但其成功的概率会比较大 。 实际上 以太坊的网络安全是由网络的全部算力衡量的 。

    4. 权益证明( PoS)

    以太坊最终会切换到使用权益证明,以解决工作量证明过于消耗资源的问
    题 。 权益证明的主要思路是 : 作为验证节点 , 首先必须拥有一定数量的 以太币,
    根据以太币的数量和时间会产生用于下注验证区块的权益。只有拥有权益的节点才能有效验证区块,当所验证的区块被打包进链后,将获得和权益成正比的区块奖励。如果是验证恶意或错误的区块,那么所下注的权益将被扣除。

    5. 以太坊虚拟机( EVM)

    以太坊虚拟机是一个被沙箱封装起来、 完全隔离的运行环境。**运行在 EVM内部的代码不能接触到网络、文件系统或其他进程,**即使是智能合约与其他智能合约也只能进行有限的交互 。

    然而,以太坊虚拟机本身运行在以太坊节点上,当我们把合约部署到以太坊网络上之后,合约就可以在所有以太坊网络节点的以太坊虚拟机上运行了。

    编译合约
    在以太坊虚拟机上运行的是合约的宇节码形式,需要在部署之前先对合约
    进行编译,可以选择使用 Remix 或 so le 编译器 。

    6. 以太坊账户

    参考URL: http://c.biancheng.net/view/1935.html

    以太坊的两种账户:外部账户和合约账户
    以太坊有两种账户,如下图所示:

    • 外部账户(externally owned accounts),由密钥控制。
    • 合约账户(contract accounts),由智能合约的代码控制。

    在这里插入图片描述以太坊的账户包括四个字段:一个随机数、账户的余额、合约代码(如果有的话)、存储(通常为空)。

    与比特币的区块中存储的是交易不同,以太坊的区块中以梅克尔帕特里夏树(Merkle Patricia Tree,MPT)形式存储的是相应的以太坊账户的状态。

    以太坊的交易是所谓的状态转换函数,一个交易触发它的执行,它将相应的账户从一个状态转变成新状态,然后新状态被存储在区块链的数据区块中。

    只有合约账户才有代码,其中存储的是 codeHash(这个账户的以太坊虚拟机代码的哈希值)。这个字段在生成后是不可修改的,这意味着智能合约代码是不可修改的。

    外部账户可以触发交易,而合约账户不能主动发起交易,只能在被触发后按预先编写的智能合约代码执行。不像外部账户,合约账户不可以自己发起一笔交易 。 但合约账户可以在响应交易时触发另 一笔交易 。 因此,在以太坊上任何动作都是由外部账户触发的交易所发起的(即动作的发起者必须是外部账户〉 。

    合约账户可以设置多重签名(multisign),比如一个简单示例是:现有一个合约账户,它要求一个转账由发起转账的人(Alice)和另一个人(Charles)签名均可。因此,当 Alice 通过这个合约向 Bob 转账 20 个 ETH 时,合约会通知 Charles 签名,在他签名后,Bob 才可以收到这 20 个 ETH(见图)。

    在这里插入图片描述

    7. 以太坊钱包

    Geth 是以太坊官方提供的客户端(钱包〉,是开发智能合约常用的工具之一,它基于 Go 语言开发 。

    Geth 提供了 一个交互式命令控制台,在控制台中可以通过接口命令来获取
    节点信息井和智能合约交互 。

    另一类常用的钱包是 MetaMask,它是一个浏览器插件,可以和 Remix 配合使用,用来部署和执行智能合约 。 相比 Geth , MetaMask 不用同步节点数据,使用 非常方便 。

    8. 存储、内存和栈

    每个账户都有一块持久化存储区域,被称为存储( storage ) 。其以 key-value对的形式存储, key 和 value 的长度均为 256 位 。 在合约中不能遍历账户的存储 。

    存储的读写操作开销(消耗 gas 的 量)较大,修改操作开销更大 。一个合约只能对它自己的存储进行读写 。

    第一个存储区被称为内存( memory ) 。 合约在执行每次消息调用时,都有
    一块崭新的 、 被清除过的内存 。 内存是线性的,可以以宇节为粒度寻址。但读取的长度被限制为 32 个字节( 256 位),写的长度可以是 l 个字节或 32 个字节 。

    当访问(无论是读还是写)之前从未访问过的内存字( word )时(无论偏移到该字内的任何位置〉,内存将按字(每个字是 32 个字节〉进行扩展 。 扩容也将消耗一定的 gas 。 随着内存使用 量的增长,其费用也会增高(以平方级别增加) 。

    第二个存储区被称为栈( stack) , EVM 不是基于寄存器,而是基于栈的虚
    拟机,因此所有的计算都在一个被称为栈的区域执行 。 栈最大有 1024 个元素,每个元素 256 位 。 每次只能访问栈顶的元素。限制是通过以下方式进行的 : 允许复制最顶端的 16 个元素中的一个元素到栈顶,或者交换栈顶元素和下面 16个元素中的一个 。 所有其他操作都只能取最顶端的元素( 一个或两个或更多元素 ,取决于具体的操作),运算后把结果压入栈顶。当然也可以把栈上的元素放到存储或内存中 。 但是无法只访问栈上指定深度的那个元素,除非先从栈顶移除其他元素 。

    9. 自毁

    合约代码从区块链上移除的唯一方式是合约在合约地址上的执行自毁操作 selfdestruct ;合约账户上剩余的以太币会发送给指定的目标,然后其存储和代码从状态中被移除

    三、 Solidity 合约内容

    官网参考: https://docs.soliditylang.org/en/latest/

    合约就像一个类(class),其中包含状态变量(state variable)、函数(function)、函数修改器(function modifier)、事件(event)、结构(structure)和枚举(enum)。合约还支持继承,通过在编译时备份代码来实现。最后,合约还支持多态。

    四、 Solidity 数据类型

    强烈推荐官网参考: https://docs.soliditylang.org/en/latest/types.html

    Solidi可 是 一种静态类型语言,常见的静态类型语言有 C 、 C++、 Java 等,静态类型意味着在编译时需要为每个变量(本地或状态变量)都指定类型(或至少可以推导出类型)。

    Solidity 的类型非常在意所占空间的大小 。另外, Solidity 的一些基本类型可以组合成复杂类型 。Solidity 类型分为两类 : 值类型( Value Type )和引用类型( Reference Type )。

    值类型(Value Types)

    官网参考: https://docs.soliditylang.org/en/latest/types.html

    值类型是指当传递这些类型时,传递的是类型的取值。值类型所占空间在 32 个字节以内,值类型变量在赋值或传参时总是进行值拷贝。

    值类型包括 :
    • 布尔类型( Boolean )
    • 整型 Clnteger )
    • 定长浮点型( Fixed Point Number )
    • 定长字节数组( Fixed-size Byte Array)
    • 有理数和整型常量( Rational and Integer Literal )
    • 字符串常量( String Literal )
    • 十六进制常量( Hexadecimal Literal )
    • 枚举 CEnum )
    • 函数类型( Function Type )
    • 地址类型( Addres)
    • 地址常量( Address Literal )

    引用类型 (Reference Types)

    官网参考: https://docs.soliditylang.org/en/latest/types.html#reference-types

    引用类型主要包括 : 数组(Array ) 、 结构体( Struct )和映射( Mapping ) 。

    函数类型( Function Type)

    Solidity 中的函数也可以 是一种类型且属于值类型 。 可以将一个函数赋值给一个函数类型的变量,也可以将一个函数作为参数进行传递,还可以在函数调用中返回 一个函数。下面是一个把函数赋值给变量的例子 。

    函数类型有两类:内 部( internal) 函数和外部( external )函数。

    • 内部函数只能在当前合约内被调用(在当前代码块内,包括内部库函数和继承的函数),它不会创建一个 EVM 消息调用,访问方式是直接使用函数名 页) 。
    • 外部函数通过 EVM 消息调用,它由地址和 函数方法签名两部分组成,访问方式是 this.f() 。 外部函数可作为外部函数调用的参数或返回值 。

    internal 和 external 既表示调用方式也表明了其可见性,很多人在编写传统程序的时候,不是很关注可见性 。 但写智能合约时大家要特别注意,如果应该使用 internal ,却使用了 external ,则很容易引发安全问题,同时也增加了 gas的消耗 。

    selector 成员属性

    公有或外部( public /external )函数类型有一个特殊的成员属性 selector,它对应一个 ABI 函数选择器,这里只要知道它是一个函数签名即可) 。

    如何区分合约地址及外部账号地址

    判断一个地址是否为合约地址或是外部账户地址
    参考URL: https://blog.csdn.net/qq_27500493/article/details/100303722

    判断一个地址是否为合约地址或是外部账户地址

    extcodesize

    获取地址关联代码长度。 合约地址长度大于0, 外部账户地址为0

    //pragma solidity ^0.4.18;
    //extcodesize获取地址关联代码长度 合约地址大于0 外部账户地址为0 
    
    contract IsCadd {
        function isContract(address addr) returns (bool) {
        uint size;
        assembly { size := extcodesize(addr) }
        return size > 0;
      }
    }
    

    五、 Solidity 中的单位

    智能合约语言 Solidity 教程系列7 - 以太单位及时间单位
    参考URL: https://www.cnblogs.com/tinyxiong/p/8407233.html

    Solidity 中有两种单位 : 货币单位和时间单位。

    1. 货币单位(Ether Units)

    一个数字常量(字面量)后面跟随一个后缀wei, finney,szabo或ether,这个后缀就是货币单位。不同的单位可以转换。不含任何后缀的默认单位是wei。
    不同的以太币单位转换关系如下:
    1 ether == 10^3 finney == 1000 finney
    1 ether == 10^6 szabo
    1 ether == 10^18 wei

    以太币单位其实是密码学家的名字,是以太坊创始人为了纪念他们在数字货币的领域的贡献。他们分别是:

    • wei: Wei Dai 戴伟 密码学家 ,发表 B-money
    • finney: Hal Finney 芬尼 密码学家、工作量证明机制(POW)提出
    • szabo: Nick Szabo 尼克萨博 密码学家、智能合约的提出者

    2. 时间单位(Time Units)

    时间单位: seconds, minutes, hours, days, weeks, years均可做为后缀,并进行相互转换,规则如下:

    1 == 1 seconds (默认是seconds为单位)
    1 minutes == 60 seconds
    1 hours == 60 minutes
    1 days == 24 hours
    1 weeks = 7 days
    1 years = 365 days

    使用这些单位进行日期计算需要特别小心,因为不是每年都是365天,且并不是每天都有24小时,因为还有闰秒。由于无法预测闰秒,必须由外部的预言(oracle)来更新从而得到一个精确的日历库。

    六、Solidity 全局变量及函数

    在用 solidity 编写智能合约的时候,有些特殊变量和函数永远存在于全局中,整体来说分为一下几类。

    1. 区块和交易属性
    • block.blockhash(unit blockNumber) returns (bytes32). 给定区块的哈希值,只支持最近的256个区块。
    • block.coinbase(address) 当前区块旷工的地址
    • block.difficulty(unit) 当前的区块的难度值
    • block.gaslimit(unit) 当前区块的 gas 上限
    • block.number(unit) 当前区块的序号(高度)
    • block.timestamp(unit) 当前区块的时间戳
    • msg.data(bytes) 完整的调用数据里存储的函数以及其实参
    • msg.gas(unit) 当前剩余的 gas
    • msg.sender(address) 当前调用发起人的地址
    • msg.sig(bytes4) 调用数据的前4个字节
    • msg.value(unit) 这个消息所附带的货币量,单位为 wei
    • now(unit) 当前区块的时间戳,等同于 block.timestamp
    • tx.gasprice(unit) 交易的gas价格
    • tx.origin(address) 交易的发起人(完整的调用链)
    1. 地址相关
    • .balance(unit256) 地址余额,单位为 wei
    • .send(unit256 amount) returns(bool) 发送指定数量的 wei 到地址,失败时返回 false. __不过这里发送是低级对等的转账。 如果执行失败,当前合约将不会以异常方式停止
    1. 合约相关
    • this: 当前合约,可以显式的转换成地址
    • selfdestruct(address recipient) 销毁当前合约,把其中的资金发送到指定的地址。

    需要掌握如何获取区块和交易 的属性、如何通过 ABI 编码函数获取编码数据 、 如何处理错误函数 ,以及有关数学和加密 的功能、 与地址及合约相关的函数。

    七、Solidity 表达式及控制结构

    略。查看原文或官方文档。

    八、合约

    1. 合约概述

    Solidity 中合约和面向对象语言中的类差不多。合约包含状态变量( 状态变
    量的数据保存在链上的区块中〉及函数 。 调用另一个合约实例的函数时,会执
    行一个 EVM 函数调用 , 这个操作会切换执行时的上下 文 ,这时上一个合约
    的状态变量就无法访 问了 。

    2. 可见性

    WF曲速未来:Solidity安全之默认可见性
    参考URL: https://zhuanlan.zhihu.com/p/41756712

    Solidity 有两种函数调用方式(在第 7 章 函数调用表达式中介绍过〉, 一种是内部调用,不会创建 EVM 调用(也叫作消息调用〉,另 一种是外部调用,会创建 EVM 调用(即会发起消息调用) 。 Solidity 对函数和状态变量提供了四种可见性,分别是 external 、 public 、 internal 、 private 。 其中函数默认的可见性是 public 。状态变量默认的可见性是 internal 。

    函数的可见性默认是 public。因此,不指定任何可见性的函数就可以由用户在外部调用。 当开发人员错误地忽略应该是私有的功能(或只能在合约本身内调用)的可见性说明符时,问题就出现了。

    3. 事件

    Eventeum - 在微服务中监听以太坊合约事件
    参考URL: http://blog.hubwiz.com/2020/02/21/eventeum-tutorial/

    事件是以太坊虚拟机 ( EVM )日志基础设施提供的一个便利接口 。在 DApp 的应用中,如果监听了某个事件, 那么当事件发生时则会进行回调 。

    以太坊智能合约中,有一类特殊的回调函数,没有函数体,以大写字母开头,一般用来记录函数状态,这类回调函数称为事件event。事件event由合约函数调用。

    九、合约编译、部署、交互、调试

    1. 合约编译

    合约的源代码被编译为 EVM 字节码和 ABI 接口说明后, 才能够使用 Web3
    部署。部署合约其实是一个交易。这个交易没有目标地址, 交易的附加数据是
    编译出来的 EVM 宇节码 。当处理该交易时, EVM 会将输入的数据作为代码执行 。这时一个合约就被创建了。

    2. 部署合约

    把 Remix IDE 生产 的代码拷贝到 geth 控制台,按下回车键运行就可以部署合约了。合约成功部署后会有提示,如下所示 。

    这时在 geth 控制台,输入创建的合约实例 simplestorage ,可以看到
    simplestorage 的详细信息,如下所示 。

    调用合约函数
    在部署合约之后,可以直接使用实例 simplestm吨e 去调用函数,如下所示 。

    simplesto 俨age.s et(3)
    simplesto 「ag e . get()

    使用 Remix+ MetaMask

    另外一个方法是使用 Remix + MetaMask 部署,我们来看看这个过程 。

    MetaMask 是一款浏览器插件形式的以太坊轻客户端,我们可以在开发过程中使用 MetaMask 和 DApp 进行交互 。 在官网 https://metamask.io/ 下载安装MetaMask 。安装完成后,浏览器工具条会显示一个小狐狸图标 。

    十、应用程序二遏制接口( ABI)

    在 以太坊( Ethereum )生态系统中,应用程序二进制接口( Application BinaryInterface, ABI )是从区块链外部与合约进行交互,以及合约与合约之间进行交互的一种标准方式 。 简单来说就是以太坊调用合约时的接口说明,即定义操作函数签名、参数编码、返回结果编码等。 当合约被编译后,那么它的 ABI 也就确定了 。

    程序二进制接口 ABI 是从区块链外部与合约进行交互的,是合约与合约之间进行交互的一种标准方式 。

    十一、智能合约最佳实践

    编码规范

    • 合约、库、事件、枚举及结构体命名
      合约、库、事件及结构体命名应该使用单词首字母大写的方式 。 这个方式也称为“帕斯卡命名 法”或“大驼峰式命名法”,比如 : SimpleToken 、SmartBank、CertificateHashRepository 、 Player
    • 函数、参数、变量及修饰器
      函数、参数、变量及修饰器应该使用首字母小写,后面宇母大写的方式 。即小驼峰式命名法。

    代码格式

    • 缩进
      使用 空格( space ) 而不是 Tab, 缩进应该是 4 个空格 。
    • 空行
      合约之间应该有空行

    函数编写规范
    在编写函数的时候,应该让大家容易找到构造函数 、 回退函数 。 官方推荐的函数顺序如下 。

    1. 构造函数 。
    2. 回退函数 。
    3. 外部函数 。
    4. 公有函数 。
    5. 内部函数 。
    6. 私有函数 。

    明确函数的可见性
    所有的函数(包括构造函数)应该在定义的时候明确函数的可见性。

    // 不建议
    event T「 ans fer、(){}
    function t 「 ansfe「(){}
    // 建议
    event L ogT 「 ans 于e「(){}
    于unction t 「ansfe 「() exte 「nal {}
    

    常量
    常量应该使用全大写字母及下画线分割大词 的方式,如 : MAX BLOCKS 、TOKEN NAME 、 CONTRACT VERSION 。

    安全性考虑

    智能合约最佳实践
    https://github.com/ConsenSys/smart-contract-best-practices

    区块链是一把双刃剑,弊端在于它的不可篡改性。 不像我们现有的互联网应用,可以轻松升级,现在的互联网思维要求我们不断试错,快速迭代 。
    在区块链上开发智能合约需要一个全新的思维,因为犯错的代价很大( 比如造成财产的直接损失〉 。 不能轻松升级会给开发带来更大的挑战 。 因此我们需要有新的开发理念。

    以下为 Consensys 总结的几点原则 :
    要对错误有所准备。任何合约都可能存在错误,需要我们在代码中预先处
    理 出现的 bug 和漏洞 。
    在这里插入图片描述在这里插入图片描述

    十二、智能合约最佳实践

    代币

    代币( Token )现在也有人称为“通证”,利用以太坊的智能合约可以轻松编写、发行一个属于自己的代币,代币可以代表任何可以交易的东西,例如:积分 、财产,等等 。 因此不论是出于商业目的,还是兴趣爱好,很多人都想创建一个属于自己的代币 。

    ERC20 Token

    ERC20 是以太坊定义 的一个代币 标准,要求我们在实现代币的 时候必须要遵守的协议,如指定代 币名称、总量、实现代币交易函数等,只有支持了协议才能被以太坊钱包支持。

    众筹( ICO )合约

    区块链技术本来就非常适合解决众筹的信任 问题 。 借助智能合约,可 以实现当募资额完成时, 募资款自动打到指定账户的功能 ; 当募资额未完成时,可退款 。 这个过程不 需要看众筹发起者的人品,不用依靠第三方平台的信用担保 。

    传统的众筹在参与之后通常不容易交易 (参与之后无法转给其他人 ),而通过用代币来参与众筹,则很容易进行交易 。 众筹 的参与人可随时进行买卖 , 待众筹项目实施完成肘,可根据代币持有量进行回馈 。

    举例说明,大家会更容易理解 。 例如有这样一个众筹: A 有技术做一个能监测健康的指环,为此向公众募资 200 万元 。 募资时 100 元对应一个代币 。 约定在指环上市之后,代币的持有人可以用 一个代币来兑换一个指环 。 而指环的研发周期是一年,因此在指环还未上市的一年里,众筹的参与人可以随时交易所持有的代币 。

    十三、去中心化应用开发

    DApp (Decentralized App ,去中心化应用),则是运行在去中心化的网络节点上的,应用端其实和现有互联网应用 一样,不过应用的后端不再是中心化的服务器,而是去中心化的网络中的节点 。这个节点可以是网络中任意的节点,应用端发给节点的请求,节点收到交易请求之后,会把请求广播到整个网络,交易在网络达成共识之后,才算是真正的执行(即处理请求的是整个网络,连接的节点不能独立处理请求)。

    在去中心化应用中,发送给节点的请求通常称为“交易”。交易和普通的请求有很大的不同,即交易的数据经过用户个人签名(因此需要关联钱包)之后发送到节点,另外普通的请求大多数都是同步的(及时拿到结果), 而交易大多数都是异步的(因为网络共识比较耗时〉,还有交易不是使用普通 HTTP JSON请求,而是使用 JSONRPC 请求 。

    如何与以太坊节点进行通信

    以太坊使用 JSON RPC 2 . 0 规范来和节点进行通信。

    首先要求我们在启动节点时,加入geth --rpc选项
    geth 会默认使用 8545 进行监听JSON RPC 请求,如果要更改端口,使用–rpcport<portnumber>向节点发送 JSONRPC 请求。

    Web3.js

    虽然通过使用 JSON RPC 请求虽然可以完成和节点的通信,但是这个请求比较烦琐,因为需要和原始的底层数据交互,参数很多,返回的数据也需要自己解析,比较容易出错 。 Web3.js 是以太坊官方提供的和节点交互的的 JavaScript SDK,可以帮助智能合约开发者使用 HTTP 或者 IPC 与本地的或者远程的以太坊节点进行交互。 当然 Web3扣同样是使用 JSON RPC 和节点进行通信的( Web3是对 JSON RPC 请求的封装),不过 Web3.js 提供了更友好的接口,实际上 Web3.js就是一个库的集合,主要包括下面几个库:

    • web3-eth 用来与以太坊区块链和智能合约交互。
    • web3-shh 用来控制 whisper 协议与 p2p 通信,以及广播。
    • web3-bzz 用来与 swarm 协议交互。
    • web3-utils 包含 了 一些 DApp 开发应用的功能 。

    在 geth 中使用 Web3.js

    geth 启动的时候会自动加载 Web3.js 库,因此可以在geth 交互控制台里直接使用 Web3.js 。

    使用示例 :

    > eth.accounts
    > eth.getBalance (”accountAddr '’)
    

    通常我们在开发的时候,可以在 geth 控制台中进行一些接口的测试及验证 。

    学习总结其他参考资料

    《精通以太坊智能合约开发》书籍
    Solidity合约开发十大常见安全问题
    參考URL: https://blog.csdn.net/shebao3333/article/details/107128878
    WF曲速未来:Solidity安全之默认可见性
    参考URL: https://zhuanlan.zhihu.com/p/41756712
    Eventeum - 在微服务中监听以太坊合约事件
    参考URL: http://blog.hubwiz.com/2020/02/21/eventeum-tutorial/
    投稿
    半小时掌握新版Remix-以太坊Ethereum智能合约Solidity编程
    https://www.bilibili.com/video/BV17A411q7p4
    [推荐]智能合约开发课02,以太坊开发知识图谱
    参考URL: https://www.bilibili.com/video/BV1LJ411U7Tw

    展开全文
  • 开发 DApp 时要调用在区块链上的以太坊智能合约,就需要智能合约的 ABI。本文希望更多了解 ABI,如为什么需要 ABI?如何解读 Ethereum 的智能合约 ABI?以及如何取得合约的 ABI? 数字猫合约 ABI ABI(Application ...
  • 以太坊智能合约开发项目实战-投票系统。大神在课程中手把手地教大家如何构建一个基于以太坊的完整去中心化应用 —— 区块链投票系统。使用remix进行合约的开发与测试。迅速掌握智能合约的编写与运用。
  • 该文档是使用以太坊智能合约实现的投票系统,内含零知识证明协议。
  • echidna:以太坊智能合约模糊器
  • 以太坊 智能合约Ethereum is a decentralized computing platform. It generates a crytocurrency token known as Ether. Programmers can write “smart contracts” on the Ethereum blockchain, and these ...
    以太坊 智能合约

    以太坊 智能合约

    Ethereum is a decentralized computing platform. It generates a crytocurrency token known as Ether. Programmers can write “smart contracts” on the Ethereum blockchain, and these contracts are automatically executed according to their code.

    以太坊是一个去中心化的计算平台。 它生成一个称为Ether的低温货币令牌。 程序员可以在以太坊区块链上写“智能合约”,这些合约会根据他们的代码自动执行。

    什么是以太坊? (What is Ethereum?)

    Ethereum is often mentioned in the same breath as Bitcoin, but it’s rather different. Bitcoin is a cryptocurrency and decentralized payment network that allows Bitcoin tokens to be transferred between users.

    以太坊与比特币经常被同时提及,但是却大不相同。 比特币是一种加密货币和去中心化的支付网络,它允许在用户之间转移比特币令牌。

    The Ethereum project has larger goals. As the Ethereum website puts it, “Ethereum is a decentralized platform that runs smart contracts.” These contracts run on the “Ethereum Virtual Machine,” a distributed computing network made up of all the devices running Ethereum nodes.

    以太坊项目有更大的目标。 正如以太坊网站所说,“以太坊是一个运行智能合约的去中心化平台。” 这些合同在“以太坊虚拟机”上运行,这是一个由运行以太坊节点的所有设备组成的分布式计算网络。

    The “decentralized platform” part means that anyone can set up and run an Ethereum node, the same way anyone can run a Bitcoin node. Anyone who wants to run a “smart contract” on the nodes has to pay the operators of those nodes in Ether, which is a cryptocurrency token tied to Ethereum. Thus, people who run Ether nodes provide computing power and are paid in Ether, in a similar way to how people who run Bitcoin nodes provide hashing power and are paid in Bitcoin.

    “去中心化平台”部分意味着任何人都可以设置和运行以太坊节点,就像任何人都可以运行比特币节点一样。 任何想要在节点上运行“智能合约”的人都必须向以太坊中那些节点的运营商付款,这是与以太坊相关的加密货币令牌。 因此,运行以太节点的人提供计算能力并在以太币中付款,类似于运行比特币节点的人提供散列能力并以比特币来付款。

    In other words, while Bitcoin is just a blockchain and payment network, Ethereum is a distributed computing network with a blockchain that can be used for many other things. Detailed information is available in the Ethereum white paper.

    换句话说,虽然比特币只是一个区块和支付网络,但以太坊是一个分布式计算网络,具有一个可以用于许多其他事情的区块链。 以太坊白皮书中提供了详细信息。

    什么是醚? (What is Ether?)

    Ether is the digital token (or cryptocurrency) associated with the Ethereum blockchain. In other words, Ether is the coin and Ethereum is the platform. However, people now often use these terms interchangeably. For example, Coinbase allows you to buy Ethereum—by which it means Ether tokens.

    以太是与以太坊区块链关联的数字令牌(或加密货币)。 换句话说,以太币是硬币,以太坊是平台。 但是,人们现在经常可以互换使用这些术语。 例如, Coinbase允许您购买以太坊,即以太币。

    This is technically “altcoin,” which really just means a non-Bitcoin cryptocurrency. Like Bitcoin, Ether is backed by a decentralized blockchain—in this case, the Ethereum blockchain.

    从技术上讲,这是“ altcoin ”,实际上仅表示非比特币加密货币。 像比特币一样,以太币由分散的区块链支持-在这种情况下,以太坊区块链。

    Developers who want to create apps, or “smart contracts,” on the Ethereum blockchain need the Ether token to pay nodes to host it, while users of Ethereum-based apps may need Ether to pay for services in those apps. People could also sell services outside the Ethereum network and accept payment in Ether, or Ether tokens could be sold for cash on an exchange—just like Bitcoin.

    想要在以太坊区块链上创建应用程序或“智能合约”的开发人员需要以太币以支付节点来托管它,而基于以太坊的应用程序的用户可能需要以太币来支付这些应用程序中的服务。 人们还可以在以太坊网络之外出售服务并接受以太币的付款,或者可以在交易所中以现金出售以太币,就像比特币一样。

    为什么分散式应用程序很有趣? (Why Are Decentralized Applications Interesting?)

    The Bitcoin blockchain stores a history of Bitcoin transactions, and that’s it. The Ethereum blockchain stores the Ether tokens in people’s wallets, but it also stores the most recent state of each smart contract as well as each smart contract’s code.

    比特币区块链存储着比特币交易的历史,仅此而已。 以太坊区块链将以太币存储在人们的钱包中,但它还存储了每个智能合约的最新状态以及每个智能合约的代码。

    A blockchain is a distributed ledger stored in multiple locations, so this means that the smart contract data is stored by those Ethereum nodes. If you create a “smart contract”—also known as an application—on the blockchain, it’s stored and run in a decentralized manner.

    区块链是存储在多个位置的分布式账本,因此这意味着智能合约数据由那些以太坊节点存储。 如果您在区块链上创建“智能合约”(也称为应用程序),则它将以分散的方式存储和运行。

    For comparison, think of many of the applications we use today. This includes email apps like Gmail, note-taking apps like Microsoft OneNote, and anything else where you use an app and store your data on a company’s servers. If the company storing your data bans your accounts, shuts down the app, or goes out of business, you’d lose all the data you had in that app unless you had an offline backup copy.

    为了进行比较,请考虑一下我们今天使用的许多应用程序。 这包括电子邮件应用程序(例如Gmail),笔记记录应用程序(例如Microsoft OneNote)以及您使用应用程序并将数据存储在公司服务器上的其他任何应用程序。 如果存储数据的公司禁止您的帐户,关闭该应用程序或倒闭,除非拥有离线备份副本,否则您将丢失该应用程序中拥有的所有数据。

    If you were using an app built on top of Ethereum, both the code that makes up the app (the smart contract code) and personal data (the state of the smart contract) would be stored on the blockchain. Whenever you used an app and changed your data, all the Ethereum nodes would update the state of the smart contract. This means that there’s no central “point of failure” that could take away your access to the data or shut down the app you use. Your data and the app’s code itself would be backed up all over the world, and no one could take all those notes offline. Of course, your data would be encrypted by the blockchain so no one else could read it.

    如果您使用的是构建在以太坊之上的应用程序,那么组成该应用程序的代码(智能合约代码)和个人数据(智能合约的状态)都将存储在区块链上。 每当您使用应用程序并更改数据时,所有以太坊节点都会更新智能合约的状态。 这意味着没有中央“故障点”会夺走您对数据的访问或关闭您使用的应用程序。 您的数据和应用程序代码本身将在世界范围内备份,没有人可以将所有这些注释脱机。 当然,您的数据将由区块链加密,因此没有其他人可以读取它。

    什么是智能合约? (What Are Smart Contracts?)

    Smart contracts are applications that run on the Ethereum Virtual Machine. This is a decentralized “world computer” where the computing power is provided by all those Ethereum nodes. Any nodes providing computing power are paid for that resource in Ether tokens.

    智能合约是在以太坊虚拟机上运行的应用程序。 这是一个分散的“世界计算机”,其中所有这些以太坊节点都提供了计算能力。 任何提供计算能力的节点都将以以太网令牌为该资源付费。

    They’re named smart contracts because you can write “contracts” that are automatically executed when the requirements are met.

    它们之所以称为智能合约,是因为您可以编写“合约”,这些合约在满足要求时会自动执行。

    For example, imagine building a Kickstarter-like crowdfunding service on top of Ethereum. Someone could set up an Ethereum smart contract that would pool money to be sent to someone else. The smart contract could be written to say that when $100,000 of currency is added to the pool, it will all be sent to the recipient. Or, if the $100,000 threshold hasn’t been met within a month, all the currency will be sent back to the original holders of the currency. Of course, this would use Ether tokens instead of US dollars.

    例如,假设在以太坊之上构建类似于Kickstarter的众筹服务。 有人可以建立一个以太坊智能合约,该合约将汇出的钱汇给其他人。 可以将智能合约写为说,当向池中添加100,000美元的货币时,它将全部发送给接收者。 或者,如果在一个月内未达到100,000美元的门槛,则所有货币都将退还给该货币的原始持有者。 当然,这将使用以太币而不是美元。

    This all would happen according to the smart contract code, which automatically executes the transactions without the need for a trusted third party to hold the money and sign off on the transaction. For example, Kickstarter takes a 5% fee on top of a 3% to 5% payment processing fee, which would mean $8000 to $10000 in fees on a $100,000 crowdfunding project. A smart contract wouldn’t require paying fees to a third-party like Kickstarter.

    所有这一切都将根据智能合约代码发生,该合约代码将自动执行交易,而无需受信任的第三方持有资金并签下交易。 例如,Kickstarter在收取3%至5%的付款处理费的基础上收取5%的费用,这意味着在100,000美元的众筹项目中将收取8000至10000美元的费用。 智能合约不需要向Kickstarter这样的第三方支付费用。

    Smart contracts can be used for many different things. Developers can create smart contracts that provide features to other smart contracts, similar to how software libraries work. Or smart contracts could simply be used as an application to store information on the Ethereum blockchain.

    智能合约可以用于许多不同的事物。 开发人员可以创建智能合约,为其他智能合约提供功能,类似于软件库的工作方式。 或者智能合约可以简单地用作在以太坊区块链上存储信息的应用程序。

    To actually execute smart contract code, someone has to send enough Ether as a transaction fee—how much depends on the computing resources required. This pays the Ethereum nodes for participating and providing their computing power.

    要实际执行智能合约代码,某人必须发送足够的以太币作为交易费用,多少取决于所需的计算资源。 这使以太坊节点参与并提供其计算能力而付费。

    CryptoKitties使用智能合约 (CryptoKitties Use Smart Contracts)

    One of the most well-known applications built using smart contracts on the Ethereum network is CryptoKitties, which bills itself as “one of the worlds’ first games to be built on blockchain technology.”

    使用以太坊网络上的智能合约构建的最著名的应用程序之一是CryptoKitties ,它自称为“世界上第一个基于区块链技术构建的游戏之一”。

    Essentially, CryptoKitties are a form of digital “collectible” stored on the Ethereum blockchain. CryptoKitties provides a good demonstration of the ability to store and exchange digital items on the Ethereum network.

    从本质上讲,CryptoKitties是存储在以太坊区块链上的一种数字“收藏品”。 CryptoKitties很好地展示了在以太坊网络上存储和交换数字商品的能力。

    New CryptoKitties are generated through “breeding.” This involves choosing two base CryptoKitties and spending Ether tokens to run a smart contract. The contracts use the two chosen cats to spawn a new CryptoKitty. These kitties and the details of the breeding process are stored on the Ethereum blockchain’s public ledger.

    新的CryptoKitty是通过“繁殖”产生的。 这涉及选择两个基本的CryptoKitties,并花费以太币令牌来运行智能合约。 合同使用两只选择的猫来生成新的CryptoKitty。 这些小猫和繁殖过程的详细信息存储在以太坊区块链的公共分类账中。

    You can “own” CryptoKitties, which are stored on the Ethereum blockchain ledger. You can sell or trade them to other people, or buy them. This is different from using a smartphone app that allows you to buy, trade, and breed cats. Those will generally be stored on the app’s own servers, and you could lose your precious digital pets if the company shut down the app or banned your account. But, because CryptoKitties are stored on the blockchain, that can’t happen. No one can take your kitties away from you.

    您可以“拥有”存储在以太坊区块链分类账中的CryptoKitties。 您可以将它们出售或交易给其他人,也可以购买。 这与使用允许您购买,交易和繁殖猫的智能手机应用程序不同。 这些通常会存储在应用程序自己的服务器上,如果公司关闭该应用程序或禁止您的帐户,您可能会失去珍贵的数字宠物。 但是,因为CryptoKitties存储在区块链上,所以不会发生这种情况。 没有人可以把你的小猫带走。

    In December 2017—coincidentally, around Bitcoin’s all-time high prices—people had spent the Ether equivalent of more than $12 million on CryptoKitties, and the most expensive CryptoKitty was sold for around $120,000.

    2017年12月,巧合的是,围绕比特币的历史最高价,人们在CryptoKitties上花费了相当于1200万美元的以太币,最昂贵的CryptoKitty售价约为12万美元。

    Like Ether, Bitcoin, and expensive paintings, CryptoKitties are worth whatever people are prepared to pay for them.

    像以太币,比特币和昂贵的画作一样,CryptoKitties值得人们准备为此支付。

    Image Credit: AlekseyIvanov/Shutterstock.com, Ethereum, CryptoKitties.

    图片来源: AlekseyIvanov / Shutterstock.com,以太坊CryptoKitties

    翻译自: https://www.howtogeek.com/350322/what-is-ethereum-and-what-are-smart-contracts/

    以太坊 智能合约

    展开全文
  • 区块链以太坊智能合约视频培训教程,该课程以区块链前沿技术实战+理论讲解,以案例剖析区块链以太防智能合约编程技术。带领学员实操演练,指导学员现场调试,并且提供完整的虚拟机文件,以保证学员下载后可以正常...
  • 网上买的开发以太坊智能合约学习视频,适合小白学习,搁在网盘里没用,删除了又可惜,拿出来分享顺便赚点积分
  • 本文将介绍如何在以太坊智能合约中实现代币的空投。区块链世界中所谓空投(airdrop),就是免费给你的区块链地址(公钥)发送代币。 代币空投的方式层出不穷,有手工打币空投的,也有向代币合约转账进行空投的,还...
  • 坚固性 以太坊智能合约的Solidity Programs
  • ethersapp是一个开放源代码的javascript客户端工具,用于在testnet和mainnet上浏览以太坊智能合约。 合同ABI维护在js / abi.js文件中。 用户可以使用添加/编辑/删除按钮手动添加和删除合同ABI,ABI将存储在用户...
  • 在本文的这个以太坊智能合约教程中,我们将了解如何使用Truffle Ethereum和以太坊专用网络来执行智能合约。 我们将在以太坊智能合约教程中查看以下主题: 使用案例:保险流程中的智能合约 智能合约的好处 安装先决...

    区块链技术在顶级技术中占据主导地位的主要原因在于其去中心化。虽然区块链的主要目的是在没有中心的情况下维护交易记录,但为了实现自动化,智能合约被引入。那么在写完智能合约之后呢?在本文的这个以太坊智能合约教程中,我们将了解如何使用Truffle Ethereum和以太坊专用网络来执行智能合约。

    我们将在以太坊智能合约教程中查看以下主题:

    • 使用案例:保险流程中的智能合约
    • 智能合约的好处
    • 安装先决条件
    • 配置Genesis Block
    • 运行以太坊专用网络
    • 创建以太坊帐户
    • 创建以太坊智能合约
    • 执行以太坊智能合约

    使用案例:保险流程中的智能合约

    区块链遵循的是“没有中央权力机构”,这就是智能合约引入的原因。但你有没有想过如何使用智能合约?那么,在以太坊智能合约的这一部分中,我将解释保险流程中智能合约的使用案例。

    让我们考虑一个航班延误保险的例子。假设你想要从出发地A到目的地C进行飞行,但你没有直接飞行。那么,你决定通过B来转机。现在,你的路线将从A到B,然后从B到C,其中B是机场,你将更改航班。不幸的是,从A到B以及从B到C的航班之间没有太大的时间差距。所以,如果有任何问题,一旦从A到B的航班延误,那么你将错过从B到C的航班。意识到这一点后,为了避免重大损失,你可能需要一个航班延误保险。

    现在,如果你从A到B的航班延误(这将使你错过从B到C的航班),你将获得保险金额。这是正常的情况,如果你的航班延误,你可以申请保险。然后,有人会核实并批准保险,最后,你将获得你的保险金额。但这是一个漫长的过程。

    你如何使用智能合约来改善保险流程?

    谈到金融交易,特别是当你拿钱时,“越快越好”,不是吗?那么,让我们看看智能合约如何加强保险流程。智能合约是数字合约,在满足特定条件时自动执行。如果航班延误,可以编写智能合约以向选择航班延误保险的人支付保险金额。因此,当航班延误并且系统记录此延迟时,保险将立即支付。

    OK!保险金额在几秒钟内支付。这就是智能合约如何简单快速地实现流程。

    智能合约的好处

    你已在上面的示例中看到智能合约如何加强财务流程。除快速交易外,智能合约还有更多好处。在这里,我列出了使用智能合约的其他一些好处:

    • 自动化:智能合约自动执行所有步骤。
    • 没有中介:当你使用智能合约时,你不需要中介来完成工作,因为一切都将由智能合约处理。
    • 成本效益:使用智能合约可以节省银行收取的交易费用和中介(如果有的话)的服务费用。

    现在,我们知道如何使用智能合约来让世界变得更快,让我们亲身体验这个以太坊智能合约教程。

    安装先决条件

    对于以太坊智能合约教程,我们需要5个重要的应用程序:

    • NodeJS
    • NPM
    • Ethereum
    • Truffle
    • Solidity Compiler

    安装NodeJS

    NodeJS是一个用于构建服务器应用程序的JavaScript框架。由于我们使用的是专用网络,因此NodeJS可以轻松构建网络应用程序。

    要安装Nodejs,请在终端中运行以下命令:

    $ sudo apt-get install nodejs
    

    安装NPM

    NPM代表Node Package Manager,用于运行Nodejs应用程序。

    要安装NPM,请在终端中运行以下命令:

    $ sudo apt-get install npm
    

    安装以太坊

    以太坊是一个基于开源和公共区块链的分布式计算平台,用于构建去中心化应用程序。

    要安装以太坊,请在终端中运行以下命令:

    $ sudo apt-get install software-properties-common
    $ sudo add-apt-repository -y ppa:ethereum/ethereum
    $ sudo apt-get update
    $ sudo apt-get install ethereum
    

    安装Truffle

    Truffle是以太坊Blokchains的开发环境,测试框架和资产管道。

    要安装Truffle,请在终端中运行以下命令:

    $ npm install -g truffle
    

    安装Solidity Compiler

    Solidity是一种用于编写智能合约的编程语言。要在我们的系统上运行智能合约,我们必须安装Solidity Compiler。

    要安装Solidity Compiler,请在终端中运行以下命令:

    $ sudo npm install -g solc
    

    配置Genesis Block

    Genesis Block是Blockchain的起点,我们需要一个genesis文件来启动Blockchain。在以太坊智能合约的这一部分中,我们将编写一个Genesis文件并对其进行配置以允许我们运行智能合约。

    让我们首先创建一个新目录,然后在该目录中创建genesis文件:

    $ mkdir ethereum-network
    $ cd ethereum-network
    $ nano genesis.json
    

    现在,在genesis.json文件中输入以下行:

    {
    "config": {
    "chainId": 2019,
    "homesteadBlock": 0,
    "eip155Block": 0,
    "eip158Block": 0
    },
    "alloc": {},
    "difficulty" : "200"
    "gasLimit" : "99999999999999"
    }
    

    保存并退出。

    运行以太坊专用网络

    在此Etheruem智能合约教程中,我们将在专用网络上部署以太坊智能合约。因此,要启动此网络,我们将使用以下命令:

    $ geth --datadir ./dataDir init ./genesis.json
    

    $ geth --port 4321 --networkid 1234 --datadir=./dataDir  --rpc --rpcport 8543 --rpcaddr 127.0.0.1  --rpcapi "eth,net,web3,personal,miner"
    

    在进一步讨论之前,让我解释一下上面命令中使用的一些重要参数:

    • datadir:存储与Blockchain相关的数据的目录。
    • rpc:启用HTTP-RPC服务器。
    • rpcport和rpcaddr分别用于设置网络的端口和地址。
    • rpcapi:允许我们使用不同的API与以太坊网络进行交互。

    将Geth连接到以太坊私有区块链

    Geth控制台是我们可以与以太坊私人区块链互动的控制台。要将Geth连接到以太坊私有区块链,请打开一个新终端并运行以下命令:

    $ geth attach http://127.0.0.1:8543
    

    现在,我们在Geth控制台中,我们可以与区块链进行通信。

    创建以太坊帐户

    要进行任何交易,我们需要一个帐户。在以太坊的智能合约教程的这一部分中,我们将看到如何从Geth控制台创建一个新的以太坊帐户。

    按照目前为止的步骤,我们已经在Geth控制台中。要创建新帐户,请在Geth控制台中运行以下命令:

    > personal.newAccount('seedphrase')
    

    seedphrase替换为你要为此帐户设置的密码。

    我们创建了一个新帐户,但此帐户没有ether。我们需要开始采矿。要开始挖掘,我们需要先解锁帐户。让我们解锁帐户并开始挖掘。

    > personal.unlockAccount(web3.eth.coinbase, "seedphrase")
    > miner.start()
    

    随着采矿不断发生,一些ether将被存入该账户。

    注意:这些ether是虚拟ether,没有实际价值。

    要检查帐户中的ether余额,我们将运行以下命令:

    web3.fromWei(eth.getBalance(eth.coinbase), "ether")
    

    当你定期运行此命令时,你将看到由于采矿而导致ether增加。

    要停止挖掘,请运行以下命令:

    > miner.stop()
    

    创建以太坊智能合约

    创建松露项目

    现在我们已经准备好了我们的私人区块链,我们将看到如何使用Truffle创建以太坊智能合约。在本教程中,我们将创建一个简单的“Hello World”以太坊智能合约。

    首先,让我们首先创建一个新目录来存储Truffle项目。然后在该目录中,我们将创建一个新的Truffle项目。打开一个新终端并运行以下命令:

    $ mkdir truffle
    $ cd truffle
    $ truffle init
    

    truffle init命令将创建Truffle项目所需的所有必要文件。

    现在我们已准备好部署以太坊智能合约的所有内容,让我们编写一个“Hello World”智能合约。

    撰写“Hello World”智能合约

    所有合约都应写在contracts目录中。 我们将切换到此目录并创建名为HelloWorld.sol的合约,并在此文件中添加以下行:

    pragma solidity ^0.4.15;
    contract HelloWorld {
        string public message;
        function Hello() public{
        message = "Hello World!";
        }
    }
    

    就是这个!但是这个智能合约不能单独执行。我们将不得不为它做一些配置。

    配置Truffle迁移

    要迁移我们的智能合约,我们必须在truffle目录的migrations目录中添加一个文件。在这个目录中,我们将添加一个名为2_deploy_contracts.js的文件,其中包含以下内容:

    var HelloWorld = artifacts.require("./HelloWorld.sol");
    module.exports = function(deployer) {
       deployer.deploy(HelloWorld);
    };
    

    保存并退出。

    要在我们的网络上运行Truffle,我们需要编辑truffle目录中的truffle.js文件。打开此文件并进行以下输入:

    module.exports = {
    rpc: {
    host:"localhost",
    port:8543
    },
    networks: {
    development: {
    host: "localhost", 
    port: 8543,
    network_id: "*",
    from: "0xfa2361236b5ac8079cb6cf250e5284922ed9ba9a",
    gas: 20000000
    }
    }
    };
    

    注意:将from地址替换为你在上一步中创建的帐户的地址。

    执行以太坊智能合约

    在以太坊智能合约教程的最后一节中,我们将了解如何在我们的以太坊专用网络上部署我们的Hello World智能合约。

    编译和部署智能合约

    在我们执行智能合约之前,我们必须首先将其编译并部署到我们的以太坊专用网络。我们将使用以下命令执行此操作:

    $ truffle compile
    

    现在,我们必须解锁我们的帐户并开始挖掘。使用Geth控制台返回终端并运行以下命令:

    > personal.unlockAccount(web3.eth.coinbase)
    > miner.start()
    

    然后,返回到具有truffle作为当前工作目录的终端并运行以下命令:

    $ truffle migrate
    

    等待部署完成。

    在私有以太区区块链上执行智能合约

    要执行Hello World智能合约,我们必须进入Truffle控制台。运行以下命令来执行此操作:

    $ truffle console
    

    你现在将在Truffle控制台。要执行智能合约,请运行以下命令:

    > var first_contract
    > HelloWorld.deployed().then(function(instance) { first_contract = instance; })
    > dApp.message.call()
    

    恭喜!你已经创建了第一个以太坊智能合约并执行了它。我希望这篇以太坊智能合约教程能够提供信息,并帮助你了解如何执行以太坊智能合约。现在,继续尝试编写其他智能合约并执行它。

    如果你想学习区块链并在Blockchain Technologies建立职业生涯,那么请查看我们分享的一些以太坊、比特币、EOS、Fabric等区块链相关的交互式在线编程实战教程:

    • java以太坊开发教程,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。
    • python以太坊,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。
    • php以太坊,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。
    • 以太坊入门教程,主要介绍智能合约与dapp应用开发,适合入门。
    • 以太坊开发进阶教程,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。
    • ERC721以太坊通证实战,课程以一个数字艺术品创作与分享DApp的实战开发为主线,深入讲解以太坊非同质化通证的概念、标准与开发方案。内容包含ERC-721标准的自主实现,讲解OpenZeppelin合约代码库二次开发,实战项目采用Truffle,IPFS,实现了通证以及去中心化的通证交易所。
    • C#以太坊,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。
    • java比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。
    • php比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。
    • c#比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在C#代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是C#工程师不可多得的比特币开发学习课程。
    • EOS入门教程,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。
    • 深入浅出玩转EOS钱包开发,本课程以手机EOS钱包的完整开发过程为主线,深入学习EOS区块链应用开发,课程内容即涵盖账户、计算资源、智能合约、动作与交易等EOS区块链的核心概念,同时也讲解如何使用eosjs和eosjs-ecc开发包访问EOS区块链,以及如何在React前端应用中集成对EOS区块链的支持。课程内容深入浅出,非常适合前端工程师深入学习EOS区块链应用开发。
    • Hyperledger Fabric 区块链开发详解,本课程面向初学者,内容即包含Hyperledger Fabric的身份证书与MSP服务、权限策略、信道配置与启动、链码通信接口等核心概念,也包含Fabric网络设计、nodejs链码与应用开发的操作实践,是Nodejs工程师学习Fabric区块链开发的最佳选择。
    • Hyperledger Fabric java 区块链开发详解,课程面向初学者,内容即包含Hyperledger Fabric的身份证书与MSP服务、权限策略、信道配置与启动、链码通信接口等核心概念,也包含Fabric网络设计、java链码与应用开发的操作实践,是java工程师学习Fabric区块链开发的最佳选择。
    • tendermint区块链开发详解,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。

    汇智网原创翻译,转载请标明出处。这里是以太坊智能合约之如何执行智能合约?

    展开全文
  • 通用UI 以太坊智能合约的通用UI。 仍处于早期开发阶段。
  • 以太坊是最早提出做智能合约的平台。由于以太坊区块链被普遍接受,因此多数区块链的智能合约采取与以太坊相似的设计。本文将详细介绍以太坊智能合约:它是什么?它有什么用? 以太坊智能合约是什么 以太坊的...
  • 以太坊智能合约与高级语言 从专业角度来说,什么是智能合约呢?智能合约是以太坊区块链上指定地址的代码和数据集合,智能合约能够直接相互发送消息,同时也能执行图灵完备计算。智能合约是建立在以太坊虚拟机字节码...
  • 程序员可以在以太坊区块链上写下“智能合约”,这些以太坊智能合约会根据代码自动执行。 以太坊是什么? 以太坊经常与比特币相提并论,但情况却有所不同。比特币是一种加密货币和分布式支付网络,允许比特币在用户...
  • 以太坊智能合约项目实战

    万人学习 2019-01-15 13:51:27
    通过这个课程的学习,我们可以了解以太坊发展的轨迹,学会洞察智能合约的漏洞,学会如何发币以及具备一定的智能合约开发技能,让学习者在区块链的大潮中立于不败之地。 本科主要介绍5个智能合约项目,包括1.奖金发放...
  • 面对现实吧。 对于智能合约,实现两个整数的加法不是很“智能”。 在本文中,我将尝试超越以前的琐碎示例,... 从以太坊开始-智能合约 (本文) 从以太坊开始-工业化 例如,让我们考虑公投的商业领域。 全民...
  • 如何利用delegatecall升级以太坊智能合约 以太坊智能合约升级 在以太坊智能合约的开发过程中,对于一些复杂的合约开发,要开发出完美没有bug的智能合约,要求是相当高的。即使编写出来的智能合约能完美没有bug,也很...
  • 以太坊开发 以太坊智能合约和Dapp开发的基础知识

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,250
精华内容 2,900
关键字:

以太坊智能合约