区块链 on Chen's Blog

区块链学习7-交易池底层实现

Fri, 04 Sep 2020 00:00:00 +0000

起源于老师提出的一个问题：区块链是如何处理同时发起的多个请求的。想了想觉得核心是交易池机制，因此准备看一下交易池的原理和实现。

智能合约知识点总结

Mon, 04 May 2020 00:00:00 +0000

项目进行过程中知识点的总结

1. 字符串比较

翻译自：Fravoll-String Equality Comparison

比较两个给定字符串是否相等，是 Solidity 编程中最常见的一种情况，但语言本身并没有提供内置函数用于字符串比较，本文介绍两种可用方法并分析 Gas 消耗情况。

1.1 StringUtils 库

第一种方法是使用 Ethereum 基金会提供的 StringUtils 库，它对每个字符进行成对比较，如果有一个字符对不匹配，则返回false。这种办法可以返回正确的结果，对于短字符串和字符不同发生在字符串前面的情况仅消耗少量 Gas。但是对于相等的字符串和长字符串，这种方法的 Gas 消耗较高，因为必须做很多比较才能得到正确结果。因此，字符串比较的两个可衡量的因素是字符串平均长度和正确率。

1.2 哈希函数

作者提出使用哈希函数进行比较，同时检查所提供的字符串的长度，从一开始就剔除长度不匹配的字符串。其步骤如下

检查两个字符串是否有相同长度，通过转换为 bytes 类型完成，因为 bytes 类型有内置长度函数。如果相同进入第2步，如果不相同返回结果；
使用 keccak256() 函数对两个字符串求哈希，然后比较计算得到的哈希值，从而确定是否相等。

一个示例代码如下

1
2
3
4
5
6
7
8


# 这段代码未经安全审计，使用有风险
function hashCompareWithLengthCheck(string a, string b) internal returns (bool) {
if(bytes(a).length != bytes(b).length) {
return false;
} else {
return keccak256(abi.encodePacket(a)) == keccak256(abi.encodePacket(b));
}
}

abi.encodePacket(...) returns (bytes) 用于对给定参数执行紧打包编码，官方文档中不推荐使用 keccak256(...) 直接计算哈希，而是使用 keccak256(abi.encodePacked(...))

1.3 Gas 消耗分析

在 Remix 编写代码测试了三种不同情况的字符串比较的 Gas 消耗

比较哈希
比较每个字符，同时比较字符串长度
比较哈希，同时比较字符串长度

结果如下表所示，输入列为输入的待比较字符串，输出列的单位为 Wei

Input A	Input B	Hash	Character + Length	Hash + Length
abcdefghijklmnopqrstuvwxyz	abcdefghijklmnopqrstuvwxyz	1225	7062	1261
abcdefghijklmnopqrstuvwxyX	abcdefghijklmnopqrstuvwxyz	1225	7012	1261
Xbcdefghijklmnopqrstuvwxyz	abcdefghijklmnopqrstuvwxyz	1225	912	1261
aXcdefghijklmnopqrstuvwxyz	abcdefghijklmnopqrstuvwxyz	1225	1156	1261
abXdefghijklmnopqrstuvwxyz	abcdefghijklmnopqrstuvwxyz	1225	1400	1261
abcdefghijkl	abcdefghijklmnopqrstuvwxyz	1225	690	707
a	a	1225	962	1261
ab	ab	1225	1156	1261
abc	abc	1225	1450	1261

可以看出，哈希+字符串长度的比较方式 Gas 消耗更加稳定，这种方式比较高效。

2. 可见性与Getter函数

转自：Solidity 0.6.4 中文文档

Solidity 有两种函数调用：内部调用（Internal Function Calls）和外部调用（External Function Calls）。前者指直接或递归地调用合约内部函数，不会产生实际的 EVM 调用，因此也被称为「消息嗲用」，后者指从合约外部调用合约中的函数，会产生一个 EVM 调用。

2.1 可见性

因此，函数和状态变量有四种可见性。函数可以指定为 external，public，internal 或 private，对于状态变量，默认是 internal 且不能设置为 external。

external：外部函数作为合约接口的一部分，意味着我们可以从其他合约和交易中调用。一个外部函数 f 不能从内部调用（即 f 不起作用，但 this.f()可以）。当收到大量数据的时候，外部函数有时候会更有效率，因为数据不会从calldata复制到内存.
public：public 函数是合约接口的一部分，可以在内部或通过消息调用。对于 public 状态变量，会自动生成一个 getter 函数（见下面）。
internal：这些函数和状态变量只能是内部访问（即从当前合约内部或从它派生的合约访问），不使用 this 调用。
private：private 函数和状态变量仅在当前定义它们的合约中使用，并且不能被派生合约使用。

合约中的所有内容对外部观察者都是可见的。设置一些 private 类型只能阻止其他合约访问和修改这些信息，但是对于区块链外的整个世界它仍然是可见的。

可见性标识符的定义位置，对于状态变量来说是在类型后面，对于函数是在参数列表和返回关键字中间，如下例

1
2
3
4
5
6
7


pragma solidity >=0.4.16 <0.7.0;
contract C {
function f(uint a) private pure returns (uint b) { return a + 1; }
function setData(uint a) internal { data = a; }
uint public data;
}

在下面的例子中，D 可以调用 c.getData（） 来获取状态存储中 data 的值，但不能调用 f 。合约 E 继承自 C ，因此可以调用 compute。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


pragma solidity >=0.4.0 <0.7.0;
contract C {
uint private data;
function f(uint a) private returns(uint b) { return a + 1; }
function setData(uint a) public { data = a; }
function getData() public returns(uint) { return data; }
function compute(uint a, uint b) internal returns (uint) { return a+b; }
}
// 下面代码编译错误
contract D {
function readData() public {
C c = new C();
uint local = c.f(7); // 错误：成员 `f` 不可见
 c.setData(3);
local = c.getData();
local = c.compute(3, 5); // 错误：成员 `compute` 不可见
 }
}
contract E is C {
function g() public {
C c = new C();
uint val = compute(3, 5); // 访问内部成员（从继承合约访问父合约成员）
 }
}

2.2 Getter 函数

编译器自动为所有 public 状态变量创建 getter 函数。对于下面给出的合约，编译器会生成一个名为 data 的函数，该函数没有参数，返回值是一个 uint 类型，即状态变量 data 的值。状态变量的初始化可以在声明时完成。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() public {
uint local = c.data();
}
}

getter 函数具有外部（external）可见性。如果在内部访问 getter（即没有 this. ），它被认为一个状态变量。如果使用外部访问（即用 this. ），它被认作为一个函数。

1
2
3
4
5
6
7
8
9


pragma solidity ^0.4.0 <0.7.0;
contract C {
uint public data;
function x() public {
data = 3; // 内部访问
 uint val = this.data(); // 外部访问
 }
}

如果你有一个数组类型的 public 状态变量，那么你只能通过生成的 getter 函数访问数组的单个元素。这个机制以避免返回整个数组时的高成本gas。可以使用如 data(0) 用于指定参数要返回的单个元素。如果要在一次调用中返回整个数组，则需要写一个函数，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


pragma solidity >=0.4.0 <0.7.0;
contract arrayExample {
// public state variable
 uint[] public myArray;
// 指定生成的Getter 函数
 /*
 function myArray(uint i) public view returns (uint) {
 return myArray[i];
 }
 */
// 返回整个数组
 function getArray() public view returns (uint[] memory) {
return myArray;
}
}

现在可以使用 getArray() 获得整个数组，而 myArray(i) 是返回单个元素。

下一个例子稍微复杂一些：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


pragma solidity ^0.4.0 <0.7.0;
contract Complex {
struct Data {
uint a;
bytes3 b;
mapping (uint => uint) map;
}
mapping (uint => mapping(bool => Data[])) public data;
}

这将会生成以下形式的函数

1
2
3
4


function data(uint arg1, bool arg2, uint arg3) public returns (uint a, bytes3 b) {
a = data[arg1][arg2][arg3].a;
b = data[arg1][arg2][arg3].b;
}

请注意，因为没有好的方法来提供映射的键，所以结构中的映射被省略。

3. 合约间调用

之前的实验合约间的调用没有成功，这次就仔细地研究一下合约间地调用机制。分为两种情况

调用者和被调用者在一个sol文件中
调用者和被调用者在不同的sol文件中

本文提到的合约调用方法的实质是抽象合约的使用。

3.1 同sol文件的智能合约调用

下面的智能合约中，Main和Add两个合约定义在一个Main.sol文件中，可以同时编译，然后逐个部署。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


pragma solidity ^0.5.0;
contract Main {
Add add;
constructor(address _m) public {
add = Add(_m);
}
function Addnumber() public view returns (uint) {
return add.add5(10);
}
}
contract Add {
function add5(uint s) public pure returns (uint){
return 5+s;
}
}

以使用Remix为例，点击编译按钮编译Main.sol文件，将会同时编译Main和Add两个合约。

编译

然后首先部署Add合约，因为Main合约的部署需要Add的合约地址作为参数。切换到部署和运行选项卡，选择Add合约，点击Deploy，成功部署后，复制合约地址。

deploy simple Add

然后重新选择Main合约，填入Add合约地址作为参数，点击部署按钮。

deploy simple Main

测试合约间调用，由合约内容可知，Main合约中的Addnumber函数调用了Add合约的add5函数，传入参数为10，得到的结果应为15。展开左侧的Deployed Contracts，点击Addnumber进行调用，结果如下。

call test

3.2 不同sol文件的智能合约调用

这一次我们测试不同sol文件的智能合约调用，来一个复杂一点的，两个合约分别是Add.sol和Main.sol。

Add.sol使用了一个结构体来定义数值，并通过映射定义查找表来寻找这个值。文件中定义了两个函数，numRegister用来向表中添加数值，addValue用来将从表中查到的指定值+5返回。之所以用这个结构是因为我们的项目里用到了，这里来测试一下可不可行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


pragma solidity ^0.5.0;
contract Add {
struct Num{
uint value;
}
mapping(uint => Num) public lookupTable;
function numRegister(uint key, uint _value) public {
lookupTable[key].value = _value;
}
function addValue(uint key) public view returns (uint) {
return lookupTable[key].value + 5;
}
}

Main.sol没有多大变化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


pragma solidity ^0.5.0;
contract Main {
Add add;
constructor(address _m) public {
add = Add(_m);
}
function Addnumber() public view returns (uint) {
return add.addValue(5);
}
}
contract Add {
function addValue(uint key) public view returns (uint);
}

仍然是先编译部署Add合约，部署后调用numRegister函数写入数值5，并调用addValue函数测试返回。

deploy comlex Add

接着编译部署Main合约，复制Add合约地址作为初始化参数，部署后调用Addnumber函数测试

deploy comlex Main

3.3 总结

合约内的调用方法是相同的，都要先实例化，然后传入被调合约地址，接着才能调用。而写在不同sol文件中时，需要额外声明被调合约的抽象合约，有些文章中说使用call，callcode或delegatecall，但并不建议，因为这三个函数都是非常底层的函数，破坏了类型的安全，只能作为最后的手段使用。

详细的解释参考了StackExchange-Calling function from deployed contract

4. 函数修饰词pure和view

转自深入理解Solidity-函数

这两个函数修饰词的作用是告诉编译器函数是否会读取/修改状态，view 表示保证不修改状态，pure 表示保证不读取也不修改状态。Solidity v0.4.17 之前没有这两个修饰词，而是使用 constant 关键字，和 view 的含义相同，不过在 v0.5.0 之后被移除，现在只能使用这两个 view 和 pure。

4.1 view 视图函数

Getter 方法会被自动标记为 view，除此之外，一个 view 修饰的例子如下

1
2
3
4
5
6
7


pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) public view returns (uint) {
return a * (b + 42) + now;
}
}

view 保证函数不修改状态，以下操作会被认为是修改状态

修改状态变量。
产生事件。
创建其它合约。
使用 selfdestruct。
通过调用发送以太币。
调用任何没有标记为 view 或者 pure 的函数。
使用低级调用。
使用包含特定操作码的内联汇编。

4.2 pure 纯函数

pure 保证不读取也不修改状态，不修改的定义上面已经提到，下面的操作被认为是读取状态

读取状态变量。
访问 address(this).balance 或者 .balance。
访问 block，tx， msg 中任意成员（除 msg.sig 和 msg.data 之外）。
调用任何未标记为 pure 的函数。
使用包含某些操作码的内联汇编。

一个 pure 修饰的例子如下

1
2
3
4
5
6
7


pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) public pure returns (uint) {
return a * (b + 42);
}
}

5. 浮点数处理

首先声明，Solidity 中支持浮点数定义，但无法赋值和进行计算。文档中对其描述是「目前还不完全支持」，虽然这意味着以后可能会完全支持，但等不及了，下面记录几个可参考的资料。

来自 ethereum stackexchange 中的回答，介绍了一些可用的库；
ABDK Math Quad，包含两个合约库，一个支持定点数，一个支持浮点数；
Mikhail Vladimirov 的 Math in Solidity 系列文章，介绍如何在 Solidity 中处理各种数学运算，写的非常棒。

6. 地址类型

在智能合约中显式传入地址类型时，可能会出现如下错误

Address checksum

This looks like an address but has an invalid checksum. If this is not used as an address, please prepend ‘00’.

关于该问题的一个讨论见 https://github.com/ethereum/EIPs/issues/55

这是因为合约中现在使用地址类型必须做一个转换，不是简单的全部大写字母或小写字母，而是遵循一定的规则，这个规则见 ethereum/EIPs#55

但是网上提供的解决方案一般是使用JS库中的转换函数，在智能合约中无法直接解决，好在，web3提供了一个在线API接口，可以调用其checkAddressChecksum函数对地址进行转换，然后将转换后的结果直接用于合约代码。

7. Gas limit问题

在搭建的以太坊私链上进行智能合约部署时，出现了以下问题

1
2


INFO [03-21|13:50:11.690] Served eth_sendTransaction reqid=24 t=684.186µs err="exceeds block gas limit"
Error: exceeds block gas limit undefined

出现该错误的原因如错误描述，是当前合约所需的gas超过了区块的最大gas。这可能与参数gasLimit有关。在创世区块的配置文件中，我们使用了默认的配置值，为0x2fefd8，转换为10进制即3141592。

注：在线转换工具

面对疫情区块链可以做些什么

Mon, 16 Mar 2020 00:00:00 +0000

这场年初爆发的疫情在国内控制住以后，反而开始在全世界其它国家蔓延，如大数据、5G等技术均在当前这场疫情中产生了自己的作用，区块链能做些什么，

区块链方向有参考价值的文章收集

Tue, 26 Nov 2019 00:00:00 +0000

很多区块链领域极有启发性的文章或者介绍极为详细的文章都很值得保存，以前直接将文章完整的转载过来，但最近发现这种方法占用空间而且毫无意义，因此

以太坊开发8-Truffle框架安装使用

Wed, 06 Nov 2019 00:00:00 +0000

Truffle和Ganache的安装使用 1. 安装Truffle 在Ubuntu18.04 下安装运行，要求Node.js版本高于v8.9.4 1 2 3

区块链学习6-IBFT共识

Tue, 29 Oct 2019 00:00:00 +0000

AMIS公司提出的 Istanbul Byzantine Fault Tolerance Consensus（简称IBFT或Istanbul BFT），是一个基于PBFT的交易一致性的共识。因为要考虑可能发

提取以太坊的区块产生时间

Fri, 05 Apr 2019 21:35:00 +0800

前言

目的是提取以太坊的区块产生时间形成数据集，初步的思路有两种：

爬取以太坊区块浏览器中的时间数据，然后格式化形成数据集输出
同步以太坊的所有区块（头），利用以太坊本身提供的接口提取每个区块的时间戳信息，然后将时间戳转换为真实的日期格式形成数据集输出，时间戳转换在线工具

查询资料过程中，了解到谷歌已提供以太坊的区块信息数据集¹。虽然数据集本身没有时间信息，但可以导出时间戳进行转换，了解到谷歌使用的工具是ethereum-etl，故最终的解决方案是：使用ethereum-etl导出时间戳，编写Python程序转换时间戳并导出数据集。

以太坊开发7-swarm存储网络使用

Thu, 28 Mar 2019 19:59:00 +0800

说实话，swarm的资料比较难找，倒是IPFS的比较多一点。最后只在Medium找到了一些，本篇文章就是在实践其中的一些项目，并通过这样来学习swarm。

参考链接：swarm官网，swarm文档，github项目

还有一些帮助理解的资料：

以太坊开发6-Docker搭建以太坊私链

Tue, 12 Mar 2019 11:24:00 +0800

在以太坊github的官方项目地址发现其支持Docker启动，同时因为Docker相对于虚拟机的易用性，决定尝试使用Docker搭建以太坊联盟链

Docker安装部分查看自官方说明，搭建过程主要参考简书-使用Docker搭建以太坊私有链并部署合约

一、Docker安装

OS环境：Ubuntu 18.04 LTS(bionic)

内核版本：4.18.0-16-generic

处理器架构：amd64

官方的安装说明位于：Get Docker CE for Ubuntu

以太坊开发5-以太坊节点连接到网络的几种方式

Tue, 12 Mar 2019 08:33:00 +0800

文章翻译自：Connecting to the network 如何寻找对等节点在初始化时，geth会使用一组记录在源码中的bootstrap节点来连接。要指定这些节

以太坊开发4-geth console命令

Fri, 08 Mar 2019 10:27:00 +0800

Geth Console是一个交互式的JavaScript执行环境，其中>是命令提示符。在这个环境里也内置了一些用来操作以太坊的JavaScript对象，可以直接使用这些对象。这些对象主要包括：

eth：包含一些跟操作区块链相关的方法；
net：包含一些查看p2p网络状态的方法；
admin：包含一些与管理节点相关的方法；
miner：包含启动&停止挖矿的一些方法；
personal：主要包含一些管理账户的方法；
txpool：包含一些查看交易内存池的方法；
web3：包含了以上对象，还包含一些单位换算的方法。

以太坊开发3-geth客户端命令

Fri, 08 Mar 2019 09:26:00 +0800

Geth是以太坊智能合约开发工具，是一个命令行工具，所以熟悉其命令参数有助于提高开发效率。本文是geth help的翻译，基于geth 1.8.

以太坊开发2-创世区块文件genesis.json

Thu, 07 Mar 2019 19:48:00 +0800

文件说明关于genesis.json的官方说明位于两处 Private network Connecting to the network 每条区块链都以创世区块开头，而genesis.json正是创世区块的配置文

以太坊开发1-虚拟机搭建以太坊私链

Thu, 07 Mar 2019 14:53:00 +0800

一、单虚拟机最简单的方式是使用一个虚拟机，这也是在条件有限的情况下的最好选择。方法是在一台虚拟机上启用多个终端，每个终端使用不同的端口通信。

区块链学习5-ETC和ETH

Wed, 16 Jan 2019 10:48:00 +0800

最近ETC遭受疑似51%攻击的影响很大，虽然最后的结果还没出来，仍不确定是真的遭受了51%攻击，还是之前官方所称的ASIC矿机测试带来的问题

区块链学习4-以太坊基础知识

Tue, 11 Dec 2018 20:34:00 +0800

1. 基本知识基本知识需要了解两部分第一部分是以太坊版本演进过程：白皮书——>黄皮书——>Frontier版本——>Homes

区块链学习3-区块链领域概况

Tue, 20 Nov 2018 14:25:00 +0800

本篇结束区块链领域概况，包括一些常见名词、核心技术、应用场景和学习区块链需要掌握的基础知识。

区块链学习2-比特币基本原理

Mon, 12 Nov 2018 00:00:00 +0000

区块链里最基本也是最重要的几个概念是地址、交易、区块、网络。比特币用地址来标识一笔交易的支出方和接收方。所有的交易最终需要被记到统一的账本（也就是区块链）上，而这个账本是通过区块确认并完成的。每一个新区块的产生，都会被打上时间戳（区块头里的一个字段，是真的时间，后面详细介绍），最终生成按照时间前后排列并加以记录的电子交易证明。每个独立节点之间又通过比特币网络来建立联系，这样就组成了一个去中心化、分布式的电子交易记录时间戳服务器系统。比特币通过构造这个分布式时间戳服务器来解决双重支付问题。

区块链学习1-比特币的诞生

Fri, 02 Nov 2018 14:02:00 +0800

区块链作为比特币背后的技术架构，是随着比特币的出现而诞生的。因此，要讲区块链的诞生，我们就不得不从比特币的历史说起。