大帅哥
0%

solidity基础10-12

发表于 更新于 分类于

Solidity极简入门: 10. 控制流，用solidity实现插入排序

这一讲，我们将介绍solidity中的控制流，然后讲如何用solidity实现插入排序（InsertionSort），一个看起来简单，但实际上很容易写出bug的程序。

控制流

Solidity的控制流与其他语言类似，主要包含以下几种：

  1. if-else
1
2
3
4
5
6
7
function ifElseTest(uint256 _number) public pure returns(bool){
    if(_number == 0){
    return(true);
    }else{
    return(false);
    }
}
  1. for循环
1
2
3
4
5
6
7
function forLoopTest() public pure returns(uint256){
    uint sum = 0;
    for(uint i = 0; i < 10; i++){
    sum += i;
    }
    return(sum);
}
  1. while循环
1
2
3
4
5
6
7
8
9
function whileTest() public pure returns(uint256){
    uint sum = 0;
    uint i = 0;
    while(i < 10){
    sum += i;
    i++;
    }
    return(sum);
}
  1. do-while循环
1
2
3
4
5
6
7
8
9
function doWhileTest() public pure returns(uint256){
    uint sum = 0;
    uint i = 0;
    do{
    sum += i;
    i++;
    }while(i < 10);
    return(sum);
}
  1. 三元运算符 三元运算符是solidity中唯一一个接受三个操作数的运算符，规则条件? 条件为真的表达式:条件为假的表达式。 此运算符经常用作 if 语句的快捷方式。
1
2
3
4
5
// 三元运算符 ternary/conditional operator
function ternaryTest(uint256 x, uint256 y) public pure returns(uint256){
    // return the max of x and y
    return x >= y ? x: y; 
}

另外还有continue（立即进入下一个循环）和break（跳出当前循环）关键字可以使用。

用solidity实现插入排序

写在前面：90%以上的人用solidity写插入算法都会出错。

插入排序

排序算法解决的问题是将无序的一组数字，例如[2, 5, 3, 1]，从小到大依次排列好。插入排序（InsertionSort）是最简单的一种排序算法，也是很多人学习的第一个算法。它的思路很简单，从前往后，依次将每一个数和排在他前面的数字比大小，如果比前面的数字小，就互换位置。示意图：

插入排序

python代码

我们可以先看一下插入排序的python代码：

1
2
3
4
5
6
7
8
9
10
# Python program for implementation of Insertion Sort
def insertionSort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i-1
        while j >=0 and key < arr[j] :
                arr[j+1] = arr[j]
                j -= 1
        arr[j+1] = key
    return arr

改写成solidity后有BUG！

一共8行python代码就可以完成插入排序，非常简单。那么我们将它改写成solidity代码，将函数，变量，循环等等都做了相应的转换，只需要9行代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 插入排序 错误版
function insertionSortWrong(uint[] memory a) public pure returns(uint[] memory) {
    
    for (uint i = 1;i < a.length;i++){
        uint temp = a[i];
        uint j=i-1;
        while( (j >= 0) && (temp < a[j])){
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
    return(a);
}

那我们把改好的放到remix上去跑，输入[2, 5, 3, 1]。BOOM！有bug！改了半天，没找到bug在哪。我又去google搜”solidity insertion sort”，然后发现网上用solidity写的插入算法教程都是错的，比如：Sorting in Solidity without Comparison

Remix decoded output 出现错误内容

10-1

正确的solidity插入排序

花了几个小时，在Dapp-Learning社群一个朋友的帮助下，终于找到了bug所在。solidity中最常用的变量类型是uint，也就是正整数，取到负值的话，会报underflow错误。而在插入算法中，变量j有可能会取到-1，引起报错。

这里，我们需要把j加1，让它无法取到负值。正确代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 插入排序 正确版
function insertionSort(uint[] memory a) public pure returns(uint[] memory) {
    // note that uint can not take negative value
    for (uint i = 1;i < a.length;i++){
        uint temp = a[i];
        uint j=i;
        while( (j >= 1) && (temp < a[j-1])){
            a[j] = a[j-1];
            j--;
        }
        a[j] = temp;
    }
    return(a);
}

运行后的结果：

"输入[2,5,3,1] 输出[1,2,3,5] "

总结

这一讲，我们介绍了solidity中控制流，并且用solidity写了插入排序。看起来很简单，但实际很难。这就是solidity，坑很多，每个月都有项目因为这些小bug损失几千万甚至上亿美元。掌握好基础，不断练习，才能写出更好的solidity代码。

Solidity极简入门: 11. 构造函数和修饰器

这一讲，我们将用合约权限控制（Ownable）的例子介绍solidity语言中构造函数（constructor）和独有的修饰器（modifier）。

构造函数

构造函数（constructor）是一种特殊的函数，每个合约可以定义一个，并在部署合约的时候自动运行一次。它可以用来初始化合约的一些参数，例如初始化合约的owner地址：

1
2
3
4
5
6
address owner; // 定义owner变量

// 构造函数
constructor() {
   owner = msg.sender; // 在部署合约的时候，将owner设置为部署者的地址
}

注意⚠️：构造函数在不同的solidity版本中的语法并不一致，在Solidity 0.4.22之前，构造函数不使用 constructor 而是使用与合约名同名的函数作为构造函数而使用，由于这种旧写法容易使开发者在书写时发生疏漏（例如合约名叫 Parents，构造函数名写成 parents），使得构造函数变成普通函数，引发漏洞，所以0.4.22版本及之后，采用了全新的 constructor 写法。

构造函数的旧写法代码示例：

1
2
3
4
5
6
pragma solidity =0.4.21;
contract Parents {
    // 与合约名Parents同名的函数就是构造函数
    function Parents () public {
    }
}

修饰器

修饰器（modifier）是solidity特有的语法，类似于面向对象编程中的decorator，声明函数拥有的特性，并减少代码冗余。它就像钢铁侠的智能盔甲，穿上它的函数会带有某些特定的行为。modifier的主要使用场景是运行函数前的检查，例如地址，变量，余额等。

钢铁侠的modifier

我们来定义一个叫做onlyOwner的modifier：

1
2
3
4
5
// 定义modifier
modifier onlyOwner {
   require(msg.sender == owner); // 检查调用者是否为owner地址
   _; // 如果是的话，继续运行函数主体；否则报错并revert交易
}

带有onlyOwner修饰符的函数只能被owner地址调用，比如下面这个例子：

1
2
3
function changeOwner(address _newOwner) external onlyOwner{
   owner = _newOwner; // 只有owner地址运行这个函数，并改变owner
}

我们定义了一个changeOwner函数，运行他可以改变合约的owner，但是由于onlyOwner修饰符的存在，只有原先的owner可以调用，别人调用就会报错。这也是最常用的控制智能合约权限的方法。

OppenZepplin的Ownable标准实现：

OppenZepplin是一个维护solidity标准化代码库的组织，他的Ownable标准实现如下： https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol

Remix 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

    modifier onlyOwner{
        require(owner==msg.sender);
        _;
    }

    function changeOwner(address _newOwner) external onlyOwner{
        owner = _newOwner;
    }
}

以 Owner.sol 为例。

  1. 在 Remix 上编译部署代码。

  2. 点击owner

    按钮查看当前 owner 变量。

    img

  3. 以 owner 地址的用户身份，调用changeOwner函数，交易成功。

    img

  4. 以非 owner 地址的用户身份，调用changeOwner函数，交易失败，因为modifier onlyOwner 的检查语句不满足。

    img

总结

这一讲，我们介绍了solidity中的构造函数和修饰符，并举了一个控制合约权限的Ownable合约。

Solidity极简入门: 12. 事件

这一讲，我们用转账ERC20代币为例来介绍solidity中的事件（event）。

事件

Solidity中的事件（event）是EVM上日志的抽象，它具有两个特点：

  • 响应：应用程序（ethers.js）可以通过RPC接口订阅和监听这些事件，并在前端做响应。
  • 经济：事件是EVM上比较经济的存储数据的方式，每个大概消耗2,000 gas；相比之下，链上存储一个新变量至少需要20,000 gas。

声明事件

事件的声明由event关键字开头，接着是事件名称，括号里面写好事件需要记录的变量类型和变量名。以ERC20代币合约的Transfer事件为例：

1
event Transfer(address indexed from, address indexed to, uint256 value);

我们可以看到，Transfer事件共记录了3个变量from，to和value，分别对应代币的转账地址，接收地址和转账数量，其中from和to前面带有indexed关键字，他们会保存在以太坊虚拟机日志的topics中，方便之后检索。

==在Solidity中，indexed 关键字用于声明事件的参数，允许这些参数在区块链的日志中被索引，这有助于外部的监听器高效地筛选这些事件。然而，并非所有类型的变量都可以使用indexed修饰。indexed关键字只能用于数据类型为address、uint、int、bool以及固定长度的bytes类型。对于更复杂的数据类型，如字符串（string）和动态数组（如bytes），不可以使用indexed修饰，因为这些类型的数据通常需要更多的存储空间，而且它们的日志存储方式与简单类型不同。==

释放事件

我们可以在函数里释放事件。在下面的例子中，每次用_transfer()函数进行转账操作的时候，都会释放Transfer事件，并记录相应的变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 定义_transfer函数，执行转账逻辑
function _transfer(
    address from,
    address to,
    uint256 amount
) external {

    _balances[from] = 10000000; // 给转账地址一些初始代币

    _balances[from] -=  amount; // from地址减去转账数量
    _balances[to] += amount; // to地址加上转账数量

    // 释放事件
    emit Transfer(from, to, amount);
}

EVM日志 Log

以太坊虚拟机（EVM）用日志Log来存储Solidity事件，每条日志记录都包含主题topics和数据data两部分。

img

主题 Topics

日志的第一部分是主题数组，用于描述事件，长度不能超过4。它的第一个元素是事件的签名（哈希）。对于上面的Transfer事件，它的签名就是：

1
2
3
keccak256("Transfer(addrses,address,uint256)")

//0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef

==产生事件的哈希和这个合约的发起者不是一个东西==

除了事件签名，主题还可以包含至多3个indexed参数，也就是Transfer事件中的from和to。

indexed标记的参数可以理解为检索事件的索引“键”，方便之后搜索。每个 indexed 参数的大小为固定的256比特，如果参数太大了（比如字符串），就会自动计算哈希存储在主题中。

数据 Data

事件中不带 indexed的参数会被存储在 data 部分中，可以理解为事件的“值”。data 部分的变量不能被直接检索，但可以存储任意大小的数据。因此一般 data 部分可以用来存储复杂的数据结构，例如数组和字符串等等，因为这些数据超过了256比特，即使存储在事件的 topic 部分中，也是以哈希的方式存储。另外，data 部分的变量在存储上消耗的gas相比于 topic 更少。

Remix演示

以 Event.sol 合约为例，编译部署。

然后调用 _transfer 函数。

img

点击右侧的交易查看详情，可以看到日志的具体内容。

img

在etherscan上查询事件

我们尝试用_transfer()函数在Rinkeby测试网络上转账100代币，可以在etherscan上查询到相应的tx：网址。

点击Logs按钮，就能看到事件明细：

Event明细

Topics里面有三个元素，[0]是这个事件的哈希，[1]和[2]是我们定义的两个indexed变量的信息，即转账的转出地址和接收地址。Data里面是剩下的不带indexed的变量，也就是转账数量。

总结

这一讲，我们介绍了如何使用和查询solidity中的事件。很多链上分析工具包括Nansen和Dune Analysis都是基于事件工作的。