标签：整型   区块   walle   对比   维护   效率   delegate   eal   内部函数   

79、solidity

2020年07月21日16:26:53

一、Solidity概述

特点：

1. 比较简单，没有多线程的概念
2. 类似javaScript
3. 不成熟，有一写bug

1. 文档

本文参考文档

官方中文文档

官方英文文档

2. 合约包含的基本元素

//指定编译器版本，版本标识符
pragma solidity ^0.4.17;


//关键字 contract 跟java的class一样  智能合约是Inbox      
contract Inbox{
    //string 是数据类型，message是成员变量，在整个智能合约生命周期都可以访问
    //public 是访问修饰符，是storage类型的变量，成员变量和是全局变量
    string public message

    //函数以function开头，构造函数
    function Inbox (string initMessage) public {
        //本地变量
        var tmp = initMessage;
        message = tmp;
    }

    //view是修饰符，表示该函数仅读取成员变量，不做修改
    function getMessage() public view returns(string) {
        return message;
    }
}

2. 合约的生命周期

//析构函数
function destroy() {
    //销毁当前合约，并把它所有资金发送到给定的地址
    selfdestruct(msg.sender);
}

调用之后，合约仍然存在于区块链之上，但是函数无法被调用，调用会抛出异常。//TODO

二、数据类型分类

1. 值类型（值传递）
2. 引用类型（指针传递）， 没有*号操作符，而是使用两个关键字来表示
   1. memory(值类型)
   2. storage（引用类型）

1. 值类型

值类型是指变量在传递过程中是将数值完整的拷贝一份，再赋值给新的变量，这种方式需要开辟新的内存空间，效率较低，两个变量完全独立，修改一个不会影响另外一个。

值类型包含

• 布尔(Booleans)
• 整型(Integer)
• 地址(Address) 《- - 没见过 0xd5957914c31E1d785cCC58237d065Dd25C61c4D0
• 定长字节数组(fixed byte arrays) // var b1 [10]byte , bytes10
• 有理数和整型(Rational and Integer Literals，String literals)
• 枚举类型(Enums)
• 函数(Function Types)

2. 引用类型

举例： string storage str1

solidity没有指针，对于复杂的结构进行高效传递方式（相当于指针）是使用关键字storage进行修饰。

复杂类型，占用空间较大的。在拷贝时占用空间较大。所以考虑通过引用传递。常见的引用类型有：

• 字符串（string）
• 不定长字节数组（bytes）
• 数组（Array）
• 结构体（Structs）

三、值类型介绍

0. 状态变量vs局部变量

定义在合约之内，但是在函数之外的变量，我们叫做状态变量，这些变量是会上传到区块链上保存的。

下面这个合约中的message就是状态变量。

solidity语言没有main函数，只要合约部署到区块链上，就会永不停歇的执行。

pragma solidity ^0.4.24;

contract Inbox{
    //状态变量
    string public message; 

    function Inbox()payable {

    }

    function setMessage(string newMessage) public{
        //局部变量
        string memory tmp= "hello";
        message = newMessage;
    }

    function getMessage() public constant returns(string){
        return message;
    }
}

1. 布尔

go语言： var flag bool , flag := true

bool flag1 ;
bool flag2 = false;

2. 整型

• int（有符号整型，有正有负）
• uint（无符号整型，无负数）
• 以8位为区间，支持int8，int16，int24 至 int256，uint同理。 int默认为int256，uint默认为uint256

创建：01.integer.sol

如果是int和uint进行相加如何处理？

pragma solidity ^0.4.24;

contract test1 {

    int8 public i8 = 333; //成员变量就是状态变量
    int i256 = 256;

    function add() constant returns(int) {
        return i8 + i256;
    }

   function isEqual(int a, int b) public pure returns(bool) {
       return a == b;
   }
}

3. 函数类型

函数类型也就是我们所说的函数，本身也是一个特殊的变量，它可以当做变量赋值，当做函数参数传递，当做返回值。

- 函数声明

函数名，函数签名(返回值，参数类型，修饰符)

!- 几个非常非常非常重要的关键字

- 访问可见性

- public、private

修饰为public的状态变量会默认生成一个同名的public函数

状态变量默认是internal的（先理解为private即可）

创建：02.publiPrivate可见性.sol

pragma solidity ^0.4.24;


contract  Test {
    //状态变量
    //类型不匹配时需要显示转换类型
    //返回值需要使用returns描述


    //public/private 可以修饰状态变量
    //状态变量默认是私有的
    uint256 public ui256 = 100;

    int8 private i10 = -10;


    //private 修饰的函数为私有的，只有合约内部可以调用
    function add() private view returns(uint256) {
        return ui256 + uint256(i10);
    }


    function isEqueal() public view returns(bool) {
        return ui256 == uint256(i10);
    }

    //Public修饰的函数为共有的，合约内外都可以调用
    function Add() public view returns(uint256){
        return add();
    }
}

- 学员问题

1. contract 误写为 constant

2. 忘记添加分号

3. 修改代码后要重新create（重新部署合约）,新版本（deploy）

4. compile一直是红色的，提示：Compiler not found

   

- view，constant，pure讲解

1. 如果一个函数里面，访问了状态变量，但是没有修改，我们使用view或者constant修饰。
2. 如果访问了状态变量，而且修改了，那么就不能constant和view，否则会报错，不修饰即可。
3. 如果没有使用过状态变量，我们要修饰为pure。
4. 如果你修饰为constant，但是你在函数中修改了，效果是：不会报错，正常执行，但是值不会改变。

创建：03.constantViewPure.sol

pragma solidity ^0.4.24;


contract test1 {

    int8 public i8 = 100; //成员变量就是状态变量
    int i256 = 256;

    //表示不会修改函数内的状态变量
    //为了明确语义，一般要加上constant（view两者完全相同）
    function add() private constant returns(int) {
        return i8 + i256;
    }

    //public 表示所有的人都可以看到的，而且可以调用
    //private表示所有人都可以看到，但是无法调用
    function mins() constant returns(uint256) {
        return  uint256(i256 - i8);
    }

   function isEqual(int a, int b) public pure returns(bool) {
       return a == b;
   }

    function setValue(int8 num) {
        i8 = num;
    }

    function setValue1(int8 num) constant {
        i8 = num;
    }
}

- payable

1. 任何函数，只要修饰为payable，那么就可以在调用这个方法的时候，对value字段赋值，然后将价值value的钱转给合约。
2. 若这个函数没有指定payable，但是对value赋值了，那么本次调用会报错。

创建：04.payable向合约转账.sol

pragma solidity ^0.4.24;


contract test1 {
    uint128 public num;

    //如果构造函数中未指定payable关键字，那么创建合约时不允许转账
    //如果指定了payable，则可以转账
    constructor() public  {

    }

    //任何函数，只要指定了payable关键字，这个合约就可以接受转账,调用时，也可以转0
    function giveMoney() public payable {

    }
}

- 构造函数

仅在部署合约时调用一次，完成对合约的初始化。可以在创建合约时转钱到合约

相当于go里面的init函数

1. 合约同名函数（已废弃）
2. constructor关键字修饰（推荐）

学员问题：

注意，所有在合约内的东西对外部的观察者来说都是可见，将某些东西标记为private仅仅阻止了其它合约来进行访问和修改，但并不能阻止其它人看到相关的信息。

- 匿名函数

• 用于转账

一个合约可以有且只有一个匿名函数，此函数不能有参数，也不能有任何返回值，当我们企图去执行一个合约上没有的函数时，那么合约就会执行这个匿名函数。

当合约在只收到以太币的时候，也会调用这个匿名函数，而且一般情况下会消耗很少的gas,所以当你接收到以太币后，想要执行一些操作的话，你尽可以把你想要的操作写到这个匿名函数里，因为这样做成本非常便宜。

//如果想向合约转账，在合约中添加如下函数即可
function() payable {
    //函数体什么都不填
}

• 用于处理不存在的函数
• 合约之间调用，非js调用

contract Test {
  function() { x = 1; }
  uint x;
}

contract Caller {
  function callTest(address testAddress) {
    Test(testAddress).call(‘0xabcdefgh‘); // hash does not exist
    // results in Test(testAddress).x becoming == 1.
  }
}

4. 地址(Address)

- 概述

以太坊地址的长度，大小20个字节，20 * 8 = 160位，所以可以用一个uint160编码。地址是所有合约的基础，所有的合约都会继承地址对象，通过合约的地址串，调用合约内的函数。

- 运算符

- 操作

- 余额（balance）

返回指定地址的余额

创建：05.address地址.sol

pragma solidity ^0.4.24;


contract  Test {


    address public addr1 = 0x0014723a09acff6d2a60dcdf7aa4aff308fddc160c;

    //地址address类型本质上是一个160位的数字

    //可以进行加减，需要强制转换
    function add() public view returns(uint160) {
        return uint160(addr1) + 10;
    }


    //1. 匿名函数：没有函数名，没有参数，没有返回值的函数，就是匿名函数
    //2. 当调用一个不存在的方法时，合约会默认的去调用匿名函数
    //3. 匿名函数一般用来给合约转账，因为费用低
    function () public  payable {

    }


    function getBalance() public view returns(uint256) {
        return addr1.balance;
    }


    function getContractBalance() public view returns(uint256) {
        //this代表当前合约本身
        //balance方法，获取当前合约的余额
        return address(this).balance;
    }

}

- 合约地址（this）

如果只是想返回当前合约账户的余额，可以使用this指针，this表示合约自身的地址

pragma solidity ^0.4.0;

contract addressTest{
    function getBalance() constant public returns  (uint){
        //return addr.balance;
        return this.balance; // <<----此处使用this代替
    }
}

- 转账（send，transfer）

send和transfer函数提供了由合约向其他地址转账的功能。

创建：06.transfer和send.sol

pragma solidity ^0.4.24;


contract  Test {


    address public addr0 = 0x00ca35b7d915458ef540ade6068dfe2f44e8fa733c;
    address public addr1 = 0x0014723a09acff6d2a60dcdf7aa4aff308fddc160c;


    //1. 匿名函数：没有函数名，没有参数，没有返回值的函数，就是匿名函数
    //2. 当调用一个不存在的方法时，合约会默认的去调用匿名函数
    //3. 匿名函数一般用来给合约转账，因为费用低
    function () public  payable {

    }

    function getBalance() public view returns(uint256) {
        return addr1.balance;
    }

    function getContractBalance() public view returns(uint256) {
        return address(this).balance;
    }

    //由合约向addr1 转账10以太币
    function transfer() public {
        //1. 转账的时候单位是wei
        //2. 1 ether = 10 ^18 wei （10的18次方）
        //3. 向谁转钱，就用谁调用tranfer函数
        //4. 花费的是合约的钱
        //5. 如果金额不足，transfer函数会抛出异常
        addr1.transfer(10 * 10 **18);
    }

    //send转账与tranfer使用方式一致，但是如果转账金额不足，不会抛出异常，而是会返回false
    function sendTest() public {
        addr1.send(10 * 10 **18);
    }
}

- call方法

略

5. 枚举类型(Enums)

• 枚举类型是在Solidity中的一种用户自定义类型。
• 枚举可以显示的转换与整数进行转换，但不能进行隐式转换。显示的转换会在运行时检查数值范围，如果不匹配，将会引起异常。
• 枚举类型应至少有一名成员，枚举元素默认为uint8，当元素数量足够多时，会自动变为uint16，第一个元素默认为0，使用超出范围的数值时会报错。

创建：07.enum枚举.sol

pragma solidity ^0.4.0;

contract test {

    enum WeekDays {
        Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
    }

    WeekDays currentDay;
    WeekDWys defaultday = WeekDays.Sunday;

    function setDay(WeekDays _day) public {
        currentDay = _day;
    }

    function getDay() public view returns(uint256) {
        return uint256(currentDay);
    }

    function getDefaultDay() public view returns(uint256) {
        return uint256(defaultday);   
    }
}

6. 字节数组

[]byte go -> bytes(后面讲)

- 定长的字节数组

solidity内置了一些数组的数据类型：（和go语言做一下对比， var b8 [8]byte），完全只读

• bytes1， ... ，bytes32，允许值以步长1递增。
• byte默认表示bytes1，byte是类型，bytes是类型，bytes1是内置数组
• bytes1只能存储1个字节，即8位的内容，bytes2最多只能存储2个字节，即16位的内容。以此类推...
• 长度可以读取 length（返回bytes5类型的长度，而不是赋值的长度）
• 长度不可以修改
• 可以通过下标访问
• 内容不可修改

支持运算：

内置成员：length，返回数组长度

存储方式：16进制ascii码

创建：08.内置定长数组byte1.sol

pragma solidity ^0.4.2;

//bytes1
contract fixedArray {

    /*
    1. 长度可以读取 length
    2. 长度不可以修改
    3. 可以通过下标访问
    4. 内容不可修改   
    */
    //bytes1 ... bytes32

    //bytes1 b1 = "xy";
    bytes2 b2 = "xy";

    bytes3 public b3 = "xy";

    uint public len = b3.length;

    //b3.length = 10;

    bytes8 b8 = "12345678";

    //b8_0返回0x31，即十进制的数字1的ascii值（3*16+1=49）
    bytes1 public b8_0 = b8[0];

    //b = "HELLO";ERROR，定义之后不可修改
    //b8[1] = "0";
    //b8= "4567";
}

- 动态大小的字节数组（见后面章节）

bytes： 动态长度的字节数组（非值类型）

string： 动态长度的UTF-8编码的字符类型（非值类型）

一个好的使用原则是: bytes用来存储任意长度的字节数据，string用来存储任意长度的UTF-8编码 的字符串数据。 如果长度可以确定，尽量使用定长的如byte1到byte32中的一个，因为这样更省空间。

四、 引用类型介绍

1. 不定长字节数组（bytes）

bytes -> []byte

• 动态字节数组
• 引用类型(表明可以使用storage来修饰，进行引用传递，指针的效果)
• 支持下标索引
• 支持length、push方法(push会帮助分配空间的)
• 可以修改
• 以十六进制格式赋值: ‘h‘ -> 0x68 -> 104
• 格外注意：对于bytes，如果不使用下标访问，那么可以不用先申请空间， 直接赋值即可，或者直接push

注意的坑：

旧版本的remix可以直接在remix中使用"helloworld"形式给bytes赋值，新版本不允许，必须使用0x格式

例如，如果函数类型为：byte b1, 那么赋值时需要输入的格式为： "h"（旧版本）, 0x68(新版本)

创建：09.动态字节数组.sol

pragma solidity ^0.4.24;


contract  Test {

    bytes public name;


    function getLen() public view returns(uint256) {
        return name.length;
    }

    //1. 可以不分空间，直接进行字符串赋值，会自动分配空间
    function setValue(bytes input) public {
        name = input;
    }

    //2. 如果未分配过空间，使用下标访问会访问越界报错
    function getByIndex(uint256 i) public view returns(byte) {
        return name[i];
    }

    //3. 可以设置长度，自动分配对应空间，并且初始化为0
    function setLen(uint256 len) public {
        name.length = len;
    }


    //4.可以通过下标进行数据修改
    function setValue2(uint256 i) public {
        name[i] = "h";
    } 

    //5. 支持push操作，在bytes最后面追加元素
    function pushData() public {
        name.push("h");
    }

}

2. 字符串（string）

• 动态尺寸的UTF-8编码字符串，是特殊的可变字节数组
• 引用类型
• 不支持下标索引
• 不支持length、push方法
• 可以修改(需通过bytes转换)

创建：10.string字符串.sol

pragma solidity ^0.4.24;


contract  Test {

    string public name = "lily";   


    function setName() public {
        bytes(name)[0] = "L";   
    }

    function getLength() public view returns(uint256) {
        return bytes(name).length;
    }

    function setLength(uint256 i) public {
        bytes(name).length = i;

        bytes(name)[i - 1] = "H";
    } 
}

设置name 长度10，name结果

{ "0": "string: Lily\u0000\u0000\u0000\u0000\u0000\u0000" }

3. 数据位置(Data location)

复杂类型，不同于之前值类型，占的空间更大，超过256字节，因为拷贝它们占用更多的空间，如数组(arrays)和数据结构(struct)，他们在Solidity中有一个额外的属性，即数据的存储位置：memory和storage。

- 内存（memory）

• 数据不是永久存在的，存放在内存中，越过作用域后无法访问，等待被回收。
• 被memory修饰的变量是直接拷贝，即与上述的值类型传递方式相同。

- 存储 （storage）

• 数据永久保存在。
• 被storage修饰的变量是引用传递，相当于只传地址，新旧两个变量指向同一片内存空间，效率较高，两个变量有关联，修改一个，另外一个同样被修改。
• 只有引用类型的变量才可以显示的声明为storage。

- 状态变量

状态变量总是stroage类型的，无法更改

- 局部变量

默认是storage类型（仅限数据结构或数组，string），但是可以声明为memory类型。

创建：11.storageVsMemory.sol

pragma solidity ^0.4.24;


contract  Test {
    string public name = "lily";
    uint256 public num = 10;



    function call1() public {
        setName(name);    
    }


    //对于引用类型数据，作为函数参数时，默认是memory类型（值传递）
    //function setName(string input) private {
    function setName(string memory input) private {
        num = 20;
        bytes(input)[0] = "L";
    }

    function call2() public {
        setName2(name);
    }

    //2. 如果想引用传递，那么需要明确指定为stroage类型
    function setName2(string storage input) private {
        num = 30;
        bytes(input)[0] = "L";
    }

    //如果局部变量是string，数组，结构体类型数据，默认情况下是storage类型
    function localTest() public {
        //string tmp = name;
        string storage tmp = name;
        num = 40;
        bytes(tmp)[0] = "L";
    }

    function localTest1() public {

        //也可以明确设置为memory类型
        string memory tmp = name;
        num = 50;
        bytes(tmp)[0] = "L";
    }
}

4. 转换（bytes1/bytes/string)

综合示例：

创建：12.bytesStringbyte1相互转化.sol

pragma solidity ^0.4.24;


contract  Test {

    bytes10 public b10 = 0x68656c6c6f776f726c64; //helloworld

    bytes public bs10 = new bytes(b10.length);

    //将固定长度数组的值赋值给不定长度数组
    function fixedByteToBytes() public {
        //bs10 = b10;
        for (uint256 i = 0; i < b10.length; i++) {
            bs10[i] = b10[i];
        }
    }


    //将bytes转成string
    string public str1;

    function bytesToString() public {
        fixedByteToBytes();
        str1 = string(bs10);
    }



    //将string转成bytes
    bytes public bs20;

    function stringToBytes() public {
        bytesToString();
        bs20 = bytes(str1);
    }
}

5. 数组

- 内置数组

已介绍

• string(不定长)
• bytes（不定长）
• bytes1...bytes32（定长）

- 自定义数组

定长数组

go numbers [10] uint

• 类型T，长度K的数组定义为T[K]，例如：uint [5] numbers, byte [10] names;
• 内容可变
• 长度不可变，不支持push
• 支持length方法

创建：13.自定义定长数组.sol

pragma solidity ^0.4.24;


contract  Test {

    //Type[Len] name

    uint256[10] public numbers = [1,2,3,4,5,6,7,8,9, 10];

    uint256 public sum;

    // - 类型T，长度K的数组定义为T[K]，例如：uint [5] numbers,  byte [10] names;
    // - 内容可变
    // - 长度不可变，不支持push
    // - 支持length方法

    function total() public returns(uint256) {
        for (uint256 i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }

       return sum; 
    }

    function setLen() public {
        //numbers.length = 10;
    }

    function changeValue(uint256 i , uint256 value) public {
        numbers[i] = value;
    }

    //++++++++++++++++++++++++++++++++++

    bytes10 public helloworldFixed = 0x68656c6c6f776f726c64;

    byte[10] public helloworldDynamic = [byte(0x68), 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64];

    bytes public b10;

    function setToBytes() public  returns (string){
        for (uint256 i=0; i< helloworldDynamic.length; i++) {
            byte b1 = helloworldDynamic[i];
            b10.push(b1);
        }

        return string(b10);
    }
}

不定长数组

• 定义格式为T [ ]，例如：string[ ] names, byte[ ] citys。
• 内容可以修改
• 可以改变长度(仅限storage类型) 支持length、push方法
• memory类型的不定长数组不支持修改长度
• 即使没有手动分配空间，直接改变长度，那么也会自动分配空间

创建：14.自定义不定长数组.sol

pragma solidity ^0.4.24;


contract  Test {

    //第一种创建方式，直接赋值
    uint8[] numbers = [1,2,3,4,5,6,7,8,9,10];

    function pushData(uint8 num) public {
        numbers.push(num);
    }

    function getNumbers() public view returns(uint8[]) {
        return numbers;
    }


    //第二种：使用new关键字进行创建，赋值给storage变量数组
    uint8[] numbers2;

    function setNumbers2() public {
        numbers2 = new uint8[](7);
        numbers2.length = 20;
        numbers2.push(10);
    }

    function getNumbers2() public view returns(uint8[]) {
        return numbers2;
    }

    function setNumbers3() public {
        //使用new创建的memory类型数组，无法改变长度
        uint8[] memory numbers3 = new uint8[](7);
        //uint8[] memory numbers3;

        //numbers3.length = 100; //无法修改
        //numbers3.push(x0);
    }
}

二维数组

//TODO

15.二维数组.sol

6. 结构体

创建：16.struct结构体.sol

pragma solidity ^0.4.5;

contract Test {
    //定义结构之后无分号，与枚举一致
    struct Student {
        string name;
        uint age;
        uint score;
        string sex;
    }

    Student[] public students;


    //两种赋值方式
    Student public stu1 = Student("lily", 18, 90, "girl");
    Student public stu2 = Student({name:"Jim", age:20, score:80, sex:"boy"});

    function assign() public {
        students.push(stu1);
        students.push(stu2);

        stu1.name = "Lily";
    }
}

7. 字典/映射/hash表（mapping）

• 键key的类型允许除映射外的所有类型，如数组，合约，枚举，结构体，值的类型无限制。
• 无法判断一个mapping中是否包含某个key，因为它认为每一个都存在，不存在的返回0或false。
• 映射可以被视作为一个哈希表，在映射表中，不存储键的数据，仅仅存储它的keccak256哈希值，用来查找值时使用。
• 映射类型，仅能用来定义状态变量，或者是在内部函数中作为storage类型的引用。
• 不支持length

创建：17.mapping映射.sol

pragma solidity ^0.4.20;


contract test {
    //id -> name
    mapping(uint => string) id_names;

    constructor()  public{
        id_names[0x01] = "lily";
        id_names[0x02] = "Jim";
        id_names[0x02] = "Lily";
    }

    function getNameById(uint id)  public returns (string){
        //加上storage如何赋值？
        string memory name = id_names[id];
        return name;
    }

    function setNameById(uint id)  public returns (string){
        // mapping(uint => string) memory id_name = id_names;
        // var ids = id_names;
        id_names[id] = "Hello";
    } 


    // function getMapLength() public returns (uint){
    //     return id_names.length;
    // }

}

五、高级语法

1. 自动推导var（忘了她吧）

为了方便，并不总是需要明确指定一个变量的类型，编译器会通过第一个向这个对象赋予的值的类型来进行推断

uint24 x = 0x123;
var y = x;

需要特别注意的是，由于类型推断是根据第一个变量进行的赋值。所以下面的代码将是一个无限循环，因为一个uint8的i的将小于2000。

for (var i = 0; i < 2000; i++)
{
    //uint8 -> 255
    //无限循环
}
pragma solidity ^0.4.24;

contract Test{
    function a() view returns (uint, uint){
        uint count = 0;
        var i = 0;
        for (; i < 257; i++) {
            count++;
            if(count >= 260){
                break;
            }
        }
        return (count, i);
    }
}

结果：

0: uint256: 260
1: uint256: 3

分析：

i, count
255, 256
0, 257
1, 258
2, 259
3, 260


00
01
10

 11111111111111111111111
1000000000000000
1000000000000001

2. 全局函数/变量

- 最重要的两个全局变量

• msg.sender

  每一次和以太坊交互时都会产生一笔交易，这笔交易的执行人就是msg.sender。简而言之：谁调用的，msg.sender就是谁，每笔交易的msg.sender都可以不同。举例：

  1. 部署合约的时候，msg.sender就是部署的账户。
  2. 调用setMessage时，msg.sender就是调用账户。
  3. 调用getMessage时，msg.sender就是调用账户。

demo:

pragma solidity ^0.4.24;


contract  Test {

    address public owner;
    uint256 a;
    address public caller;

    constructor() public {
        //在部署合约的时候，设置一个全局唯一的合约所有者，后面可以使用权限控制
        owner = msg.sender;
    }

    //1. msg.sender是一个可以改变的值，并不一定是合约的创造者
    //2. 任何人调用了合约的方法，那么这笔交易中的from就是当前msg.sender
    function setValue(uint256 input) public {
        a = input;
        caller = msg.sender;
    }
}

• msg.value

  我们在介绍payable关键字的时候说，如果函数修饰为payable，那么这个函数可以接收转账，这笔钱通过remix的value输入框传递进来。

  在转账操作中，这笔钱是通过我们调用一个函数从而产生一笔交易而转入合约的，换句话说，是这笔交易附带了一笔钱。在合约中，每次转入的value是可以通过msg.value来获取到的。注意，

  1. 单位是wei
  2. 有msg.value，就必须有payable关键字

demo:

pragma solidity ^0.4.24;


contract  Test {

    //uint256 public money;

    mapping(address=> uint256) public personToMoney;

    //函数里面使用了msg.value，那么函数要修饰为payable
    function paly() public payable {

        // 如果转账不是100wei，那么参与失败
        // 否则成功，并且添加到维护的mapping中
        if (msg.value != 100) {
            throw;
        }

        personToMoney[msg.sender] = msg.value;

    }

    function getBalance() public view returns(uint256) {
        return address(this).balance;
    }
}

注意，测试时，传入的地址要加上英文双引号！！！

- 区块和交易的属性

示例：(使用图形化ganache测试)

pragma solidity ^0.4.24;


contract Test {

    bytes32 public blockhash1;
    address public coinbase;
    uint public difficulty;
    uint public gaslimit;
    uint public blockNum;
    uint public timestamp;
    bytes public calldata;
    uint public gas;
    address public sender;
    bytes4 public sig;
    uint public msgValue;
    uint public now1;
    uint public gasPrice;
    address public txOrigin;

    function tt () public payable {
        //给定区块号的哈希值，只支持最近256个区块，且不包含当前区块
        blockhash1 = blockhash(block.number - 1);
        coinbase = block.coinbase ;//当前块矿工的地址。
        difficulty = block.difficulty;//当前块的难度。
        gaslimit = block.gaslimit;// (uint)当前块的gaslimit。
        blockNum = block.number;// (uint)当前区块的块号。
        timestamp = block.timestamp;// (uint)当前块的时间戳。
        calldata = msg.data;// (bytes)完整的调用数据（calldata）。
        gas = gasleft();// (uint)当前还剩的gas。
        sender = msg.sender; // (address)当前调用发起人的地址。
        sig = msg.sig;// (bytes4)调用数据的前四个字节（函数标识符）。
        msgValue = msg.value;// (uint)这个消息所附带的货币量，单位为wei。
        now1 = now;// (uint)当前块的时间戳，等同于block.timestamp
        gasPrice = tx.gasprice;// (uint) 交易的gas价格。
        txOrigin = tx.origin;// (address)交易的发送者（完整的调用链）  
    }
}

3. 错误处理

在创建合约时设置owner（合约的所有人）

pragma solidity ^0.4.24;


contract Test {

    address public owner;

    constructor() public {
        owner = msg.sender;
    }
}

传统方法：采用 throw 和 if ... throw 模式(已过时)，例如合约中有一些功能，只能被授权为拥有者的地址才能调用

if(msg.sender != owner) { 
    throw; 
}

等价于如下任意一种形式：

if(msg.sender != owner) { 
    revert(); 
} 

//assert和require是推荐的方式，里面的参数要求值为true，即期望的结果
assert(msg.sender == owner); 
require(msg.sender == owner);

示例：

//描述编译器版本
pragma solidity ^0.4.24;


contract Inbox{ 

    //定义变量：类型 + 变量名
    string public message;   // var name string
    address public manager; //合约的部署者（拥有者）
    address public caller;  //合约函数的调用者


    function Inbox() payable {
        manager = msg.sender;
    }

    function setMessage(string newMessage) public {
        caller = msg.sender;

        // if (manager != msg.sender) {
        //     throw; //如果函数调用者不是管理员，直接抛异常
        // }


        // 断言：
        // 1. 一条语句，既包含了条件，又可以抛异常（推荐）
        // 2. 条件是期望的结果，与普通的条件判断相反
        //   （条件为true，继续执行，条件为false，抛出异常）

        // require(manager == msg.sender);
        assert(manager == msg.sender);

        message = newMessage;

    }


    //如果有返回值，一定要加上returns关键字，使用()包裹起来    
    function getMessage() public constant returns(string){
        return message;
    }
}

4. 修饰器（modifier）

修改器(Modifiers)可以用来轻易的改变一个函数的行为。比如用于在函数执行前检查某种前置条件。修改器是一种合约属性，可被继承，同时还可被派生的合约重写(override)。下面我们来看一段示例代码：

//描述编译器版本
pragma solidity ^0.4.24;


contract Inbox{ 

    //定义变量：类型 + 变量名
    string public message;   // var name string
    address public manager; //合约的部署者（拥有者）
    address public caller;  //合约函数的调用者


    function Inbox() payable {
        manager = msg.sender;
    }

    //一个函数可以使用多个修饰器
    function setMessage(string newMessage) public onlyManager onlyManager2(msg.sender){
        caller = msg.sender;
        message = newMessage;

    }

    //如果有返回值，一定要加上returns关键字，使用()包裹起来    
    function getMessage() public constant returns(string){
        return message;
    }

    modifier onlyManager {
        require(manager == msg.sender);
        _; //下划线代表修饰器所修饰的代码
    }

    //修饰器可以带有参数
    modifier onlyManager2(address _caller) {
        require(manager == _caller);
        _; //下划线代表修饰器所修饰的代码
    }
}

5. 两个常用单位

- 货币单位

• 一个字面量的数字，可以使用后缀wei，finney，szabo或ether来在不同面额中转换。
• 不含任何后缀的默认单位是wei。如1 ether == 1000 finney的结果是true。

pragma solidity ^0.4.24;

contract EthUnit{
    uint  a = 1 ether;
    uint  b = 10 ** 18 wei;
    uint  c = 1000 finney;
    uint  d = 1000000 szabo;

    function f1() constant public returns (bool){
        return a == b;
    }

    function f2() constant public returns (bool){
        return a == c;
    }

    function f3() constant public returns (bool){
        return a == d;
    }

    function f4() constant public returns (bool){
        return 1 ether == 100 wei;
    }
}

- 时间单位

• seconds，minutes，hours，days，weeks，years均可做为后缀，默认是seconds为单位。
• 1 = 1 seconds
• 1 minutes = 60 seconds
• 1 hours = 60 minutes
• 1 days = 24 hours
• 1 weeks = 7 days
• 1 years = 365 days

pragma solidity ^0.4.0;

contract TimeUnit{

    function f1() pure public returns (bool) {
        return 1 == 1 seconds;
    }

    function f2() pure public returns (bool) {
        return 1 minutes == 60 seconds;
    }

    function f3() pure public returns (bool) {
        return 1 hours == 60 minutes;
    }

    function f4() pure public returns (bool) {
        return 1 days == 24 hours;
    }

    function f5() pure public returns (bool) {
        return 1 weeks == 7 days;
    }

    function f6() pure public returns (bool) {
        return 1 years == 365 days;
    }
}

6. 事件（Event）

相当于打印log，但是需要在调用端才能看到，web3调用时演示

pragma solidity ^0.4.0;

contract ClientReceipt {
    //定义，注意，需要加分号，相当于一句语句，与struct和enum不同。
    //类似于定义函数原型
    event Deposit(
        address indexed _from,
        uint indexed _id,
        uint _value
    );

    function deposit(uint _id) {
        //使用
        Deposit(msg.sender, _id, msg.value);

        //TODO
    }
}

7. 访问函数(Getter Functions)

编译器为自动为所有的public的状态变量创建访问函数。下面的合约例子中，编译器会生成一个名叫data的无参，返回值是uint的类型的值data。状态变量的初始化可以在定义时完成。

pragma solidity ^0.4.24;


contract  Test {

    // 加了public 的转态变量，solidity会自动的生成一个同名个访问函数。
    // 在合约内部使用这个状态变量的时候，直接当初变量使用即可, 不能直接当成方法使用
    // 如果在合约外面向访问这个public变量（data），就需要使用xx.data()形式
    uint256 public data = 200;


    function getData() public view returns(uint256) {
        return data;
    }

    //This代表合约本身，如果在合约内部使用this自己的方法的话，相当于外部调用
    function getData1() public view returns(uint256) {
        //return this.data;   //不能使用.data形式
        return this.data();
    }
}

contract Test1 {

    function getValue() public view returns(uint256) {
        Test t1 = new Test();
        return t1.data();
    }
}

8. 合约（重要）

- 创建合约和外部调用

1. new关键字，返回值是一个address，需要显示转化类型后才能使用
2. C c1形式，此时c1是空的，需要赋值地址才能使用，否则报错

demo:

pragma solidity ^0.4.24;


contract  C1 {

    uint256 public value ;

    constructor(uint256 input) public {
        value = input;
    }

    function getValue() public view returns(uint256) {
        return value;
    }
}

contract C2 {
    C1 public c1;  //0x0000000000000
    C1 public c11;  //0x0000000000000
    C1 public c13;

    function getValue1() public returns(uint256) {

        //创建一个合约，返回地址
        address addr1 = new C1(10);  //balance , transfer方法
        //return addr1.getValue();

        //需要显示的转换为特定类型，才可以正常使用
        c1 = C1(addr1);

        return c1.getValue();
    }


    function getValue2() public returns(uint256) {

        //定义合约的时候，同时完成类型转换
        c11 = new C1(20);
        return c11.getValue();
    }


    function getValue3(address addr) public returns(uint256) {
        //传进来的地址必须是同类型的，如果是不是C1类型的，转换时报错
        c13 = C1(addr);
        return c13.getValue();
    }
}

- 继承

1. is关键字， 可以同时继承多个父合约。
2. 当父合约存在同名函数时，默认为最远继承原则
3. 可以指定某个父合约，调用它的方法

pragma solidity ^0.4.24;


contract baseA {

    function getData() public pure returns(uint256) {
        return 1;
    }
} 


contract baseB {

    function getData() public pure returns(uint256) {
        return 2;
    }
} 


contract sonA is baseA, baseB {

    function getSonData() public pure returns(uint256){
        return 3;
    }

    function getData3() public pure returns(uint256) {
        return baseA.getData();
    }
}

- 合约间如何转钱

这个是官方示例，介绍如何使用一个合约向另一个合约转账。

pragma solidity ^0.4.24;


contract TestA {

    string public message;

    function invest(string _input) payable public {
        message = _input;    
    }

    function getBalanceA() public view returns(uint256) {
        return address(this).balance;
    }
} 



contract TestB {

    TestA public a1;

    constructor() public {
        a1 = new TestA();
    }

    function() public payable {

    }

    function pay() public {
        //TestB调用TestA的invest方法时，如何转账给TestA？
        //把TestB的钱转给TestA， 并不是调用pay函数人的钱
        a1.invest.value(5 ether).gas(21000)("hangtou!");
    }

    function getBalanceB() public view returns(uint256) {
        return address(this).balance;
    }

}

9. internal和external

访问函数有外部(external)可见性。如果通过内部(internal)的方式访问，比如直接访问，你可以直接把它当一个变量进行使用，但如果使用外部(external)的方式来访问，如通过this.，那么它必须通过函数的方式来调用。

pragma solidity ^0.4.24;


//private ,           intenal ,            external,            public
//合约本身可以调用，  合约及子类可以调用， 只能在合约外部调用， 可以被任意的合约调用

contract C1{
    uint public c = 10;

    function accessPrivate() private returns(uint) {
        return c;
    }

    function accessInternal() internal returns (uint){
        return c;
    }

    function accessExternal() external returns(uint){
        return c;
    }

    function call1() public returns(uint) {
        // accessExternal(); //无法在内部调用external修饰的函数
        accessInternal();
    }

    function call2() public {
        this.accessExternal(); //this调用函数，相当于外部调用

        // this.c;   // ok
        // uint a = this.c; // error
        uint b = this.c();   // ok
        // c();
    }

    function call3() public returns(uint) {

    }
}

contract C2{

    function callExternal() public returns(uint){
        C1 c1 = new C1();
        // external修饰的只能在外部调用
        return c1.accessExternal();

        //internal修饰的只能在内部调用
        // return c1.accessInternal();
    }
}

contract C3 is C1 {

    function test() public returns(uint) {
        // C1 c1 = new C1();
        // c1.accessPrivate();

        // this.accessInternal(); //error
        // c1.accessInternal(); // error
        return accessInternal();

    }

}

10. 元组（tuple）

return（a, b, c）

solidity无法返回自定义的数据结构，所以若想返回一个自定义结构的数据，需要在函数中一次返回多个值，即元组。元组是一个数据集合，类似于字典但是无法修改数据，使用圆括号包括多种数据类型。

1. 可以包含多个数据
2. 类型可以不同
3. 不可以修改
4. 使用圆括号包裹

pragma solidity ^0.4.5;

contract Test {

    struct Student {
        string name;
        uint age;
        uint score;
        string sex;
    }

    //两种赋值方式
    Student public stu1 = Student("lily", 18, 90, "girl");
    Student public stu2 = Student({name:"Jim", age:20, score:80, sex:"boy"});

    Student[] public Students;

    function assign() public {
        Students.push(stu1);
        Students.push(stu2);

        stu1.name = "Lily";
    }

    //1. 返回一个Student结构
    function getLily() public view returns(string, uint, uint, string) {
        require(Students.length != 0);
        Student memory lily = Students[0];

        //使用圆括号包裹的多个类型不一致的数据集合：元组
        return (lily.name, lily.age, lily.score, lily.sex);
    }
}

11. 内置数学函数

keccak256(...) returns (bytes32)

哈希函数，代替sha3（废弃）

pragma solidity ^0.4.24;


contract Test {

    function test() public pure returns(bytes32){
        bytes memory v1 = abi.encodePacked("abc", "b", uint256(1), "hello");
        return keccak256(v1);
    }
}

12. 其他

for、break、continue

- new

创建对象，合约等

- delete

• delete操作符可以用于任何变量(map除外)，将其设置成默认值
• 如果对动态数组使用delete，则删除所有元素，其长度变为0: uint[ ] array0 ; arry0 = new uint
• 如果对静态数组使用delete，则重置所有索引的值: uint[10] array1 = [1,2,3,4,5,6];
• 如果对map类型使用delete，什么都不会发生
• 但如果对map类型中的一个键使用delete，则会删除与该键相关的值

pragma solidity ^0.4.24;


contract  Test {

    //01. string 
    string public str1 = "hello";

    function deleteStr() public {
        delete str1;
    }

    function setStr(string input) public {
        str1 = input;
    }

    //02. array 对于固定长度的数组，会删除每个元素的值，但是数组长度不变
    uint256[10] public arry1 = [1,2,3,4,5];

    function deleteFiexedArry() public {
        delete arry1;
    }

    //03. array new

    uint256[] arry2 ;
    function setArray2() public {
        arry2 = new uint256[](10);
        for (uint256 i = 0; i< arry2.length; i++) {
            arry2[i] = i;
        }
    }

    function getArray2() public view returns(uint256[]) {
        return arry2;
    }

    function deleteArray2() public {
        delete arry2;
    }

    //04. mapping

    mapping(uint256 => string) public m1;

    function setMap() public {
        m1[0] = "hello";
        m1[1] = "world";
    }

    //Mapping不允许直接使用delete，但是可以对mapping的元素进行指定删除
    // function deleteM1() public {
    //     delete m1;
    // }

    function deleteMapping(uint256 i) public {
        delete m1[i];
    }
}

13. 编码规范

1. public放到最前面
2. 函数参数加下划线

14.合约销毁

1. selfdestruct(msg.sender); 可以销毁合约，并将合约内的金额转给指定的地址。
2. 合约销毁后，不再工作，无法继续调用其方法。
3. 合约销毁，并不是将合约删除，只是不工作。
4. 合约销毁权限一定要控制好。

pragma solidity ^0.4.24;


contract Test {

    string public name;

    address manager;

    constructor(string _input) public payable {
        name = _input;
        manager = msg.sender;
    }

    function getBalance() public view returns(uint256) {
        return address(this).balance;
    }


    function kill() public {

        require(manager == msg.sender) ;

        selfdestruct(msg.sender);
    }

}

六、智能合约案例

1. 查看代币合约

2. 代币源码

- ERC20标准

合约中实现这些标准接口函数

contract ERC20 {
    function totalSupply() constant returns (uint totalSupply);
    function balanceOf(address _owner) constant returns (uint balance);
    function transfer(address _to, uint _value) returns (bool success);
    function transferFrom(address _from, address _to, uint _value) returns (bool success);
    function approve(address _spender, uint _value) returns (bool success);
    function allowance(address _owner, address _spender) constant returns (uint remaining);
    event Transfer(address indexed _from, address indexed _to, uint _value);
    event Approveal(address indexed _owner, address indexed _spender, uint _value);

    string public constant name = "Token Name";
    string public constant symbol = "SYM";
    uint8 public constant decimals = 18;  // 大部分都是18
}

- 参考链接

1. 以太坊：什么是ERC20标准？

   https://www.jianshu.com/p/a5158fbfaeb9

2. 以太坊ERC20 Token标准完整说明

   https://blog.csdn.net/diandianxiyu_geek/article/details/78082551?utm_source=gold_browser_extension

- 查看真实的代币情况

//演示

- 分析BNB代码

pragma solidity ^0.4.8;

/**
 * Math operations with safety checks
 */
contract SafeMath {
  //internal > private 
    //internal < public
    //修饰的函数只能在合约的内部或者子合约中使用
    //乘法
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    //assert断言函数，需要保证函数参数返回值是true，否则抛异常
    assert(a == 0 || c / a == b);
    return c;
  }
//除法
  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    //   a = 11
    //   b = 10
    //   c = 1

      //b*c = 10
      //a %b = 1
      //11
    assert(a == b * c + a % b);
    return c;
  }

    //减法
  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
    assert(b <= a);
    assert(b >=0);
    return a - b;
  }

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
}

contract QiongB is SafeMath{

    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;


    mapping (address => uint256) public freezeOf;


    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);

    /* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);

    /* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

    /* Initializes contract with initial supply tokens to the creator of the contract */

    //1000000, "QiongB", 18, "QB"
    function QiongB(
        uint256 initialSupply, //发行数量
        string tokenName, //token的名字 BinanceToken
        uint8 decimalUnits, //最小分割，小数点后面的尾数 1ether = 10** 18wei
        string tokenSymbol //QB
        ) {
        decimals = decimalUnits;                           // Amount of decimals for display purposes
        balanceOf[msg.sender] = initialSupply * 10 ** 18;              // Give the creator all initial tokens
        totalSupply = initialSupply * 10 ** 18;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes

        owner = msg.sender;
    }

    /* Send coins */
    //某个人花费自己的币
    function transfer(address _to, uint256 _value) {
        if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
        if (_value <= 0) throw; 
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows

        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender

        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    //找一个人A帮你花费token，这部分钱并不打A的账户，只是对A进行花费的授权
    //A： 1万
    function approve(address _spender, uint256 _value)
        returns (bool success) {
        if (_value <= 0) throw; 
        //allowance[管理员][A] = 1万
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    //mapping (管理员 => mapping (A =>1万)) public allowance;
    //mapping (管理员 => mapping (B =>2万)) public allowance;

    /* A contract attempts to get the coins */
    function transferFrom(address _from /*管理员*/, address _to, uint256 _value) returns (bool success) {
        if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
        if (_value <= 0) throw; 
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
           // mapping (address => mapping (address => uint256)) public allowance;
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        //allowance[管理员][A] = 1万-五千 = 五千
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }

    function burn(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
        if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        totalSupply = SafeMath.safeSub(totalSupply,_value);                                // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }

    function freeze(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
        if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                // Updates totalSupply
        Freeze(msg.sender, _value);
        return true;
    }

    function unfreeze(uint256 _value) returns (bool success) {
        if (freezeOf[msg.sender] < _value) throw;            // Check if the sender has enough
        if (_value <= 0) throw; 
        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      // Subtract from the sender
        balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
        Unfreeze(msg.sender, _value);
        return true;
    }

    // transfer balance to owner
    function withdrawEther(uint256 amount) {
        if(msg.sender != owner)throw;
        owner.transfer(amount);
    }

    // can accept ether
    function() payable {
    }
}

七、验证（verify）合约

Ropste Duke AD，已经Verify

https://ropsten.etherscan.io/address/0x8136d63e3c1e3e8e93560a965c635f2704ce7c22#code

1. 为什么要验证合约

部署了一个合约之后，如果想让大家参与进来，那么必须接受大家的审计（审计一定要部署完就做，这样可以保证完全匹配），以确保你的合约的功能确实如你所说，全世界的人都看到了合约的所有功能，那么就可以放心使用了

2. 验证方式

//操作 ，优化填否

3. 操作验证后的合约

1. 浏览器上的数据是如何解析的？

注意:

1. 在remix部署到ropsten，将合约的地址添加到metamask的AddToken中，只输入地址即可，其他两项（name，decimals会自动加载出来）
2. metamask中只能查看token数量，但是无法进行token交易
3. 可以使用Myetherwallet页面网站来进行转账
4. 可以使用MyEtherWallet客户端进行转账
5. 可以在验证合约之后，在浏览器上直接完成转账。

4. 以太坊上的数据为什么能被看到？

所有的数据都是通过交易产生的，无论是上传数据，亦或是调用方法，那么传入的数据都是通过inputdata传递进来的，而这个字段是公开的，所有所有的数据都是透明的。

END

2020年07月22日12:48:08

79、solidity语言学习——2020年07月22日12:49:06

标签：整型   区块   walle   对比   维护   效率   delegate   eal   内部函数   

原文地址：https://www.cnblogs.com/oneapple/p/13360054.html