Web3视频转文字汇总

2018年09月08日留言

Solidity编码规范 | 02 | 合约声明

Hello, 我是Keegan小钢，今天我们继续来讲解Solidity编码规范。之前我们讲了为什么需要编码规范，以及文件命名和文件编排的一些编码规范和建议。今天这一节，我想给大家聊聊关于合约声明的一些编码规范和良好的编码建议。我们一个个来过。

首先，第一个建议是，第一行需要声明SPDX License Identifier，即声明所使用的开源证书。我们来看一下实例，第一行是需要声明这个东西的。如果缺失这行代码，虽然编译时不会报错，但会出现一个警告，如“Warning: SPDX license identifier not provided in source file”，意思是没有提供许可证标识符。编译器会建议你在发布前添加这一声明。因此，建议大家加上这行代码以减少警告。

这是第一个点。

第二个点，声明编译器版本。我们建议根据不同情况来处理编译器版本的声明：

如果是interface、library或者抽象合约，建议声明兼容版本，比如pragma solidity ^0.8.0;。这个符号（^）表示支持0.8.0及以上的版本，但不能超过0.9.0。
如果是要部署的具体合约，则建议声明固定版本。比如pragma solidity 0.8.26;，这是一个固定版本的声明。

我们来看具体的实例。以Uni V4为例，它的PoolManager合约是需要部署的，因此它声明了固定的版本0.8.26。而其他的合约，比如NoDelegateCall（一个抽象合约），声明的是兼容版本^0.8.0。ProtoOps也是一个抽象合约，同样声明了兼容版本。Interface也是类似的，比如0.8.0或0.8.24，根据需要使用特定版本的特性。

为什么要这么定义呢？因为对于需要部署的合约，声明固定版本可以确保其在不同环境下的行为一致。而对于interface、library或抽象合约，它们可能会被其他项目引用，因此使用兼容版本可以提高扩展性。如果声明了固定版本，其他项目在引用时也必须使用相同的版本，这样的限制会降低扩展性。

接下来看import语句的建议。

建议指定名称导入。这是什么意思呢？我们来看个例子，很多人习惯直接写import "path/to/file.sol";，但现在的建议是最好指定要导入的具体组件名称，比如import { ISomeInterface } from "path/to/file.sol";。这样可以明确知道导入的是什么，避免不必要的混淆。
如果第三方合约存在多个版本时，建议指定版本号。例如OpenZeppelin库，我们可以看到它有很多个不同的版本实现（如5.0.2, 5.0.1, 5.0.0等）。如果不指定版本号，可能在不同时间编译时引用的版本会不同，从而导致代码行为发生变化。因此，建议明确指定所使用的版本号。

不过，如果你引用的第三方库本身没有多个版本，比如Uniswap V3库，它只有一个正式版本1.0.0，那么就不需要指定版本号，这样反而显得多余。

总结一下，以上就是关于合约声明的几个编码规范和建议：

声明SPDX License Identifier。
根据合约类型，声明兼容或固定的编译器版本。
Import语句建议指定名称导入。
当第三方库存在多个版本时，建议指定版本号。

希望这些规范能帮助你写出更清晰、规范的Solidity代码。

20251019

解密以太坊交易的背后：EVM 执行 ERC20 转账全流程

大家好,今天通过一个经典的面试题来介绍以太坊上交易的完整生命周期,尤其是EVM是怎么执行交易的。

经典面试题

**题目:**在以太坊上发送了一个token,比如发送1个ERC20的token,这背后到底发生了什么?

这个题目很难回答,因为可以回答得很简单,也可以回答得很深。你回答的每一个点,其实都可以继续追问其他问题,所以很考验你对以太坊或者EVM链运行的理解。

交易结构

当我们发起一个交易的时候,交易的结构通常是这样:

基本字段

to: 交互的对象地址,假设是USDC的合约地址
data: 函数的ABI编码
- 比如调用transfer函数
- 给Alice发送token
- 金额100
gas limit: gas限制
价格相关: base fee等

交易发起流程

编码和签名
- 对交易内容做RLP编码
- 编码后的数据哈希后用私钥签名
- 假设Bob发起这笔交易,Bob用他的私钥做签名
- 签名后的信息发送到区块链网络
节点验证
- 节点收到交易后首先验证签名
- 验证nonce
- 验证是否有足够的手续费等
- 验证通过后放到待打包的交易池里面
- 从中挑选手续费比较高的交易去打包

EVM执行过程

EVM结构

打包就是执行的过程。当执行智能合约时,会启动一个EVM实例。EVM里面有几个核心组件:

1. 代码区(Code)

存放二进制代码

2. 上下文环境(Context)

每次调用另一个智能合约时,上下文环境会切换
相当于内存里的东西,是易丢失的数据(volatile)

3. 栈结构(Stack)

EVM是一个栈结构的虚拟机

4. 程序计数器(PC - Program Counter)

指向代码执行到哪里
不断指向下一个语句

5. 其他组件

剩余的gas
内存(Memory)

代码加载

当收到一个交易时:

加载合约代码
- 把交易的to地址(USDC)的代码加载到EVM
- 从链的存储空间找到这个地址对应的代码
账户存储结构
- USDC合约有存储空间,包含mapping
- mapping记录了每个用户的balance
- 一个账户有几个属性:
  - 以太坊余额
  - 代码(Code)
  - 状态存储(Storage) - mapping存在这里

函数选择器匹配

USDC代码加载到EVM后,执行流程:

1. 加载calldata

1 2	加载交易的data数据从data中提取前4个字节 → 函数选择器

2. 匹配函数

ERC20里有很多方法
通过switch case依次与合约里的函数匹配
transfer有一个函数选择器(假设是0x…开头)
匹配到对应的方法后,进入该方法

Transfer方法执行

伪字节码流程:

1 2	1. balance[from] -= 100 // from地址减去余额 2. balance[to] += 100 // to地址加上余额

具体的EVM指令:

操作from地址:

1
2
3

1. SLOAD - 加载from在存储的位置,读取数据
2. SUB - 对数据做减法(减100)
3. SSTORE - 存回对应的槽位置

操作to地址:

1
2
3

1. SLOAD - 加载to的余额
2. ADD - 做加法(加100)
3. SSTORE - 存回存储

所有用户的余额都记录在USDC合约里面。

指令执行机制

1. 代码执行

完整的指令块加载到EVM代码区
程序计数器(PC)不断根据指向往后执行
先执行到函数匹配部分
然后跳到对应方法
执行SLOAD、SUB、SSTORE等指令

2. 栈操作

每个PC指令运行时,把数据推到栈里面
因为EVM是栈虚拟机
比如减法:用栈里的两个数做减法
把减法结果重新推到栈里面

3. 数据读写

从存储加载数据
在内存中运算
把结果存回存储

Gas机制

Gas初始化

初始值:

根据交易指定的gas limit
经过验证后扣除一些gas
假设初始给了60K gas
进入EVM执行时还剩50K

Gas消耗

执行规则:

每个EVM指令都有对应的gas消耗
可以在相关网站查到每条指令的gas
比如:
- LOAD(加载内存)
- SLOAD(加载存储)
- 每个都有对应的gas

消耗过程:

每执行一条指令,gas减去对应消耗
要么程序全部执行完
要么gas不够了直接退出

实际消耗示例

假设:

开始给了60K gas
执行到末尾还剩1K gas
实际消耗: 60K - 1K = 59K gas
用户需要为59K gas支付手续费

手续费计算

Gas价格参数

交易包含两个价格参数:

maxFeePerGas: 最大gas费用
maxPriorityFeePerGas: 优先级费用(tips fee)

计算示例

假设:

最大费用(maxFeePerGas): 10 Gwei
优先级费用(maxPriorityFeePerGas): 2 Gwei
当前base fee: 7 Gwei

判断:

base fee(7) + priority fee(2) = 9 Gwei
9 Gwei < maxFeePerGas(10 Gwei) ✓

实际支付:

手续费 = 实际消耗gas × 实际gas价格
实际gas价格 = 9 Gwei
Bob支付的手续费 = 59K × 9 Gwei

费用分配

销毁和奖励:

base fee部分(7 Gwei)被销毁
priority fee部分(2 Gwei)给矿工/验证者

计算:

销毁: 59K × 7 Gwei
矿工获得: 59K × 2 Gwei

执行结束

返回值处理

执行到结束会有返回值
函数里定义的参数和返回值通过memory存储
通过memory把数据返回

完整流程总结

构造交易并签名
发送到网络,节点验证
放入交易池,等待打包
EVM加载合约代码
匹配函数选择器
执行字节码指令
操作栈和存储
消耗gas
返回结果
支付手续费

这就是完整的EVM执行ERC20转账的逻辑。

视频分享到这里,谢谢大家,拜拜!

通过面试题深入理解 EVM 存储布局

大家好,今天来聊一下EVM的存储布局。

面试题背景

之前有学员遇到这样的问题:面试官问他,在可升级的合约里面有一个mapping,这个mapping的value类型是结构体,那请问在升级后的版本里面,可不可以在这个结构体里面添加一个变量?

这个问题很考验大家对EVM存储布局的理解。

合约升级的基本规则

安全的添加方式

首先来看什么情况下,在升级后的合约里面添加变量是安全的。

示例合约V1版本:

contract V1 {
    address owner;   // 槽位0
    uint256 amount;  // 槽位1
}

升级到V2版本:

在合约升级时,存储变量要对齐。添加变量时,只能在后面添加变量:

contract V2 {
    address owner;   // 槽位0
    uint256 amount;  // 槽位1
    uint256 x;       // 槽位2 ✓ 正确:在后面添加
}

错误的添加方式

不能在中间或前面添加:

如果在中间添加变量,或在前面添加变量
那新变量会占据原来owner的位置
导致数据错位

存储槽的分配机制

变量会按顺序在存储槽里面分配:

第一个变量对应槽位0
第二个变量对应槽位1
以此类推

槽位空间范围:

非常大的空间,范围是2^256

错误示例:

contract V2_Wrong {
    uint256 x;       // 槽位0 - 占据了原来owner的位置!
    address owner;   // 槽位1 - 被挤到下面
    uint256 amount;  // 槽位2 - 被挤到下面
}

这样X会对应着原来owner的数据,会出现莫名其妙的问题。

Mapping的存储布局

现在情况更复杂,涉及mapping和结构体。我们要清楚结构体以及mapping的数据是怎么存的。

结构体的存储方式

定义结构体:

struct User {
    uint256 account;
    uint256 age;
}

如果直接定义User类型变量:

1
2
3

address owner;    // 槽位0
uint256 amount;   // 槽位1
User user;        // 槽位2-3

User在第2个槽位开始,占据两个槽:

槽位2: account
槽位3: age

Mapping + 结构体的存储

更复杂的情况:

1
2
3

address owner;              // 槽位0
uint256 amount;             // 槽位1
mapping(uint => User) users; // 槽位2(仅占位,实际数据离散存储)

Mapping元素的存储位置计算

问题: users[0]存在哪里? users[1]又存在哪里?

答案: Mapping的长度是变化的,我们不知道它有多少个元素,不能连续存储。

原因:

如果连续往后存,假设users后面有一个变量x
那么x就没办法存了,因为不知道mapping有多少数量

实际存储方式 - 离散存储:

users本身在槽位2,但实际数据是离散存储的。

users[0]的槽位计算:

1 2	槽位 = keccak256(key拼接slot) = keccak256(0 拼接 2)

这个哈希值作为它真正的存储位置,假设计算结果落在某个空间位置。

因为User占两个槽,所以users[0]占据两个连续槽:

计算出的槽位: account
计算出的槽位+1: age

users[1]的槽位计算:

1	槽位 = keccak256(1 拼接 2)

同样计算出一个哈希值作为存储位置,占据两个连续槽。

离散存储的特点

可以理解为:

像沙滩里面的沙子,每个沙子是一个存储空间
每个沙子都是独立的、离散的
每个mapping元素都离散地分布在2^256这个巨大空间里

为什么不会冲突:

这个空间非常大
冲突概率忽略不计

优势:

不会影响后续定义的变量
添加元素不会把后面定义的变量顶掉

回答原问题:能否在结构体中添加成员

场景:Mapping + 结构体

mapping(uint => User) users;

struct User {
    uint256 account;
    uint256 age;
}

问题: 可不可以在User结构体里面添加一个成员变量?如果可以,添加在哪里?

分析

因为结构体内部的内容是连续存储的:

每个User占据连续的槽位
account和age是连续存放的

错误方式:在中间添加

struct User {
    uint256 account;
    uint256 active;  // ✗ 错误:在中间添加
    uint256 age;
}

问题:

现在占了三个空间
active会取到原来age的值
程序会造成莫名其妙的错误

正确方式:在末尾添加

struct User {
    uint256 account;
    uint256 age;
    uint256 active;  // ✓ 正确:在末尾添加
}

为什么安全:

前面两个数据还是在原来的位置上
因为key不变,还是会在原来的槽位上
只要在末尾,不和原来的数据冲突,可以安全添加
只是刚开始这个值没有数据而已

结论: 在末尾添加是安全的。

追问:如果是数组呢?

问题升级

如果不是mapping,而是数组:

1
2
3

address owner;    // 槽位0
uint256 amount;   // 槽位1
User[] users;     // 槽位2(起始位置)

问题: 可以往这个结构体里面添加成员吗?

数组的存储方式

数组在EVM里是连续存储的:

存储规则:

槽位2存储的是数组的起始位置
实际数据从keccak256(2)开始连续存储

假设起始位置计算结果在某个位置:

users[0] - 连续槽
users[1] - 连续槽
users[2] - 连续槽
...

数组会连续分配一段空间,元素依次存放。

能否添加成员?

答案:不能(一般情况)

原因:
不管往结构体里面添加什么数据:

添加到开头:新数据会把age覆盖掉
添加到中间:新数据会把age覆盖掉,age会把下一个users元素的数据覆盖掉
添加到末尾:age会把下一个users元素的数据覆盖掉

因为数组是连续存储,添加成员会导致所有后续数据错位。

特殊情况:可以添加

唯一可行的情况:添加小类型变量,与现有变量共用槽位

struct User {
    uint256 account;  // 256位
    uint256 age;      // 256位
    bool isActive;    // 8位 - 可以添加!
}

为什么可以:

account占一个完整槽(256位)
age和isActive共用一个槽
- age: 248位
- isActive: 8位
- 总共256位

三个变量占两个槽,没有增加槽的数量。

注意:

这种方式可以添加
但会让程序变得很复杂
可读性不是很好

变量合并规则

重要原则:
两个变量如果合在一起没有超过256位,它们会合并共用一个槽。

总结

Mapping的情况

✓ 可以在结构体末尾添加成员
✗ 不能在中间或开头添加
原因:每个元素离散存储,互不影响

数组的情况

✗ 一般不能添加成员
✓ 特殊情况:添加小类型变量与现有变量共用槽位
原因:数组连续存储,添加成员会导致数据错位

关键知识点

1. 存储槽分配:

变量按顺序占用槽位(0, 1, 2…)
每个槽256位

2. Mapping存储:

本身占一个槽位
实际数据离散存储
位置 = keccak256(key + slot)

3. 数组存储:

本身占一个槽位
实际数据连续存储
起始位置 = keccak256(slot)

4. 结构体存储:

内部成员连续存储
多个成员可能共用一个槽(总共不超过256位)

如果能讲到这些,面试官会明白你对存储布局已经非常了解了。

今天就分享到这里!

最小代理合约的原理和运用

课件位置：https://learnblockchain.cn/activity/77

大家好,我是33357。今天给大家讲解最小代理合约的原理和应用。

为什么讲最小代理合约

首先,最小代理合约可以节约部署一个代理合约的gas费,因为它可以做到一个最小的gas消耗。

EIP标准

最小代理合约是一个EIP标准:

EIP-1167: 最早的最小代理合约标准
EIP-7511: 最近0xAA提出的改进版本
- 主要因为以太坊升级增加了PUSH0指令
- 可以用PUSH0直接做一些操作,比之前更省gas

看到0xAA提出了EIP,我在想大家也可以试试去提一个EIP。毕竟年纪也都差不多,都是国内的开发者。

学习价值

最小代理合约作为学习OP code的案例非常适合:

比较简单
比较通用,很多人都用得上
功能比较通用
有很多使用场景

什么是最小合约

最小合约分两部分:

部署gas最小 - 目前一般指这个
执行gas最小

只要能做到部署的gas费最少,基本上就是最小代理。

技术的比喻

我这次画的不是饼,是一口锅。技术就像一口锅:

光有热锅,没有水和面,做不出饼
光有技术,没有其他资源(资金、市场),做不出利润
个人使用这口锅能做出什么,还要看个人手艺

做了这么多年智能合约工程师,我认为技术能做的比较有限。技术只是给大家一个工具,这工具怎么使用、能有多大用,要看大家个人发挥。

什么是代理合约

代理合约分为两部分:

Proxy代理合约 - 存储数据
逻辑合约 - 存储逻辑

为什么需要代理合约

智能合约是不能修改的。为了实现可升级,把不可升级的合约变成可升级合约,必须要用到代理合约。

工作原理

代理合约把一个合约分成两个部分:

存储合约(Proxy): 存储数据
逻辑合约: 部署逻辑

执行流程:

调用者调用代理合约
代理合约通过delegatecall调用逻辑合约
delegatecall让代理合约去执行逻辑合约的代码

可以理解为:把一个合约分成两部分,一部分用来做数据存储,另一部分用来做计算执行。存储的数据和执行的计算分开。

升级优势

做合约升级时:

可以把逻辑合约替换掉
数据还存在代理合约里面,不会变
代理合约地址不会变

资金安全:

资金存在代理合约地址
以太坊、USDT等代币存储地址都是代理合约地址
每次更新逻辑,逻辑合约地址虽然换了,但代理合约地址不变
资金一直掌握在代理合约地址上
升级时资金不用动,更加安全

安全隐患

目前很多链上项目都是可升级合约。可升级合约虽然方便,但也有安全隐患:

主要风险:

逻辑合约可以随时改
比如投资某个币或池子,如果项目方更改了合约
随时可以按修改后的规则把资金提走
原来没有权限提的,升级一下逻辑合约就能提走了

安全措施:

时间锁
多签
确保项目官方不能那么容易就做合约升级

代理合约的模式

代理合约分了一些其他模式:

透明代理
信标代理
最小代理(本次重点)

最小代理的特点

最小代理也是一种代理方式,但和可升级的不一样。

与普通代理的区别

代理合约特点:

必须把逻辑合约的地址存在代理合约里面

最小代理特点:

为了达到最小,把逻辑合约地址写死了
逻辑合约地址不能改
代码不能改(除非用selfdestruct,但以太坊升级后会删掉这功能)

优缺点

优点:

部署gas成本低
执行合约代码的gas成本低

缺点:

不能修改逻辑合约地址
没有管理员

这很好理解:修改逻辑合约地址肯定要有管理员许可,既然没有设定管理员,自然就不能修改逻辑合约地址。

使用场景

为什么不直接部署逻辑合约?

最小代理有特别的功能:

如果想要部署很多代理合约
但逻辑很复杂
想省gas去部署很多执行相同代码的合约

举例:

部署一个逻辑合约需要10000 gas
部署一个最小代理直接代理这个逻辑地址只要100 gas
可以拥有很多合约地址,但部署概率更低
多个代理地址指向同一个逻辑地址

理解字节码基础

想从字节码层面理解智能合约,需要了解:

堆栈(Stack)
内存(Memory)
存储(Storage)
OP code概念

可以参考EVM code相关网站,上面讲得比较详细。

最小代理合约的字节码

最小代理合约的字节码总共45个字节。接下来会分析这一串代码到底是什么意思,怎么写出来的。

四个执行步骤

看起来很长一串代码,其实总共只有四个步骤:

第一步:复制calldata到内存
第二步:执行delegatecall
第三步:复制returndata到内存
第四步:返回数据或回滚交易

字节码结构说明

每行包含:

执行位置 - 0, 1, 2, 3…顺序执行
字节码 - 一个操作按一个字节存储(8位),用两个16进制表示
OP code名字 - 每个字节码对应一个操作名
堆栈 - 所有操作都要先压入堆栈
内存
说明

堆栈机制

重要概念:

所有操作的数据要先加入堆栈,然后才能执行
目前只有16个可操作的堆栈位置
写智能合约时经常出现stack too deep(堆栈溢出16个)
就是因为一下压入的数据太多,超出了EVM的规范限制

内存机制

跟计算机内存差不多的理解
把比较长的数据保存在内存里
执行结束后自动消失

第一步:复制calldata到内存

执行流程

位置0: 0x36 - CALLDATASIZE

获取calldata的size(交易数据的长度)
把这个长度压入堆栈

位置1: 0x5F - PUSH0

将0压入堆栈

位置2: 0x5F - PUSH0

再将0压入堆栈

位置3: 0x37 - CALLDATACOPY

将前面三个数据作为参数执行
从左到右读取数据

CALLDATACOPY参数

参数说明:

destOffset: 内存的目标地址(这里是0)
offset: calldata的起始位置(这里是0)
size: calldata的大小

执行结果:
将0到calldata size的数据,复制到从0开始的内存空间。

本来calldata在交易上,现在把它成功复制到合约执行的内存里面。

第二步:执行delegatecall

执行流程

位置4: 0x5F - PUSH0

位置5: 0x5F - PUSH0

位置6: 0x36 - CALLDATASIZE

位置7: 0x5F - PUSH0

位置8: 0x73…20字节 - PUSH20

将逻辑合约地址(20个字节)压入堆栈

位置29: 0x5A - GAS

将剩余的gas加入堆栈

位置30: 0xF4 - DELEGATECALL

执行delegatecall

DELEGATECALL参数

参数比较多,需要详细讲解:

gas: 执行delegatecall需要给的gas
address: 指定的逻辑合约地址
argsOffset: 参数在内存的起始位置
argsSize: 参数占内存的大小
retOffset: 返回值的位置
retSize: 返回值的大小

本例中的参数:

gas: 默认gas
address: PUSH20时直接压入的地址
argsOffset: 0
argsSize: calldata size
retOffset: 0
retSize: 0

执行效果:
将0到calldata size的内存数据作为参数,执行指定地址的代码。

执行结果

执行完成后:

将执行是否成功记为success
压入堆栈
作为参数执行完后,数据会自动清除
delegatecall会自动将执行是否成功的结果(0或1)加入堆栈
可以判断堆栈顶的数字是0还是1来判断执行是否成功

第三步:复制returndata到内存

因为执行delegatecall后有返回值,返回值要处理的话,也要把它复制到内存。

执行流程

位置31: 0x3D - RETURNDATASIZE

获取返回值的大小
压入堆栈

位置32: 0x5F - PUSH0

位置33: 0x5F - PUSH0

位置34: 0x3E - RETURNDATACOPY

将0到returndata size的returndata
复制到从0开始的内存空间

RETURNDATACOPY参数

参数说明:

destOffset: 要复制到内存的目标地址
offset: returndata的起始位置
size: returndata的大小

注意:
内存中的calldata被returndata覆盖掉了,因为calldata现在已经没用了。

执行完后,三个参数被清除,只剩下一个success结果在堆栈。

第四步:返回数据或回滚交易

这部分做判断,判断交易是否成功:

成功就返回returndata
不成功就回滚交易

执行流程

位置35: 0x5F - PUSH0

位置36: 0x3D - RETURNDATASIZE

将returndata的size加入堆栈

位置37: 0x91 - SWAP2

将堆栈的第一个元素和第三个元素互换
success和returndata size做了个调换

位置38: 0x602A - PUSH1 0x2A

将0x2A压入堆栈

JUMPI指令详解

位置40: 0x57 - JUMPI

JUMPI需要详细讲解:

因为在汇编语言中没有if判断或for循环的高级语言结构
只有跳转代码
JUMPI是一个跳转指令

参数:

counter: 跳转的位置(这里是0x2A)
b: 条件判断

执行逻辑:

如果第二个参数b是true,就跳转到counter位置
如果是false,就不跳转,继续往下执行

本例中:

堆栈有0x2A和success
判断success(第二个位置的参数)是true还是false
如果true,跳转到0x2A位置

跳转目标

位置42: 0x5B - JUMPDEST

跳转的目标位置必须有一个接收函数
不能随便跳,要有这个接收函数才能跳到这个地方,否则报错

两种结果

如果delegatecall执行失败(success为false):

直接执行位置41的代码
0xFD - REVERT: 返回0到returndata size的内存数据,并且回滚交易状态

如果delegatecall执行成功(success为true):

跳转到位置42(0x2A)
执行JUMPDEST后继续往下
0xF3 - RETURN: 正常返回0到returndata size的内存数据

完整逻辑总结

整个代理合约分四步:

复制calldata到内存 - 获取参数
执行delegatecall - 调用逻辑合约,用自身的合约环境
复制returndata到内存 - 获取返回值
返回内存数据或回滚交易 - 检查执行是否成功

这个逻辑应该不算很难。通过这四步,实现了一个比较完整的代理合约逻辑。

为什么是最小代理

直接用字节码写
比较简洁,没有什么多余的操作
没有编译器的中间环节
是一个非常完整的代理合约
所有代理合约的功能基本上都可以实现

部署最小代理合约的字节码

Init Code和Runtime Code的区别

部署合约时:

先执行init code
init code的执行结果的返回值就是runtime code
runtime code才是真正被部署在合约上的字节码

举例:
写合约时有初始化过程,比如把msg.sender赋值给管理员,这是在init code里做的操作。Runtime code是init code的返回值。

部署代码结构

要部署最小代理合约到一个地址上,不能直接部署,要有部署代码。在运行时代码前面加一小串作为init code。

Init Code执行流程

位置0: 0x602C - PUSH1 0x2C

将0x2C加入堆栈

位置2: 0x80 - DUP1

复制堆栈的第一个元素,并加入堆栈
变成两个0x2C

位置3: 0x6009 - PUSH1 0x09

将0x09压入堆栈

位置5: 0x5F - PUSH0

将0压入堆栈

位置6: 0x39 - CODECOPY

CODECOPY参数

三个参数:

destOffset: 要复制到的目标地址
offset: code的起始地址
size: code的大小

执行效果:
将0x09到0x2C的code(附属上去的部署代码那一串),复制到从0开始的内存空间。

位置7: 0x5F - PUSH0

位置8: 0xF3 - RETURN

将0到0x2C的内存数据返回

Init Code的任务

Init code执行的任务:

把code复制过来
然后返回它
其实就两个操作

部署过程:

执行的是整个一大串代码
但真正部署在地址上的是它的返回结果
从0x09开始的那一段才是要部署的代码
前面的是返回操作

0x2C的含义

0x2C不是位置,是大小
从0x09开始数0x2C个大小(44个位置)
所以是从0x09开始的

Gas消耗

部署合约时最消耗gas的部分:

不是整个一串
是真正保存在合约地址上的代码
真正部署在合约历史上的代码gas消耗最多
前面init code只是执行,不会保存在合约地址上
前面那一串的gas花费很少

重要原理:
要理解存储和执行的概念差别非常大:

执行一个代码可能只消耗十几个gas
但存储这一串代码就是几千几万gas

最小代理的gas优化:

前面init code消耗少
但后面runtime code部署时消耗较多
做gas优化最好从存储角度优化,效果最好
存储节省的空间要比单纯执行节省的多得多
存储消耗的gas比执行大很多

为什么用操作码

这里用了calldata size和code size等操作码,直接用这些操作比复制更方便。

优化技巧:
尽量用原有的操作。比如获取msg.sender:

有人可能把msg.sender复制给一个变量owner
再去读owner
这样要先复制给内存,用时再从内存复制到堆栈,绕了一圈
直接使用msg.sender操作就直接到这一步了

虽然优化不了多少,但在OP code里面直接有的操作,直接用比辗转要好一点。

存储和调用的区别

存储:

可能只对发布人消耗多
只消耗一次
对调用者不关心

调用:

只要调用都会消耗
调用时也会修改存储
具体场景具体分析

Gas成本和任务计算

在测试网上测试的结果:

部署成本

总计: 41,028 gas

最小代理字节码部署: 8,828 gas
create和create2固定消耗: 32,000 gas
其他: 200 gas

执行成本

调用空函数: 192+ gas

delegatecall固定消耗: 100 gas
其他数据消耗

create和create2: 32,000+ gas

调用一个函数最基本也是32,000 gas,不可能一个字都不写。

与普通代理对比

相比一般用Solidity写的代理合约(基本上都是十几万往上),最小代理的gas成本非常少。

优化历程

做gas优化时:

一开始用Solidity写
后来用Yul写
最后用汇编(Assembly)写

汇编比较接近于直接用字节码写。

Gas单位说明

gas limit的单位就是直接算个数
到时候乘以gas price
要分清楚gas limit和gas price
EVM code上定义的就是mini gas
真正算价格时要乘以gas price

最小代理合约应用

1. 挖Token

场景:
链上有很多挖矿项目(如XEN):

模式是用一个账号去挖,用gas去挖
过了锁定期,可以把它提出来
合约里没有限制合约地址能不能挖

使用私钥地址的问题:

比较浪费gas
需要做归集操作
- 先归集以太坊
- 再归集代币
- 因为一个地址做swap很亏,要归集起来再swap
- 这又是一笔消耗

使用最小代理的优势:

批量部署:

一次能部署100多个地址
一个交易就可以完成

操作便捷:

挖的时候是一次操作
提取的时候也是一次操作

冷热地址机制:
以太坊上做交易时:

第一次交互某个合约地址是冷地址,多消耗2,000 gas
在同一个transaction里第二次或第三次交互这个合约,变成热地址,少消耗2,000 gas

Gas返还机制(已废除):

以前为了鼓励节约存储
从0变到非0收20,000 gas
从非0变成0返还一半gas
如果分两笔交易,这个差别会比在同一笔交易里大很多

Gas Token(已废除):

2020-2021年还有点用
利用了以太坊的返还机制
合约地址selfdestruct销毁时会返还gas
把非零数值改成0也会返还gas
现在升级后,返还机制被改掉了
以太坊开发者说会有很多垃圾交易,所以把返还机制废除了
现在性价比不高,用的人很少

2. 抢NFT

应用场景:
有些空投可以用合约地址来绕过限制。

SEN合约案例:

1 2	claimRank() // 没有限制msg.sender是不是合约地址 claimReward() // 也没有限制

可以用合约创建地址去调用这些函数。

BEANZ NFT案例:

之前发过NFT空投
随便谁都可以mint
但限制一个地址最多mint三个
没检查msg.sender是不是合约地址
可以用这个方法绕过地址限制

操作方式:

一次申请给100个合约地址
100个合约地址去交互
不需要把币打到100个地址上去
只要有这个地址的权限就可以交互
gas由主账户(tx.origin)出,不是msg.sender

Gas优势:

不光是冷地址问题
发起一次交易还有21,000的交易费
如果用合约,能省一半以上的gas
前提是合约没有限制不能用合约地址
如果做了限制,就只能用外部地址一个个去操作

3. 子合约

钱包应用:
想做钱包应用,比如多签钱包、AA钱包:

每个用户注册一个钱包
给他分配一个地址
可以用最小代理合约
因为部署的gas最小

注意:
可升级不太好做。

4. 批量发行Token

应用:
做逻辑差不多的token:

可以弄很多地址
逻辑都是一样的

5. 发行NFT

应用:

做好逻辑地址
发很多代理地址
代理地址功能都是一模一样的
定制化不太多

能否做出比最小代理更小的合约

这是一个扩展话题。

功能阉割

最小代理合约分四部分:

复制calldata到内存
执行delegatecall
复制returndata
返回returndata或回滚

这个功能比较全,但如果想阉割掉一些功能,可以做得比它更小。

优化方案

1. 不要calldata

只有一个函数,只要一个功能
其他功能没有意义
可以把位置0-3这四个字节全部删掉

2. 不要return

不要返回值,执行就好了
可以把复制returndata的部分删掉
后面的return也可以删掉

3. 不要指定逻辑合约地址

PUSH20部署时gas消耗最长
这20个字节是最长的一段
节省gas最多的方法

替换方案:
用msg.sender替换掉逻辑地址:

谁调用它,谁就是它的逻辑地址
但这样没有任何权限了
谁都可以用
如果有人看到代码,可能攻击你
没那么安全

4. 删除回滚检查

如果比较自信
可以把检查success的部分删掉
不检查是否成功,默认成功了

优化结果

虽然能做得更小,但整体通用性变差。如果完全不需要什么通用性,只是用来做单一功能,可以做改造。

改造效果:

目前8,828 gas可以降到5,000多
执行的话可以降到140

总结

祝大家能用好这口锅(这个工具)。工具到底怎么用、怎么赚钱,靠大家自己。

关于提EIP

我在想怎么提一个EIP。你们有提过EIP吗?

EIP提案机制:

它只是一个通用标准
比如ERC-20
如果大家都一直用这个标准,把它推到生态里面
大家可以一起用

提案难点:

现在提的太多了,每天都有很多
如果提一个没有人讨论、没有人关注,也没意义

EIP分类:

有些是协议标准(底层改变)
有些是应用标准(如ERC-304,跟底层没关系)

通过之后:

要大家一起用
有些人不做这个库,或没做这个通用标准,也没什么用

现在分类:

协议标准:一般人都提不了协议的
应用标准:提应用标准,让人一起用

比如ERC-777,如果大家都没人用,就像茅台埋在地窖,别人不知道你有,也就没意义了。

好的,我接受录制了。

Hardhat的基本使用

Hardhat简介

Hardhat是一个智能合约开发的脚手架工具,就像盖大楼前需要先搭架子一样。它会预先创建好相关的目录结构,包括contract目录、deploy目录、test目录以及其他相关配置。这样开发者在写智能合约时,只需要关注业务逻辑和功能,而测试、部署等细节问题都由Hardhat解决。

对于任何成熟的项目,都会有Quick Start(快速上手)文档。Hardhat的快速上手文档虽然只有一篇,但包含了最核心和最重要的功能。如果想深入了解,还有更详细的文档说明。基本上花一个小时跟着Quick Start过一遍,就能了解项目的使用方法。

安装和初始化

环境准备

Hardhat是一个JavaScript库,需要在本地电脑上安装Node.js。

安装Hardhat

在空目录下执行安装命令。可以使用npm或yarn(yarn是多线程并行处理,安装速度更快):

1	yarn add hardhat

如果安装包比较慢,可以配置国内镜像源(如淘宝npm镜像),这样就相当于请求国内网络,速度会更快。

安装完成后,会生成node_modules文件夹和package.json文件。

初始化项目

执行初始化命令:

1	npx hardhat init

初始化时会有四个选项:

创建JavaScript项目(推荐选择)
创建TypeScript项目
TypeScript + Viem
Empty(空项目)

建议选择第一个JavaScript项目,比较简单且足够使用。

接下来的配置:

项目根路径: 默认为当前目录
添加.gitignore文件: 选择Yes。gitignore文件的作用是在git commit时,忽略指定的文件(如编译产生的文件、node_modules等),这些文件不会被推送到代码仓库

配置完成后,会安装项目依赖的各种包。

项目目录结构

初始化完成后的目录结构:

contracts目录

存放智能合约。默认生成一个示例合约Lock.sol,这是一个锁仓合约:

创建合约时附加以太坊平台币,并设定锁仓期限(unlock_time)
平台币锁定在智能合约中
到期后可以通过withdraw方法提取
会验证当前时间是否大于锁仓时间,以及调用者是否是owner

scripts目录

存放JavaScript脚本,包括deploy.js部署脚本:

引入库
设定常量(锁仓时间、锁仓数量等)
部署合约
等待部署完成
打印相关信息(使用console.log)

test目录

存放测试代码。测试代码量通常是合约代码的3-4倍,因为需要验证方方面面:

事件测试
方法测试
requirement验证测试

虽然测试代码比较繁琐,但在智能合约开发中必须完成。示例中Lock合约34行代码,对应的测试代码有126行。

其他文件和目录

node_modules: 存放Node.js的包,可以随时联网安装,不需要上传到代码仓库
.env: 存放敏感信息(如私钥)的文件。通过环境变量方式读取,比直接写在代码里更安全。这是开发智能合约的最佳实践,避免将敏感信息不小心上传到GitHub
.gitignore: 指定哪些文件不被推送到代码仓库(如node_modules、编译产生的文件等)
artifacts: 编译时生成的文件夹
cache: 编译时生成的缓存文件夹
package.json: 类似Python的requirements.txt,记录项目依赖包及版本。别人拿到这个文件后,可以安装相同的依赖包来运行项目
README.md: 项目说明文件
yarn.lock: 版本锁定文件

Hardhat任务

Hardhat以任务(task)形式组织功能。查看所有可用任务:

1	npx hardhat

常用任务包括:

compile: 编译
test: 测试
clean: 清理
console: 控制台
flatten: 扁平化(将多个相互依赖的合约合并成一个文件,方便验证或混淆依赖关系)

编译

执行编译任务:

1	npx hardhat compile

编译成功后会生成两个文件夹:

artifacts: 包含编译后的结果
cache: 缓存文件

这两个文件夹已经被写入.gitignore,不会提交到代码仓库。

ABI文件

在artifacts目录下可以找到编译后的ABI(Application Binary Interface)。例如Lock.json文件包含:

abi: 合约对外交互的接口描述
bytecode: 字节码

ABI的作用:

智能合约工程师需要提供给前端/后端两个数据:已部署的合约地址和ABI
ABI描述了如何与合约交互,包括方法名、输入参数、输出参数、是否需要支付等
前端/后端只需要ABI和地址,就可以与合约交互,不需要了解合约内部实现

链上合约交互:
即使不知道链上合约的源码,只要知道ABI,就可以与合约交互。甚至可以通过分析交易,推测参数和返回值,自己构造ABI来交互。这也是一些黑客的攻击方式——对未开源的合约,通过逆向工程构造ABI进行交互。

测试

执行测试任务:

1	npx hardhat test

调试技巧:使用console.log

Hardhat提供了在智能合约中打印状态的方法,用于调试:

在合约中导入Hardhat的console库:

1	import "hardhat/console.sol";

在合约方法中使用console.log打印状态:

1 2	console.log("Unlock time is", unlockTime); console.log("Current block timestamp", block.timestamp);

运行测试时就能看到打印的信息

这是Hardhat提供的特殊功能,在Remix IDE中不容易实现。

部署

本地部署

运行部署脚本:

1	npx hardhat run scripts/deploy.js

默认部署到本地虚拟机。

启动Hardhat节点

Hardhat提供了本地虚拟机,类似Remix IDE的Remix VM:

1	npx hardhat node

启动后会:

在本地8545端口启动HTTP和WebSocket服务(127.0.0.1:8545)
提供20个测试地址(从0到19)
每个地址有10000个ETH

查看启动信息:
由于信息显示很快,可以使用管道和more命令查看:

1	npx hardhat node \| more

Remix IDE连接Hardhat节点

Remix IDE可以连接Hardhat的本地节点:

在Remix的Environment选项中选择”Hardhat Provider”
连接到HTTP://127.0.0.1:8545
可以看到20个地址,每个有10000个以太坊

这样Hardhat本地环境和Remix就联动起来了,工具组合使用会更强大。

部署到测试网

要部署到测试网(如OKC测试网),需要修改hardhat.config.js配置文件:

module.exports = {
  solidity: "0.8.0",
  networks: {
    localhost: {
      url: "http://127.0.0.1:8545"
    },
    okc_testnet: {
      url: "OKC测试网RPC URL",
      chainId: OKC链ID,
      gasPrice: gas价格,
      accounts: [私钥]
    }
  }
};

重要的安全实践:
不应该直接将私钥写在配置文件中,正确的做法是:

将私钥存放在.env文件中
在配置文件中通过process.env读取环境变量
这样代码传给别人时,不会泄露私钥

部署到指定网络:

1	npx hardhat run scripts/deploy.js --network okc_testnet

问题排查案例

遇到的问题

部署到OKC测试网时报错:

1	provider error: too many arguments, one wanted

排查步骤

分析错误信息: 提示参数太多,但本地部署没问题,说明合约和部署脚本没问题
搜索错误: 将错误信息放到Google搜索,找到Hardhat官方GitHub仓库的issue
查看讨论: 发现其他人也遇到同样问题,都是在部署到OKC链时发生。部署到以太坊测试网没问题,说明是OKC的问题
找到解决方案: 有人建议在deploy contract方法中添加gasLimit参数,因为OKC使用的版本较低,不支持eth_estimateGas方法
应用解决方案: 在部署脚本中添加gasLimit参数:

const lock = await Lock.deploy(unlockTime, { 
  value: lockedAmount,
  gasLimit: 某个值
});

验证成功: 部署成功后,到OKC测试网浏览器查询合约地址,确认部署成功

经验总结

遇到错误时的解决方法:

遇到的问题99.99%别人都遇到过
直接搜索英文资料,质量最高
去官方GitHub仓库的issues查找
这些是信息的源头,给出的答案质量最高

不要只搜中文资料:

很多问题没有被翻译成中文
搜中文网站可能找不到解决方案
直接看官方文档和issues更有效

总结

Hardhat的基本使用涵盖:

安装和初始化
目录结构理解
编译、测试、部署流程
本地节点启动和使用
与Remix IDE联动
部署到测试网
问题排查和解决

这些是智能合约开发中能涉及到的核心用法,掌握后就可以进行完整的智能合约开发工作了。

Web3 远程就业 & 项目接单：Solana 狙击机器人自动化分析与交易需求分析、项目设计、DEX Swap 功能演示

前言

Hello，大家好，我是秀才。今天呢我给大家再分享一下，就是 Web3 项目接单这块儿的一个汇总。如果大家对这块感兴趣的话，请关注下我。

这块我们准备给大家准备了一个 Solana DAPP 开发的项目框架。如果大家对我这个项目比较感兴趣的话，可以参与进来。

秀才给大家画了几个模块：

第一个是左边的菜单栏
第二个是我们的钱包开发
第三个是我们的交易记录
第四个是我们这边的 Tab 页

如果大家对这块非常感兴趣的话，可以关注一下我，然后支持这块的讲解。

项目接单列表

OK，let’s go。下面的话就是有几个项目接单的列表，我把这块的项目接单的功能都给它梳理好了。

大家可以看到 Solana 相关的一些项目的话非常多。首先最比较火的就是现在比较火的：

1. 狙击机器人 - 自动化分析和交易

这是一个狙击机器人，自动化分析和交易的需求，这块的话非常的巨大。很多人都希望能做一个这个工具，这属于一个工具。

2. 以太坊 Uniswap DAPP 平台开发

基于 Base L2 这个公链上面的合约开发，以及它的 DEX 开发和/或者说 DeFi 平台的搭建。

3. Solana 狙击手

也是一个狙击机器人，它要实现自动购买、自动卖出的功能。

4. 以太坊上面的 NFT 迁移

主导发币。

5. 网站开发

这块的话秀才也有一个专门的网站。

技术栈要求

在这里的话，秀才也给大家准备了一个非常专业的网站。如果你会点：

Java
Go 语言
Solidity
Rust
React
前端技术
Flutter
iOS/Android
Node
C++

那么你对这个 Web3 行业感兴趣，想从 Web2 转向 Web3 应用，成为一个优秀的 Web3 开发工程师，那么请关注一下我。这里的话就是加入进来，立即开始学习，请联系一下我。

Solana 狙击机器人需求详解

其实大家对这个需求了解不多的话，咱们今天就以一个 Solana 狙击机器人、这个自动化分析和交易这个需求，来给大家系统讲解一下如何去做项目接单和一些保障你的项目，进行远程面试或远程就业这块的指导。

项目背景

我们先了解一下这个需求。他说了，我们正在寻找一个高级的区块链后端开发和量化分析师。

该工具可以：

利用历史记录
钱包的一些活动数量
来对 Meme 币进行一些抢购条件
通过评分算法和机器学习模型，来支持交易进行处理的交验

这块他已经介绍了，这是一个基于 Solana 的生态。他说这不是一个基础的流动性机器人。

核心功能要求

如果你想要实现这个功能的话，你必须要有：

1. 钱包及行为分析能力

2. 智能提取数据能力
对 Pump.fun 和 Raydium 这个 DEX 的智能提取数据。

3. 延迟敏感执行能力

4. 链上模式的掌握
对于这个链上的一些模式，非常的清晰掌握。

5. 构建交易模拟引擎
你需要构建一个以 Solana 为中心的 Trade Simulation Engine，也就是交易模拟引擎，固定交易逻辑（Fix the trade logic）。

6. 实时代币发布检测
Real-time token launch detect，就是实时代币的发布检测和一个 Score System。

这块也是大多数老板，还有一些喜欢玩这个交易的小伙伴们，他们对这个非常的——需求量非常大。

7. 钱包评分逻辑
比如说 ROI、胜率、基本资本的部署、可信度，这块他们也需要有一些这种评分逻辑。

8. 高潜力代币过滤
需要过滤高潜力的代币的轻量级预测模型（Filters high-potential token prediction model）。

9. 自动化卖出逻辑
甚至就是说你可以狙击到这个，像他这种自动化进行卖出的逻辑和回撤的跟踪，这块也是非常的重要。就是你狙击了之后，你能自动化地去进行一些交易，然后还有就是回撤。

10. 代码质量要求
对代码的质量，比如说你的模块化、代码效率，以及他这块也非常要求比较高。

11. UI 仪表盘
以及我们的 UI 的仪表盘，他希望在后台有一个 UI 的仪表盘，然后在那里能够展示。

12. 链上数据监控
你具有这个需要连接 Solana，然后去进行链上数据监控。

13. 代币评分系统
从帮助代币的发币，或者说执行这些特征，然后根据这个历史表现，为交易者提供一些这个代币的实时评分。

14. 训练模型
比如说他需要你参考这个 XGBoost 是吧，还有一个固定的 Meme 币的交易启动模拟。

其实他这里说了很多，也需要就是说怎么去实现这个功能呢？这也是我们做这个 Web3 项目一个简单的、重要的考量。

系统设计方案

技术架构

好的，今天呢我们再给大家分享一下，就是基于 Go 语言和 Web3 开发，这个自动化交易的机器人的分析和自动化交易系统的实现方案。

上个视频我们不是讲了这个需求嘛，这块需求的话，我们结合我们现有的技术栈，还有一个就是我们现有的框架，基于这个 Go 语言和 Solana Web3，开发了一个这样的技术栈，来开发它。

主要涉及到这几个功能：

1. 数据获取
我们先把这个数据获取下来。

2. 特征提取

3. 模拟回测

4. 自动交易
以及它的自动交易的完整的架构。

系统架构详细说明

数据接入：
我们需要接入这两个：

一个是 Raydium
一个是 Pump.fun

需要 Solana 的 WebSocket，以及我们这边的历史数据特征，还有就是执行校验。

模块设计与实现

模块一：数据接入

数据接入的话，需要在这个 DEX 的链上监听。它需要干什么？需要就是实时的连接这个 Phantom，还有就是这个 Raydium 的监听，比如说你个代币创建，还有一个钱包交易。

这块还有一个，它使用了这个 Go 的 WebSocket 去监听这个扫描，一个就是 Slot，还有一个就是 Transaction。这块也很重要。

还有就是使用这个 Solana 的 JSON RPC，用我们 Solana Go SDK 进行拉取数据。

如果大家对这个模块比较感兴趣的话，可以联系一下我，我们进行就是在这个 DAPP 项目上面开发，然后把这个数据抓起来抓取出来，然后再往这个 DAPP 上面进行开发。比如说我们这块的数据抓取，就是抓取链上，我们在这个上面进行开发。

模块二：特征提取

这个模块，我们需要从这个交易中提取一些结构化特征，包括：

钱包行为字段：
（比如说这几个字段）

代币初期的数据：
（比如说这几个字段）

如果你对这个模块比较感兴趣的话，可以联系一下我，我们进行合作进行二次开发。

模块三：模拟回测

经过这些数据，进行回测，就是模拟它的交易。通过把这些历史数据拉取下来，我们去根据一些策略，固定一些策略，然后进行交易的胜率和回撤。

这也是模拟机器人还要去做的一个功能。如果大家对这个项目比较感兴趣的话，我们可以在这个项目上面进行二次开发，把这个数据拉取下来，根据一个策略，根据一个胜率、回撤，然后进行自动一个模拟。

模块四：代币评分

如果大家对这个比较感兴趣的话，就是它的需求，就是判断这个代币是否能够狙击，还有就是这个钱包质量这些，还有一些流动性的深度，它都是通过一些大模型因子。

可以利用这个 XGBoost，如果你对这个算法，还对这个大模型比较感兴趣，也可以参与进来，通过这个 AI，然后加上这些 Web3 的技术，实现这块的功能。

这一块也是非常的难。如果你对这块——如果你有这个能力的话，请联系一下我，我们一起合作，我把 Web3 的知识，和你这个 AI 的知识我们进行结合，把这个模块给它实现。

模块五：自动化交易执行

最后一个模块就是自动化交易的执行模块，这个也是最关键的，也是这个我要给大家着重讲解。

主要就是：

他怎么样执行买
怎么执行卖
怎么样去自动去调用钱包交易
还有卖出的逻辑

比如说前期你学了这个充值、转账、提现，钱包的开发，那么后面的话就要实现一个自动的买、自动的卖。这个是需要通过 Swap，因为他们监测的这个数据，全都是进流动性的数据，流动性拿出来之后，你要进行 Swap。

项目阶段规划

在讲这个自动化交易之前的话，我们对这个项目阶段进行一下规划：

第一个阶段：
数据接入加 Token 监听

第二个阶段：
钱包、代币分析和模块

第三个阶段：
模拟器

第四个阶段：
自动交易加 UI

UI 这块我给大家准备好了，自动化交易，这也是我们现在要去给大家讲的，这个也不难，我给大家系统讲解一下。

Swap 功能演示

以太坊 Swap 演示

如果你想学这个自动化交易的话，来到这个场景和应用场景，还有就是这个以太坊这个场景，它俩这个场景里面包含了这个进行 Swap 相关的功能。

如果大家对这个 Swap 这块不太懂的话，这边我们给大家提供了一个以太坊的 Swap，大家系统学习。

这边是一个以太坊，这边是个 Solana，主要先给大家看一下以太坊这边的功能。因为 Solana V3，因为最终要做这个狙击机器人的话，一定要实现这个 Swap 功能。

Swap 功能在这边的话，就是我们有一个系统的课程。如果大家对这个 Swap 感兴趣的话，我们先给大家展示一下这块。这个的话也是我们一个最主要的核心内容。

连接钱包
它需要连接下这个钱包。先要学习这个网页版，学完了之后，我们再做这个手机版。手机版的话也非常简单，只需要连接到我们 Go 服务器，Go 服务器进行——你看这个页面，这个页面就是我们一个钱包里面，最主要的一个 Swap，进行一个支付。

Swap 界面功能

你用的是什么代币
你接收什么代币
还有一个代币的列表，这个都是从链上数据抓取下来

这个功能的话到时候可以给大家展示一下。我们这个网页版，现在的话以以太坊为例。

价格换算演示
比如说我输一个一块钱，稍等一下，这里现在就变成了一个 2.67769ETH。这里我们——如果你不输的话，这里就不会让你点。你输了话，这里他会进一个价格的换算，和我们这边网页版一样，就是你输了这里，它自动会换算。你这里用的是什么币，这里是用的什么币，它都给你换算一下。

Swap 核心概念
我拿笔再给大家讲一下，这块非常重要。这是一个 Swap：

这块你去付多少钱
你接收多少钱
这是你的余额

现在我这边的余额就没有了，先给大家展示一下。如果你输了之后，这个按钮就会亮。

Swap 交易流程

现在我们网页版去进行 Swap 一下，这里的话就有一个让大家直观的感受。

机器人买卖逻辑
你去调这个 Swap，最终这个机器人他要去买卖，他怎么去买卖的？无非就是说：

你把你这块 SOL，或者你把你这块 USDT/USDC，把这个 SOL 给卖进去
买的话就是通过 USDT 或者 USDC，买个什么代币，比如说这个 SOL 代币

比如说我这边的，你去花多少钱。首先你去 Swap 的时候，他先要去调一下这个以太坊这边的 Approve 接口，Approve 接口完了之后，他去授权你这个网站。

交易费用
这里面有一些费用：

Gas 费
Master 费
还有一些其他的费

这里面有几个字段，我点一下这个 Confirm，稍等一下。主要就是给大家展示一下这个 Swap。

交易确认演示

刚才 Swap 一半，在这里还要确认一下。这里的话会有——先看一下，刚才他让我进行二次确认，我就二次确认一下。稍等一下，这里的话待会它会有一个提示。

OK，这里有个交易哈希（Transaction Hash）确认，这里的话需要在这个 Etherscan 上面进行查看。这个查看的话就是需要在这个钱包，要找到这个 MetaMask 钱包。

我把这里再放大一下，找一下这个 MetaMask 钱包，稍等一下。这个 MetaMask 钱包里面，我们能看到他的到底有没有交易成功。

这里有个交易详情，我们稍等一下。这里 Confirm 成功了，有一笔失败了，我们需要看一下这个记录。

查看链上交易记录
刚才这个交易成功之后，这边有一个交易哈希，这个交易哈希，这里面可以查看到这个链上的交易记录，还有一些费用，还有一些其他一些费用。如果大家感兴趣可以点一下看一下。

GitHub 仓库与学习资源

最后的话就是给大家再科普一下，我们这边有一个 GitHub 上面的仓库，这个仓库里面我们会提供一些：

项目源码
项目的代码
文档
视频

包括 DAPP 开发远程就业十天的内容，不止十天，后面还会继续加。

代码展示
还有就是我们的代码，Solana DAPP，你看到这个项目，你能看到这个项目它怎么运行，全都是代码在这里。还有就是合约代码在这。

如果你对这个比较感兴趣的话，我们可以提供一些文档和代码，还有一些视频，专门去辅助你学习这块，做一个自动化交易的狙击机器人。

后续规划

后面我们结合这个项目架构，刚才那个开发周期通过前端，还有就是合约，还有后端，怎么去把这个数据抓起来，进行模拟交易，这个是后面的预告。

如果大家感兴趣的话，赶紧加入进来，我们系统学习这个 Web3 技术。学完之后你可以：

远程就业
项目接单

余额变化验证
你看这里余额就变了，这个余额就加了，有没有发现？这块的话，这里变了，这里加了。大家觉得这个项目怎么样？

如果对这个项目比较感兴趣的话，我甚至可以把这块代码开放给大家。这块代码也是我们在 GitHub 上面有个私有仓库，你对我进行关注，给我点赞，让更多人参与下，然后加入到这个秀才 Web3 大师之路这个社区，我们进行更多的系统交流学习。

学习资源与课程大纲

后面再讲一下质押，还有就是我们的交易自动化交易，通过 Go 语言进行实现，而这只是一个开端。

希望大家对这个频道感兴趣，对我这个 Web3 项目频道，这个网页上面的频道感兴趣，我们进行合作。

100 天 Web3 全栈开发大纲
这还有 100 天的 Web3 全栈开发的大纲，还有就是这边的就是非常多。如果大家对这个比较感兴趣的话，我会把这些视频都发布到这个网站上面，这个 Solana 高级开发这个专辑，大家就能近距离地去学习这块。

反馈与互动
上个视频我发了之后，很多——播放量还可以，也有一些粉丝朋友们进行关注一下我，联系一下我。这也是我要做这个初衷，如果做就是一定要做一些这种干货分享，带着大家进行一起做项目，手把手的进行教。你学会了之后的话，你也可以跟我一样，一起接单。

你看这些文档都非常专业，还有就是一些功能都非常全。如果你对这块比较感兴趣的话，就联系我。

总结

好的，这个视频我们就分享到这了。这个视频有一二十分钟，大家就是每个视频大家细看，从第一分钟看到最后一分钟，对你有些启发。

好的，我们今天这个视频我就分享到这里，谢谢大家观看，我们下期见，拜拜！

别再给黑客送钱了！详解常见重入攻击手段与防范策略 | 链上安全

一、什么是重入攻击及经典案例

重入攻击，顾名思义，就是重复进入的一种递归攻击。重入攻击最早开始于The DAO事件。

重入攻击最开始是由于Solidity的一个语言特性——智能合约在接收转账时会触发fallback函数。这个fallback函数早期应用于合约接收以太坊后自动触发一些行为逻辑。但在The DAO攻击事件发生后，fallback更多地被理解为与重入攻击挂钩。

随着ERC-721、ERC-1155等协议的增多，现在重入攻击不仅仅发生在以太坊转账，在ERC-721、ERC-1155等高级协议中也存在重入风险。

尽管这种攻击事件最早发生在2016年，但现在重入攻击事件也是屡见不鲜。比如2022年发生的一些重入事件：

7月11号，经过Beosin的EagleEye监测，Omni合约遭受了重入攻击事件，黑客获利约425个以太坊
4月30号，Fei Protocol的一个池子也遭受了重入攻击事件，黑客获利更多，达到了28,380个以太坊，价值8034万美元

The DAO事件回顾

The DAO事件在以太坊整个历史发展中是一个值得回顾的事件，因为本次事件导致了以太坊硬分叉，促使以太坊分裂成ETC和ETH两条链。这是以太坊上最早的重入攻击事件。

重入攻击不仅发生在Solidity语言中，在其他语言的链上也有可能导致重入攻击事件的发生。

二、重入攻击详细讲解

2.1 以太坊经典重入攻击

The DAO事件是由一个德国创业公司使用的DAO合约，由于以太坊转账的程序设计不合理，导致了重入攻击事件。

攻击原理示例

左边是一个参照The DAO事件写的简单被攻击合约，右边是含有重入攻击漏洞的攻击合约。

被攻击合约分析：

这是一个非常简单的合约，存在一个mapping用来记录在合约里存储的以太坊余额。合约包含简单的deposit和withdraw函数，实现存取功能。

balance记录存储的余额
当外部调用者调用deposit函数时，会附加以太坊，并用变量存储发送者存入的余额
withdraw函数用于提取存入到本合约的余额

漏洞关键点：

注意观察withdraw函数，它有一个提取余额的函数msg.sender.call{value}()，这个函数的作用是将合约里的以太坊发送给调用者。

关键问题在于：发送完余额后，才更新合约里的账本，减去调用者提取后的余额。

当余额发给接收者对象（如果是合约）时，会触发fallback函数。在攻击合约的fallback函数中，攻击者可以编写恶意回调逻辑，再次调用withdraw函数。

由于在fallback函数调用后，balance账户余额实际上并没有发生改变，导致可以通过require判断，从而导致重入攻击的发生。

攻击流程：

调用withdraw后，合约会调用攻击合约的fallback函数
fallback函数中又调用withdraw函数
在程序结构顺序上导致递归产生
由于withdraw里面调用了目标合约的fallback函数，并且fallback函数写入了恶意回调逻辑，从而导致攻击事件发生

2.2 ERC-721/ERC-1155/ERC-777的重入风险

随着NFT标准出来后，像ERC-721、ERC-1155，以及ERC-20的扩展标准ERC-777，都仿照fallback函数实现了一种高级转账特性。

当转发ERC-721 NFT或ERC-1155时，如果转账对象是合约，都会call目标转账合约里的特别接口函数，即receive函数。

三个标准的回调函数：

ERC-721：onERC721Received函数
ERC-777：实现了ERC-777转账的回调通知函数
ERC-1155：
- 单个转账函数
- 批量转账函数

因此，尽管是代币和NFT，也有可能发生重入风险。原因在于转账后会调用目标的通知函数。

会调用通知函数的方法：

ERC-721：safeTransferFrom、safeMint等函数，在向合约转账时
ERC-777：send、transfer、operatorSend、mint等函数，在向合约转账或铸币时
ERC-1155：在向合约转账或铸币时

如果在这些通知函数里写入了回调逻辑，便有可能发生重入风险。

为什么带”safe”的函数反而不安全？

以safeTransferFrom和safeMint为例：

在safeTransferFrom函数中，它调用了内部的_safeTransferFrom函数。在转账发生后，会调用目标合约的onERC721Received函数，去检查目标合约是否实现了这个接收函数。

通过调用目标函数的selector来判断合约是否实现了高级转账通知功能，从而满足了重入攻击的特性——调用目标的某个函数。

2.3 ERC-721空投合约重入攻击案例

被攻击合约分析：

左边是一个简单的空投合约，有一个airdrop函数。在airdrop函数中调用safeMint来向调用者铸造NFT并发送。

重入漏洞原因：

调用safeMint铸币后，会调用目标合约的onERC721Received接口
攻击合约会实现这个接口
合约有两个账本来记录空投数量和是否领取过空投

关键点：

调用airdrop后，先检查被调用者是否已经领取过空投。当第一次调用airdrop时，条件满足（为false，表示没领过空投），然后调用safeMint向目标铸造空投。

当调用到onERC721Received函数后，这个函数又反过来调用airdrop，导致记录是否领取空投的变量状态始终为false，从而可以经过检查，导致重入攻击发生。

攻击逻辑：

调用airdrop
airdrop调用safeMint铸币
safeMint为实现高级转账，调用checkOnERC721Received函数
这个函数再次调用攻击者的onERC721Received
攻击者提前写好恶意回调逻辑
形成递归调用，绕过检查
导致ERC-721重入攻击发生

2.4 真实案例：Idols NFT商城重入攻击

这个重入事件是Idols NFT商城的重入攻击漏洞。

buyGood函数分析：

这个函数用来购买NFT商品。值得注意的是，在这个存在重入漏洞的合约中，和刚才的ERC-721重入攻击demo非常类似：

在函数调用开始之前进行各种账本变量检查
检查完后，将商品发送给调用者
完成后才进行账本变更

这里就产生了可能导致重入攻击的风险。

第二个函数：acceptOffer

这个函数用于接受商品的出价，由卖家控制。在这个函数中：

开始前检查账本变量
将NFT发送给购买者
删除带有这个goodId的账本
判断为false

这个变量记录NFT的奖励。

攻击原理：

这两个函数可能导致重入攻击。在buyGood函数中，删除账本是在调用safeTransferFrom之后进行的。

当攻击者调用buyGood购买这个goodId，拥有了NFT后，攻击者再用acceptOffer函数反向将购买的NFT打入到卖家里。当卖家和buyGood的seller一致时（这是非常特殊的情况），就可能造成无限调用这两个函数。

由于这两个函数在调用后才删除账本变量，使得检查可以通过。随着迭代次数增加，奖励值会不断累加，直到累加到合约上限，然后一次性提取合约的以太坊。

这个漏洞和NFT漏洞非常类似，都是调用了safeTransferFrom。

2.5 非标准代币重入攻击

除了上述例子外，还有一些开发者非常容易忽视的重入情况。

Fake ERC-20案例：

这是一个容易忽视的重入合约。合约记录了用户是否交换过fake代币。

exchange函数会将外部调用传入的地址发送给这个合约，然后本合约将fake代币按1:1比例铸造并发送给调用者。

重入风险所在：

非常值得注意的是，exchange的地址参数是用户输入的。既然是用户输入，那有没有可能用户输入一个非标准的ERC-20代币？实际上是有可能的。

可以写一个继承了ERC-20接口的合约，来实现safeTransferFrom函数接口。

攻击合约分析：

攻击合约写了两个函数：

攻击开始函数
transferFrom函数

有意思的是，这个transferFrom并不是严格的ERC-20函数，而是攻击者自己写的逻辑。在transferFrom函数里，又返回调用了exchange函数，从而导致递归调用。

即便不是ERC-721或ERC-1155函数，完全信任用户输入的地址也会导致重入发生。

攻击思路：

调用attack函数，它会调用exchange
exchange会调用目标发过来的地址（攻击地址）
调用攻击地址的transferFrom，再回过去调用exchange
导致账本变量（是否交换过代币）始终为false
导致require判断条件无效
可以不断循环递归
递归完后账本变量才改变
导致被外部控制地址的重入事件发生

2.6 真实借贷协议重入案例

这个案例不是凭空得来的。在今年的一次重入事件中，观察到了相关借贷协议的重入事件发生。

在交易中发现了特别奇怪的现象：在第一次deposit之后，发生了两次铸币。

代码分析：

通过对该协议的代码分析，发现：

deposit函数里的token地址是被攻击者传入的
deposit函数又调用了depositToProtocol函数
这个函数又调用了token里的另外一个函数
然后铸造了平台代币

漏洞关键点：

在depositToProtocol函数里，调用了目标的safeTransferFrom。这个函数由目标传入的地址来将用户存入的代币发给协议地址。

发送完后再次铸造凭证币。因此在这次攻击事件中，攻击者重写了safeTransferFrom，把这个函数的逻辑反过来调用deposit，导致了循环递归调用。

三、安全审计中如何避免重入攻击

3.1 重入攻击的特点总结

通过三个例子的总结，可以发现重入攻击的特点：

未按检查-生效-交互模式设计：合约并未严格按照”检查-生效-交互”模式来设计转账函数或交互函数
调用目标合约函数：一定是调用了目标合约的某个函数，并且这个函数被攻击者所控制

重入攻击的两个必要特性：

递归
在交互还没有生效之前进行检查

因此，不仅在以太坊Solidity语言有重入漏洞风险，其他实现了高级调用或转账通知的链也可能存在重入漏洞。

3.2 安全审计如何发现重入漏洞

1. 工具检测

通过安全工具检测，能够把常见的以太坊转账重入漏洞，以及ERC-721、ERC-777等高级特性标准的重入漏洞扫描出来。

2. 人工审计

在人工审计时，严格注重代码实现的顺序，要求项目方严格按照”检查-生效-交互”方式来设计合约函数。

3. 输入数据验证

对合约输入的数据都进行严格的检查和测试。因为从安全角度来说，攻击的发生点一定是在输入数据之后，这个数据可以触发某个漏洞。

在审计过程中，对用户需要输入的参数基本上都不完全信任，对每一个参数都进行检查。

4. 风险预警系统

7x24小时风险预警系统可以在重入攻击发生后提供事件预警。

5. 形式化验证和模糊测试

Beosin审计团队采用形式化验证工具以及模糊测试来保证合约代码安全性。

6. 多环节审计

审计过程中至少有五个环节的审计步骤，结合扫描工具和安全专家，依靠工具和人工验证两种方式交叉验证合约安全性。

利用混合引擎进行自动化检测测试验证，来证明这些可重入的安全变量，有效发现智能合约中新的微妙漏洞。

7. 全面审计服务

包括智能合约安全审计、后门审计、闪电贷攻击审计等一系列审计。审计完成后，出具全面的安全审计报告。

3.3 Beosin EagleEye监测工具

Beosin EagleEye系统提供7x24小时实时风险预警。平台使用AI技术，不仅可以自动监测合约安全，也可以监控链上运行状态和实时交易。

欢迎大家使用Beosin EagleEye检测工具。

下一期课程将针对闪电贷和业务逻辑漏洞的防范进行讲解。

不止套利！闪电贷竟然可以做这么多事！详解闪电贷攻击手段 Part1

课程介绍

这是BuidlerDAO和Beosin以及小幽灵社区联合推出的链上安全系列课。第一堂课讲了重入攻击内容，第二堂课由Beosin的高级审计专家Frank老师带来，讲解闪电贷的基本攻击原理、链上的防范和缓解措施。

今天主要分享三大块内容：

什么是闪电贷，闪电贷与区块链安全
如何缓解闪电贷攻击
如何监控闪电贷攻击

一、什么是闪电贷

1.1 闪电贷的概念与特性

闪电贷这门协议实际上是2018年就提出来了，它和传统借贷有所不同。传统借贷一般需要抵押品，但依靠区块链技术以及智能合约语言的特别优势，在以太坊以及现在的其他链（如BSC等）都用到了闪电贷技术。

闪电贷在区块链上具有以下三种特性：

第一，无抵押贷款
闪电贷不需要任何抵押，不需要任何资金、token或相关token等，都可以获得你想要的token，用来做套利等操作。

第二，依靠智能合约实现
闪电贷依靠区块链上的智能合约来实现功能。

第三，及时性（”闪电”特性）
贷款过程是即时的，需要在一个区块内完成贷款和还款。在区块链里一个区块，快的话像Solana可能在400ms左右就可以执行一笔交易，慢一点的如以太坊现在也有12-13秒左右，一笔交易就可以完成。

针对传统贷款来说，闪电贷的优势特别明显，还款和借款的速度非常快。

交易回滚特性
根据合约语言的特性，交易失败会回滚。在闪电贷安全性方面，如果整个交易中存款和贷款之间达不到一定条件，这笔交易会自动回滚，一定程度上保证了闪电贷协议的安全性。

因此，闪电贷是在以太坊等公链或DeFi出来的时候，一种创新性的零风险贷款。

1.2 常见闪电贷实现

Uniswap闪电贷

Uniswap对于大多数人而言应该是很多人都知道的代币交换协议，它实际上也存在闪电贷功能。功能实现是在Uniswap的swap函数里面，在swap函数里有一个data参数，它会在借贷之后调用目标的一个function，实现闪电贷功能。

传统交易 vs 闪电贷交易对比：

以Uniswap的DAI和ETH交易池为例：

传统方式：
如果想用代币去做一些合约或业务，需要用ETH去兑换DAI，收取0.3%的手续费，把ETH换成DAI，然后拿代币去实现所需的业务。

使用闪电贷：
不需要质押任何东西，直接调用Uniswap闪电贷函数，把想要借贷的东西借出来（比如DAI或ETH）。可以实现零抵押把池子里的代币借出来，然后做想做的业务（比如套利等）。做完之后，只需要把本金和利息还回去，就实现了业务流程。

Uniswap闪电贷函数实现分析

swap函数参数：

amount0Out / amount1Out：需要借贷A还是B
to：接收方的地址
data：接收合约的参数（通过编码形式传进去）

执行流程：

第一步：校验参数
校验兑换数量参数是否合法，以及可借贷的数量、池子里储备金（两种代币的储备金）是多少。

第二步：判断地址合法性
判断to地址是否合法。

第三步：快速转账（核心特点）
判断to地址合法后，直接使用safeTransfer把所需token直接打给调用者。这里突出了第一个特点——非常及时、快速。

第四步：回调执行（闪电贷核心）
如果data的长度大于零，会调用to地址的uniswapV2Call接口或函数。这里可以发现Uniswap的闪电贷需要目标函数实现uniswapV2Call这样的接口。

闪电贷的逻辑业务（包括套利等业务逻辑）实际上是在借贷出代币后的uniswapV2Call函数里实现的。如果涉及攻击，也是通过调用目标的这个地址来实现闪电贷攻击。

第五步：余额校验
调用完后，会校验token0或token1的余额，为下一步还款做准备。

第六步：还款验证
在swap里面，需要校验储备金，检查还款后的金额是否大于贷款加上费用部分，以验证是否已经还款。

这说明在调用目标的uniswapV2Call接口之后，在这个接口里需要做的事情是：实现业务合约，执行完业务合约后，需要把还款和费用还回给pair。

第七步：K值校验和更新储备金
进行K值校验以及更新储备金。

总结：
经过swap函数分析，可以总结为三点：

快速借贷
调用目标合约接口，在接口里实现业务逻辑（可能是套利等）
还款

Aave闪电贷

Aave也是一个经典的闪电贷协议，实际上也非常清楚，和Uniswap差不多。

flashLoan函数参数：

receiverAddress：接收地址（和swap里的to地址类似）
asset：需要借贷的token地址
amount：需要借多少
params：接收方法参数（用于跨合约调用时传参）

执行流程：

第一步：查询流动性
查询可借贷的流动性究竟是多少，判断池子里储备的流动性是否足够，即是否大于等于所需借贷数量。

第二步：计算费用
计算借贷费用。特别需要注意的是，在Aave里费用分为两部分：

借贷费用
协议费用

这和Uniswap不同的地方体现在：第一是费用结构，第二是token类型（Aave支持多种token）。

第三步：转账
把token地址实例化后，调用transferToUser，把借的代币转给目标。

第四步：跨合约调用
转账后，跨合约调用目标的执行闪电贷接口函数。

第五步：还款校验
执行完业务后，和Uniswap一样，会校验是否还款，是否已经付清费用。

第六步：更新状态
更新闪电贷合约的状态。

总结：
通过这两个闪电贷可以看出，闪电贷实际上是一个非常方便且实用的功能，无非就是一个快速借贷的功能。

二、闪电贷与区块链安全

2.1 闪电贷攻击现状

**问题来了：**既然闪电贷只是方便借贷，然后把借贷的钱去做想做的事情（也可能是套利），再把钱还回来，为什么还会有闪电贷攻击这个说法呢？

闪电贷本身是一个DeFi金融产品，方便了借贷。但随着发展，也被应用到漏洞攻击上面。

2022年上半年统计数据：

使用闪电贷进行黑客攻击的案例将近20余次
占比26.6%（基本占了1/3左右）
涉及金额达到3.329亿美元

常见攻击组合：

闪电贷 + 治理攻击
闪电贷 + 价格操纵攻击
闪电贷 + 重入攻击

这些是目前闪电贷攻击手法中影响巨大的攻击事件。

2.2 案例一：闪电贷 + 逻辑漏洞攻击（2021年6月23日）

攻击概况：
位于币安智能链的稳定币平台（现改为Binance）遭受闪电贷加逻辑漏洞攻击，损失高达460万美元。

漏洞分析

有问题的代码：
问题出现在紧急销毁（相当于紧急提取）函数中。

代码逻辑很简单：

查询调用者的余额
把质押在合约里的token转出来
触发一个事件

对比正常提取函数：
与正常的DAO治理提取函数相比，功能实现差不多，但有一个关键不同：

**致命漏洞：**紧急销毁时，没有销毁存放在合约中的流动性凭证（shares）。

这个shares是什么？在抵押品里，会根据抵押的数量进行分红，这些分红用shares表示。shares代表分红份额或股份，用流动性数量来计算。

**问题关键：**没有销毁流动性，导致份额计算错误。

那么流动性从哪里来？质押代币从哪来？
这就是闪电贷的用武之地。

攻击流程

第一步：获取LP代币
攻击者从稳定币池里兑换了流动性代币（LP token），并将其兑换成攻击所需的流动性代币。

第二步：质押LP代币
攻击者把兑换出来的流动性代币全部质押到具有漏洞的合约里。此时攻击者有了shares。

通过闪电贷创造了攻击条件——拥有shares。

第三步：重复提取
攻击者调用紧急提取函数，重复两次把质押的241万LP流动性代币提取出来。由于没有销毁shares，可以重复提取。

根据链上交易可以看到，攻击者重复调用了两次函数，获得了两倍的LP token（相当于赚了一倍LP token）。

第四步：兑换和还款
把所有攻击得到的LP token兑换成BUSD，用于偿还闪电贷。这是与借贷时相反的操作：把LP代币兑换成BUSD，还给提供闪电贷协议的地址。

第五步：获利
最后，把获利部分发给攻击者。

攻击特征总结

在闪电贷攻击里有非常明显的特征：一借一还。

在这个案例中，闪电贷本身只提供了借钱功能，给攻击者创造了条件。真正的漏洞点还是在合约本身。

2.3 案例二：闪电贷 + 治理攻击（2022年4月17日）

攻击概况：
某项目遭受闪电贷加治理攻击，黑客获利7600万美元，协议损失更大。

背景信息

在攻击发生之前，攻击者已经提交了提案。在这个治理合约中有一个限定：需要治理有一天的延迟。

攻击者提前提交了两个提案：

提案一：提取合约里的所有钱
提案二：将25万美元的代币发送给乌克兰捐赠地址（涉及俄乌冲突）

漏洞分析

第一个函数：投票记录函数（recordVote）
计票方式是查询投票代币账户的余额。

第二个函数：紧急执行函数（emergencyExecute）

需要通过的条件：

必须是一个没有受限制的提案
超过了直接锁定的时间阈值（需要提前一天投票，需要大于一天的时间）
第三个条件
**问题关键：**投票的票数是否大于既定的投票阈值

漏洞所在：
投票方式是通过查询余额，而余额可以通过闪电贷快速获得，因此这个限制形同虚设。

攻击流程

第一步：准备初始资金
攻击者从混币器获得了初始资金，用于部署合约。因为新建的地址上没有原生代币用来部署合约，需要获得初始资金。为了逃脱监管，攻击者使用了Tornado Cash混币器。

第二步：借贷大量资金
利用闪电贷借到了超过10亿的资金。这里体现了闪电贷的特点：借贷数额只要满足池子的需求或最大数量，实际上都可以借出来。这里的资金类型非常多，仅仅是为攻击做第一步初始化，创建第一个条件。

关于执行时间的问题：
有人问：执行这么多操作不会超时吗？

实际上所有操作是在一笔交易里完成的，都是在闪电贷接口里面完成的。在区块链里实际上没有”超时”这个说法。

区块链上所有交易能否执行成功，不是看时间，而是看账户是否支付了这笔交易所需执行的gas费用。gas衡量一笔交易所需花费的计算资源。如果计算资源足够，不超过最大的gas limit，那么交易尽管看起来很复杂，仍然能够执行成功，而且执行完成几乎是在一瞬间完成。

所以”超时”这个说法是不存在的。

第三步：获取投票代币
攻击者需要获得投票权代币。这个代币是一种流动性代币。

攻击者把借贷出来的资金：

创建了三种代币的交易对
获得了CRV的流动性代币
这种流动性代币又可以去质押兑换出LUSD
将另外一部分CRV代币换成其他代币

可以发现在链上交易中，攻击者发起攻击时进行了很多交易兑换，所有目的就是获得投票代币。攻击者获得了两种投票代币。

满足攻击条件：
攻击者的第一个条件满足了——有足够的代币余额去支撑，回到之前说的有足够的余额来绕过投票阈值检查。

第四步：投票和执行
进行投票，然后将协议合约里的所有代币都转移到了黑客部署的合约中，最后成功获利。

案例总结

通过第二个例子可以看到，闪电贷实际上还是为攻击创造了一种条件。

小结

今天分享了两个闪电贷攻击案例：

闪电贷 + 逻辑漏洞：利用紧急提取函数没有销毁份额的漏洞
闪电贷 + 治理攻击：利用投票机制基于余额的漏洞

两个案例都体现了闪电贷的作用：为攻击创造条件，提供大量资金。真正的漏洞还是在项目合约本身。

（未完待续，Part 2将继续讲解如何缓解和监控闪电贷攻击）

毒上加毒！当闪电贷遇上重入攻击！详解闪电贷攻击手段 Part2 | 链上安全

案例三：闪电贷 + 价格操纵攻击

3.1 攻击背景

这个项目虽然损失比较小，但被拿来作为案例，是因为它与传统的预言机设计形成了鲜明的反差。

3.2 漏洞分析

问题函数：收藏函数

这个函数的作用很简单：会根据你持有的NFT，给你发送持有NFT的奖励。函数里写了很多逻辑来分配这个奖励的费用。

关键漏洞点：

问题出在计算PCD（代币）价格的地方，也就是价格预言机出现了问题。

价格获取函数分析：

查看getPrice这个函数，发现它调用了另一个函数来获取PCD价格。问题在于：

查询代币的余额
计算代币的价值

计算方式存在问题：
价格 = USDT价格 × 1e18 / PCD数量

既然是除以PCD的数量，那只要想办法操纵PCD数量，就可以操纵价格。

这里操纵的是LP（流动性代币）池子里面的数量。 PCD是流动性代币池子里的数量，它根据流动性池子里的实际数量来计算外部价值。因此可以通过控制外部LP池子里的数量，进一步控制价格。

3.3 攻击流程

第一步：利用闪电贷操纵价格

攻击的核心思路：如何以较少的钱去购买较多的PCD？

答案：把PCD的价格压低。

具体操作：

使用闪电贷把池子里的USDT大量套出来
为什么要大量套出来？因为在swap机制中，如果想要兑换USDT，必须向合约里注入大量的PCD
这个协议类似Uniswap，可以从交易池子里面交换两种代币

第二步：增加PCD数量，降低价格

第一笔交易支付了大量PCD（这些PCD从最开始的初始资金兑换过来）
通过闪电贷把USDT套出来后，池子里的PCD数量剧增
根据公式，PCD数量增多，分母变大，价值就减小
此时PCD价格急剧减少

第三步：低价购买PCD

由于池子数量发生变化，价格也发生了变化，攻击者调用收藏函数，以极低的价格购买了大量PCD。

特别说明：
这个函数购买的PCD会进行一段时间的锁仓，这也是为什么这笔交易过后，归还了闪电贷之后，攻击者并没有及时把代币收益转发出来。

从调用链里可以看见，攻击者只是简单调用了收藏函数，购买了大量PCD代币。

第四步：还款和价格恢复

攻击者在几天之后：

把锁仓的所有代币解锁
此时PCD价值已经恢复正常

为什么会恢复正常？
因为闪电贷用完之后要归还，把多余的USDT还回去后，PCD就减少了，池子重新平衡，PCD价格又上去了。

第五步：高价卖出获利

攻击者把解锁的PCD通过PancakeSwap卖出，获得巨大利润。

3.4 攻击总结

攻击手法非常巧妙：

通过闪电贷把池子里的USDT套出来
大量增加PCD的数量，导致PCD价格大降
价格下降时，攻击者获得大量PCD
归还闪电贷的USDT后，PCD数量减少
PCD价格恢复到原来的价格
攻击者把获利的PCD解锁，通过外部的PancakeSwap卖出

获利来源：

时间差和价格差
内部价格计算（基于实时数量）vs 外部价格（基于TWAP时间加权平均价格）
两个计算价格的Oracle内部外部的价格差，也让攻击者可以进一步获利

与前面案例的不同：

之前的案例是需要闪电贷某个token去执行攻击，这里的闪电贷可以直接触发漏洞点——通过更改数量来触发漏洞。

启示：

在Oracle设计方面，特别是项目方的Oracle设计：

建议使用时间加权平均价格来进行计算
尽量依靠值得信赖的第三方Oracle查询
自己写Oracle容易出问题

案例四：闪电贷 + 重入攻击（2022年3月15日）

4.1 攻击概况

Omni协议遭受了闪电贷加重入攻击，黑客总共获利800万美元。

4.2 漏洞分析

问题根源：ERC-677 BridgeToken

在ERC-677 BridgeToken的transfer函数中，重写了callAfterTransfer这样一个钩子函数，导致了这次攻击事件的发生。

为什么会导致攻击？

回顾之前讲的重入攻击，重入攻击的第一个条件：在转账或者进行交互之前，会去调用目标合约，基本上就是”transfer and call”这样的行为。

在以太坊中，将以太坊转到一个合约里去，会调用这个合约的fallback函数。ERC-677代币也是这样。

Transfer函数分析：

首先调用transferInternal，这是一个非常简单的transfer实现，就是基本转账——我把代币转给你
问题在于：使用了callAfterTransfer这个钩子

callAfterTransfer的问题：

当to地址为合约时，会调用contractFallback函数。这个函数里调用了onTokenTransfer函数签名。

这个onTokenTransfer是一个非常普通的函数接口：

1	onTokenTransfer(address from, uint256 value, bytes data)

风险所在：

如果调用的目标合约里，这个onTokenTransfer函数是可控的，就可以回调回来，从而形成重入攻击。

因此，ERC-677这个token在这里埋下了一个隐患。

4.3 借贷协议的漏洞

关键函数：borrow函数

在借贷协议里有一个函数调用了这个transfer，我们来看这个借贷协议的函数是怎样实现的。

调用链：

borrow 函数
调用 borrowInternal 函数
调用 borrowFresh 函数

borrowFresh函数分析：

这是一个非常经典的借贷函数：

第一步：检查参数
对参数进行检测，检查是否合法（经典的函数检查）

第二步：转账（问题所在）
马上调用doTransferOut函数

doTransferOut实际上就调用了我们刚才所讲的埋下隐患的ERC-677 BridgeToken的transfer。

第三步：生效（更新状态）
更新账本变量状态，更新借贷账本。这是一个非常简单的借贷逻辑：我把钱借出去，然后记录我的借贷账本。

漏洞关键：

这个函数没有按照”检查-生效-交互”这样的逻辑模式去实现借贷逻辑，而是：

检查
交互（转账）
生效（更新状态）

doTransferOut分析：

直接调用了token的transfer函数。而我们刚才讲过，ERC-677的transfer会有”transfer and call”这种行为。

满足重入攻击的两个条件：

没有按照”检查-生效-交互”模式实现
调用了具有回调功能的transfer函数

导致了这次重入攻击的发生。

4.4 攻击流程

虽然找到了漏洞点，但利用漏洞需要一些条件，攻击者利用闪电贷创造了攻击条件。

第一步：闪电贷借款

攻击者从SushiSwap协议里进行了闪电贷，进行了三笔借贷：

2,090,000 USDC
3,370,000 WBTC
等其他token

为攻击做准备。

第二步：部署多个合约

攻击者部署了多个合约，为什么要创建多个合约？

实际上就是在多个合约中写同样的攻击逻辑，然后用这些钱同时发起攻击。

第三步：重入攻击

在攻击的函数调用链里，可以看到重入攻击的特征：

调用borrow函数
触发contractFallback
在contractFallback里又回调borrow
使得账本还没有生效之前，再次调用borrow函数
绕过检查，实现两倍套利

重入攻击的明显特征：
递归执行函数的执行流特征。

第四步：还款获利

完成攻击后，归还闪电贷，获得利润。

三、如何缓解闪电贷攻击

回顾刚才的案例，特别是第二个案例（使用代币数量投票）和第三个案例（价格操纵），我们可以总结出以下防御措施：

3.1 关键交易需要延时处理

原理：
闪电贷的特点是在一个函数调用、一笔交易里实现逻辑。因此，如何避免在一笔交易里实现逻辑，是防止闪电贷攻击的关键点。

建议：

延迟至少两个区块
在两个区块之间，实际上会有短暂的锁仓
锁定用户价值必须锁定

这样可以阻止闪电贷攻击，因为它违背了闪电贷的第一个原理——在一笔交易里执行完成。

3.2 使用时间加权平均定价（TWAP）

建议来源：
来源于第三个案例，在闪电贷加价格预言机的价格操纵攻击中。

问题：
刚才的价格操纵案例是根据实时数量来计算价格。

TWAP的优点：

可以累积一段时间里的平均价格
计算平均价格
消除某一段时间内的剧烈价格波动

因此推荐使用时间加权平均定价（TWAP）这样的价格计算方式。

3.3 高频率的价格更新机制

为什么需要高频率更新？

当更新次数越多，价格就越准确，使得某一瞬间的价格操纵无效。

3.4 更严格的治理逻辑

适用场景：
实际上放在DAO治理里，很多DAO的提案提交都是根据代币数量去提交的。

建议：

关注提案的合理性
避免出现逻辑漏洞

如果有严谨的审计逻辑，实际上也可以消除这样的微小漏洞。

3.5 从根本上禁止闪电贷调用

实现方式：

使用Solidity语言的特性——追踪调用者或交易的发起源。

代码实现：

1	require(tx.origin == msg.sender)

原理：

msg.sender：在跨合约调用（function call）中，指代的是调用者
tx.origin：交易的发起者

当调用者和交易发起者是同一人（即外部账户EOA账户）时，可以避免跨合约调用。

效果：
闪电贷的逻辑是写在合约里面的，必然会涉及到跨合约调用。用这样一个简单的require就可以直接禁止闪电贷接口调用某个函数。

四、如何监控闪电贷攻击

4.1 Beosin EagleEye工具

在上节课中推荐了由Beosin开发的工具——EagleEye。

功能：

根据相应的标签等去监测或预测链上状态和交易行为
识别异常交易
识别套利攻击
监测私钥泄露
监测资产被盗风险

使用方式：
可以在这个平台上，根据相应的标签去搜索和监控相应的交易，从而捕捉到闪电贷攻击交易。

4.2 Tenderly工具

（课程中提到的另一个工具，用于查看交易详情和调用链）

总结

今天分享了闪电贷攻击的四个案例：

闪电贷 + 逻辑漏洞：紧急提取函数没有销毁份额
闪电贷 + 治理攻击：利用投票机制基于余额的漏洞
闪电贷 + 价格操纵：操纵LP池子数量来操纵价格
闪电贷 + 重入攻击：ERC-677的transfer回调机制配合借贷协议漏洞

防御措施五要点：

关键交易需要延时处理
使用时间加权平均定价（TWAP）
高频率的价格更新机制
更严格的治理逻辑
禁止闪电贷调用（require(tx.origin == msg.sender)）

监控工具：

Beosin EagleEye
Tenderly

今天的分享到这里结束。

Flashbot 隐私节点的运用

会议讨论了以太坊链上交易在公共节点中面临的抢跑、尾随和三明治攻击等安全问题，重点介绍了Flashbots及其隐私节点技术如何通过私有交易池、交易打包、指定执行顺序与区块、自动撤回失败交易等功能来缓解这些问题。同时探讨了隐私节点的工作机制、市场份额变化、使用场景如防止MEV攻击、拯救被盗资产、无Gas交易支持，并分析了当前多隐私节点竞争环境下需向多个节点提交交易以提高成功率的策略。此外还分享了实际套利案例、利润分配方式、节点作恶风险及未来以太坊可能引入的失败交易免Gas机制。

一、MEME Pool与链上攻击

公共节点交易流程

交易发送至MEME Pool后按Gas费排序，高Gas交易优先被矿工打包。
MEME Pool具备筛选交易、按Gas Price排序、广播交易及提供待打包交易给矿工的功能。

链上常见攻击类型

交易抢跑（Front-running）：攻击者监听到有利可图的交易后，以更高Gas费抢先执行，使原交易失败。
交易跟随（Back-running）：攻击者在目标交易后立即执行另一笔交易以获取利润。
三明治攻击（Sandwich Attack）：攻击者在目标交易前后各插入一笔交易，抬高买入价并在高价卖出，从中获利。

滑点机制的滥用

DEX设置滑点容忍范围（如2%），本为保障成交率，但被套利者利用进行价格操纵。

二、Flashbots与隐私节点解决方案

Flashbots核心功能

隐私交易发送：交易不进入公共MEME Pool，仅在确认后广播，避免提前暴露。
多交易打包：支持将多个交易组合成一个包统一发送，实现原子性操作。
指定交易顺序：可设定自身或他人交易的执行顺序，增强控制力。
指定区块与时间：允许交易在特定区块或时间段内执行。
失败交易自动撤回：若无法执行，交易自动取消且不收取Gas费用。

架构与工作流程

Searcher构建交易包 → 发送给Block Builder → Relay中继器汇总 → 提交给验证节点。
多层结构旨在聚合最大价值区块，由出块者选择打包。

经济激励机制

谁提供的区块价值越高，越容易被矿工采纳。
收益部分作为“贿赂”返还给矿工，剩余归Searcher所有。

三、隐私节点生态现状

市场份额分布

Behavior Build占43%，OpenMEV占26%，RSIC占20%，Flashbots仅占2.3%。
隐私节点整体在验证节点中占比高达80%-90%，因能提供更高收益。

使用建议

为提高成功率，应同时向多个主流隐私节点提交交易包。
单一节点成功率低，但失败无成本损失。

四、隐私节点应用场景

防止MEV攻击

利用隐私节点隐藏交易，避免被抢跑或夹击。

拯救被盗资产

通过打包两笔交易：先转入Gas费再提取资金，防止黑客监控并抢先转移。

减少失败交易损失

失败交易不会消耗Gas，降低操作风险。

支持无Gas交易

平台如1inch、CowSwap利用Flashbots技术实现用户签名即完成交易，由第三方代付Gas。

防止NFT/Token Mint被打废

隐私节点可在模拟执行失败时不提交交易，避免无效Gas支出。

五、技术实现与开发实践

接入方式

不同隐私节点API接口类似，基于Flashbots标准开发可兼容多数节点。
需使用专用RPC URL，交易需签名后封装成包发送。

利润分配模式

可通过合约或附加交易将利润分给矿工，支持预付（Gas Fee）或后付（合约转账）。
后付模式成本更低，无需预先持有大量ETH。

节点信任与作恶风险

中心化节点可能存在作恶行为，如私自复制交易套利。
用户无法完全规避此类风险，依赖节点信誉机制。

六、未来趋势与挑战

新型交易类型提案

以太坊计划引入新型交易类型，允许失败交易免缴Gas，减少资源浪费。

节点准入控制

隐私节点可通过IP限制、签名认证等方式防止滥用和垃圾请求。

生态演化

更多验证节点自建MEV模块，导致Flashbots市场份额下降。
出现会员制节点（如BSC 48 Club），通过质押代币获得优先服务。

Claude整理的:

Flashbots与隐私节点技术分享

大家好,我是33357。在座的各位都是builder,但我今天给大家讲一点科学家的东西,就是Flashbots和隐私节点。如果你们想做一点链上的套利,或者科学家类似的事情,Flashbots是必备的工具。隐私节点的好处在于,它跟你们平时用的那些公开节点是不一样的。接下来我就为大家讲解一下这个里面具体的一些细节。

Mempool的功能

首先要讲一下Mempool的一些功能。在以太坊上,你们在发送公共节点发送交易的时候,所有的交易都是先进入Mempool然后再会被矿工打包的。

Mempool有几个功能:

第一个是它可以筛选交易进入判定阶段。你在以太坊上发交易的时候,并不是所有交易都能直接进入Mempool的,它有一个限制,其中最明显的一个就是gas限制。如果你发送交易的gas低于那个base fee per gas,它就不能进入Mempool。因为Mempool要保证它里面存储数量不能太大,要不然太多垃圾交易会堵死它。

第二个是将pending交易按gas price进行排序。Mempool里面的交易会按照gas fee从高到低依次往下排,gas fee越高的交易,它的优先级越高。

第三个功能是广播判定交易。在Mempool里面的交易都会被广播给所有节点,你们可以通过节点拿到这些Mempool里面的交易数据。

最后一个是提供pending交易给矿工打包。矿工打包的时候,他会首先从这个Mempool里面筛选交易,比如说筛选前100个交易,就是从gas费从高到低往下开始选,把它筛选进来,然后进行一个打包的工作。

Mempool引发的攻击

自从2020年、2021年那时候DeFi开始火的时候,这个机制其实产生了一些问题。Mempool会引发一些攻击:

**第一个是交易抢跑。**你在公共节点发送一笔交易,进入Mempool之后,你的这笔交易就会被监听到。如果别人有个机器人的话,就可以监听到你的交易上链了。如果他觉得你这笔交易对他而言是有利可图的,他就可能在监听到你这笔交易之后,发送一笔比你的gas price更高的交易。因为他的gas price更高,所以你的交易优先级就会往后靠,他的优先级比你高,所以他的交易先被确认,你的交易就可能因为他交易过了,所以就直接失败了。

**第二个是交易跟随。**比如说你往Mempool里面发送一笔交易,他觉得跟在你后面做一笔交易是有利可图的,那么他就可以设置一个比你的gas费稍微低一点点的交易,然后发到Mempool里。因为它的优先级会比你低一点,但不会低太多,紧接着你的这笔交易之后,它就可以跟随一笔交易来获得他认为有的利润。

**第三个是三明治交易。**它其实是把交易抢跑跟交易跟随给结合起来了。比如说Alex想要在DEX上买X,但是这笔交易在Mempool上被Bob监听到了。他就可以在你买之前,先去买这个X把X的价格抬高,这样的话你就只能买到价格更高的X。然后他在你的交易之后再紧跟一笔交易,再把之前买的那个X卖掉。这样的话,他因为是一个低买高卖的操作,所以说他就可以获得一笔利润。而你本来如果按正常的价格买X是不会有这个波动的,但是因为Bob发送了这种三明治式的交易,把你的交易夹在里面,导致了你买了比原来价格还要高的X。

为什么会有这种交易呢?还有另外一个原因,就是Uniswap在交易的时候会给你一个滑点。这个滑点最开始是为了,因为链上交易它不是实时的,会有波动性。如果设置的价格太精确,你就没办法成交。所以最保险的方法就是为了保证用户体验,他会给你设计一个滑点,比如说2%,如果价差是在2%以内是可以接受的。但这也给了一些套利者的空间,因为既然你可以接受2%的价差,那我就往2%这个极限里面给你把价差跳出来。

Flashbots的功能

Flashbots针对这些问题做了一些改进:

**第一个功能是发送隐私交易。**你的交易在发送的时候不是发送到公共节点,而是发送到Flashbots的私有节点。这样的话,你的交易就不会在Mempool阶段被公开。在你的交易pending阶段,你的交易是不会公开的,只有在你的交易确认了,它才会被广播在整个区块链网络上。

**第二个功能是发送多个交易。**在以太坊上,其实你一次交易只能调用一个合约。但是Flashbots通过打包,可以把多个交易打包在一起,然后一起发送。而且这多个交易可以是不同的地址提交的。

**第三个是指定交易顺序。**你可以把你的交易的一些哈希做排列,比如0、1、2、3、4、5,就按这个顺序进行指定成交。而且这个交易顺序不光是你的交易,你可以指定别人的交易。比如说你监听到了一个哈希为1的交易,你就可以指定你的交易必须在1的后面,这也是可以指定的。

**第四个是指定成交的区块和时间。**Flashbots可以指定你的这笔交易成交在哪个区块号,比如说100或者1000。时间的话就是区块时间,你也可以指定时间,指定区块都可以。

**最后一个是撤回失败的交易。**如果你的这笔交易在你指定的那个区块和时间没有办法完成,它是reject的,那么他就会自动撤回,而且你不用付出失败手续费。

Searcher工作原理

这边的话就是一个简单的searcher,searcher就是利润搜索者。区块链上有一个词叫MEV,就是最大可提取价值。这个最大可提取价值一般可以认为是一个机器人,它会搜索区块链上的所有交易,然后来检查有什么样的价值可以提取。你可以通过检查以太坊的一些状态信息,或者是Mempool里面的数据,或者其他的一些数据,然后做数据汇总之后,汇总为searcher就是一个机器人。检查到可提取价值之后,你再通过Flashbots打包发送给区块链上。

这个依赖的前提是这个节点,这个Flashbots的节点它刚好具有打包权。Flashbots的打包权其实不太稳定,如果在那个区块你指定的区块可能如果没有打包权,那也只能回撤交易,就相当于没有发送了。所以说的话就是这个还要看一个市场占有率,因为现在不只是Flashbots了,还有很多其他的隐私节点,他们都在抢那个打包权。

Flashbots的基本结构

这边讲一下Flashbots的一个基本结构。从searcher开始发送一个包给block builder。Block builder会发送,这边其实有好几个block builder,它们都会发送各自的交易,他们认为应该打包的交易,发送到relay。这个是一个中继器,中继器也有好几个,中继器会发送他们认为价值最大的块,给MEV-Boost这个节点。这个会汇总所有的中继器的交易数据,然后他也会把交易全部汇总之后,也获得一个最大价值的块,给最后的以太坊验证节点。

这其实分了好几层,就从用户到中继器,到MEV-Boost,到最后才是以太坊的验证节点。这么做还是为了能获取一个最大价值的块。因为现在网上有很多隐私节点,他们的数据都会最后汇总在一起,获得一个最大价值的块,谁的块价值最大,矿工就打包谁的。

他们会把一部分收益返回给打包的矿工。现在像做隐私节点Flashbots,最大的竞争力就是你能提供更大的价值给矿工,你给矿工的钱越多,矿工打包你的可能性越大。Bot的钱是你先给矿工分了以后,你才自己拿剩下的。如果别人给矿工的钱更多,那你的交易就不会被打包了。

原来是Flashbots占了80%多的市场占有率,现在的话我目前看只有2%点几了。现在有很多的隐私节点,你现在要想做的话,必须给所有的节点都发一次,不光是Flashbots,把所有的节点都发一次,这样的成功概率才更大。

隐私节点的接口

这边我列举了一个Beaver Build的文档。隐私节点其实是根据Flashbots改过来的,那个接口其实都一样,你只要掌握那个通用的接口,你就可以接入所有的隐私节点。因为标准是Flashbots定的,标准出来了,其他就跟随。

这个RPC,首先他说的就是你不需要验证你的交易交易签名和头。因为Flashbots为了减少发送垃圾交易,它会要求你做一个签名来认证你的身份。如果你这个签名发送很多无效的交易,他现在其实有个评估体系,他可以评估你的交易历史记录,看看你有多少笔交易是有价值的。如果你一直提供有价值的交易,他就会提高你的信用,然后可能会提高你的交易优先级。但这个节点是不care的。

Standard translation第一个就是普通发送普通的交易,你只要签名就可以了,把交易签一下名,这个不涉及打包。第二个就是发送一个包,它第一个参数txs就是把你的交易全部放在这个数组里面,就是签名过后的交易放在这个数组里面。然后这个是block number,就是你想要这个包里面的交易在哪个block number被打包。然后这个是max timespan和min timespan,就是最小时间和最大时间。

后面几个参数,这个是refund,就是矿工打完包拿走了他的费用之后再给这个最先发起这个叫searcher的人,填的是这个地址。它是一个percent,最后这个是地址。你可以给这个包设一个比例,就是你最多能拿多少。还有这个UUID,你可以给这个包设一个唯一标识。

给矿工支付的方式

一般这种方式是怎么做的?就是打钱的这个动作,我是封装在我的尾随交易的这笔交易里面。用合约来说一般是最稳的,因为合约你可以实时计算。你也可以直接发送,就是最后添加一笔交易,发给矿工多少钱。但是你如果发送交易就是预先设好的,你用合约可以实时计算你的利润。只要矿工能拿到这笔钱就可以。

他自己其实也会预先测量一下这个钱是不是能拿到。我感觉是会先模拟一下,看看你能拿多少钱。那个列表上有直接的API可以匹配拿到多少钱。你在发交易的时候转到那个coinbase。

我记得Flashbots官方有段代码叫做coinbase的block transfer。加那段代码的话,就把这个贿赂给打包者。我去查了一下,最后打包出来区块的时候,这个block builder会在这个区块的最前面或者在最后面,它会加一笔交易去转给矿工。

在线问题解答

**Flashbots绝对隐私吗还是相对隐私?**这个说实话也不好说,因为Flashbots相当于一个中心化的节点,如果是你自己做,你肯定可以添加一些东西去获取这些交易。但是对一般人来说其实是接触不到的。

**Build节点作恶怎么办?**这个我不是很清楚。我听说有节点可能会自己跑一些套利的东西。如果你正好碰到的话,这个没办法,因为build权限是最大的。其实我之前也在猜会不会是我用了一批的build,为了增加成功率,有可能是某一个然后出现了问题。

隐私节点的使用场景

**第一个是防止交易在Mempool上被攻击。**既然用了隐私节点,它不会在Mempool上被公开,他们也就无从攻击。

**第二个是可以更好地去攻击Mempool上的交易。**因为你用Flashbots可以指定你的交易顺序,你还可以如果失败了也不用付失败的gas费。所以Flashbots它既可以保护你的交易,也可以让你去攻击别人。就是黑恶势力交了保护费之后,就被黑恶势力保护了。但如果不交这个保护费,你还是被黑恶势力更狠地压榨。

**第三个是拯救被恶意监控钱包的资产。**这个是0xAA之前在推特上发的,他可以去拯救一些资产。因为Flashbots可以同时打包多笔交易。如果你的钱包被盗了,一般那个黑客会监控你的钱包地址,如果你敢转过来一笔gas费,他立马把你转走。但是你使用Flashbots可以同时发送两笔交易,一笔是转入gas fee的,另一笔是把你的资产救出来的,你可以把这两笔交易同时发出去。这样的话黑客就监测不到你转入gas fee的那笔信息,你就可以非常安全地把钱给取出来。很多黑客监测空投,这种收益是隐藏起来的,你不去注意基本上看不到。

**第四个是减少交易失败带来的损失。**因为Flashbots能无损失地撤回你的失败交易。现在比如说1inch那种swap平台,它可以提供这种隐私节点的服务,让你的交易被夹的概率更低。

像BSC,它好像最近出了一个BSC 48 Club。他那个比较特殊,他还有一个会员体系,就是你要买他的币去做质押,他就给你优先权。

还有一些区块链,它虽然是EVM但是跟以太坊不太一样,它的Mempool是在验证节点之间共享的,不在普通节点之间共享。这样的话你想拿到这个数据,你就要去做一个验证节点,验证节点成本非常高。所以就是这个Mempool你不一定拿得到。还有做Flashbots的话,就是要整个生态有这种需求,能养活这些节点,这才比较关键。

还有现在很多swap平台推出了无gas交易,就是你只要一个签名让别人来帮你完成这个swap,他也是用的Flashbots这种技术。比如COW,还有Uniswap推出的UniswapX,它也可以。它好像是开放的,如果你能自己做个机器人去帮别人完成交易的话,你可以收到一些利润。不过这个要去对接那个API,因为那个签名的话是不走链上的。

隐私节点的市场份额

接下来讲一下隐私节点的市场份额。Beaver Build的出块率是43%,Beaverbuild是26%,rsync是20%,Flashbots有2.3%,然后下面就是越来越小的了。

这个占有率是指占整个所有验证节点的份额,应该是隐私节点的份额。隐私节点在整个节点中占比很高了,我估算的话应该有百分之八九十。因为隐私节点能提供的利润更高,所以一般来说接入隐私节点的收益更大。

当所有人都接入的时候,每个节点都不完全公开,会不会造成问题?现在的话还没有,因为主要是一些科学家在用这些节点,或者一些比较注重被夹的swap。但以后不好说。现在被夹的大单是越来越少了。

他不把他收到的消息广播给别人,他直接发送给打包的人,没有中间步骤。之前的节点要广播,是为了去中心化网络的安全。你在隐私节点上发交易跟Mempool上发交易有一个很大的不同,就是Mempool上的交易成交率更高,因为你是发送给所有的节点的。如果矿工没有接入这个隐私节点,那他肯定打包不了你的交易。

一个隐私节点接入的验证者是有限的,但Mempool可以接入所有的验证者。你在Mempool上就是发送给所有验证者的,所有验证者不管谁打包都可以拿到你交易。但是你接入隐私节点,那就只有跟隐私节点有关系的这些验证者才可以打包。

现在以太坊从PoW转成PoS之后,它的出块节点其实是固定的,比如Lido那些节点,其实更加集中化了。那就更集中化了,你就可以方便那些隐私节点去对接。如果是你自己开一个电脑去挖矿,你怎么可能去对接那么多隐私节点?你只能拿Mempool。

他是只是在一个小范围内广播。之前是全网广播,现在隐私节点是在一个小范围内做筛选。验证者找到这一批交易,它没有一个前提是这批交易必须是经过很多个节点验证。节点只需要验证这个是有效交易就可以了,但是你具体选择哪个交易是矿工的权利。矿工肯定是选择能赚最多钱的。现在就相当于验证者节点把这从上到下的活全部干完了。

现在Flashbots市场占有率下降就是因为很多节点自己搞这种。这节点很多节点运行个机器,它什么都不管就放在那,并不去深入分析交易。你要去深入分析交易,你才能从很多交易里面发现能够抓取的利润。但这个事情需要专门的人来做。

你怎么保证矿工刚好就能把你这笔交易打包?你一笔交易发到节点上,最后你接入你这套体系的矿工并没有拿到这一次的打包权。他不保证,他只是保证你失败了也不会损失手续费。拿到的话他就拿到了,哪怕没拿到的话你也可以重新发一笔。如果份额低的话,他拿到的概率就会小一点。

使用案例代码

接下来看一个隐私节点的使用案例。这是我写的,上面的provider URL就是隐私节点列表。因为你现在想提高成功概率,你就得同时发给很多个节点。这个是一个循环,调用这个web3的provider。这边是直接调用节点API的,你提供这个provider URL,然后按照这个格式,这边是txs,这个是target的block number。有的节点要求是用16进制来传送那个block number。

为了提高我的交易被打包概率,就是我把我知道的节点全部发一遍。反正谁抢上了反正都能帮我打包,没抢上也不会损失。比如说我一次发了50个节点,假设有10个抢到了,那剩下的49个我不用付出任何代价。

这个sign就是你的交易签名。这边是发送一个单笔交易的,其实你可以打包很多交易在里面,把交易签名塞进去就可以了,这个很简单的。

人家运行这个节点,你指定的区块号,如果你要做节点,就布一堆机器,你不需要有什么成本,除了机器的成本。因为打包是矿工打的,你付的钱不是给节点,如果你要做这个隐私节点,其实你不是矿工,你还发给矿工。客户也给,其实算一起。他有个relay的网络也是一个单独的网络。发给你自己的可能就跟发给运行那个隐私节点的矿工一起。如果打包这个交易的是矿工,只是相当于这个矿工通过这个节点暴露出来的API。也有专门做隐私网络的,但他们其实也是一大坑。

隐私节点和普通节点的区别就是隐私节点不广播。普通矿工他要接收广播过来的交易,隐私节点他只接受一堆交易,他不需要接收别人的广播。

Flashbots的代码使用

接下来看一下Flashbots,Flashbots发的还比较复杂一点,因为它要做一个签名验证。这边的话就是你用一个provider建立一个Flashbots的节点。这边要传一个wallet,wallet的话就是你要用这个wallet做一个签名,让它来识别你的身份,标记你的身份。以后他可能会收集一些你的数据来确定你这个账户到底是不是垃圾账户。

第二个就是发送一笔交易了,也是一个signed bundle,也是一个包,就是签名过的包,一个数组。第三个就是等待包被确认,如果结果是1的话,它就是被回退了,其他的就是交易成功。

如果我的交易成交率低的话,它会减少我的打包优先级。你把你的交易签名打个包,然后就发给节点就可以了。这个RPC URL要不一样。

怎么给他钱?钱的话你可以在合约里面给,也可以在交易里面,你把gas price设高一点,也是给矿工。其实地址定了的话,怎么样都可以。不过这里还涉及一个,就是你用gas price的话,你得先付钱。你在合约里面给的话,你就是后付钱。他是一个先付后付的问题,gas price要求你钱包里必须先有这笔钱你才能付。你在合约里面把利润拿到了之后,再分一块给矿工,那这样就是你先拿到利润之后再付。这个后付成本其实低一点,因为先付的话你得钱包里有钱。

还有一个就是现在EIP-1559好像不能设置成0,因为它有一部分要被燃烧掉。燃烧的这部分是不给矿工的,但是tips就是优先费可以给矿工。Base fee应该不可以设置为0。

套利交易案例

接下来这个是我在网上找了一个套利交易。上面就是一个简单的Uniswap V2和V3之间,两个不同的池子进行套利。因为两个池子价格不一样,你可以把低的搬到高的那边,然后你就获得一些收益。这边比较简单,首先是0.0858个ETH,然后换这个FMB,FMB是在V2上换的。然后V2上你再去V3上换,V3上换,最后换到0.0891,这个就比0.0858高了。你获得一些收益,然后再扣除这个手续费还是有赚的。

因为现在以太坊上比较卷,你这么点收益就自己去抢了。都在卷,你不套就被别人套走了。他付了0.003的手续费,收益有那么一点,大概3.5美元。如果程序自动化的话也无所谓。程序自动运行的话,这个主要就是看市场,如果市场波动剧烈,你就能套很多。市场风平浪静,你就套不到。

Flashbots浏览器

接下来讲一个Flashbots浏览器,你可以在这边看到一些它上面的交易。这个会显示矿工利润,还有gas,然后这个bundle有多少个包。这边会显示一些交易,还有这个币种,最后显示矿工拿了多少。具体的收益你要点进那个哈希里面去看一下。

这个包应该有编号的,这个包很大,包了不少东西。这个可以给你们提供一些参考,什么套利的方式,你们有兴趣可以去看。

一个套利机会

接下来就是我给大家分享的一个机会,这个真的是一个机会。这个以太坊地址,你去看,他是一个回购池,每小时回购一次,然后他会给0.01的以太坊作为你的奖励。你去回购了,这个就是你的奖励。

回购就看你gas费多少。他这边有几千个以太坊,这池子有几千个以太坊。你去调用它的回购函数,就这个bond的函数。然后你看它里面的交易,他其实就是把3.3个以太坊去换这个Titan,然后你就可以获得0.0109或0.0989的以太坊。

回购,他这个是设置的是一个自动化的回购,就是每小时回购一次,每次回购3.3个以太坊。只要有人去调了那个函数,给你返利。返利就是0.01。回购每次都是固定的3.3,返利就是0.01。

这个利润也被卷得很低了现在。他这个3.3是池子里的以太坊,不是你自己的。这是回购池的以太坊。你看交易的时候,有几个人在抢,实际上抢的人可能不止这么点,因为他们都是用的隐私节点去跑,失败了你看不出来。你想去抢的话也一定要用隐私节点,因为如果用普通节点,被监听到,他立马加gas,然后你就失败,你就亏gas。

他做这个是为了提升他的交易量。有些项目就是需要有一些定时调

用,比如说一天调一次也好,一个小时调一次也好。但他不想自己弄,他就公开给你们,谁都可以来调,然后我就奖励给你。就是一个定时函数,他又不想自己去操作,就奖励你一个参与费。

这边其实还有一些少的,比如0.0101的,这个就多了那么一点点。因为他这个其实也不是非常稳定,如果你去钻的话,还是有一些缝可以钻的。

这个是我以前发现过的,那时候还没那么卷。然后我去跑了几次跟别人卷到一起之后,我把gas抬到了很高,然后他们就通过Etherscan来联系我,说我们可以合作,你把你的bot停掉,然后我给你分成。就这样算一种合作,大家都不要卷。人家卷来卷去全给矿工了,有什么意思呢?大家都在做白工。

Etherscan有那个聊天工具的,它可以直接给你地址发消息。当时我就是暂时加入了合作,但是合作这个不长久,因为你没办法监督。只要有一个人卷,大家都只能卷。就只要有一个卷王,大家都别睡了。第一个卷的能得好处。

就是有点鸡肋,你吃吧,收益不多。你不吃吧,别人可能就在吃。因为如果你不卷,别人发现你不卷之后,他就降gas,然后就被他吃掉了。这其实也是一个充分内卷的市场。所以说以太坊上套利,现在你只能做那些别人发现不了的,就是暂时没有人发现的。他有窗口期的,你要抓住窗口期。

项目方会不会自己参与?也有可能。他们自己参与对项目方来说也没有什么损失,他本来就是找人帮忙,可能就有一些自己搞,或者有别的目的。但你看这池子里多少个以太坊,你说项目方不眼馋吗?

防打废功能

还有最后一个就是防打废。比如说以太坊上有很多mint交易,比如抢一个NFT,抢一个token什么的。你用隐私节点就可以防止被打废掉。比如超出上限了,mint比如1万个,你打到10001个去了,那你就打废了。打废了之后你要亏gas,但是你用隐私节点的话,你就可以不亏这笔gas。还有如果你会做bot的话,你可以去监控。

现在其实以太坊要推出新功能了,就是上个星期,他们要加入一个type类型,交易type类型。这个type类型就是说如果这个交易会失败,它可以就像隐私节点一样,不支付gas。这是新的一种类型。因为之前失败的时候,你跑的那部分代码其实你还在消耗资源。现在他有计划新加一个交易类型,就是失败了就不付gas。这个是刚提的提案,应该还在讨论阶段。

但这样的话,如果不限制的话,你故意发很多半途而废的交易,可能会对节点造成攻击。隐私节点的话,它其实会事先做筛选的。隐私节点它不是面向所有人的,然后它还会记录你的IP地址什么的。有的隐私节点是有频率限制的,你只能调用它多少次。但是以太坊如果没有这种限制的话,可能会被攻击。比如Flashbots,它是让你做个签名,其他的应该是通过IP地址之类的进行控制。包括说我就可以把你拉黑。

其他链的情况

**两些链有类似Flashbots吗?**Flashbots主要不是链的问题,而是这些节点愿不愿意做的问题。就是防打费,就是让你失败了也不会扣gas,就是这么简单。

**BSC可以和Polygon吗?**Polygon我就不知道了,BSC好像有在做的。48 Club那个东西比较奇怪,它那个gas price跟以太坊不是独立的。48 Club它那个RPC,你可以用一个很低的gas price发交易,但是它限制你的gas limit。你只有去质押他的币,你可以拿到更多的gas limit。他主要是能用一个很低的gas price去发交易,其他的节点都是正常的gas price。他是为了推他的生态币,你质押他的生态币,你就可以获得更多的gas limit去发这个低gas price的交易。他赚钱不靠gas费,靠他那个币。

总结

好的,今天就讲到这里了。谢谢大家,感谢线上的朋友。

这是我登链的地址,还有我的微信公众号的二维码。大家有兴趣可以关注一下。

补充说明:

Flashbots和隐私节点是链上套利和MEV提取的重要工具
隐私节点可以保护交易不被抢跑,也可以用来攻击Mempool中的交易
使用时需要同时向多个隐私节点发送交易以提高成功率
市场竞争激烈,利润空间被压缩,需要快速发现新机会
未来以太坊可能推出新的交易类型来解决失败交易的gas费问题

最小代理合约的原理和运用

大家好,我是登链社区的33357。今天给大家讲解最小代理合约的原理和应用。

为什么要讲最小代理合约

首先,最小代理合约可以节约部署一个代理合约的gas费,因为它可以做到一个最小的gas消耗。

最小代理合约其实是一个EIP标准,最小的是EIP-1167。最近0xAA又提出了一个EIP-7511,它比1167做了一些改进,主要是因为目前以太坊升级增加了一个PUSH0操作码,可以用这个PUSH0直接做一些操作,比之前更省gas。

我在想,既然0xAA能提出EIP,其实你也可以试一下去看看怎么提一个EIP,毕竟年纪也都差不多,然后都是国内的开发者。

最后,最小代理合约作为学习OP code的案例是非常适合的,作为第一次学OP code的案例。首先它比较简单,功能比较通用,很多人都用得上,还有很多使用的场景。

什么是最小合约

最小合约它分两部分:一个是部署gas,还有一个是执行gas最小。你可以从这两个方面来定义,但目前一般来说指的是部署gas,只要能做到部署的gas费最少,基本上就是最小代理。

这次给大家画的不是一个饼了,这是一口锅。我讲技术的东西,技术其实就是一口锅,你光有热锅没有水跟面,做不出饼。你光有技术,没有一些其他的,比如资金、市场上的东西,其实做不出来,没有办法做出利润。个人使用这种锅能做出什么饼,还要看个人的手艺。

就我自己做这么多年智能合约工程师来看,如果作为技术的话,我能做的其实是比较有限的。我认为技术就是我给大家教的话,只是能教给大家一个工具,这工具个人怎么使用,还要看大家个人的发挥。

什么是代理合约

代理合约分为两部分:一部分是proxy代理合约,还有一部分是逻辑合约。

代理合约一般是做什么用的呢?因为智能合约是不能修改的,所以很多人为了做可升级,就把不可升级的合约变成可升级合约,就必须要用到代理合约。

代理合约把一个合约分成了两个部分:

一个部分是存储数据的合约,称为proxy,一般叫代理合约
另一部分是逻辑合约,存储部署逻辑的合约

当调用者调用代理合约的时候,首先会调这个代理合约,然后代理合约会调用delegatecall来调用这个逻辑合约。delegatecall的作用就是让代理合约去执行逻辑合约的代码。

你可以这样理解:把一个合约分成两个部分,一部分用来做数据存储,另一部分用来做计算执行。你可以把存储的数据跟执行的计算分开来,以后做合约升级的时候,可以把逻辑合约给替换掉,但是数据还存在代理合约里面,就不会变。

代理合约的优势

还有一个优势是:比如你在做一些资金操作,资金一般会存在代理合约,因为代理合约在升级的时候,它的地址是不会变的。比如一些代币,不管是以太坊还是USDT,存的地址都是代理合约的地址。每次更新逻辑之后,逻辑合约地址虽然换了,但是代理合约地址不会变,资金也一直掌握在代理合约地址上。这样的话,每次升级的时候,资金也不用去做什么更换,不用动,这样就更加安全。

可升级合约的安全隐患

目前很多链上的项目做的都是可升级合约。可升级合约虽然比较方便,但是其实也有一定的安全隐患。

首先第一个安全隐患就是它的逻辑合约是可以随时都可以改的。比如你去投一个代币或者池子什么的,如果项目方随时可以更改代理合约,就可以把你的资金按他自己修改后的规则提出去。本来是没有权限提的,升级一下逻辑合约,他就能提走了。

所以一般做代理合约的话,最好也会有一些安全措施,比如时间锁或者多签,这样可以确保项目官方不能那么容易就去做合约升级,替换掉原本的逻辑。

代理合约的模式

代理合约分了一些其他的模式,比如透明代理、信标代理。

最小代理也是一种代理的方式,但是跟可升级的不一样,最小代理一般来说是不可升级的。代理合约有一个特点,它必须要把逻辑合约的地址存在代理合约里面,但是最小代理为了达到最小,把逻辑合约地址给写死了。这样的话逻辑合约地址是不能改的,除非用SELFDESTRUCT可以把原来的代码替换,不过以太坊升级很快就会把这东西删掉。

最小代理合约的特点

最小代理合约相比普通的代理合约,有两个优点:

部署gas成本低
执行合约代码的gas成本低

但是有两个缺点:

不能修改逻辑合约地址
没有管理员

这个是蛮好理解的,因为修改逻辑合约地址肯定要有管理员的许可,既然没有设定管理员,自然就不能去做修改逻辑合约地址的操作。

为什么不用普通的逻辑合约

有人问:不能升级的话为什么不用普通的逻辑合约?

因为最小代理有一个特别的功能:如果你想要部署很多的代理合约,但是逻辑很复杂,你想要省gas去部署很多执行相同代码的代理合约,就可以用最小代理,让它指向这个逻辑地址。

可能你部署一个逻辑合约需要1万的gas,但是你部署一个最小代理直接去代理这个逻辑地址的话,可能只要100多gas。这样的话可以做到你拥有很多合约地址,但是部署gas更低。就是多个代理地址指向同一个逻辑地址。

从字节码层面理解智能合约

如果要从字节码的层面理解智能合约,你需要了解堆栈、内存、存储和OP code的一些概念。

我给大家看一下最小代理合约的字节码,总共就45个字节。接下来我会分析一下这一串代码到底是什么意思,怎么写出来的,让你们理解这个最小代理合约是怎么运行的。

我画了四步,最小代理合约那么长一串代码,其实总共只有四个步骤:

第一步:复制calldata到内存

首先第一列是执行位置,第二列是字节码,第三列是字节码对应的OP code的名字,第四列是堆栈,第五列是内存,最后一列是说明。

执行位置就是你在执行字节码的时候,它是从00、01、02、03这样顺序执行下去的。字节码就是一个操作按一个字节来存储,也就是8位,可以用两个16进制来表示。每个字节码对应一个操作名,这样比较好理解一点。

堆栈你们需要了解一下EVM code执行的逻辑:所有的操作都要先压入堆栈,要把操作用的数据先加入堆栈,然后才能执行。堆栈目前一共只有16个可以操作的位置,所以你们在写智能合约的时候会经常出现那个stack too deep 16个堆栈的问题,那是因为你们加入的数据太多了,一下压栈数据太多,超出了EVM的规范限制。如果了解这个的话,这个就好处理。

内存的话,就跟我们计算机内存差不多的理解,就是你把那些比较长的数据可以保存在内存里面,然后等执行结束,它就会自动消失。

我们先来看一下把calldata复制到内存,它是怎么操作的:

执行位置00:字节码是36,操作名是CALLDATASIZE,它会返回你执行智能合约的时候交易的calldata有多长的长度,然后把这个长度压入堆栈,这是第一步
执行位置01:字节码是5F,操作名是PUSH0,意思就是将0压入堆栈
执行位置02:也是5F,同样是将0压入堆栈

这样的话堆栈里面就有了三个数字。

执行位置03:字节码是37,执行CALLDATACOPY,意思是将前面这三个作为参数执行

CALLDATACOPY从左到右读取数据:

第一个参数是destOffset(目标偏移),就是你要把calldata复制到内存的起始地址,在这里是0
第二个参数是offset,是你要复制的calldata的起始位置
第三个参数是size,是你要复制的calldata的大小

这样就可以把0到calldatasize这么大的calldata复制到从0开始的内存空间。就是从起始地址到size,取那么一段大小的calldata,然后复制到destOffset指定的内存地址。

这样就可以成功的将0到size这个位置的calldata复制到从0开始的内存空间。这边可以看到calldata本来在交易上的,你把它成功复制到合约执行的内存里面。

第二步:执行delegatecall

从执行位置04开始:

04:5F,PUSH0,将0压入堆栈
05:5F,PUSH0,将0压入堆栈
06:36,CALLDATASIZE
07:5F,PUSH0
08:这边有点不一样,是73,后面跟的是一串合约地址。PUSH20就是把这个合约地址20字节压入堆栈
1D:5A,GAS,将剩余的gas压入堆栈
最后执行位置1E:F4,DELEGATECALL

DELEGATECALL要好好讲一讲,它参数比较多:

第一个参数是gas,就是执行这个delegatecall需要给的gas
第二个是address,指定的地址
第三个和第四个是argsOffset和argsSize,就是参数在内存的起始位置跟参数占内存的大小
最后的retOffset和retSize,是返回值的位置跟返回值的大小

在最小代理合约这边,参数是:

gas:默认gas
address:在PUSH20的时候直接压栈的地址
参数的内存起始位置是0,大小是calldatasize
最后两个返回值直接设置的是0

调用这个操作可以将0到calldatasize的内存数据作为参数,执行那个地址的代码。在执行完成之后,它会将执行是否成功记为success,压入堆栈。

你们可以看一下,把它作为参数执行完之后,它会自动清除,数据就自动消失了。同时delegatecall会自动将执行是否成功的结果(就是0或1)加入堆栈,之后可以判断这个success,判断堆栈顶那个数字到底是0还是1来判断这个执行是否成功。

第三步:复制returndata到内存

因为这个执行delegatecall之后它会有返回值,返回值你要处理的话也要把它复制到内存才能处理。

从1F开始执行:

1F:3D,RETURNDATASIZE,获取返回值的大小,然后压入堆栈
20:80,DUP1
21:80,DUP1
22:3E,RETURNDATACOPY,将0到returndatasize的returndata复制到从0开始的内存空间

你们可以看到这个内存,那个calldata被returndata给覆盖掉了,因为calldata其实现在也没有用了,可以用returndata覆盖掉它。

这边这三个参数执行完了之后就没了,然后只剩下了一个success在堆栈。

RETURNDATACOPY的参数也是:

第一个是destOffset,要复制到内存的目标地址
offset是returndata的起始位置
size是returndata的大小

第四步:返回数据或者回滚交易

这边做判断,判断交易是否成功,成功的话就返回那个returndata,不成功的话就回滚交易。

从23开始:

23:5F,PUSH0
24:3D,RETURNDATASIZE,将returndata的size加入堆栈
25:91,SWAP2,将堆栈的第一个元素和第三个元素互换。你们可以看到这边的success被换到前面来了,跟那个returndatasize做了个调换
26:将一个字节压入堆栈,这边是PUSH 2A
27:是JUMPI

JUMPI要讲一讲。如果用汇编的话,没有那个if判断或者for循环,只能用jump。因为作为一个汇编语言,只有跳转代码。

JUMPI是一个跳转:

第一个参数是counter,是跳转的位置。这边为什么要压栈一个2A呢?因为它是想要跳转到2A这边
第二个参数是b,如果第二个参数b是true的话,它就跳转,如果是false的话,它就不跳转

这边堆栈就是一个2A跟success,它会判断这个b,判断第二个位置的参数是true还是false,是true的话就直接跳转到counter位置。

我们看到counter位置2A这边有个JUMPDEST,跳转的话必须要在跳转的目标位置有一个接收函数,你不能随便跳,要有这个接收函数才能跳到这个地方,不然会报错。

如果条件,就是上步的delegatecall执行是false的话,就直接执行29位置的代码,就是REVERT,直接返回0到returndatasize的内存数据,并且回滚交易状态。

如果成功跳到2A,就是上步执行delegatecall正确返回是true,就会成功跳转到2A的位置,然后执行接着往下执行,就是RETURN,正常返回0到returndatasize的内存数据。

这样的话整个合约逻辑就是这样。

总结四步流程

整个代理合约就分了四步:

复制calldata到内存,就是获取参数
执行delegatecall,delegatecall的作用就是执行目标代理合约地址的代码,用自身的合约环境
复制returndata到内存,就是获取返回值,因为执行的话有返回值,返回值要获取到内存
返回内存数据或者回滚交易,就是要检查这个delegatecall是否成功

你们如果研究一下的话,这个逻辑应该还不算很难。通过这四步实现了一个比较完整的代理合约的逻辑。

之所以说它是最小代理合约,因为:

首先它是直接用字节码写的
比较没有什么多余的操作
也没有编译器的一些中间环节
而且它是一个非常完整的代理合约,所有的代理合约的功能基本上都可以实现

部署最小代理合约的字节码

最小代理合约的字节码,其实还有一个部署最小代理合约的字节码,你们也要了解一下。

首先你要部署一个合约的话,要了解init code跟runtime code的区别:

部署合约的时候,会先执行你的init code
init code的执行结果的返回值,就是runtime code
runtime code才是真正被部署在合约上的字节码

就是你们在写合约的时候会有一个初始化对吧,会有一个初始化的过程,比如你把那个msg.sender赋值到管理员,就是在init code里面做的操作。runtime code是init code的返回值。

这边可以看一下,这是一个部署代码。你要部署这个最小代理合约到一个地址上,直接部署是不行的,要有部署代码。这边就是在这个代码前面加了一小串作为它的init code。

你可以看一下:

00:602C,PUSH 2C,把2C加入堆栈
01:80,DUP1,复制堆栈的第一个元素并且加入堆栈,这样就变成两个2C了
02:6009,PUSH 09,把09压入堆栈
05:5F,PUSH0,将0加入堆栈
06:39,CODECOPY

CODECOPY也是三个参数:

第一个是destOffset,要复制到的目标地址
offset是code的起始地址
size是code的大小

也是复制到内存,将09到2C的code复制到从0开始的内存空间。这是要复制到内存上。

07:5F,将0压入堆栈
08:F3,RETURN,将0到2C的内存数据返回

这样就是执行了一个init code。init code的任务就是你在部署的时候,你执行的其实是这一大串,但是你真正部署在地址上的是它的返回结果。

只要了解这个就可以了。这个init code比较简单,没有对地址做什么操作,就是把那个code复制过来,然后再返回它,其实就两个操作。

这个2C的意思不是位置,它是大小,就是从09开始数2C个大小就2C个位置,所以其实是从09开始的,它是一个位置大小的概念。

前面那一段代码的作用就是把后面这一串代码返回。你可以理解就是前面那一段代码的作用,就是把后面这一串代码返回。

你们在部署的时候,真正被消耗gas,部署一个合约的时候最消耗gas的,不是整的一串,是你真正保存在合约地址上的代码,就是你真正部署在合约地址上的代码,才是花gas最多的。前面这一段只是一个执行,它不会保存在合约地址上,所以前面那一串的gas花费很少。

你们要理解一个存储,就是在以太坊上存数据和执行的,单纯执行跟存储的gas差别是非常大的。执行一个代码可能只消耗十几个gas,但是你要存这一串代码就是几千几万了。所以最小的代理,消耗就是后面这一段比较多。

如何做gas优化,也是从存储的角度来做优化,优化效果最好。除非你做很多循环,不然的话做优化最好还是做优化存储,因为存储消耗的gas比执行大很多。

OP code优化技巧

前面比较简单,用了calldatasize,前面又用了一个calldatasize,其实直接用这个操作比用复制更方便。这就是尽量用它原有的操作。

就是你在写汇编的时候,比如你要获取msg.sender,有的人可能把msg.sender直接复制给内存,然后再去读那个owner,可能觉得更省gas。其实你直接读msg.sender,比把它复制到内存再什么内存中读到堆栈,其实是更浪费,因为有操作,操作就是你先把它复制给内存,然后你要用的时候要从内存复制到堆栈,就是绕了一圈。但你直接使用msg.sender,就直接给到这一段了。

这就是有这个优化的一个方式,虽然优化不了多少,说实话。就是在这个OP code里面直接有的,你直接用比那个护着来护着去的,确实要好好一点。

存储和执行的gas区别

就是存储跟执行更关注存储。因为init code只执行一次,你说的存就存在合约上面,只会消耗发布人的gas,只消耗一次。调用是只要调了都会消耗。

存储可能只对发布的人比较贵,但是对调用的,你不关心。调用的话有的调用也会修改存储,也会修改存储。你看这个如果是修改的时候,那就你们就是做一点具体场景。

Gas成本和计算

目前的话,我在测试网上做了一遍测试,它的部署成本是8828,再加上一个32000,32000是调用create和create2的固定消耗。就是你真正部署上面的字节的费用是8828。

执行的话,我是调用了一个空函数,空函数它执行gas是192往上。因为delegatecall虽然有固定消耗是100,还有一些其他的数据消耗,目前是192往上。

create是32000以上,create2也是32000以上。你调用一个fallback是最基本的也是32000,反正你不可能一个字都不写吧,目前gas成本就这个样子。

相比于那个一般的代理合约来说,是非常少的。一般你用Solidity写的代理合约,基本上都是十几万往上。

其实做这个gas优化,我一开始是用Solidity写,后来用Yul写,最后用Huff写。Huff的话,其实它比较接近于那个用bytecode直接写的那种。

gas limit的单位就直接算了个数,到时候你就乘以那个gas price。就是你要分清楚gas limit和gas price。gas limit就是这个EVM code上它这个定义的就是mini gas,你到时候真正算价格的时候,要去乘以那个gas price。

冷热地址

还有一个就是以太坊上做交易的时候,在一个transaction里面,你第一次交互的地址,第一次跟这个地址交互,它是一个冷地址,冷地址你要多交2000 gas。如果在这个transaction里面第二次或者第三次跟这个合约交互,就是热地址,它变成热地址可以少2000 gas,就是有这个机制在这里。

还有就是以前网上还有一些gas退还机制,那gas退还机制就是为了鼓励存储,从0变到非0,收20000,但如果你从非0变成0,会返还你一半的gas。如果你分两笔交易,这个差别会比在同一笔交易里面大不少。

Gas token

有人问网络运行中间有一个gas token,就是来提醒gas的。那个gas token之前还有点用,现在被废了,现在不行了,现在已经不行了。之前是在2020、2021年的时候还有点用,它是利用了以太坊那个机制,合约地址SELFDESTRUCT销毁会返还,你把非0数值改成0也会返还gas。但是现在升级之后,返还机制改掉了,而且以太坊开发者也不鼓励这样做,说会有很多垃圾交易,就把返还机制给废了。现在已经性价比不高了,用的人很少。

最小代理合约的应用

第一个应用:挖token

第一个用的比较多的就是我之前一般用的就是挖token。因为链上有很多XEN这种,它的模式就是拿一个账号去挖,用gas去挖,然后过了一定时间,过了锁定期,你就可以把它提出来。

这种合约里没有限制合约地址能不能挖。如果你一般用私钥生成的那种外部地址去挖的话,其实是比较浪费gas,没有用这种最小代理的方便。

首先一个就是你用合约的话,一次能部署,目前的话是100多的地址,就一个交易100多地址就可以部署出来。而且你在挖的时候是一次操作,你在提取的时候也是一次操作。

你如果用私钥的话,你要去做归集,你要归集以太坊,然后把那个代币也归集,因为一个地址做swap是很亏的,你要把它归集起来才再去swap,这又是一笔消耗。

还有一个就是冷热地址的区别。你在一个transaction里面,第一次交互的地址是冷地址,你要多交2000 gas。如果在这个transaction里面第二次或者第三次跟这个合约交互,就是热地址,变成热地址可以少2000 gas。

还有合约的,以前网上还有一些gas退还机制,存储就是从0变到非0收20000,但如果你从非0变成0,会返还你一半的gas。如果你分两笔交易,这个差别会比在同一笔交易里面大不少。

第二个应用:抢空投NFT

第二个应用是抢空投NFT。因为有一些空投,你看一下这个是XEN的合约代码,这边是claim rank,这边是claim reward,这边没有限制你用msg.sender是不是合约地址。你可以用最小代理去新建一个地址,新建一个地址去运行这个claim rank,然后reward也没有限制是不是合约地址来调用它,你也可以用合约新建地址去调用。

这样的话一般成本就会比别人用不用合约的会低很多。

NFT我用的是Beanz的这个例子。Beanz之前不是发过那个NFT的空投吗,他这个就是随便谁都可以mint的,但是它会限制一个数量,好像是一个地址最多mint三个吧。你就可以用这个方法去绕过它的地址限制,他这边也不检查msg.sender是不是合约地址,也没检查过,只是减少数量。

有人问:我一次申请给100个合约地址是吧,然后100个合约地址去交互,那我也要把币打到100个地址上去?

不需要不需要,他是你只要有这个地址的权限,你就可以去交互。gas是由你的主账户出的,就是你的那个tx.origin出的,不是你那个msg.sender的,你知道吧。gas消耗的实际是tx.origin发起的。

使用合约地址的优势

就像你刚刚说的,会有第一次冷地址问题,还有你发起一次交易还有21000的交易费,那个交易发起费用你也要交。

所以如果会用合约的话,这边能起码省一半以上的gas,当然前提是他那个合约没有限制不能用合约地址。他如果做限制了,那就没办法了,你就只能用那个外部地址一个一个去操作。

第三个应用:子合约

最后一个是子合约。比如说你想做一个钱包应用,什么多签钱包啊,类似那种AA钱包什么的,然后你每个用户进来注册一个钱包,你就给他分配一个地址,你就可以用这个最小代理合约,因为说实话部署的gas最小。

当然它这个可升级不太好做,可升级不太好做。

第四个应用:批量发行token

第二个是批量发行token,你也可以用这个来做批量发行。可能就是你做那个逻辑差不多的这种token,你可以弄很多的地址,那个逻辑都是一样的,就是token的逻辑都是一样的。

第五个应用:发行NFT

最后一个就是发行NFT的话,你做好逻辑地址,然后发很多代理地址,然后代理地址它功能都是一模一样的。这个定制化就不太多。

能否做出比最小代理合约更小的代理合约

最后,能否做出比最小代理合约更小的代理合约?这个是一个扩展。

因为你看到这个最小代理合约,它这边是四个部分:

复制calldata到内存
执行delegatecall
复制returndata到内存
返回returndata或者回滚

它分了四步,但是这个功能比较全。但是如果你想阉割掉一些功能,你可以做的比它更小。

优化方案一:不要calldata

比如说你不要calldata,就是它只有一个函数,就一个功能,其他的功能对你没有意义,你就可以把00-03这四个字节全部删掉。

优化方案二:不要returndata

或者说你不要return的,你不要返回值,执行就好了,就不要返回值什么东西了,你就可以把这个复制returndata到内存的,这个复制给删掉,后面那个return你也可以删掉。

优化方案三:不指定逻辑合约地址

还有一个就是不指定逻辑合约地址。这边PUSH20,它指定了逻辑合约的地址,但其实如果你有某种方法把这个逻辑地址删掉的话,其实节省的gas是最多的,因为这个PUSH20部署花费的是最长的那一段,这20个字节是最长的一段。

我目前想的办法就是用msg.sender替换掉的,但是这样的话就是谁都可以,他就是谁调用它,谁就是它的逻辑地址,就是你就没有任何权限了,谁都可以用这个。看看运气,如果有人看到你的代码,可能他可以来攻击你,就没那么安全。

优化方案四:不要回滚检查

最后是回滚检查,就是你可以把如果你比较自信,可以把这个检查success的给删掉,就是你不要检查它是否成功,你就默认它成功了,就是你把这些东西删掉。

虽然能做到把最小代理合约做的更小,但是它整体的通用性就变差。但如果你只是完全不需要什么通用性,你只是用来做单一功能的,你可以做一些改造。

改造的话,目前的话我可以把这个8000多改造到5000多,就现在8828可以把它降到5000多,然后执行你把这个删掉的时候,执行的话好像也能降到140左右。

总结

最后就祝大家能用到这口锅,这个工具。这个工具到底怎么用,怎么赚钱呢,靠大家自己。

还有一个我在想怎么提一个EIP,你们有提过EIP吗?在那个上面提案,但是怎么通过呢?就是你提的怎么让别人通过来。

它只是一个通用标准,就比如像ERC20,就是说如果大家都一直用这个标准,把它推到那个库里面,大家可以一起去用,我是这么理解吧。我自己也没提过,我就是看过很多。

现在提的太多了,就是每天都会有很多。其实就是你提一个如果没有人讨论,没有人关注,也没意义。

一开始有些交易,像那个datatype(数据类型)相关的,之前也有在类似的上面,应该是V神提出的那个。还有反倒是很开放的,有些是底层做改变,有些是像ERC304跟底层没关系的,就是要看大家得一起用。

比如说通过了之后,如果有些人不做这个库,或者没有做这个通用标准,我感觉也没什么用。

现在不是分了一个是协议标准,一个是应用标准吗?能提协议的,我感觉一般人都提不了协议的,都提应用的。应用是让人用这个东西,就是大家一起不用。

你说我提个EIP-7511,那大家都没问题。但如果没人用这东西,就是说你其实也就是像茅台一样埋在酒窖,别人不知道。

那我结束录制了。

编者注:

本文整理自登链社区33357关于最小代理合约(Minimal Proxy Contract)的技术分享演讲,涵盖了EIP-1167和EIP-7511标准的原理、字节码层面的详细解析、gas优化技术、以及实际应用场景等内容。文章保留了演讲者的原始表达风格和技术细节,为开发者提供了一个深入理解最小代理合约的完整参考。

链上数据在交易中怎么创造alpha之怎么寻找聪明钱

大家好,我叫Robert,是在Dune时代做数据应用开发的。我之前在飞书做过知识库,在币安做过一些业务的开发,现在主要在Dune做数据应用的开发。

之所以分享这个主题,主要是因为提到数据,大家可能就想到怎么找聪明钱。但是我做的研究也不算太深,所以今天会很担心,就是大家辛辛苦苦来了一趟,怕大家没听到什么。所以如果大家中间有什么问题,就可以直接打断我,直接问。

什么是聪明钱

其实大部分时候我们提到聪明钱,聪明钱是一个非常概括的东西。这句话本身是一个好的问题,我们其实要深入探究的话,就需要问两个问题:什么是聪明钱,然后为什么要寻找聪明钱。

其实大部分人的语境里面,聪明钱默认是那些赚到钱的资金。但是其实这个定义没有太大的意义,因为有些资金赚到钱是因为各种因素,比如说他有一些消息,或者他有某种技术,比如MEV或者各种抢跑。

为什么要寻找聪明钱

我们需要再深入思考一下,为什么要找聪明钱。

比如说一开始,对我来说,我一开始是想知道那些聪明钱到底是怎么赚钱的,或者是怎么通过他们来判断链上的行情。

第二个想法可能是跟单,我当时想的是,我能不能通过跟着他们的行动来赚到钱。

但是这些本质上都是为交易提供决策。其实它本质是做交易,寻找聪明钱这个事情可能只是一个影子。但是做交易的盈利的关键点,其实是打造一套交易系统,这交易系统可能更偏向传统金融的概念。如果之前炒过股,或者有做交易的经历的话,应该会很熟悉这个词。

为什么需要交易系统

大部分时候其实我们做交易的时候都有,有时候是凭感觉。凭感觉有个问题,就是我其实没法知道我做过的这个决定到底是对还是错,因为我通过个人判断,有时候会有很多主观的因素。

比如说可能我今天看到了什么信息,然后根据这个信息做判断。比如说KOL,或者是我加入了一个群,然后群里可能有些FOMO的气氛,然后我跟着这个FOMO的气氛做了一个买入的决策。

但其实事后不管是赚钱了还是亏钱了,我都会有个问题:我怎么知道我做的这次交易到底是对的还是错的?

所以就需要把具体的这个决策流程固化下来。

交易系统的三个模块

大部分时候交易系统可以分成三个模块:

策略的选择
仓位控制
风险控制

实际上我交易盈利的,就是alpha的来源是某种策略或者信息。我只有把我的策略写成很确定的逻辑,我才能通过信息、通过数据来判断我这个决策到底是不是对的。

币圈交易策略分类

这是我的一些经验。就是我在币圈里交易的时候,发现了一些什么策略,然后我做了一个分类:

低风险策略

比如说低风险的策略,可能是一些人会在链上买币,然后通过质押来获取staking的收益,同时在交易所做一个卖空的对冲,这样子又可以赚取一些资金费率。但是这种收益一般在10个点以下,但是相对来说风险会比较低。

还有一部分是流动性质押。流动性质押一般是窄带质押,然后通过期权或期货进行对冲,赚取swap的手续费。这也是一种相对比较成熟的玩法。但是因为最近的交易量很低,市场热度很低,所以其实最近的质押收益会比较少。

中高风险策略

中高风险的,可能就是主流币种的高抛低吸,还有事件驱动交易这两种。我把它放在中风险,但是他可能相当于是传统金融里面的高风险。但是在币圈里面,他已经算是一个比较相对中低风险的玩法。

高风险策略

高风险的玩法其实就是有那种科学家打新,各种mint,或者开杠杆的合约。

跟踪聪明钱的意义

这就是我总结下来的,跟踪聪明钱的意义:其实应该知道当前市场上哪些策略正在盈利,然后那些策略,或者是跟你进行同样操作的那些资金,他们都是现在都在做一些什么操作。

或者说,如果你发现跟你做同样策略的资金没有进行任何操作的话,那可能是这个策略当时不太适合现在的市场,或者说他们现在已经换了一个玩法。

怎么追踪相应策略的资金

Staking策略

比如说如果你专注做staking的话,你就可以通过stETH的玩法,或者cbETH的那些玩家。其实那些只要玩过这些协议的,你就可以把它筛出来,他们已经算是相对来说聪明的资金。然后你再根据你的需要去把特定的一些玩家筛选出来。

流动性窄带质押

如果是做流动性窄带流动性质押的,其实现在只有Uniswap V3这个协议支持这种。

主流币高抛低吸

还有一些玩主流币高抛低吸的,这个可以通过一个query。等一下我会把这个材料放出来,其实就是一个query。

这是我最早在我们平台上写的一个query,其实就是回测一段时间内,在一个币种内进入和进出的成本,然后通过这个成本的差价,比对他的成本来对账号的操作进行一个排序。

这个拿的是一个Uniswap的一个币种,是Uniswap的那个地址,然后跑下来的结果大概是这个样子。这其实不是一个很准的表,但是其实很多时候我们不好找到一个非常准的数据。

通过这个地址的交易历史判断,它其实是一个相对稳健的一个玩法,主要还是在质押。就是当前主要的玩法还是质押,然后它主要的交易操作都是在去年。所以其实可以看出,现在市场上一些相对稳健的资金是没有操作的,就是赚staking的收益。

事件驱动交易

还有一些玩法是事件驱动的交易,他们主要是在一些,因为其实很多区块链的事件和活动都是公开的,然后事先是可以知道具体的日期。

一般这种玩法可能已经偏消息面了,就是你可以,一般来说应该是这种玩法,是在那种事件之前,你会去通过各种渠道拿到那个在那个事件会发言的那些项目方的信息,然后可能如果判断有机会的话,会提前埋伏进去。

这种资金不是很好找,因为它有点像老鼠仓。但是其实之前我的一个经历是,上半年的时候在一个Space上,听一个大V说Arbitrum上半年会有些动作,然后事后看他3月1号发布新的产品之后,就走出了一波独立的行情,然后比大盘的走势要强势不少。所以说如果有玩这种事件驱动的交易,可以选择这种方式。

杠杆交易

接下来就是杠杆交易。杠杆交易的话其实比较推荐Dune上的看板,因为真的很全。这个query把Dune上的,就是GMX上所有做交易的账号的收益给算出来了。其实可以根据这个收益来筛选出那些交易水平比较高的账号。

打新资金的案例分析

我之前做一些跟踪的时候,发现了一些打新的资金。他们可能是另外一套玩法,做一个比较好玩的玩法分享。

因为我们一直有做一些链上信息的监控,然后之前发现了一个币,阴差阳错。它其实就是一个很普通的皮球盘,但是跟踪这个币的时候发现,他的创建者,他的资金来源于龙卷风(Tornado Cash)。

他的最初始的资金来源于龙卷风,然后他发了两笔资金出去,然后这两个账号分别都创建了一个币,发了一个皮球盘。一个账号的收益是50几个以太坊,另外一个账号收益是30几个以太坊。

我很好奇为什么这种模式可以,为什么这种模式可行。就是这只有两种解释:

一种是可能是黑钱在洗钱,他希望把倒出来的资金洗成合法的资金
另外一种是他用某种方式获得流量,可以吸引散户进来

如果是第一种可能性的话,其实就没有分析的必要。然后分析了一下第二种可能性。

我发现很神奇的是,他们都往一个账号打了0.5 ETH,这边也是。然后我就打开了这一个账号,发现这个账号天天都有人给往这个账号里打钱。于是我就很好奇,搜索一下,发现这个账号是DexTools的收款地址。

DexTools是一个非常有名的图表网站,土狗交易所吧,可以这么理解。应该是炒土狗的人首选的两个平台之一。

DexTools打币策略

所以就有一个假设,可能就是往这个账户里打钱的这个地址所创造的币种,过段时间会涨。

于是我搜索一下,发现其实已经有人做过类似的事情。这个账号在Dune上其实已经被监控了。

我早上就是这个文章其实是早上写的,我们来看一下最近的这笔交易,其实是九个小时之前。是这个账号建的一个合约,然后在这个交易创建这个币种。

我们是可以看到它走势的,他的时间大概就是在早上,就是九个小时之前。然后他收到钱之后确实是涨了,大概不止一倍,涨了45倍。

观众问:这个是啤酒盘吗?

这个不确定,我还没看代码。

但是DexTools上面是有很多啤酒盘,然后我之前其实看别的币种,是有些人在做这种交易,就是监测到上币就马上买入,然后可能涨个多少就卖出。

不过因为很多项目是皮球盘,所以其实比较成熟的玩家,还是一般是买入之后马上做流动性质押,然后用流动性质押来把币卖掉。

因为我看过一个很低端的啤酒盘,就是它有个方法是可以把别人的balance设成零,就好像虽然是你买入的那个币,但过一会儿你看,发现余额是零。

这就是刚刚看的那个地方。看起来是一套已经有很多人在玩的策略。我也还没有实战,反正就是看链上数据,经常会发现这种奇奇怪怪的玩法。

关于皮球盘的讨论

观众问:从安全角度来看,自动化的检测程序是没办法检测的话,它代码可以隐藏到合约里?

对对,这个啤酒盘全都靠猜,是不是。但皮球盘有一些特点,就是它一般来说,比如说他可能是禁止交易,但他绝对不会禁止那个流动性质押,就是那个池子的合约的地址。

所以其实有个方法,就是你通过提供流动性来买入。但其实反正这种玩法有很多风险,就是被套的资金也有不少,我也看过好多。

观众讨论:可以赶紧冲,只要监控了上去…让你做老鼠仓…

但是有个问题是,可能撤掉池子的时候可能会有问题。就是因为你通过池子,就是你通过加入池子来买入,但是你卖出的那个操作,就需要不能触发那个transfer。因为大部分那个啤酒盘都是在transfer那一层做限制。

所以这种可能针对不同的啤酒盘,还是需要不同的解法。

观众问:DexTools上面他有一个认证吗?

其实没有很多内容。有些具体的query,可能等一下我把这个材料分享一下,大家可以看一下链接。

编者注:

本文整理自Robert在登链社区关于”如何通过链上数据寻找聪明钱”的技术分享演讲,涵盖了交易系统的构建、不同风险等级的策略分类、如何追踪特定策略的资金、以及通过链上数据分析发现的一些有趣案例(如DexTools打币策略)等内容。文章保留了演讲者的原始表达风格和与观众的互动讨论,为读者提供了一个从数据分析角度理解加密货币市场的参考视角。

链上数据在交易中怎么创造alpha之智能合约工程师的赚钱方法

开场与背景

大家好，我是33357，目前是智能合约工程师，专门做智能合约方面研究。今天给大家分享一下我作为一名智能合约工程师是怎么赚钱的。副标题其实是”走向一个不会赚钱的道路”。

为什么要讲赚钱呢？因为我之前在GitHub上分享技术，有个社区群，很多人线下交流时都问我怎么赚钱，但我当时没准备，一时回答不出来。我研究这个话题很长时间，发现有很多零碎的东西。希望今天的分享能给大家一些帮助，也许可以反过来帮助我赚钱。大家可以互相分享，到底怎么做能赚钱。

画饼声明

首先声明，下面讲的东西都是我给你们画的一个饼。讲起来很容易，但做起来不一定容易，可能没有我讲的那么容易。饼这个东西，看起来很好看，但吃起来不一定好吃。我做的这个饼不一定最适合你们，最好能找到最适合自己的赚钱方法。

实际上我做的这个饼也不是特别完善，还需要跟别人交流。有些东西我也是听别人的，看别人的，不是自己亲身经历的，也要依靠别人的经验。

赚钱的两种方式

工作赚钱

大部分人能接触到的就是工作赚钱。但工作是有成本的：

时间成本：要上班、早起、打卡、加班
做事成本：要学习新技术、实践测试、应用
更新技术成本：比如以太坊升级了，还得去更新技术
社交成本：要跟领导、同事、客户社交

我目前没有固定工作，如果想去固定工作的话，感觉成本可能有点高。

用钱赚钱

另外一个方法就是用钱赚钱。这是被动收益：

时间自定，不用打卡上班
没有社交成本
最重要的是：在公司上班做的东西，后续收益都不是你的，你只是领工资。项目持续运营的收益不是你的，相当于要一直工作才能一直有钱赚。但如果能找到用钱赚钱的办法，就算不工作了，收益还是一直会给你。

要实现用钱赚钱，需要三个条件：

本金的原始积累
被动收入：本金放进去有增长率
被动收入覆盖支出

原始积累的方法

1. 区块链大周期

指比特币的4年减半周期，也是牛熊周期。只要能把握这个4年周期，在牛市卖掉、熊市买回来，就能实现收益增长。

虽然看起来简单，但要做到需要：

知道自己能力和认知的边界：不能把钱全部拿去买土狗币
投入足够数量的本金：比如投入50%的钱，四倍增长就能让本金增长两倍
拿得住4年：很多人拿不了那么长时间

关键是要保证4年的生活资金不被投资的钱干扰。影响生活的钱绝对不能拿出去投资。

我预估下个牛市比特币能到10万美元，是根据以前趋势类比的。上个牛市2021年最高6万多，按照之前的倍数，下个牛市至少得破10万。

另外，作为智能合约工程师，我的全部知识都在这个行业内。如果比特币真的归零了，我的知识基本也就没用了，整个职业生涯也就结束了。所以我做这个职业就得有这个信心。我从大学毕业就进区块链公司做智能合约，其他行业经验全部没有。我已经被整个行业绑定了——社交是圈子里的人，工作经验是圈子里的，什么都是圈子里的。

目前我的投资是比特币和以太坊对半分。

2. 套利和盘子

这两个差不多，薅羊毛就是套利，如果整个羊都直接开膛破肚了就是端盘子。

利用市场规则套利

抢跑机器人：Uniswap刚出来的时候，大家都去发token、发池子，就有很多抢跑机器人。你刚创建池子，机器人马上就第一笔交易买入。如果你池子钱变多了，想把钱套出来，机器人每次都比你快一步先撤出来。

我当时想做限定合约套机器人的钱，但技术有限，而且在以太坊上测试太贵，每次都是花真金白银测试。研究了两个礼拜，光是gas费和部署合约费就花了不少。后来发现机器人会识别陷阱合约，而且它的节点比我的好，最后就放弃了。

Friend.tech：这是做社交的项目，KOL上去发币，你买这个币就能进KOL群。如果能爬推特上大V的数据，等他在FT上开房间发币后第一时间去买，也可以赚钱。

它会暴露一个地址，因为玩FT会给你创建钱包，这个钱包绑定了推特或谷歌邮箱。它用的是Privy（类似AA钱包的东西）。有了地址就可以查到绑定的推特，再查粉丝数量，然后根据这些制定策略买入卖出。

当时还有人故意创建推特号刷粉，刷个几万十几万粉丝去骗机器人。发点黄图、色情视频就能涨几万粉，然后把账号改成Web3大佬的样子。

三明治攻击：Uniswap做交易有延时，为了防止价格波动导致交易失败，会给一定的价格容错空间。机器人会钻这个容错空间，把本来你能换更多的价差给抹平了。

之前以太坊基金会卖ETH时也被套了几千刀。现在三明治已经转到内存池上了，要做这个需要有内存池的节点，还要跟别人抢gas费。除非有Flash bot，但现在好像不好用了。现在比较大的团队，一天能赚上百万刀。利润真的非常庞大，但90%给了矿工。

我之前做的不是三明治，是DEX之间用闪电贷做套利。一般要交70%给矿工。而且链上数据太透明，可以做些跨链交易或DEX到CEX的交易，或者去做小币种、冷门swap，主流的话可能没那么多利润。

清算：DEX之后另一个比较大的套利机会。但这个也蛮卷的，清算只有到牛市过了、币价大幅下跌的时候才会多，现在都不太行。

利用规则漏洞

Fomo3D：这是2019年的项目，在以太坊上做了个盘子，最后一个进去的人可以拿走全部资金。累积了几千甚至几万个ETH后，被一个黑客堵死了以太坊网络。

设计是你花一个ETH进去，如果接下来一个小时内没有别人进来，所有奖励就归你。黑客作为最后一个进去后，发了很多垃圾交易把以太坊网络堵死，花了几百甚至几千个ETH的gas费，堵了一个小时。他是拉高gas费，不断发交易，如果你发的比他高，他就再发交易把你的交易盖住。

那时候还是gas price算法，现在是EIP-1559算法，要堵一个小时成本会更高。

USDC暴雷：硅谷银行暴雷导致USDC狂跌，跌了十几个点甚至20点。链上有很多套USDC跟其他稳定币的机会。

有很多合约卖东西按U计价，直接在合约里写死USDC=USDT=BUSD。可以用USDC买，买了之后可以赎回。平常没问题，但USDC暴雷时就引发挤兑。

我找到过一个合约里面有十几万余额，如果全部换走，按十个点算能赚1万多刀。但我那时候不太清楚链上闪电贷，1万1万地换，结果被某个机器人发现了，他钱多直接一下全换走了。估计有监控看到交易异常，复制我的交易直接套了一笔。

所以平时如果能多收集一些把汇率写死的合约，特殊时候可能会有用处。

GameFi五花八门：游戏比一般链上东西复杂得多，因为有链下逻辑。之前比较火的是链下游戏，现在有全链上游戏。如果有套利机会，不带链下的可以用传统Web2的东西，比如攻击服务器。

我之前玩过一个可以撸的游戏，完成任务就给你币。但我没用脚本，只是自己一个人弄。过了几个月币崩盘了，官方说被工作室给撸爆了。

现在打金的游戏有Big Time等，我还没玩过。之前Axie、Decentraland、那个马的Mana我也玩过一阵子，完成任务直接给钱包发币。那时候还是0.5个Mana，我觉得不值钱就卖了，后来涨到2刀一个。

ETH分叉：以太坊分叉时，所有官方DeFi项目都转到POS链上，ETHW上面的项目就没人维护了。相当于分开了一部分数据，但数据换成ETHW还值点钱。

一开始官方界面不支持，要自己去调合约。那时候浏览器也不大好用，我最后是自己写合约用Remix调。我本来存有USDC，把假的USDT换成ETHW，换了几百几千。

后面的分叉也一样，如果关注以太坊升级，像质押项目肯定也有机会。现在以太坊上面有什么东西就去撸一遍，之前遭受过攻击的重新攻击一次，可以换点钱。不过现在ETHW已经不值钱了，一开始的时候还值9刀。

如果提前知道技术路线，可以提前布局质押这个方向的项目。

AA钱包：我之前看过，它升级了好多版本1234的，我一开始一直用都不知道用哪个版本。

执行层面

代码漏洞：跨链桥被盗太多了，有的是私钥被盗，有的是合约漏洞。

社会工程：龙网是之前的一个交易所，据官方说法是工作人员收到一个邮件，里面包含安装包，安装后交易所资料就被盗了。这是社会工程方面的案例。

很多公司其实代码方面没问题，但内部人员被渗透或被攻击。我之前做的公司，合约私钥就直接给我了，我觉得这有漏洞。工作人员不应该这么轻易接触私钥。这也是执行层面的漏洞，不完全是代码层面的问题，是公司流程和人员方面的。

估算这个盈利时间，投入的时间成本至少得一年以上，得研究。时间短的话不一定能找到机会，找到机会也不一定套得出来。收益太看人了，可能是一顿饭的钱到发大财，差别很大。做这个人跟人的差别就很大。

3. 远程接单

Web3比较流行远程工作。我之前疫情时在公司远程工作过一段时间，后来离职继续干活。

按我的想法，远程工作最好找老外，拿欧美工资，达到美国水平。但这要求比较高：

要会英语
要懂工作流程
还得有渠道去找
签合同、收款也是问题

目前比较多的是可以发U，按美元或人民币计价。发U倒是方便，不用开户换汇。一部分是国内的，中国人对接。还有一部分是香港和新加坡的，也算华人，可能给的比国内多点，月薪差不多5万人民币（不是刀）。最高的是欧美的，但具体多少我没见过。

第二个是接任务。有一些任务平台，但我找到的都是做翻译的。做代码的要求英语比较多。现在还有一些外包项目。总的来说在国内接任务不算多，如果去找外国平台应该会更高，但渠道和经验都是问题。

最后一个是自己找客户。我有几个群友问我做东西，但一方面市场价我不是很清楚，另一方面合作成本也是问题。一般应该是先付一半，做完后续再付一半。相比找任务，直接跟客户谈条件会好一点，但得有自己的客户源。

做这个最好先有工作经验。远程沟通效率比面对面低，而且比较费时。如果没经验，沟通合作很难，项目可能做半年都做不出来。

我之前做远程就有这个问题，合约写完了，前端后端等了两个月都没做出来。人家按月发工资，但我觉得很无聊。我把合约写完了就给他写文档，写了一个月文档。后来也算了。

远程工作是蛮舒服的，自己把任务完成就行了，不用担心领导在背后盯着你。你上班的时候看行情什么的，可能会担心领导盯着你，但自己远程的话就轻松很多，反正没人盯你，干别的也管不着。

做远程接单差不多也要一年以上，有机会拿到欧美行业的薪水。

4. 自媒体

我一开始做分享，发现有很多人来加我好友，我就做了个群。我就想着怎么把这些群友变现。

我搞了个圈子，一周发一篇文章，他们有什么提问我都回一下。做自媒体其实赚不到多少钱，远不如你自己去打工。但它可以扩展你的关系，别人会相信你。

比如我这次来这边，也是因为我做的自媒体，有人看到我然后邀请我进来。之前还线下约过一次。如果没有做自媒体，可能我们一辈子都不认识。钱还是次要的。

如果想做自媒体收费，有两种：

做个圈子收会费
卖教学，一篇教学按天收费

做技术偏技术方面的，我从2022年开始做了一年多，写了点东西。目前群里差不多1000个人。主要收益是一些渠道方面的、关系方面的，还有别人的信任，可以降低以后合作的成本。

目前我只是做文字方面的，写篇文章。接下来可能会扩展一下做视频，感觉受众可能多一点。有的人写代码的时候不想看文字，就听一些东西，拍个视频有一搭没一搭地看，感觉比成本低，轻松一点，毕竟不光能看还能听。

5. 工作附加属性

去上班不光能拿工资，在Web3工作特别是区块链公司，有一些奖励可能是token、NFT或者项目的销售分成。分成一般是合伙人比较多，员工没什么分成。

我之前公司发NFT，发1万个，作为项目员工可以给你一两个。一开始那个不值钱，后来又没给我分，比较尴尬。我离职也是因为公司自己做了一个项目还比较赚钱，但没给我分，我就感觉没意思就不干了。

Token的话，之前做远程时那个人说以后发token给我分0.5%，但后来项目我感觉不太靠谱，又拖了很长时间就不做了，那token自然也没拿到。

Token比股票期权好一点，因为股票期权得上市后才能拿到，token只要上线swap或交易所就能直接变现，周期没有那么长，变现比IPO快多了。当然前提是得找一个比较好的公司。

做工作可能会有一些内部消息。比如我是写合约的，链上的一些机制会给我配比表。如果那东西值钱，我就可以提前囤一些比较稀有的。还有一些更新，比如版本更新要改什么机制，如果你知道的话可以想办法搞一些。

我之前公司有一个员工，公司不是卖NFT嘛，他有内部渠道能自己绕过去买，买了100多万吧，后来被抓到了。

说到可升级合约，这又是一个问题。可升级合约理论上什么都能升级。如果是不靠谱的项目，他直接把合约升级，把你的币全踢走就跑路了。

最后一个是合作方的消息。这方面市场接触比较多，你要做项目市场的就接触到很多合作方。我有几个朋友之前做DeFi的市场，不知道买了什么就发财了。但如果你是做技术的，除非专门负责跟别人对接，一般是技术领导会负责跟别人对接，这样才能拿到消息。

工作附加至少也要一年时间，收益看你的工资和公司。比如币安这种大公司机会很多。小项目本身就干不了什么，也没什么可套的。

被动收入的方法

1. DeFi质押

目前最稳的是稳定币。比如MakerDAO做得比较大，年化5%。它是用美国国债做准备金资产，有5%的年化收益率。但在主网上gas费比较高，资金少了不一定划算，至少要500刀，不然一年才25刀。

资金量比较大的话，可以抵押进去，拿到的代币可以再重新去借贷做杠杆。收益率是阶梯式的，钱越多收益率越低。一开始好像是8%,后来钱多了就降成5%了。

好处是：

降低门槛，不要去券商开户、做KYC
收益率全球都能来
只要合约是开源的，钱就是安全的

质押分单币和双币：

单币：稳定币比较推荐。其他类型的币要做对冲，不做对冲可能亏得很惨。我之前压过一个币压了一年跌了80%,给我50%的利率也没用，基本纯亏。做对冲的话合约费率开太高也不一定划算。
双币：比单币收益高一点，一般8%到10%。现在很低了，之前牛市有十几20%。做稳定币比较保险，但有些项目会额外奖励swap token。牛市时这个token会涨很多，带动额外收益。价格波动后要小心无常损失。

对冲要用期权来做，但我没研究过。除非项目跑路或者假币，不然一般不会亏。研究一下差不多一个月时间，可以拿到至少5%的年化利率。但要真大规模投入，我建议还是分散一下，因为区块链风险比较高。

2. 全球利率

我刚查的一年期国债利率：

美国5.4%
香港4.6%
德国3.7%
新加坡3.3%

最简单的方法是去香港，香港有美元存款和国债。我去开过户也买了点，属于比较稳的被动收入。我没做基金、股票，就买了点债券和定期存款。

香港比较推荐中银汇丰，还有招商永隆这几个银行。汇丰有个国际转账到其他地方的汇丰银行免手续费。但要去开别的国家的汇丰银行比较难，可能要50万存款。

稳定币之间也有套利机会。比如币安上面稳定币质押会给收益，USDC、USDT这些之间可能有万一到万二的收益。这属于稳定币之间的套利。

还有资金费率套利。很多链上和交易所的资金费率收益时间不一样，可以利用这个去吃资金费。或者当某个币资金费率负得很大（空头很强）时，会有一批人想吃资金费开多，你可以在合适位置开进去吃他们那一波拉升的钱然后赶紧跑。这偏向于合约交易。

时间投入一个月以上，收益看你去哪个地方，大概能5%左右吧。

3. 返利卡

币安发过一个Visa卡，质押300个BNB就给你返8%的消费金额，花100块钱返8块钱。但额度是5000欧元，返利最高500欧元。我用了一段时间后，合作的银行好像不跟币安合作了，银行卡也被吞掉了。现在币安卡好像不发了。

还有Crypto.com的卡，但大陆好像注册不了。

借记卡方面，香港有汇丰银行的Level借记卡，消费按0.4%给你返。汇丰是按港元返，你得花港元，100%返。

信用卡方面有美国的信用卡，但需要美国信用记录。我只是加了个群看到有人聊，但具体没操作过。开卡奖励都是几百刀。

时间至少一个月，收益如果光拿返利的话，把U换成港币绑微信支付宝，卡费是0.5%。

4. 货币兑换

一般出U的话怕冻卡。我现在一般走银行渠道，但银行手续费比较高。券商的话一般会给你一个免费额度，有的券商不是按百分比收费，是按固定收两到三刀。

还有一些支付机构，比如Wise、Payoneer，他们是专门做货币置换的。但要小心有些老牌机构可能会跑路，最好不要存钱，要换的时候自己换就行。我朋友被冻过30万，我也赔了几千块钱。

银行方面主要是找对加密货币比较友好的银行。传统银行不支持交易所转账，得做过一道——从交易所换成欧元或美元，先到对加密货币友好的银行，再转到传统银行。

研究差不多起码一个月，收益是有更安全的渠道。现在很多U商做U卡的汇率基本都是2%以上，如果研究透银行这套就可以省下来，基本1%到3%。

最后的建议

花钱可能比赚钱更重要。因为要达成不必赚钱的目标，需要：本金 × 被动收益率 > 支出

增加本金比较难，提高被动收益率也很难，但减少支出相对容易，这个是你可以控制的。如果花了钱能提高你的收益，那就更好了。

最后，祝大家都能吃到这个饼！

Solana交易分析与钓鱼欺诈

开场介绍

大家好，我是登链社区的汤尼熊，欢迎大家来到我们Open Space公开课。今天很高兴邀请到Go Plus两位研究员，一位是吴志颖，还有一位是杨晶晶，跟大家分享Solana的交易分析以及钓鱼欺诈。

感谢主持人的介绍，我们今天的主题是Solana上的交易分析和钓鱼欺诈。这不是一个非常学术性的报告，我们打算分享一下近期在这个领域的一些探索和结论。

背景与现状

我们知道Solana最近其实火起来了，一些钓鱼行为也扩展到了这个生态上。比如在以太坊、BSC这些生态里面的钓鱼行为，已经在Solana上开始扩散开了。

右下角有一个Scam Sniffer的报告，在去年年底12月份就有超过2000个用户遭到钓鱼，损失金额已经达到了百万美元级别。所以我们希望通过这个报告，来引起大家对Solana钓鱼欺诈的重视。

在讨论钓鱼欺诈之前，我们希望先对Solana交易进行一个讨论。如果要完整了解钓鱼欺诈的话，不可避免地要对交易执行进行理解或分析。

Solana交易基础

RPC接口

Solana交易可以通过官方提供的RPC接口来获取。所谓RPC接口，就是能够实施区块链节点之间的通信，或者采集区块链数据。这里提到的RPC方法，更多是指JSON-RPC，而不是gRPC之类的。

常见的返回数据主要包括：

交易涉及到的账户列表
交易中涉及到的指令
代币余额变化

这一点和以太坊的交易还是有些不太一样。其中最重要的还是指令，指令是用来实现具体业务逻辑的，交易触发了什么过程就由这个来决定。

指令结构

这里的指令和以太坊相比还是有些不同。在以太坊的交易中，常见的触发函数或触发某些过程的手段，是在交易的data里面去指明哪些函数要被触发。如果要触发好几个函数，在Solana里面只需要在交易里面塞多个指令就可以了，不用像以太坊那么麻烦。

对于交易里面的指令，它会有几个比较重要的部分：

Program：指明这个指令要触发哪一个程序
Accounts：这个指令会涉及哪些账户
Data：指令输入的参数是什么

右下角这张图展示的是我们怎样从原始数据或RPC数据里面去解析细节。对于一个指令，它的account里面全都是数字，这里的数字表示在交易账户列表里，哪些索引对应的账户地址是跟这个指令相关的。

Data是instruction data，是一个base58编码的字符串。这个字符串base58解码以后，第一个数字表示的是这个指令触发的是这个程序里面第几个函数或函数的序号，其他数字就是这个函数输入的参数。

Program ID Index指明交易账户列表里面的第几个账户是我要触发的那个程序的地址。

版本化交易与Address Lookup Table

在解析指令的过程中，我们是把所有的账户、用户地址都放在交易里面。但实际上Solana的交易体积是有限制的，只有1200多个字节。考虑到地址是一个比较长的字符串，如果全部放在交易里面，只能放35个账户地址。这种交易我们叫它经典的交易。

放35个地址对于一些更复杂的业务逻辑来讲其实不太好。如果希望触发更多的指令，可能就会受到约束，因为账户地址不能再扩展了。

所以有一些协议，就是版本化交易，它扩展了交易里面可以涉及到的地址列表。具体实践是引入了一个Address Lookup Table（ALT）来扩展地址列表。

ALT是存储在链上的一个账户里面的数据。这个表格以程序数据的方式存储在链上的某个账户中。当我们发起一笔交易的时候，可以在交易里去指定使用的ALT的账户地址，以及要用到这个ALT里面哪些索引对应的地址。

左下角这张图形象地展示了这个效果。经典的交易把所有地址以原文（32个字节）全部放到交易里，大概要160多个字节。如果改成用版本化的交易或ALT的方法，只需要放32个字节（ALT的账户地址）以及ALT里面那些指定地址对应的索引就可以了。这样存五个地址，空间就缩小了很多，缩小了3/4。

如果通过RPC去请求，也能看得到。有一些账户列表里的地址是从交易里面来的，直接写在交易里了；还有一些是从ALT里面来的，也会标注出来。

SPL Token

Token是区块链上一个非常重要的概念。以太坊上提供了ERC代币协议，如果开发者希望发行一个代币，只需要按照协议规定的输入输出去实现一个自己的程序或合约就行了。

但在Solana中，它给了一个不需要自己写合约的方案，这也规避掉了很多自己写合约可能带来的问题。如果是Solana上的代币发行方，只需要调用Solana的程序库，就可以自动发行一个新的代币。发行的这一类代币我们叫它SPL Token。

常见操作包括：

创建一个新的账户
创建一个新的代币
铸造
转移
代币授权
代币兑换等

更多细节可以查看GitHub链接。

Mint Account和Token Account

有关SPL Token，还有两个比较重要的概念：Mint Account和Token Account。

它和以太坊的token不太一样。SPL的token不直接把token存在你的账户里，而是新开一个账户，由这个新开的账户来存储现在持有代币的情况，这个账户就叫Token Account。怎样指明现在存储的代币类别呢，就是用Mint Account来指明。

在右下角这张关系图里面可以看到，对于某一种代币，每一个持有这个代币的钱包（Wallet Account）都有一个对应的Token Account。Token Account指明了代币类别（Mint）、owner就是这个钱包是谁，还有amount就是持有这个代币的数量。

从交易的RPC里面也可以解析出来，只要加一个参数jsonParse就可以了。比如在右下角这个解析结果里，source表示发送方的Token Account，destination表示接收方的Token Account。还有一些程序的地址，就是Token ID，表示SPL Token官方发行的工厂程序的地址。还有amount、decimals这些就是金额以及小数位。

虽然RPC提供了一些比较便捷的手段，但要解析这些不同类别的指令还是得有一些额外的努力。所以我们这边有一个开源的工具Blockchain Spider，可以比较快地帮助你实现这个功能，有兴趣大家可以看一下。

模拟交易

基本概念

在介绍完交易的概念以后，比如说我们想要发起一笔交易，在发起交易之前，其实有一个手段可以在交易上链之前观察交易的执行结果，就是模拟交易。

模拟交易怎么做呢？它也是通过RPC发起的。我们构建完一个交易的对象，然后将它序列化以后，请求simulateTransaction这个方法。它会返回模拟交易的结果，比如说哪些账户代币发生了变化，哪些账户权限有变动等。

这个功能跟EVM兼容链里面的eth_call或debug_trace_call有点像。这个功能在钱包软件里面也经常见到。比如Backpack这个软件，交易发起之前会给你模拟一下，看一下这个交易执行完以后会出现哪些变化。这其实有利于我们作为用户去检查交易的安全性。

反模拟

但是某些情况下模拟交易是会失效的。有一些反模拟或虚假模拟的方法，可以导致模拟交易失败。

反模拟是指交易模拟因为某些原因，比如网络原因，导致交易执行结果没有办法被模拟出来。

我列举了两种可能的原因：

1. 钱包的实现机制：早期的Phantom，大概21年的时候，发起多笔交易时会把不同交易内的指令全部合并到一个交易里面，然后再实施模拟。因为交易大小有限制（1200多个字节），如果超过了这个限制，模拟交易就会失败。这是早期钱包实现的机制。

2. 网络原因：做模拟交易也是要请求一个RPC服务的。比如触发了拒绝服务攻击，或者在浏览器里Chrome浏览器装了一个插件，那个插件把模拟交易的请求给代理掉了，代理到了他自己虚构的服务或不存在的服务，那模拟交易也会失败。还有一些比如请求太多，长时间未响应，也会导致模拟失败。

我们举了一个例子，简单写了一个代码来实施反模拟。拿Phantom钱包为例，在实施模拟交易的时候有意制造一些网络错误。

代码是这样的：首先通过Solana的web3去连接一个RPC服务，在RPC服务搞完以后，创建了很多交易——一笔交易里面有60条指令，这样的交易搞了50个。把这些交易收集到列表里面以后全部发给钱包去做签名和发送。

我们算一下，这边有3000个指令，数据算比较多的。如果你的网络不是特别稳定，或者服务或远端的服务不够稳定，有可能就会导致网络超时。像这种情况下，模拟结果你就看不到，但实际上如果你点了确认，你的钱就被转走了。

虚假模拟

虚假模拟是指虽然模拟没有受到网络波动或什么原因，但模拟出来的结果跟链上执行出来的结果可能不太一样。

我们列举了两种可能的原因：

1. 持久化的随机数（Durable Nonce）：这本来是Solana链上的一些特性。Solana的交易在发起之前要去引用一个之前的区块哈希来保证安全性，比如防止重复等。但这种方法对多签场景下不太友好，所以这个机制推出后允许你先签名这个交易，然后在未来的某个时间再发起交易。

但是如果你的交易触发了一个可升级的合约，那么签名的时候模拟出来的交易结果可能和发起交易的执行结果不一样。比如我先签名，签完以后有人恶意改了这个可升级的合约，把它升级了，里面变成了钓鱼的逻辑，然后我再把签名以后的交易上链，这个时候就出问题了。

2. 钱包的实现机制：某些钱包在同时模拟多个交易的时候结果会不太准确。

我们还是用Phantom钱包举例，以第二个比较简单的为例。在这个例子里面跟刚才的代码基本没有区别，唯一就是数量从50改成了2。

同时发起两笔交易的情况下，模拟是可以成功的，也会返回余额的变化情况，但这个结果不太准确。我们可以算一下，每一笔交易都有50个指令，每一个指令都是200个单位的Lamport（Solana的最小单位），每一笔交易发送的金额都是0.00001个SOL。我们发起了两笔交易，那应该是0.00002个SOL。

这里相当于钱包只给你模拟了一笔交易的结果，如果你确认了，其实它是发两笔交易出去的，结果可能不太一样。通过这种虚假模拟的例子可以看到，模拟的结果也不一定特别可信，这种方式可能会给钓鱼者提供一些方法，让用户资金产生泄漏。

Solana钓鱼类型

经过前期调研，我们发现Solana上目前存在多种类型的钓鱼诈骗，主要流行的有四个类型：

空投诈骗
钓鱼签名
权限转移
地址投毒

下面对这四类分别展开介绍。

1. 空投诈骗

空投诈骗是指钓鱼者在Twitter、Discord等社区中投放伪装成空投活动的钓鱼网站链接。

如果是针对NFT的链上空投钓鱼，是指钓鱼者向用户空投关联了钓鱼链接的NFT，并诱使用户点击这个链接。

案例：用户收到了一个声称可以兑换1000个ZERO代币的NFT，用户点击了NFT中的链接并签署交易，后面发现钱包中的ZERO、USDT等代币都被盗了。

原理：钓鱼者通过虚假的空投活动诱使用户进入网站，并签署将钱包连接到该网站的交易。这时网站会发起包含一个或多个SOL或SPL Token转账指令的钓鱼交易，来获取用户的相应数字资产。

钓鱼者使用一个或多个指令转账是有区别的：

低级钓鱼手段：一笔交易转一种类型的代币，只进行SPL代币的转账
升级版钓鱼：在一笔交易中包含很多个转账指令，可以把不同类型的代币全部转走

2. 钓鱼签名

一些有经验的用户会通过观察钱包的模拟交易结果来避免空投钓鱼。然而钓鱼者利用这一点，采用了反模拟和伪造模拟的技术来迷惑用户。

如右图所示，这里显示的是钓鱼者伪造的交易模拟结果，可以看到有丰厚的收益，从而增加恶意交易被签名的可能性。

总结：钓鱼签名通过合并交易、恶意浏览器插件等反模拟手段，使得钱包软件显示虚假的收益结果，甚至不显示模拟结果，从而诱导用户签署钓鱼交易。

反模拟技术隐藏了交易执行结果，用户看不到，会导致用户无法了解交易的风险，进而确认这笔交易。

3. 权限转移

首先介绍一下，Solana上的SPL Token的approve操作并不会直接导致代币的转移，但会导致代币资产权限的转移。

因此，钓鱼者会通过诱导用户签署包含approve的钓鱼交易，使得用户钱包中的某个代币账户所有权转移到钓鱼者的钱包。

在代币账户所有权发生转移的时候，如右图所示，此时主流钱包软件会发出所有权转移的警告提示。在获取代币所有权之后，钓鱼者就可以取走所有的代币资产了。

原理：由于Solana中的每个代币都会有一个单独的账户（Token Account），黑客发起包含Create Set Authority Instruction这个操作的交易。发起这个操作就可以改变代币账户的所有者。一旦该操作成功，哪怕代币还在用户的钱包中，用户也无法转出了，只能看黑客进行操作。

4. 地址投毒

地址投毒的目标是诱导用户向钓鱼地址进行转账。该钓鱼账户与用户日常交互或用户认可安全的地址很相似，比如它们有相同的前缀或后缀，而这些前缀后缀都是经过精心设计的。

如右图展示的，可以看到这两个地址除了红圈框出来的不同之外，前缀和后缀都是相同的，从而迷惑用户使用这个伪造的钓鱼地址，并向该地址进行转账。

地址投毒常见于以太坊、波场链，近期也逐渐扩散到Solana生态中。

地址投毒可以细分为以下几个类别：

类型1：零额度或少量转账
钓鱼者转移零额度或少量的加密货币，诱导用户错误地复制历史交易记录中的钓鱼地址。

类型2：转账和空投的混合投毒
钓鱼者通过在交易备注中添加空投钓鱼链接来实现投毒。如右图展示的，钓鱼者通过少量代币的转账，在memo（交易备注）中添加钓鱼链接，从而诱导用户点击链接。

类型3：靓号投毒
所谓靓号是指钓鱼者生成和系统程序ID类似的地址作为钓鱼地址。如右图所示，使得用户错误地认为该地址是一个受信任的地址。

这类诈骗在2024年2月3号，Scam Sniffer在推特上报道了这起Solana地址投毒事件。可以看到攻击者生成和系统程序相同尾号（五个1）的地址，从而让用户误认为该伪装地址是一个正常的系统程序。

靓号地址可以通过命令进行生成。比如我想要一个四个8的前缀，那么就把四个8这个前缀写到命令中，然后就可以得到。

应对措施

我们给出了以下几点应对措施：

1. 善于利用钱包交易模拟功能

使用Phantom、Backpack等钱包提供的交易模拟功能，仔细查看交易模拟结果。对钱包拦截并提示有风险的交易，尽量做到不确认。

2. 严格审查交易内容

不轻易签署任何无法了解模拟结果的交易。有必要的时候也可以手动检查指令的相关细节。

3. 注意交易对手方

比如地址投毒诈骗，它通过模仿系统程序ID或项目方的地址，故意让用户混淆钓鱼地址和合法地址。这时候我们需要注意交易的对手方是什么样的。

问答环节

Q：用户列表是怎么存的？Address Lookup Table是存在哪的？

A：Address Lookup Table相当于链上一个合约里面的数据，是一个全局的。将来任意的交易都可以访问那个表。这个表是可以添加新的地址的，但不能删。如果现在我的地址没有在上面，我要发起一笔交易，需要额外发起一笔交易往这个Address Lookup Table里面添加新的地址进去。大家可以共用一个Table，也不是特别有必要为每一个交易申请一个新的Table。

Q：Mint账号跟创建Token的工厂是什么关系？

A：在Solana上这些账户都是由系统的工厂程序创建的，不是你自己创建的。比如Mint Account、Token Account、Wallet Account都是有一个系统的程序创建出来的。要触发那个系统的程序才能拥有这些Account。

Q：权限转移时模拟会展示吗？

A：权限转移还是会提醒的。主流钱包一般都会提醒，比如权限从某一个自己的钱包地址转出的话，一般会给你提示一个警告，最好不要签。但如果你非常信任这个程序，还是可以签的。

Q：权限转移为什么不直接关掉？

A：确实有应用场景。比如我希望把资产交给某些DeFi应用，让他帮我去赚钱，或者是机枪池，希望他帮我去找更多的质押项目去生成利润。这种情况就是把钱交给别的程序让他帮我去管。这种程序一般都会打上标签，大家都比较信任他，就不会轻易给你做提醒。

Q：模拟交易是在DApp里写还是钱包自动有？

A：一般的钱包都有模拟交易的功能。虽然写代码的时候有选项可以让他不要模拟，但钱包软件还是比较谨慎的，会直接把这个操作忽视掉。基本上能够确认的交易都会模拟一遍。

Q：Solana的USDT合约没有开源，怎么知道具体逻辑？

A：Solana上不太需要去看合约的具体逻辑。因为Solana上的token都是官方程序给你写死了的，给了你一个模板，你写出来的token肯定是符合安全性要求的，大家都一样。如果要区别哪些是假的token，可以通过地址。做转账或模拟交易的时候可以看到，假的代币的地址跟用户公认的代币地址应该是不同的。

Q：如何防止MEV攻击？

A：夹子在以太坊、BSC、Polygon这些链还是挺常见的。Solana上不是所有人都能出块，只有几个受控的节点（被验证过的、被公认的节点）是允许出块的。这种情况可能会比较少。不排除有MEV，但估计没有以太坊那么严重。至少目前还没有听说过在Solana上大规模泛滥MEV攻击的情况。

Q：如何检测貔貅盘？

A：还是回到SPL Token。Solana的token是不允许你自己搞的，只有Solana给你提供的模板，你必须按照这个模板来创建token。在以太坊上只给你提供了一个ERC的代币协议，你想怎么实现是你自己的事情，在里面插一些貔貅盘的逻辑也没关系。但在Solana上按照官方模板来实现，一定是可以转走的。你要检验他的Program ID一定要是官方的Program ID。

Q：虚假模拟第一种情况有没有方法识别？

A：在RPC层面还是会有一些阻断方法。虽然通过这种机制让模拟交易看起来没什么风险，但最终还是要将交易发送上链，也要走RPC，也要通过sendTransaction方法。一个潜在的解决方案是搞一个自己做过安全加固的RPC。在这个RPC上做一些交易分析，不管有没有模拟过，在最后提交交易的时候，交易会被RPC服务做一些分析。如果服务觉得交易确实有问题，就不让它发起。从RPC层面是会有一些解决方法的。

Q：同时模拟多笔交易钱包出现缺陷，直接调用Solana RPC的simulateTransaction方法是不是就没有这个问题？

A：如果是自己去模拟，把每一笔交易的模拟结果都拿出来看，是不会有这个问题的。只是钱包做的时候可能只给你模拟了其中一笔，就会有一些偏差。

Q：如何查看没有开源的合约逻辑？

A：看不到源码的逻辑有两种可能。一种是看到的是系统里面定义的那些过程，比如SPL Token用预定义好的模板生成的token，可以到Solana的library在GitHub上看，他那个SPL Token具体在某一个操作上的逻辑是怎么样的。还有一种是程序确实不开源，这种只能通过逆向分析的方法把源码拉出来看，那就太难了。如果确实又没有公开ABI或Solana上叫IDL，又不公开源码，只有一些底层的操作码字节码，那确实没有办法。

Q：如何查看Lookup Table？

A：在getTransaction里面加一个encoding的参数是jsonParse。加了这个以后，获取的交易里的账户地址列表就会显示出来哪些地址是来自于Transaction，哪些地址是Lookup Table里的。

以上就是我们这节课关于Solana交易分析与钓鱼欺诈的全部内容，谢谢大家！

为什么你应该对 MEV 保持乐观

https://learnblockchain.cn/video/play/1469
视频由: ETHGlobal 发布，登链社区翻译只为分享优质内容。
登链社区始于 2017 年，通过高质量内容平台和线上线下集训营，助力 Web3 开发者成长
视频 AI 总结：
该视频的核心内容是介绍 Flashbots 的 Shea 对 MEV（最大可提取价值）的未来持乐观态度的原因，并深入探讨了以太坊的区块构建过程及其演变。她解释了区块构建的重要性，以及 Flashbots 如何通过 MevGet 和 MevBoost 等协议来解决 MEV 带来的问题，并介绍了 Buildernet，一

大家欢迎回来，这次壁炉聊天确实非常有趣，幸好我们有一个缓冲时间，完美填补了这个间隙。接下来我们就直接进入下一个环节，而且这次我们不再休息，要继续完成下午的剩余议程。那么不多说了，让我们欢迎下一位演讲者，而这次，我想邀请来自Flashbots的Shay为大家讲解，为什么你应该对MEV保持乐观，请大家热烈鼓掌。

大家好，让我看看，我是来自Flashbots的Shay，今天我想谈谈为什么我对MEV的未来充满乐观，我也认为你应该如此。

区块构建的核心地位

如果你在构建以太坊，最近可能经常听到关于扩容互操作性等话题的讨论，让L1更具竞争力。但你可能不了解的是，所有这些都依赖于一个许多人很少关注的角色，这就是我们所说的区块构建者，这也是本次演讲的核心内容。我将介绍区块构建是什么，以及它在以太坊上的演变，近期的技术突破与升级，并探讨这对以太坊的诸多积极影响。

什么是区块构建

那么什么是区块构建？稍后我们会深入精彩内容，但最简单的解释是，每个区块链区块包含一个交易顺序列表，区块构建就是决定下一个列表的内容，哪些会被包含，哪些会被排除，以及交易顺序如何安排。

以太坊默认客户端有内置处理方式，它只是按价格排序公共池中的所有交易，按MEP池排序。这对简单转账等操作效果良好，但当需要执行DeFi操作时会更复杂。

许多DeFi协议会提供无许可激励，吸引机器人执行有用任务如清算不良债务，或对齐两个交易所的价格，我们称之为激励机制——最大可提取价值（MEV）。有时用户如你我进行DeFi交易也会产生MEV，例如，如果他们的交易引发价格波动，这实际上为机器人创造了套利机会。

MEV带来的挑战

生成或竞争MEV的DeFi交易比简单转账更复杂。它们需要隐私保护，因为如果你公开即将进行交易的事实，他人可能抢先交易并给你更差价格。同时还会产生大量垃圾交易，由于这些高收益MEV奖励的竞争激烈，只有少数能真正获胜，最终导致大量交易失败。

这曾给以太坊带来严重问题。大约五年前，MEV导致链上充斥垃圾交易，用户在公共MEV池中被抢跑攻击。

MEV-Geth的解决方案

2020年Flashbots推出了侧链MEV-Geth，通过链下拍卖增强标准客户端，以解决MEV竞争问题。首次实现向矿工私密提交交易以避免抢跑，并引入了我们所说的回滚保护，防止失败交易上链。这对MEV机器人非常有利，因为未中标无需承担损失，大幅清理了以太坊的垃圾交易，同时实际上提升了矿工区块价值，因机器人不再计入失败交易风险。

所以，好的，任务圆满完成，我们解决了区块构建问题，我可以离开……

仍存在的问题

仍存在问题。用户缺乏真实隐私或矿工承诺，即使MEV-Geth保持交易私密且不抢跑，矿工仍可窥探重组交易窃取MEV。此外这些用户问题，还导致协议中心化风险剧增，因为提取MEV和优化交易顺序实际上非常复杂，更专业的矿工可能知道获得更多MEV收益，从而进一步集中网络资源。

PBS：提议者构建者分离

2022年合并期间，以太坊推出新机制——质押者构建分离（PBS）。正如名称所示，PBS分离了交易排序，即区块构建与广播职责，将区块传输至网络，此前由矿工完成，现在由验证者。这将核心协议与MEV中心化的影响隔离开，因为所有提议者都可以，无论他们多么精巧，他们都能平等自由地访问下一个区块。

Flashbots通过名为MEV Boost的协议实现了PBS。这一实现的关键部分是一个新角色——中继器，它为不信任的构建者和提议者提供了隐私和承诺，以便安全协作，因此提议者可以窃取MEV，然后验证构建者的提交，这样提议者无需信任他们。

区块构建者市场

这启动了区块构建者市场，因此现在任何人都能竞争性地构建更优区块。我们吸引了大量参与者，效果很好，这也推动了区块构建的更多创新和竞争。

使用MEV Boost构建的区块在过去一年产生了约四倍（比无此功能的区块多四倍）的执行层奖励，这非常酷。同时也大幅缓解了验证节点集的集中化。但Talc做了一个很棒的演讲，实际上去年在ECC大会上提到过这一点，你应该看看。

总之，任务完成……

PBS未解决的中心化问题

PBS并未解决MEV的集中化问题，它只是将问题从提议者转移到外部区块构建市场。虽然任何人都可以，你知道的，技术上参与这个市场，但这并不意味着权力分布变得平等。

MEV Boost推出两年后，90%的以太坊区块由两家团队构建。这背后的原因很有趣，你可能认为胜出的构建者拥有百倍更好的软件，但实际上我们已对此进行基准测试，赢得1%区块的构建者与赢得50%的差异不大。

订单流的问题

真正原因是订单流。过去两年，利用订单流获利是以太坊最大收益来源之一。钱包和应用生成大量价值，通过用户支付的优先费用实现链上交易落地。这些应用和钱包希望从中获利，因此开始签订协议，将订单流独家发送给特定区块构建者，以换取优先处理和退款。

典型案例是香蕉枪与钛豹之间的协议，香蕉枪是顶级Telegram机器人和钛豹构建者，这些订单流争夺战的具体表现。

独家交易的危害

但这些订单流竞争的具体表现，独家交易对市场造成了严重损害。新团队加入并创新和竞争变得异常困难。这些交易大量消耗了现有团队的时间，我本想专注于开发新功能，而不是做业务拓展。

由于独家订单流交易高度不透明且相互协调，开发者常以低效方式相互竞争。这里形成了一种有趣的循环：开发者竞相高价获取更多区块，以便获得准入资格，以获取更多订单流并提升排行榜排名，让订单流提供方关注他们。但在补贴竞标时，开发者实际上提高了用户准入成本。

根本问题：信任机制

最终，我认为根本问题在于我们受限于信任机制。目前用户和钱包要获得隐私和承诺保障，需要与运行基础设施的团队建立社会协议。他们想要退款，或避免被前端攻击，运行，必须与运营团队达成社会协议。

社会协议和信任机制的问题在于无法规模化，你知道的，限制了市场参与者数量，减少竞争，导致更差结果。

前进的道路：消除信任壁垒

我想谈谈如何前进，如何消除限制区块构建的信任和排他性壁垒。这是我们多年来在Flashbots研究的问题，我想分享近期取得的几个关键突破。

我们认为减少区块构建中的信任需从技术革新开始。我们需要能保护数据隐私的基础设施，确保构建者履行承诺，并且运行速度极快。

TEE：可信执行环境

我们认为存在能满足这些约束的硬件，一种名为可信的新型机器，或并非全新机器类型，尽管我们在MEV中使用它，以全新方式，称为可信的执行环境（Trusted Execution Environment，或TEE）。我认为有人之前提到过，但基本提供机器背书，明确指定运行的软件，防止他人，你知道的，查看发送给它的敏感数据。

这基本实现了可验证执行，保密链下基础设施，比如在完全不可信的机器上运行区块构建者。你不必，你知道的，信任运营商或做特殊交易，你可以远程验证人们是否遵守规则。

最近一年我们在生产环境中应用这些技术取得了很大成功，像区块构建这样的用例。

Buildernet的诞生

我们创建了一个专门用于构建以太坊区块的网络，我们称之为Buildernet，可验证性，私密且非常快速。今天Builder Net正在构建以太坊3.5%的区块，L1区块。我之前展示过这个数据，一周前，还是2.5%，增长非常迅速，我们对此感到非常兴奋。

Buildernet的特别之处

同时也期待Builder Net升级以太坊的区块构建，有几个我认为非常特别的地方。

多运营商模式

首先你会注意到，Builder Net中有多个团队在运行节点，不同于由单一团队运营的传统区块构建者。我们可以安全地让可能互不信任的不同团队运行Builder Net并让他们进行基本证明，他们正在运行正确代码。

实际上，Builder Net有三个运营商，今天，Flashbots，暂且不提Beaver Build。

多运营商模式有几大优势：

拥有多个运营商，Builder Net对故障更具抗性，如果Nevermines节点宕机，你知道的，Builder Net仍会构建区块。我们的最终目标是让任何人无需许可即可运行节点。

Builder Net也更抗审查。节点可以自定义合规策略，即使某个运营商过滤特定交易，另一个仍可包含它们。

订单流共享

这一切的关键在于我们所说的订单流共享。Builder Net中的所有节点，将看到的交易与网络中其他节点共享。以前无法安全实现这一点，因为与不可信方共享订单流会暴露用户被抢先交易的风险，但通过这种方式解决了这个问题。

这实际上启动了一个良性循环：共享订单流降低了运行构建者的启动成本，因为你不再需要签订协议，在极限情况下，你只需启动一个节点。这会增加参与区块构建的积极性，提升核心产品的韧性和竞争性，而不是，你知道的，将所有时间花在这些协议上。随之而来的是，创造了更好的市场，吸引更多人想要使用，从而推动更多订单流进入系统。

无许可退款规则

最后，Buildernet还有一个特殊属性，它确立了无许可退款规则。所有向Builder Net提交区块的参与者都会获得对应价值的退款，他们为区块贡献的价值，而非这些零碎的握手协议。我们创建了协议级规则消除独家订单流协议。至今已退还约150万美元。

Buildernet的整体效果

整体效果相当酷。我认为这是重大进步，你知道的，如果回顾早期Builder Net的问题，通过共享订单流和无许可退款消除独家订单流竞争，并减少单点故障，使更多方能参与区块构建过程。

信任难以规模化，但Buildernet的协调退款机制，能提供比独家协议更好的执行效果。多元操作者比单一团队更具韧性。

区块构建的更广阔视角

这也是冰山一角。如果你还记得我们最初对区块构建的定义，也就是这个，实际上有很多很多，幕后有很多参与者，他们决定了当前交易如何被包含在区块中。

所以我认为，区块构建不再是那个单一实体，而是一个过程，一个包含，你知道的，搜寻者，解决者，填充者，订单流拍卖，序列表。

Builder Net的首个应用是解决市场结构问题，在L1区块构建中，但我们打算继续使用这些轨道，来升级堆栈中的其他部分。所以你知道的，TEE搜索者，TEE解决者，TEE序列器。作为一点铺垫，我们其实已经在运行这些功能了。

Buildernet对以太坊三大问题的解决方案

接下来会发生什么？我认为构建网络是加速以太坊许多目标的核心关键。现在我只是要抛出一堆想法，每个都可能是一场完整演讲，但希望这能引起你的兴趣，与我们和其他致力于这些项目的人合作。

好的，让我们回顾讨论内容，那些大问题，特别是三个核心问题，我认为很多人今天都在问。

第一个问题：如何超越Solana

第一个问题，如何超越Solana？我认为以太坊感受到的竞争压力并不隐秘，与其他L1链如Solana相比。对Solana无恶意，我甚至认为这是非常有益的，让我们共同进步，但构建网络能让以太坊实现差异化。

如果你关注Solana，最近，你知道验证者正在大量夹击以太坊。另一方面，早已在这一领域领先，通过开发PBS等技术。现在结合基于TEE的区块构建，我们可以进一步推进，获得硬件级保障防止用户被夹击。

我们还可利用构建网络将以太坊gas市场升级为第二价格拍卖，这，如果你不了解，意味着使用将更便捷且成本更低。这实际上意义重大，没有其他链，我知道的有这个。

以太坊作为构建平台

最后，我认为以太坊真正押注的另一点，是成为他人想构建的平台，如同其他机构或应用。就在本周早些时候，我们听到，你知道的，罗宾汉正在推出以太坊分片方案。

这里有个关键点，应用真正关心用户执行的具体方式，它们不仅仅想编写智能合约，实际上非常希望控制或参与所依赖的基础设施。我认为以太坊有两条独特路径实现这一点，这两条路径我们都可以通过构建者网络做得更好。

选项一：启动自己的分片方案

好的选项，首先是启动自己的分片方案，就像罗宾汉为应用定制专属区块空间，比如Unchain，为交易打造的定制化区块空间，或World Chain区块空间优先处理，你知道的，来自验证人类的交易。

甚至在以太坊之外，你知道这是明确的行业趋势，像Hyper Liquid这类应用，拥有为特定需求设计的区块空间链，优先处理撤单。以太坊的分片方案，核心路线图独具优势，你知道的，为此做好了准备，相比Solana这类更封闭的链。

但常见担忧是这些应用依赖中心化序列表，或仅由少数实体负责排序，往往因为这是应用正常运行的关键。你知道这很难实现真正快速，撤单和交易处理，如果你在全球各地发起大量请求。

但我觉得这仍引发问题，我们如何至少提升用户保障？嗯，重大改进是让序列表运行在TEE，然后，可验证其确实执行了，目的链应完成的操作。因此若以太坊是专属区块空间的最佳归宿，构建者网络就是使其可信的关键。

选项二：自定义共享链的区块构建流程

好的，第二个选项，第二种是自定义共享链的区块构建流程，如以太坊L1。

与Solana不同，以太坊拥有高度可编程的区块构建流程。我们曾看到那张复杂的桑基图，展示所有参与者的关系，原因在于我们外包了整个流程，整个区块构建过程通过PBS交给外部市场。

应用已在近年充分利用这一点。举个例子，一种牛交换和Uniswap引入的链下拍卖，解算器或填充者将竞争填充交易并为用户提供更优价格。整个拍卖过程会在交易上链前完成，作为更广泛的区块构建流程的一部分。

但同样存在这些权衡取舍，现在必须信任这个新的链下参与者，可能引入新权限或隐私泄露风险。没错，Builder Net也能帮助解决这个问题，可为应用提供可验证，保密通道以并行运行高质量链下拍卖，或我认为未来将嵌入区块构建流程本身。

这能真正减少应用的依赖，额外基础设施或能提升拍卖竞争。想象一下，如果Unswap X，你知道的，使用TEE让更多人参与权限，RFQ。

TL;DR，以太坊是为应用和机构设计的，Builder Net帮助它们运行更优。

第二个问题：如何扩展以太坊

好的，第二个大问题，我们如何扩展以太坊？这对许多人来说显然是首要问题。

当前扩展的最大限制其实是EVM。有更早的演讲详细讨论过这个，但快速总结，主要是MEV机器人产生的垃圾交易，现在正在消耗主要以太坊分片半数的Gas。因为手续费低廉，MEV是私有化的，机器人正用大量投机交易轰炸链，希望其中某个能成功。

两部分解决方案

解决这个问题需要两部分：

首先需要链下MEV拍卖。还记得我们曾有类似L1链上的垃圾问题，多年前以太坊主网就出现过这种情况。我们通过将MEV竞争转移至链下拍卖解决，类似于今日的区块构建者，高效区块构建流程，就像我们正在开发的，Builder Net正是减少垃圾交易的关键。

第二，还需从源头提高搜索效率，使机器人发送更少垃圾。如果仔细分析，减少垃圾的最佳方式是提供更多信息，避免人们盲目猜测，他们只需发送更少的交易。

这几乎在回避问题，如何在不暴露用户面临前抢风险的情况下向机器人提供更多数据？而TEE也解决了这个问题。我们找到了一种方法让机器人在完全私有用户数据上运行完全私有代码，无需双方或操作方泄露数据。若感兴趣还有更多内容，但首批TEE搜索者已运行数月，他们已实际捕获了L1原子市场的一部分。

这对提升Rollup效率和减少垃圾信息至关重要。总之以太坊扩展路径依赖TEE区块构建基础，我们已在BuildNet中开发这些技术，相当酷。

第三个问题：如何改善以太坊用户体验

好的我说了三个问题，第三个也是最后一个问题，如何改善以太坊用户体验？

许多人希望以太坊感觉更快更互操作。

预确认方案

让以太坊感觉更快的核心思路是提供预确认，在交易被包含前，如何确定确认有效？最佳答案是信任中心化排序器，或许用声誉机制，或许让用户质押大量资金。

如果我们改用TEE技术呢？即可验证排序器或构建者的运行软件，无需大量抵押或信任。我们已实现这一方案，名为Flash Blocks已被多家机构采用，我们认为未来可用于L1预确认。

这里有个有趣推论，顺便说这些TEE节点可互换，可以随时替换，无关紧要，如果是Flash Bot，或你的TEE权限，只要具备有效证明，因此向TEE预添加轮换选举相当直接。

改善跨链交互

解决方案，有趣事实，除了让以太坊感觉更快，构建网络还可帮助改善跨链交互。

举例说明，非常快速，若看OP风格跨链，基本包含两个步骤，首笔交易在源链落地，第二笔在目标链发起约一到两块后。但遗憾的是，需等待第二笔交易约两到四秒。

那好吧，如果你有区块构建器，这个，你可以使用闪存区块来快速预确认状态更新，从源链到目标链的变更。因此现在第二条链可以开始在，比如几百毫秒而非几秒。

好的，这里另一个有趣的地方是目标链需要获取，源链上最新确认的状态信息，从而可以接受中断交易。而今天的基本解决方案是，你需要为所有交互的链运行全节点。但如果链处于TEE，则可以直接验证证明，工作量大幅减少。

更广阔的前景

这些都是低垂的果实，我认为我们还有很多可以做的，通过高度优化的TEE区块构建器提升跨链互操作性。因为从极限角度考虑，链间的同步组合性，实际上只是如何协调区块构建流程的问题。

因此随着我们不断推进链间紧密中断处理，我认为这将开始呈现，我们之前在高性能区块构建中已解决的许多问题，你知道如何并行化流程部分，解决冲突，处理异常，回滚。

结语

总之，这全都关乎区块构建。我对这一点充满信心，因为以太坊始终走在技术前沿，比如PBS机制，以及现在Buildernet，我们已具备解决这些挑战的工具。但我们才刚刚起步，所以我希望你能加入我们这些研究开发者。

谢谢！

深入解析 libp2p [EN]

Wenkang
Twitter: https://x.com/ChenWenKang1
Slides: https://docs.google.com/presentation/d/1bq4-BLo0HR1ZqPcLf9uaCQFNt1rOO9QCQwA2NmdpV9k/edit?usp=sharing

开场

大家好，今天我们要深入探讨libp2p。这里有个问号，因为它并不算特别深入。这是我尝试了解更多关于libp2p的旅程，如果你发现任何错误，请指出。

什么是libp2p

那么什么是libp2p？实际上只是P2P网络通信的库集合，名称非常明确，由Protocol Labs开发，并且被广泛使用，包括以太坊共识客户端，以及许多其他你可能或可能不知道的分布式系统。所以是的，这就是为什么它基本上在驱动所有这些系统。

在这次演讲中，我将讨论libp2p的三个组件：传输、网络穿透和发布订阅。传输，即字节如何、数据如何实际在互联网上传输；穿透涉及如何通信，或如何找到可能在防火墙后的私有节点；发布订阅，这是P2P客户端或节点之间分发和监听其他节点消息的主要机制。

第一部分：传输

传输协议基础

这是发送和接收数据的基础协议。你可能听说过传输可能被切断，通常是TCP、UDP，或用于Web的协议，即HTTP和HTTP/3。

libp2p目前支持TCP作为传输，QUIC、WebSocket、WebTransport及WebRTC。每个支持不同环境：TCP和QUIC通常仅支持非浏览器环境，其余部分通常用于浏览器环境，允许你在浏览器与其它节点之间建立类似长连接，甚至在浏览器与浏览器之间。这是为了让QUIC协议能在浏览器环境中运行，这非常实用，尤其是当你运行需要点对点连接的网络应用时。

QUIC协议详解

我想谈谈QUIC，这是第四层协议的新版本。QUIC的作用是减少请求或网络请求的往返时间。

在常规TCP中，客户端与服务器或不同客户端之间的通信需要TCP握手——三步握手过程，即确认，然后另一方确认收到服务器的响应，之后进行TLS握手，这是用于加密连接本身的协议，最后才能开始传输数据。这就是常规TCP连接的流程。

而QUIC，因为使用UDP协议，因此无需经过常规TCP握手，通常只需一次往返：初始连接，然后同步，之后即可开始发送数据。如果是重新连接或重试，在初始连接后，甚至可以达到零往返，直接向服务器发送数据，如果之前已连接过也是可能的。

这非常令人兴奋，因为可以减少网络往返时间，意味着连接本身的开销更小，这意味着数据可以更快发送。如果你发送大量数据包，或者你想需要创建大量连接，这最终变得足够大或有效以提高连接效率。

以太坊与QUIC

来自共识客户端方面，QUIC标准并未真正最终化，这就是不使用QUIC标准的原因。他们考虑这一点确实很有趣，你知道他们没有采用QUIC，因为支持仍然不足。但非常有趣的是，由于我们之前的演讲者实际上在其中一个EIP中讨论了以太坊，他们确实谈到用QUIC替代TCP，所以新客户端可能支持QUIC，谁知道呢。你可以查看，我留下链接在这里，这样你可以随时搜索找到。

libp2p的寻址方式

在继续之前，让我们简要讨论libp2p的寻址方式。你可能熟悉IP地址的格式，比如198.5.1.100.0，还有IPv6。

对于libp2p，通常对于这个库来说，他们用多地址（Multiaddress）格式编码节点间的连接。这很容易阅读，大致上这个例子展示了它的外观。你分隔部分，可以看到IPv4地址，这个节点的TCP端口，以及这是一个带有标识符的P2P部分。这就是用来表示如何连接特定节点的标准方式，这就是非常标准的TCP连接。

之后你会看到另一种地址类型，多地址实际上展示的是中继P2P连接。所以是的，非常直观，这就是为什么libp2p协议使用它。

在规范中你可以看到，有很多协议ID的提及，用于协商使用的协议是什么。例如，这是电路中继v1，这是一个客户端在节点上使用的标识，用于说”嘿，我正在使用这个协议，你支持吗？”如果不支持，会有回退机制。看起来非常像多地址格式，但并非完全相同，但确实，这只是个趣闻，这被广泛使用。

第二部分：网络穿透

NAT与防火墙

接下来我想讨论的第二部分，这不是P2P特有的，这是当前网络中普遍使用的功能。

本质上我们所有设备，或者如果你有互联网，希望你有路由器，你的电脑会连接到路由器，而路由器通常会配备防火墙和NAT（网络地址转换器）。它本质上将公共IP地址转换为私有IP地址，这就是为什么在家庭网络中查看，所有设备通常会从192开头或类似地址开始，这是一系列具有相同前缀的地址，然后以其他内容结尾，例如192.168.0.100、101、102、103等等。

但你的公网地址实际上是不同的，你的公网地址，通常你的家庭只有一个公网IP地址，这就是互联网看到你的连接方式。

防火墙工作原理

所以当你发送请求到某个地方时，通常你需要开放某个端口的防火墙，或者需要中继来建立连接。当你发送请求时，接收端会收到请求，如何将请求返回给你？然后发送到你的IP网络，你的防火墙知道如何将请求中继回你的节点。

如果这种情况不存在，会发生的是，你将无法到达目标。这就是我们所说的允许私有连接的技术。你的防火墙，这并不一定是默认暴露的，我们的防火墙出于安全原因不开放太多端口。

如果你熟悉网络基础或网络原理，通常要暴露某个端口或将连接导向特定设备，需要进行端口转发。如果需要为每个连接都这样做会非常麻烦。所以是的，我们有这个机制来发送或接收设备请求。

连接记录机制

只是为了展示它的样子，比如如果某台公共电脑尝试连接你的电脑，发送信息时会被路由器防火墙拦截，因为路由器不会记录该节点或服务器的请求，它不会接收，可能因此无法接收。

要真正接收请求，你需要主动发起连接。如果你先发起连接，防火墙会允许该特定连接的任何响应。

所以当你发送请求时，实际上会添加一条记录说明来源信息，所以B是你的内部LAN地址，然后你的网络或防火墙会记住它指向的目标是什么。你的网络基本上会按照这条记录处理，当响应返回时，会检查该记录是否存在，或者我们称之为网络元组存在，如果存在，也会将其发送到正确位置。

打洞技术（Hole Punching）

所以我想讨论的，或者许多连接遇到的问题，是双方节点都位于防火墙后的情况，导致无法访问，因为其中一方必须先发起连接才能建立。如果双方互相尝试发送数据，会被直接拒绝，必须有一种方法让其中一方先行通过，比如先发送连接请求。这就是所谓的打洞技术。之所以叫打洞，是因为在防火墙上实际打了一个孔。

要实现这个，或允许两个私有网络间的通信，你需要某种机制。假设双方地址均已获取，当你发送时，会被拒绝，因为防火墙中没有对应记录。但防火墙会添加自身记录，假设双方互不知晓对方位置，然后发送请求，应能通过，因为现在防火墙已有记录。然后双方也能继续发送，因为存在从A到B的出站连接。

这就是打洞技术的大致过程，这是现代互联网的一个组成部分。这些都是允许你与防火墙后的人通信的组件，无需过多思考。

libp2p的穿透实现

那么libp2p是如何运作的？它与这里的例子非常相似，但你会发现它需要多个服务器，并且每个都很集中化。libp2p允许以去中心化方式实现。

这是一个三步流程，他们使用三种协议：

第一步：AutoNAT（自动网络检测）

第一次，这相当于当我运行一个节点时，我想知道是否可被访问，我想要实际连接到其他节点。第一次我需要确认我的节点是否可达，或者他们能否呼叫我。

基本上我的节点会告知所有可访问的公共节点并说，”能否尝试联系我并测试能否接通？”如果我没有被所有人接通，当我收到他们回复说无法接通，则我需要进入下一步。如果我能被其中任何一个接通，意味着我的节点可被互联网访问，因此没有问题，我可以轻松建立连接，他们可以轻松发送我更新。这就是检测的第一步。

第二步：电路中继（Circuit Relay）

如果我有问题，我们将进入下一步，即电路中继。这始于我向一个公共节点询问，一个已被所有人可达的节点，最近的那个。最近的节点实际由DHT（分布式哈希表）确定，今天我不再讨论DHT，但本质上是分布式哈希表。

我会让最近的节点作为中继节点，所以我将预留部分他们的计算资源，然后告诉他们，”你能帮我转发任何发给我的消息吗？”如果节点同意的话，你就会得到这样的结果。

回想一下，我之前简单提到了多地址和寻址机制。如果节点2同意让我作为中继，作为中间节点，接下来我可以向所有无法直接联系我的节点宣告，”嘿，我的地址是这个，通过这个地址连接我。”

在地址中可以看到，实际上会告诉所有查看者，通过查看地址就能知道这是中继节点，这是一个点对点电路，然后是我的节点标识。所以节点1、节点2通常会被实际的点对点标识替换。

这就是如何实现其他节点也能通过中继节点连接到你。但这不是永久方案，因为节点2也不愿持续处理你的计算。

第三步：DCUtR（直接连接升级）

所以我们转向方案三，即DCUtR（Direct Connection Upgrade through Relay），这允许你直接建立连接，这完成了整个穿透过程。

假设节点3不想直接连接节点1，它会发起请求，通过节点2作为中继，然后测量节点3发送连接请求到该节点所需时间。如果是私有节点，必须经过两个中继，一个用于节点1，一个用于节点3。

中继会测量从节点3到目标节点所需时间，并通过此确定向彼此发送请求所需的时间。然后他们做了非常聪明的事情：首先会发送一个同步请求，它将尝试在特定时间点调用节点1，这是发送首个请求到中继所需时间的一半，减去发送请求所需的时间。

利用这个时间，这样做是为了同步时间，他们希望同时建立连接。如果成功的话，整个穿透过程就完成了，现在可以进行直接连接。因为如果同时进行，实际上在双方网络中创建了精确的空隙，防火墙和连接得以建立，因为存在出站连接。这也是为何需要同时有入站连接。

这就是实际的穿透过程，这非常重要以连接大量节点。许多节点位于防火墙后，对于许多希望托管自己节点的标准用户，这几乎已经完成。所以是的，所有这些都被libp2p抽象化了，因此大多数时候我们直接使用，但了解这些也很重要。

第三部分：发布订阅（PubSub）

PubSub基础

最后，你常听到的内容，当我们谈论P2P以及你最常交互的部分，这是通信机制，或与其它节点交流，称为发布订阅（PubSub）。因为它使用订阅机制，节点订阅到某个主题，当有人向主题推送消息时，你将收到响应。

本质上是向主题发送新内容，你将得到结果。这在集中式环境中更容易实现，这里有一个可信的数据源供查询消息，但在P2P情况下会变得复杂一些，因为难以确定信息来源。

消息结构

这就是每个消息的结构，例如在libp2p中，每条消息包含订阅和发布以进行通信：你想要订阅的哪个主题，以及你发布的消息内容。这就是大致的结构，这在规格页面有说明。它仅包含这些内容，这是两个元素的数组：订阅和发布。

三种发布机制

目前libp2p支持三种发布机制：

FloodSub

第一种是FloodSub，仅通过网络传输，这非常简单。本质上，当你收到消息时，或者当你想发布到某个主题时，发送到目标地址，这里的所有节点。所以你要发送给所有已知的订阅该主题的节点，然后它们会执行相同操作。

你可以看到，这是一个复杂的网络图，A发送给C、D、B，B发送给所有可见节点。B从A接收消息，在其区域中可以看到来源A，因此不会再次发送给A。D不知道是否已接收消息以及E，因此需要发送给D和E，但A也已发送给D。

在这种情况下存在大量冗余，你会频繁收到重复的消息。但这种方法简单且大多数时候有效，只是非常冗余且占用大量带宽。

RandomSub

因此有人引入了随机机制（RandomSub），而不是发送给所有人，我只发送给一个小的子集，随机子集从而减少带宽。但由于不考虑网络拓扑，或节点与你的距离远近，从网络结构来看，在选择对等节点时可能会有运气不佳的情况。因此可能选中距离很远的节点，当与之同步时，这会显著增加时间消耗。

不过，这是简化网络带宽的方案，这只是运气问题，且不考虑谁更接近你、谁更适合、谁是最优对等节点。

GossipSub

因此我们转向以太坊使用的当前PubSub，具体是GossipSub协议，版本为1.1。这是1.2和1.3版本，不过，我们有1.1版本。

GossipSub 1.1本质上进行了混合，因此存在：

全局网状网络：仅传输元数据的网络
本地网状网络：用于传输数据

当有PubSub时，出现新主题，本地节点会通过类似FloodSub接收，但更大的网络仅通过控制消息共享元数据。

GossipSub控制消息

GossipSub还定义了多个子协议，帮助更高效发送消息，也能更好选择对等节点。我不会详细讲解，这基本解释了控制消息的作用，这些消息通过元数据网络传输。

它们是真正的八卦消息，我们称之为Gossip，因为节点间仅传递少量数据。元数据实际非常小，每个字段通常仅一两个字段，且字段非常简短，因此传输速度极快。

GRAFT消息

例如，这就是GRAFT，这实际上意味着你想将某人加入这个话题，加入你的本地网络、本地网状结构，你会将完整消息发送到这里。这实际上是说明我正在将其添加到我的网络中，让对方知道你在我网络里。我会向你发送完整消息，这是双向的，所以如果你将他们加入你的网络，他们很可能也会将你加入网络。

这就是控制消息GRAFT。在此之前他们处于全局网状结构，现在他们进入了你的本地网状结构。

IHAVE消息

这就是IHAVE流程，所以这通常是指，当有新消息时，假设有人有新消息，会发送给本地网状结构内的所有人，较小的网络、较小的节点组。

除了发送给所有本地网状结构，本地节点还会传播，发送一个IHAVE控制消息给外部节点，更远的节点，只需告知他们，”对啊，我拥有这条消息。”如果他们对此感兴趣，他们可以请求。

IWANT消息

这就是一个例子，假设有人在你的本地网状结构之外，拥有你通过流言协议得知的信息，你可以通过发送IWANT控制消息来获取。非常直接，IWANT，然后他们会立即发送给你，发送完整消息给你并同步数据。在此情况下如果其他节点没有该消息，则再次发送给他们。

PRUNE消息

最终，PRUNE（修剪）控制消息会通知某些节点希望从本地网络中移除，这样他们就不再需要接收你的更新了。这通常用于减少本地网络中的人员数量，当你人数太多时，你可能想要减少这个数量，以降低带宽占用。

总结

这就是基本原理。非常感谢大家的聆听！

Q&A环节

问：为什么人们不直接使用其他类似的协议？

答：我认为其中一个原因是，在转向libp2p协议之前，缺乏大量标准化的点对点协议。当然还有所谓的点对点传输协议，但它们并不完善。

确实存在一些点对点协议，但通常用于内容同步，例如你想下载其他节点拥有的数据片段，比如BitTorrent。其工作原理与这个类似，但主要用于内容传输。

libp2p协议现在相对成熟，并且投入了大量工作，所以我们通常会使用它。实际上以太坊执行客户端早于libp2p协议，他们有自己的P2P框架，称为DevP2P，功能类似，只是地址处理等细节有所不同。

所以，我认为主要原因只是因为libp2p协议较为成熟且被广泛使用，这非常好，这就是人们使用它的原因。如果存在更合适的新型协议，人们可能会采用它，但目前还没有。

Claude:

大家午安。今天我的 talk 是关于 LibP2P 的深入探讨。这个问号是因为其实不是特别深入。这是我尝试学习 LibP2P 的一个过程，如果你发现任何错误，请随时指出。

LibP2P 简介

LibP2P 是什么？它实际上就是一个用于 P2P 网络通信的库集合。这个名字很明显，它由 Protocol Labs 创建，被广泛使用在 IPFS、以太坊共识客户端以及很多其他分布式系统中。LibP2P 基本上为所有这些系统提供支持。

在这次演讲中，我会具体讲三个 LibP2P 的组件：传输层（Transport）、网络穿透（Net Traversal）和 Gossip Sub。传输层是指数据如何在互联网上实际传输；网络穿透是关于如何与可能在防火墙后的私有节点通信；Gossip Sub 是 P2P 客户端或节点之间分发和监听消息的主要机制。

传输层（Transport）

传输层是发送和接收数据的底层协议。你可能听说过，通常是 TCP、UDP，或者用于网页的 HTTP。LibP2P 目前支持 TCP 作为传输协议，还有 QUIC、WebSockets、WebTransport 和 WebRTC。每种协议支持不同的环境。

TCP 和 QUIC 通常支持不在浏览器中运行的应用，其余的通常在浏览器中使用，允许浏览器和其他节点之间，甚至浏览器之间建立 LibP2P 连接。这对于在浏览器环境中运行 LibP2P 非常有用，特别是如果你运行某些需要 P2P 连接的 Web 应用程序。

QUIC 协议

我特别想谈谈 QUIC，它是第四层协议的较新版本。QUIC 的作用是减少网络请求的往返次数。

在常规的 TCP 通信中，客户端和服务器或不同客户端之间需要这么多的请求响应：

TCP 握手（三步）：SYN、SYN-ACK（确认）、然后是另一个确认
然后是 TLS 握手（加密连接的协议）
最后才能开始发送数据

而 QUIC 因为使用 UDP，不需要经过常规的 TCP 握手，通常只需要一次往返：初始连接、同步，然后就可以开始发送数据。如果是重新连接或在初始连接后重试，甚至可以做到零往返，直接开始发送数据。

这很令人兴奋，因为减少网络往返意味着连接本身的开销更少，可以更快地发送数据。如果你发送大量数据包或需要创建大量连接，这最终会显著提高连接效率。

从以太坊共识客户端的角度来看，当时 QUIC 标准还没有最终确定，这是他们不使用 QUIC 标准的原因。但很有趣的是，在 Lodestar Ethereum 的一个 PR 中，他们实际上讨论了使用 QUIC 替代 TCP。所以也许新客户端会支持 QUIC，谁知道呢？

LibP2P 地址格式

在继续之前，让我们谈谈 LibP2P 如何进行寻址。你可能熟悉 IP 地址的样子，比如 198.51.100.0。还有 IPv6 版本，是十六进制的。

但对于 LibP2P，这个库通常使用这种类型的地址来编码节点之间的连接。这被称为多地址（multi-address）格式，相对容易阅读。它使用斜杠分隔各部分。例如，你可以看到节点的 IPv4 地址、端口、TCP 端口、P2P 以及带有标识符的 P2P。这在各处用于表示如何连接到特定节点。

这是非常标准的 TCP 连接。稍后你会看到另一种类型的多地址，实际展示中继 P2P 连接。它非常有表现力，这就是为什么 LibP2P 使用它。

在 P2P 规范中，你可以看到很多关于协议 ID 的提及，用于协商使用什么协议。例如，这是电路中继协议 0.1 版本。这是客户端或节点用来表示”嘿，我在使用这个协议，你支持吗？”的 ID。如果不支持，会有一个回退机制。它看起来很像多地址格式，但不完全是多地址。

网络穿透（Net Traversal）

网络穿透不是 P2P 特有的，在我们当前的网络中随处可见。

每个设备，或者如果你在家有互联网，你有路由器，连接到路由器的计算机，你的路由器通常充当防火墙和 NAT（网络地址转换器）。它本质上将你的公共 IP 地址转换为私有 IP 地址。这就是为什么如果你查看家庭网络，所有设备通常都以 198 开头，然后是不同的后缀，如 198.0.100、102、103 等。但你的公共地址实际上是不同的。你的公共地址通常整个房子只有一个公共 IP 地址，这就是互联网看到你的方式。

当你向某处发送请求时，通常会通过互联网，你需要在防火墙上暴露某些端口，或者需要某种中继来进行连接，这样当你发送请求并被接收时，接收端知道如何将请求发送回你。当他们发送到你的 IP 时，你的 NAT、你的防火墙知道如何中继回你的节点。如果这不存在，它基本上永远不会到达你。

网络穿透是我们称之为允许我们向私有连接发送请求的技术，而你的防火墙默认不一定暴露。出于安全原因，我们的防火墙默认不会暴露很多端口。如果你熟悉网络原语或网络，通常要暴露某个端口或暴露到特定设备的连接，你需要做一个叫端口转发的事情。如果你需要为每个连接都这样做，那会非常麻烦。

场景说明

让我展示一下它的样子。场景一：如果一个随机的公共计算机试图向你的计算机发送一些信息，它会被你的防火墙、你的路由器拒绝，因为你的路由器不记得有任何请求到该节点或该服务器，它不会接收。它可能是恶意的，所以不会接收它。

要实际接收它，你必须是发起连接的一方。如果你首先发起连接，你的防火墙将允许对该特定连接的任何响应。当你发送请求时，实际上会添加一条记录，记录源 IP 源端口（你的内部局域网地址），然后你的 NAT 或防火墙会记住它指向的目的地。当响应返回时，它会检查记录或这个 NAT 元组是否存在，如果存在，它会将其发送到正确的位置。

很多 P2P 连接遇到的情况是场景二，即你的两个节点都在防火墙后面，你无法访问它，因为记住，其中一个需要先启动连接才能让连接通过。如果两者都试图互相发送内容，它会拒绝。你必须有某种方式通过其中一个先发送连接或其他方式让它们通过。

打洞（Hole Punching）

这就是为什么有一个叫”打洞”的东西。之所以叫打洞，是因为你字面上在防火墙上打了一个洞。

要实际允许两个私有端点之间的通信，你需要这样的设置。首先，节点一发送一个将被拒绝的请求。但当你发送它时（假设双方都知道彼此的地址），你会被拒绝，因为节点二的防火墙中没有这样的记录。但节点一会在自己的防火墙中添加一个元组。

然后，由于我们假设节点二知道节点一在哪里，节点二会发送一个请求，这次会通过，因为现在节点一的防火墙中有记录了。然后节点一也可以开始发送，因为现在节点二有了出站连接。这大致就是打洞的原理。

在现代互联网中，我们有 TURN 服务器、STUN 服务器，让你可以与防火墙后的某人通信，而不需要想太多。

LibP2P 的打洞方式

LibP2P 如何打洞？它与这个例子非常相似，但你注意到需要多个服务器，而且每个都相当中心化。LibP2P 允许你以去中心化的方式做到这一点。

这是一个三步过程，使用三个协议：AutoNAT、Circuit Relay 和 DCUtR（直接连接升级）。这也是为了能够访问可能运行在防火墙后的节点，它们可以同步，可以互相通信。

第一步：AutoNAT

当我运行一个节点时，我想知道我的节点是否可访问。我想连接到其他节点。所以第一步，我需要知道我的节点是否可达，或者他们是否能呼叫我。

基本上，我的节点会告诉所有我能访问的公共节点：”嘿，你能试着呼叫我，看看能否接通吗？”如果我被所有节点都呼叫不到，并且我从它们那里得到回应说”你不可呼叫”，那么我知道我需要进入下一步。如果我能被任何一个呼叫到，意味着我可以被互联网访问，所以没有问题，我可以很容易地建立连接，它们可以很容易地向我发送更新。

第二步：Circuit Relay

如果我有问题，我们会进入下一步，即电路中继。这从我询问一个公共节点开始——一个所有人都能到达的节点。最近的节点实际上是通过 DHT（分布式哈希表）确定的。我会告诉离我最近的节点（为了效率）：”嘿，我想预留你作为中继，我会预留一些它们的计算能力，让它们帮我中继任何发给我的消息。”

如果节点说好，你会得到这样的结果。回想一下，我讲过多地址和寻址。如果节点二说”好的，可以使用我作为中继，作为中介”，会发生什么呢？现在我可以向其他无法直接到达我的人宣传：”嘿，我的地址是这个，通过这个地址连接我。”你可以在地址中看到，它实际上告诉所有看到它的人，这是一个中继节点，通过查看”P2P/节点二/P2P-circuit/我的节点”。节点一、节点二通常被实际的 P2P 标识符替换。

这样其他节点就可以通过节点二到达你。但这不是永久解决方案，因为节点二也不想一直处理你的计算。

第三步：DCUtR

所以通常我们会进入第三步，DCUtR。这允许你直接连接，这基本上就是打洞。

假设节点三想直接连接到节点一，它会通过节点二作为中继运行一个连接请求，然后测量节点一向节点三发送连接所需的时间。我这里展示的是节点三是公共节点的情况。当然，如果是私有节点，会有两个中继。

节点三会测量从节点三的请求到节点一的请求所需的时间，通过这个确定互相发送请求需要多长时间。然后它们做了一些非常聪明的事情：首先会向节点一发送一个同步信号，让它知道”是的，我们想连接”。

一旦发送同步请求，它会尝试在 T/2 时（通过中继发送第一个连接请求所需时间的一半）呼叫节点一，减去节点一向节点三发送连接请求所需的时间。使用这个时间的原因是它们想同步节点三拨号节点一和节点一拨号节点三的时间，让它们同时建立连接。

如果成功，打洞就完成了，它们现在可以进行直接连接。因为如果它们同时进行，本质上创建的是在它们的 NAT 防火墙上同时有一个洞，连接可以完成，因为有一个出站连接，所以也预期有一个传入的响应连接。

这基本上就是打洞。对于实际访问很多在防火墙后的节点来说，这非常重要。对于想托管自己节点的标准用户来说，我会说这基本上是必需品。这一切都被 LibP2P 抽象掉了，大部分时候我们只是使用它。但了解一下很好。

Gossip Sub

好，最后是 Gossip Sub，当我们谈论 P2P 时你听到最多的，也是你交互最多的。这是你与其他节点通信的机制。它被称为 Gossip Sub，因为它使用发布-订阅模式，节点订阅一个主题，每当有人向主题 A 推送消息时，你就会得到响应，得到结果。任何发布到主题 A 的新内容，你都会得到结果。

在中心化设置中，这很容易实现，有一个可以查询消息的真实来源。但在分布式设置中，事情变得有点复杂，因为很难知道真实来源从哪里来。

消息结构

这是一些技术细节，这是模式的样子。在 LibP2P 中，每条消息由订阅和发布组成，用于传达你想订阅什么主题以及你发布了什么消息。这大致就是它的样子，在规范页面上。它只是包含这些，是两个东西的数组：订阅和发布。

Pub Sub 机制类型

LibP2P 目前支持三种类型的发布-订阅机制：

1. Flood Sub

顾名思义，就是淹没网络。这非常简单。本质上，当你有一个想发布的主题或消息时，你把它发送给你能看到的每个对等节点。所以你发送给你知道的订阅这个主题的每个其他节点，然后它们做同样的事情。

这是一个非常复杂的图。A 发送给 C、D、B，C、D、B 发送给它们能看到的所有节点。我只谈谈 B。B 从 A 接收，在它的区域内，它可以看到 A（已经从它接收了），所以不会再发送给它。还有 D（不知道是否已经收到消息）和 E。在这种情况下，会发送给 D 和 E，但实际上 A 也发送给了 D。所以有很多冗余，你会多次收到重复的消息。但它很简单，大多数时候都有效，只是非常冗余，占用大量带宽。

2. Random Sub

这就是为什么有人引入了 Random Sub，它是 Flood Sub，但不是发送给所有人，我发送给一个小的随机子集。这减少了带宽，但因为它不关心网络拓扑或另一个节点在网络中离你有多近，你在选择对等节点时可能会不走运。你可能选择一个非常远的节点，当你发送、当你与它们同步时，这基本上需要更长时间等等。

但这是一个减少网络带宽的简单方法。只是有不走运的问题，你不考虑谁离你更近，谁最适合同步。

3. Gossip Sub

这就是为什么我们使用以太坊目前使用的 Gossip Sub。具体是 Gossip Sub v1.1，还有 v1.2 和 v1.3，但我们谈论的是 v1.1。

v1.1 本质上使得有一个仅元数据网络或全局网格（global mesh）和一个本地网格（local mesh）。你的本地网格是发送完整数据的地方。当有新主题时，你本地网格中的每个人都会发送，类似于 Flood Sub。

然而，有一个更大的网络，只通过我们称之为控制消息的方式共享元数据。

控制消息

有几个子协议在 Gossip Sub 中定义，帮助你更好地发送消息，也更好地选择你的对等节点。这些通过元数据网络发送，基本上通过 gossip 传输。我们称之为 gossip，因为节点之间只是交谈，讨论非常少量的数据。元数据绝对非常小，每个消息基本上只有一两个字段，而且是非常小的字段。

GRAFT（嫁接）

例如，GRAFT 流程，本质上意味着你正在将某人添加到你的主题中，添加到你的本地网络、本地网格中，你会在那里发送完整的消息。这基本上只是告诉他们：”嘿，我把你添加到我的网络中，知道你在我的网络中，我会向你发送完整的消息。”这是双向的。如果你把他们添加到你的网络，他们很可能也会把你添加到他们的网络。

在此之前，他们在全局网格中，现在他们在你的本地网格中。

IHAVE（我有）

这是 IHAVE 流程。通常当有新消息时，假设节点一有新消息，它被发送给本地网格中的所有人，较小的节点组。节点四除了发送给所有本地网格、本地节点外，还会向外面的人，一些更远的节点发送或 gossip 一个 IHAVE 控制消息，告诉他们”是的，我有这条消息”。如果他们感兴趣，他们可以请求。

IWANT（我想要）

如果我感兴趣，这是一个例子：假设你本地网格之外的某人有一些你从 gossip 协议中听说的信息，你可以通过说 IWANT 控制消息告诉它给你。非常直接，”我想要”，然后他们会把完整消息发送给你，让你同步数据。在这种情况下，如果其他节点没有那条消息，节点四会再次发送给他们。

PRUNE（修剪）

最后，PRUNE 控制消息告诉某个节点，他们想从你的本地网格中移除，这样他们就不想再从你那里获得更新了。这通常用于减少本地网格中的人数。当人太多时，你可能想减少以降低带宽。

Q&A 环节

问题1：为什么人们不直接使用其他协议？

我认为其中一个原因是，在 P2P 之前，没有很多标准化的 P2P 协议。当然一直有 torrenting 协议，但它们主要用于内容同步。BitTorrent 主要是用于内容，让你下载其他对等节点拥有的一些数据。

它的工作方式类似，但主要是针对内容的。LibP2P 之所以被主要使用，是因为它在这一点上相当成熟，投入了大量工作。所以通常我们会使用它。但实际上以太坊执行客户端在 LibP2P 之前就存在了，所以他们实际上有自己的 P2P 框架叫 DevP2P，做类似的事情，只是在寻址等方面有一些差异。

我认为主要原因就是因为 LibP2P 相当成熟，人们使用它，它非常标准化，这就是为什么人们使用它。如果有其他更适合的新协议，人们可能会使用那个。但目前来说，就是 LibP2P。

问题2：关于组网权限

在 P2P 中，我最感兴趣的部分其实是组网的权限。比方说以 Gossip 系统为例，一个节点如何加入到网络中？如何知道现在有哪些节点，哪些网络跟我感兴趣同样的 topic，以及一个 topic 如何只有权限去发送新消息？

很好的问题。它怎么知道呢？实际上是通过 IHAVE、IWANT 来知道到底谁有什么 topic。所以 IHAVE 的信息是通过 gossip 传播的，你不需要在本地的较小组里。这个所谓的元数据网络或全局网格，在这种情况下，节点比较多，你会尽量连接到很多节点，就像 Flood Sub 的原理一样，谁都会有。但他们交换的资料只有 IHAVE、IWANT 这种 gossip。

通过这里你就知道谁有什么，然后你有兴趣的时候，就开始用 GRAFT 这个 gossip 跟他们说”我要把你加入我的本地网格、本地组、本地集合里”，就可以开始收到完整消息了。

对于权限问题，Gossip 本身，topic 发布的权限，如果我没记错的话，他们其实没有定义得太完整，因为他们有一个叫 auth option 和 signature option 的东西，但他们现在目前没有在用这两个数据结构。我觉得权限应该不是在 LibP2P 里面直接控制的，根据我的了解。

问题3：DoS 攻击问题

DoS 的问题，其实通过我之前说过的子协议来解决。在子协议里面，v1.1 有个叫 peer scoring（对等节点评分）的。它会给你的节点打分数。如果你的信息跟其他节点相比看起来没有价值，它就会给你很低的分数，然后把你从本地网格里面移除掉，丢掉。这是通过这个来减少 spam。其实还有几个子协议可以做这个东西，但这是其中一个。

Gossip Sub 这个协议提供了一个全局网格和一个本地网格。本地网格通常是比较靠近的网络，让你交换完整的信息。全局网格是交换元数据，这样你的带宽就不会太多，因为你不需要把它发到整个网络，只发到靠近的，然后靠近的再慢慢传送出去。

问题4：关于 DevP2P

以太坊客户端用的，执行客户端用 DevP2P，共识客户端用 LibP2P。唯一我了解到的话，它们的分别主要在于寻址，就它们怎么样去识别每一个节点，怎么样去连接有一些分别。但底层大部分东西其实是一样的，只是他们用一个叫 ENR 的东西来做节点寻址。

剩下的差不多一样。唯一的理由为什么执行客户端没有再用 LibP2P，我了解到的是因为 DevP2P 已经在那里了，他们已经用了很久。如果改到 LibP2P 会花蛮多时间，而且需要顾虑一些东西。不过他们底层的东西是接近的，implementation 蛮接近的。

问题5：大数据处理和编码

随着以太坊发展，传大数据的需求会变大，比如区块会变得越来越大。不知道有没有在开发一些算法去处理这些大数据的，比如说编码、随机编码之类的？

LibP2P 本身如果没记错的话，好像没有。应该是有一些新的 Gossip Sub 的方式让你减少数据传输量。但如果你说用编码，是数据压缩之类的编码，我不觉得它现在目前 LibP2P 有做这一类的东西。但那是一个可能会往那个方向走的，但不是 LibP2P 本身。

整体上我不确定，但有一个新的 Pub Sub 协议叫做 Episub（Epidemic Sub）。那一个应该会比 Gossip Sub 更加高效，会用更少的带宽。但那一个如果没记错的话，只有在 Golang 里面有这个 implementation，目前还没有广泛使用，不太确定是为什么，应该是有某些理由。

有补充：有一个研究项目在 EthResearch 上，他们研究一个叫 RLNC 的，希望用 erasure coding 做 Gossip。有个 POC，但只是 POC。因为有一些问题：一方面问题是有些人觉得太复杂了，直接 P2P 比较简单；另外 RLNC 也用了一些密码学相关的东西，也不太好。第二个问题是有一个 patents 的问题。

谢谢大家！

智能合约深入解析

哈喽各位,今天咱们来讲一下智能合约。你呢不用做笔记,需要Web3转型资料的小伙伴可以找我来拿。

智能合约的基本概念

智能合约是以太坊的核心,也是它和比特币的最大区别。它的本质是跑在区块链上的一段代码,咱们提前写好执行规则,当满足条件的时候就会自动执行,全程不用人工去干预,也没法去篡改。

合约的状态包括这几项:当前的余额、合约代码,以及通过MPT结构存储的状态变量。MPT英文是Merkle Patricia Tree,翻译过来就是默克尔帕特里夏树。

智能合约的代码一般是用Solidity语言来编写的,而且写合约不难,语法和JavaScript很像,有点开发基础就能快速上手。能编写智能合约的语言有这些,你看看你会哪种语言。

智能合约的代码结构

接下来呢咱们拆解它的代码结构:

首先得声明一下Solidity的版本号,不同版本的语法有细微差异。Solidity是面向对象语言,Contract关键字和C++的类作用类似,是合约的基础框架。

合约里会定义很多的状态变量,它是强类型语言。像uint无符号整数和C++等常见语言一致,但是它有独有的address类型,专门用来表示区块链地址。

再往下是两个event事件,核心作用是记录操作日志。咱们以网上拍卖合约为例,这里的HighestBidIncrease会记录新的最高价的出价人地址和金额,这个PaidToBeneficiary会记录最终赢家和其出价。

它还有特殊设计,比如mapping,本质是哈希表,存的是地址对应uint数值的映射,但不支持直接遍历,所以咱们得用bidders数组之类的方式记录哈希表里的元素。

数组又分为两种:

固定长度数组定义时要写清长度,比如说address[1024]
动态长度数组用push就能加元素,比如说bidders.push,查length属性就能知道元素数量了

最后是构造函数,在Solidity 5.0以上的版本已经废弃了与合约同名的写法,它只在合约创建时调用一次。

构造函数下面是三个public修饰的成员函数,其他账户都能调用。其中bid函数带payable关键字,这部分咱们在后面会讲到的。

如何调用智能合约

OK讲完了智能合约的定义和结构,咱们重点说怎么调用它。其实逻辑和日常转账很像,拿个例子来讲一下你就懂了。

比如A发起一笔交易给B:

如果B是普通账户,就是常见的普通转账,那和比特币转账逻辑一样
但如果B是合约账户,这笔转账本质就是A在调用B这个智能合约了

那怎么指定调用哪个函数呢?关键在交易的data域里。

具体来说:

sender address是发起调用的账户地址
to contract address是被调用的合约地址
要调用的函数、需要的参数以及参数值都会放在data域里

之前代码例子里的函数没参数是一个特殊情况。

咱们再看几个关键字段:

value是调用时顺带转账的钱,例子里value为零,说明只是单纯调用了函数,没有转钱
gas used是交易实际花的gas
gas price是单位gas的价格
gas limit是愿意花的最大gas

这里另外提一句,以太坊现在从PoW转向了PoS机制,核心逻辑没变,但gas的消耗、验证者选择都和PoS相关,这部分后面再讲。

合约调用合约的三种方式

除了外部账户以外,一个合约也能调用另一个合约的函数,主要分三种情况,咱们逐个说一下。

第一种:直接调用

比如有A和B两个合约,A合约能通过emit触发log事件写日志。这里event定义事件,emit调用事件,预置不影响程序逻辑。

B合约要调用A合约,会先把A的地址转成A合约实例,再直接调用A的foo函数。但要注意的是,以太坊只有外部账户能发起交易,合约是不能主动触发的。所以得先有外部账户调用B的callAFooDirectly函数,由这个函数转手调用A的foo函数,B就相当于中间人了。

第二种:address.call调用

用法是第一个参数写函数签名,后面跟着具体参数。

和直接调用的核心区别是在错误处理:

咱们在直接调用的时候,被调用合约A抛异常,发起调用的合约B会跟着回滚
但用call的话,被调用合约抛异常只会让call返回false,发起合约不会出错,还是能继续执行的

另外call传参要更严格的编码格式,这里我建议用abi.encodeWithSignature,写清函数签名和参数,能减少错误。

第三种:delegatecall调用

用法和call类似,但有两个关键的差异:

一是不能用value转钱
二是call会切换到被调用合约的上下文,而delegatecall只复用被调用合约的代码,存储数据和账户余额等属性都用当前合约的

它主要是用来复用其他合约的库代码,避免重复编写。不过要注意,delegatecall要求被调用合约代码和当前合约存储结构兼容,否则有存储碰撞的风险。我建议通过接口interface明确函数交互规则,防止混乱。

关键函数和转账规则

接下来咱们聊关键函数和转账规则。这里的关键函数有payable、withdraw、receive、fallback。

核心是先搞懂为啥bid函数带payable,另一个却没有。这个要从以太坊的规则说起:合约账户想接受外部转来的钱,对应的函数必须标payable。

咱们拿简单的拍卖举例:bid函数是用来竞拍出价的,比如你想出100个以太币,得调用这个函数,同时把100个以太币转到合约里锁定,直到拍卖结束才能拿出来,这样能防止只喊价不掏钱。所以bid函数要接收转账必须带payable。

那再看withdraw函数,它不用payable的原因很简单:在拍卖结束后,没拍到的人调用它取走之前锁定的钱,这个过程不是给合约转钱,只是拿回自己的钱,自然就不需要标payable了。

其实总结一下就是函数带不带payable,本质看它是收钱还是取钱:

要收钱的话就标payable
只取钱的话就不用标

咱们看之前转账的例子,value的字段是零,没实际转钱,对应的函数就不用定义成payable。这背后是以太坊的明确规则:只要函数需要接收外部转账,就必须标上payable。要是用不到转账功能,完全不用写这个关键字,不然强行转钱过去会直接出错、抛异常的。

两个特殊函数:receive和fallback

咱们先看核心规则:

receive函数:

无参数、无返回值
只在一种情况会触发:也就是外部账户给合约转纯ETH,且交易没有data域
它优先级会比fallback高
合约想接收这种纯以太币,必须定义它,且加payable,否则就会转账失败

fallback函数:

定义是同样无参数、无返回值
有两种情况会触发:
1. 调用合约不存在的函数,也就是有data域但函数不匹配
2. 转纯以太币时,合约没定义receive或receive没标payable
它要接收以太币也得加payable

两者的区别还是很明确的:

receive管无data的纯以太币转账
fallback管调用不存在的函数,或无receive时的纯以太币转账

合约没这两个函数或没标payable,就没法收外部以太币,强行转会抛异常。

还要注意:

只有合约账户有这些函数和payable
外部账户是没有的
转账金额可设零,但gas费是必须给的
金额是给收款人的,gas费是给PoS机制下的验证者的

**为啥这么规定呢?**因为不给gas费交易是不会被打包的。

智能合约的创建和运行

创建过程

讲完了调用方式和关键函数,咱们再说说智能合约是咋创建的,以及它是咋运行的。

首先咱们讲一下它的创建过程。咱们写好的智能合约代码得先编译成字节码。创建合约的时候,得由外部账户发起一笔特殊的转账交易:

注意转账金额设为零,因为咱们不是真的转钱,只是为了发布合约
只需要把编译好的合约代码放进交易的data域里就行了

和其他交易一样,创建合约也得付gas费。在以太坊共识机制下,这笔交易会由验证者节点打包。创建成功后,系统会自动生成一个专属的合约地址。

运行环境

OK接着咱们再说说运行环境。智能合约是在以太坊虚拟机EVM上跑的。

大家都知道JVM虚拟机的设计是为了让Java程序在不同设备上都能跑,EVM的思路也是一样的。加了一层虚拟机,EVM还有一个特点:寻址空间特别大,是256位的。咱们之前提过的uint的类型就是256位,这和咱们平时用的设备不一样。以前的机器多是32位,现在很多服务器是64位,和256位比起来根本不是一个量级的。

Gas费机制

OK接下来咱们重点聊聊gas费机制。咱们先从比特币和以太坊的编程模型对比着来讲,两者的设计理念差别还是很大的。

比特币追求的是简单:脚本语言功能有限,比如不支持循环。

而以太坊要提供图灵完备的编程模型,很多在比特币上很难实现、甚至做不到的功能,在以太坊上都能很轻松实现。

但图灵完备也带来了新的问题:如果合约里出现死循环咋办?全节点收到智能合约调用请求时,根本没法判断会不会陷入死循环。这其实是计算机理论里的停机问题,从原理上就没法解决。

那以太坊是怎么应对的呢?答案就是引入了gas费机制。

在发起智能合约调用的时候,必须支付gas费。咱们来看交易的数据结构:

account nonce是交易序号,作用是防止重放攻击
gas limit是这笔交易愿意消耗的最大gas量
gas price是单位gas的价格
两者相乘就是这笔交易最多可能花的gas费

不过以太坊切换到PoS机制后,多了个base fee,也就是基础费用,它会根据网络拥堵情况动态调整。现在交易发起者要付的总gas费计算公式是:(base fee + priority fee) × gas used。其中这个priority fee就是用来激励验证者优先打包交易的。

咱们再看其他的字段:

recipient是收款地址
amount是转账金额,也就是转给recipient的钱数

这里咱们要明确一点:gas费和转账金额是完全分开的,两笔钱。

payload就是咱们之前说的data域,里面存着要调用的合约函数和参数。

在全节点收到智能合约调用的请求后,会先根据gas limit算出最多可能花的gas费,一次性从发起账户里扣掉。然后随着合约的执行,再算出实际消耗的gas量。如果过程中gas费不够了,交易就会回滚。

不同的操作指令消耗的gas费也是不一样的:

如果是简单的加法和减法之类的指令,gas费就很低
像取哈希这种复杂的指令,gas费就会贵点
如果涉及到存储状态的指令,gas费也会偏高
如果只是读取公共数据的指令,比如说像SLOAD这种的,就是免费的

错误处理逻辑

咱们再说说以太坊的错误处理逻辑。这里有个核心的特点:所有交易执行都具有原子性,要么从头到尾完整执行,要么完全不执行,绝对不会出现只执行一部分的情况。不管是普通转账还是调用智能合约,全都遵循这个规则。

所以一旦智能合约执行过程中出了错,整个交易就会回滚,回到执行前的状态,跟没发生过一样。

那哪些情况会导致出错呢?最常见的就是gas费不够,具体分为两种情况:

如果交易执行完,实际消耗的gas没超过设定的gas limit,那么扣除基础费用和实际消耗的gas费用后,剩下的gas费会退回发起账户
但如果执行过程中gas limit用完了,交易就会立刻回滚,而且已经花掉的gas费是不会退还的。这部分费用里base fee会被销毁,优先级费用priority fee归验证者。总之花出去的部分一分都不会退。

这种设计其实主要是为了防止恶意攻击的。咱们试想一下,如果gas不够还能回滚退款,攻击者可能会反复发送高消耗但是低gas limit的交易,这样就会浪费验证者的资源,却不用承担成本,很容易引发DoS攻击。那不退gas费这样的规则就能从根源上避免这种情况。

三种触发异常的方式

OK那除了gas不够以外,智能合约执行出错还有一种常见的情况就是显式抛出异常。Solidity提供了三种触发异常的方式。

这里先提个版本细节:Solidity在8.0以上默认开启了溢出检查,不用再手动用assert判断数值溢出了。

具体来说:

第一种触发异常的方式就是assert(bool condition):

这个是专门用来判断合约内部逻辑错误的
比如说存储的状态数据出现了异常
只要条件不满足,就会立刻抛异常并回滚交易

第二种是require(bool condition):

主要用来校验外部输入或环境条件的
比如说拍卖还没结束就有人调用结束函数
条件不满足的话就会抛异常回滚,而且会把没消耗的gas费退还给发起账户

第三种就是revert或revert(string reason):

这种属于无条件触发回滚,还能带上自定义的错误信息
这种适合复杂逻辑下的异常处理
比如说满足多个特定条件的时候手动触发回滚,并且说明原因

另外在Solidity 8.0以上版本,支持try-catch异常捕获机制。但是咱们要注意它的适用范围:这个只能捕获外部合约的调用,比如说用call和delegatecall调用其他合约,或者库函数调用产生的异常。写法上会通过try包裹调用逻辑,用catch处理异常情况。

嵌套调用的回滚规则

最后咱们再讲一下嵌套调用的回滚规则,这里也分为三种情况:

第一种是直接调用:要是被调用的合约抛出异常,发起调用的合约会跟着连锁回滚,整个交易就直接失效了。

第二种是用call或delegatecall调用:即便被调用的合约抛出了异常,调用函数只会返回false,发起调用的合约也不会自动回滚,需要手动判断返回值再处理。比如说用if-else决定是继续执行还是手动触发回滚。

第三种情况是向合约转账的时候:如果触发了receive或者是fallback函数,要是这两个函数抛出异常,转账结果会因方式的不同而有变化:

如果用transfer转账会直接回滚
用send或call转账只会返回false,不会自动回滚

区块结构和资源限制

OK接下来咱们先看区块头block header的数据结构,里面有两个关键字段:gas limit和gas used。

咱们首先要分清这两者的区别:

gas used是一个区块里所有交易总共消耗的gas总和
而gas limit是这个区块里所有交易加起来能消耗的gas费的上限

这里要注意的是啥呢?就是它不是单个交易gas limit的简单相加。

咱们再对比一下以太坊和比特币的资源限制机制,他们两个的思路是完全不同的:

比特币是按区块大小限制的,固定1MB,是用交易的字节数来衡量资源消耗的
但是以太坊不一样,它是用gas费来限制资源的

核心原因是因为智能合约的逻辑复杂度差异太大了。比如说简单的转账合约和复杂的DeFi合约,他们所消耗的资源那真是天差地别,必须用指令集的gas费消耗来精准量化。字节数根本满足不了这种精细度的需求。

交易发布规则

接下来咱们再聊聊交易发布的规则和智能合约有哪些特性的限制。

首先说一下交易的发布。在上链的交易里,不光有执行成功的,也有失败的。那可能有人会问:失败的交易为啥还要发到链上呢?

其实核心的原因是gas费的处理。如果不发布的话,gas费就没法扣。只在本地扣是没用的,必须上链形成共识,扣掉的gas费才能真正进入验证者的账户。而且其他节点也得重新执行这个失败的交易,验证这个gas费是否合理。

**那怎么判断交易是否成功呢?**每个交易执行完都会生成一个交易收据receipt,里面的status字段就是结果标识:

在Solidity 8.0以上的版本里,status等于1代表成功,status等于0代表失败
如果你用的是低版本的Solidity,则需要通过返回值或异常来做出判断

智能合约的特性限制

咱们再来说说智能合约的特性限制。

第一个就是不支持多线程

咱们现在用的电脑普遍是多核处理器,十几核都是很常见的。但Solidity里根本没有多线程相关的语句。

为啥呢?因为以太坊是交易驱动的状态机,这个状态机必须是完全确定的。给定同一个智能合约和相同的输入,输出或者下一个状态必须完全一致。毕竟所有全节点都得执行同一组操作,最终达到同一个状态才能进行验证。如果状态不确定的话,MPT树的根哈希就对不上了。

而多线程的问题在于啥呢?在于多个核心访问内存的顺序可能不同,执行结果可能不一致。要在多核环境下实现确定性重演,技术难度还是挺大的。

其他限制

除了多线程以外,其他可能导致执行结果不确定的操作也不支持:

比如说生成真正的随机数:真正的随机数是不确定的,不同机器生成的结果可能会不一样。所以以太坊智能合约没法生成真正的随机性,只能用伪随机性。比如通过block.timestamp区块时间戳加block.prevrandao加交易哈希来生成。要是不用这种方式的话,不同全节点的执行结果就会出现差异。

而且智能合约不能像通用编程语言那样通过系统调用获取环境信息,因为每个全节点的执行环境不一样。智能合约只能通过固定变量获取一些状态信息,大家可以看这两张图。

address类型详解

接下来咱们聊两个重点:一个是address类型的成员,另一个是向合约转账的不同方式。这俩是很容易弄混的,咱们得掰扯清楚。

address类型的成员

咱们先看address类型的成员。它里面有个成员变量叫balance,剩下的都是成员函数。

balance是uint256类型,单位是以太坊的最小单位wei,作用也很直接,代表这个address对应的账户余额。

这里有个关键点要注意:这些成员函数的语义和咱们直观理解的不一样,跟balance变量的逻辑也完全不同。

咱们举个例子:

address.balance是这个地址账户有多少余额
但如果写address.transfer(12345),可不是这个address账户转出12345个wei,而是当前合约往这个address地址转入12345 wei

再具体点说,假设智能合约C里有个函数F,函数里写了address.transfer(12345),意思就是从C的合约账户里转12345个wei到这个address对应的账户里。

address.call也是一个道理,不是address合约主动发起调用,而是当前合约去调用address对应的合约。

函数调用方式

咱们再说说address类型里的函数,调用方式主要是call和delegatecall。

在这里提个版本细节:Solidity 5.0以上版本已经废弃callcode了,因为它存在存储的安全风险。所以用delegatecall替代了callcode,而且用的时候必须严格控制两个合约的存储结构的兼容性,避免出问题。

向合约账户转账的三种方式

最后咱们讲向合约账户转账的三种方式,它们的区别还是很大的,大家先看图上的内容:

第一种方式(transfer):

失败会抛异常回滚
固定给2300 gas
适合简单ETH转账,能确保转账成功

第二种方式(send):

失败返回false不回滚
也固定给2300 gas
适合需要手动处理失败的转账,比如退款

第三种方式(call.value):

失败返回false不回滚
会消耗剩余所有gas
适合需要带额外逻辑的转账,比如触发合约函数

这里要特别注意的是:transfer和send给的2300 gas只能够接收合约执行简单的日志操作,比如emit事件,没法执行调用其他合约这样复杂的逻辑。这样就能有效防止重入攻击。

而call.value会传递剩余所有gas,用的时候要特别小心。比如先把状态清零再转账,避免重入。

网上拍卖合约实例

OK现在咱们拿网上拍卖合约来当例子,把之前讲的知识点都串起来,这样理解会更加透彻。这个例子在Solidity官网上就能找到。

关键角色和参数

咱们先看合约里的关键角色和参数:

第一个是受益人beneficiary:比如你要拍卖自己的古董,那你就是这个beneficiary。

第二个是auction end:用来记录拍卖结束的时间。

第三个是highest bidder:存着当前最高出价人的地址。

拍卖规则

咱们先把拍卖规则说清楚,其实很直观:

在auction end之前,所有人都能参与出价。但出价的时候必须把对应金额的以太币转到合约里暂时锁定,而且锁定后是不能中途退出的。如果你出价后又后悔了,想提前把钱拿回来,这在合约里是不允许的。

等到拍卖结束后:

最高出价人highest bidder的钱会自动转给受益人beneficiary
这时候受益人就得把古董交给highest bidder
而其他没拍到的人,只要调用对应的函数,就能把当初自己锁定的钱取回来了

这里还有个细节是允许多次出价的。比如说你第一次出了100个以太币,后来想提高出价到120个以太币,你不用重新转120个以太币,补20个以太币就行。但是得有个前提:新出价必须比当前的最高出价要高,不然就是无效的。

事件和构造函数

另外之前提过的两个event:

HighestBidIncrease会实时记录竞拍的信息,记录谁出了新的最高价、出了多少
PaidToBeneficiary记录最终谁赢了、钱转给了受益人多少

还有一个constructor构造函数,在合约刚创建的时候就会把受益人的地址和拍卖结束时间存好,这两个信息是拍卖的基础。

核心函数逻辑

接下来咱们重点看一下核心函数逻辑。

咱们先从最关键的竞拍函数bid来讲:这里Solidity 7.0以前的版本用的是now,7.0以后的版本用block.timestamp替代了now。

然后是结束拍卖函数auction end:这里用了先清零状态再转账的安全模式,还显式

判断了转账是否成功,能避免重入攻击。

最后是未中标者退款函数withdraw。

智能合约的发布流程

智能合约的发布流程其实很简单,分三步就能搞定了:

第一步是编译代码:用Remix、Truffle这些常用工具,把写好的Solidity代码转换成字节码bytecode。

第二步是发起部署交易:得用外部账户发起,注意交易的to地址要设为0x0,data域里填编译好的bytecode,value设置零。咱们之前说过,部署合约不转钱就可以设置为零,然后要付足gas费。

第三步是等待打包:在PoS机制下,验证者会打包这笔部署交易。一旦成功了,系统就会返回一个专属的合约地址,之后所有人都能调用这个合约了。

合约状态的存储

然后再说说合约状态的存储。像出价记录bids、最高出价人highest bidder、拍卖结束时间auction end,这些合约状态全都存在合约账户的MPT里,也就是默克尔帕特里夏树。

每次合约状态变更,比如说有人新出价,导致highest bidder发生了变化,MPT的根哈希都会跟着更新,并且同步到区块链上。

就连每次的竞拍记录,在调用bid函数后也会实时更新到MPT里。这样就能确保所有全节点都能同步到最新的竞拍状态,不会出现数据不一致的情况了。

智能合约的安全问题

最后必须跟大家重点强调:智能合约的安全问题也是重中之重。

智能合约代码一旦发布到区块链就没法修改了,能保证规则透明、没人能作弊,这是它的优点,但也是最大的风险点。要是代码里藏了漏洞,事后根本没机会修复,损失可能是无法挽回的。

典型的漏洞案例

咱们先看一个典型的漏洞案例。如果auction end函数里的ended变量赋值位置不对,可能会有问题。但实际上如果两个人同时调用auction end函数,矿工执行第一个调用后,ended就变成true了,第二个调用就执行不了。因为智能合约不支持多线程,没有并发执行。

黑客攻击案例

如图假设有一个黑客通过合约账户参与竞拍,会有什么结果?

这个黑客合约只有一个hackerBid函数,参数是拍卖合约的地址address auctionContract。函数会把地址转换成拍卖合约的实例:Auction auction = Auction(auctionContract),调用拍卖合约中的bid函数把钱发送过去。

由于合约账户不能自己发起交易,需要黑客从外部账户发起交易,调用这个黑客合约的hackerBid函数,然后这个函数再调用拍卖合约的bid函数参与拍卖。

拍卖结束退款的时候会有什么问题呢?

我们再看一下右边的这个图。拍卖合约通过循环退款,退到黑客合约账户上的钱会调用黑客合约的fallback函数。但如果黑客合约没有定义fallback函数,转账会失败。而transfer函数会引起连锁式回滚,导致整个转账操作失败,所有竞拍者包括受益人都收不到钱。

因为智能合约执行具有原子性,一旦出错会回滚到执行之前的状态,就好像拍卖从来没有发生过。但竞拍者的钱已经锁定在智能合约里了,没办法取出来。因为合约代码不可篡改,出现这种情况怎么办呢?没有办法。

因为智能合约的规则是由代码逻辑决定的,代码发布到区块链上就改不了了,这就是区块链的不可篡改性。智能合约如果设计不好,有可能把收到的以太币永久锁起来,谁也取不出来。

锁仓的例子

比如用智能合约锁仓。比如我们要开发一个新的加密货币,然后预留一部分加密货币给开发者。这些币都打到一个智能合约账户,锁仓3年,3年以后这些币才能用。

如果写错时间,多写一个零,变成30年,这些币就会锁30年,没办法修改。这有点像不可撤销的信托法律条款,设计有问题也可能导致钱取不出来。

所以发布智能合约之前一定要多次测试。可以在testnet测试网上用假的以太币做测试,确认没问题情况下再发布。

那我能不能在智能合约里留一个后门修复bug?比如给合约创建者超级用户的权利?这样做有可能出现卷款跑路的情况,需要所有人信任超级用户,这跟去中心化的理念背道而驰,绝大多数区块链用户不能接受。

拍卖合约的改进

那怎么修改拍卖合约,避免上述问题呢?

第二个版本把auction end拆成两个函数:左边的withdraw和右边的payToBeneficiary。

withdraw函数是让没有竞拍成功的人自己调用取钱,函数逻辑是:

首先判断拍卖是否结束
然后看调用者是不是最高出价者,如果是不能把钱给他,要留给受益人
然后看调用者账户的余额是不是正的,amount是他的账户余额
然后用msg.sender.send(amount)把账户余额转给发起调用的人
然后把账户余额清成零,免得下次再来取一次

payToBeneficiary函数是把最高出价给受益人,逻辑是:

判断拍卖已经结束
最高出价金额大于零
然后把最高出价转给受益人

重入攻击问题

但这样修改还有问题,可能遭遇重入攻击(Reentrancy attack)。

如果有一个黑客写这样的程序:

hackerBid函数参与竞拍
hackerWithdraw函数在拍卖结束时调用取钱
黑客合约的fallback函数会再次调用拍卖合约的withdraw函数取钱

因为withdraw函数中转账语句msg.sender.send(amount)在清零操作之前,转账时会调用黑客合约的fallback函数,而fallback函数又调用withdraw函数,陷入递归调用,根本执行不到清零操作,导致黑客可以不停从拍卖合约中取钱。第一次取自己的出价,后面取别人的钱。

递归取钱会在三种情况下结束:

拍卖合约余额不够
汽油费不够
调用栈溢出

黑客合约的fallback函数会判断拍卖合约余额是否足够、当前调用剩余汽油,满足条件就再发起一轮攻击。

避免重入攻击的方法

怎么修改避免重入攻击呢?一个最简单的方法是先清零再转账。

我们看图右边payToBeneficiary的写法是正确的:

先把highest bidder的账户余额在哈希表中清成零
然后再转账
转账如果不成功的话,再把余额恢复

这是对于可能跟其他合约发生交互的情况的一种经典编程模式:

先判断条件
然后改变条件
最后再跟别的合约发生交互

在区块链上,任何未知的合约都可能是有恶意的。所以每次向对方转账或者调用对方函数的时候,都要提醒自己:对方合约或函数有可能反过来调用当前合约并修改状态,小心一点总是好的。

使用transfer/send避免重入

除了先清零再转账之外,还有一种办法。我们看图就是不用call.value(amount)的方法转账。

对比修改前后的代码,除了把清零位置提前,转账时用send,用transfer也可以。

send和transfer的共同特点是:转账时只发送2300 gas,不足以让接收合约再发起一个新的调用,只够写一个log,这样就避免了重入攻击。

其他设计问题

网上拍卖的合约设计需要注意很多问题。还有一个问题:如果不是黑客合约,就是一个普通的账户,忘了写fallback函数,参与拍卖后也没办法修改合约补上fallback函数,因为合约已经发布到区块链上了。

就算创建新的合约,旧合约已经参与拍卖并被记录在循环里,也没办法解决退款问题。

我们讲了智能合约中可能出现安全漏洞的一些例子,这些安全漏洞在实际当中是真的会发生的。

好了,今天的分享就到这里了,需要Web3转型资料的小伙伴可以找我来拿,我们明天见!

去中心化永续合约交易所Perp DEX兴起与格局

一、永续合约与Perp DEX的兴起背景

去中心化永续合约交易所(Perp DEX)已经成为加密圈的核心金融基础设施,理解Perp DEX是搞懂DeFi运作的第一步。永续合约本身是个中性工具,就像一把瑞士军刀,既可以是高风险的投机利器让你一夜暴富,也可以是风险管理、套利交易的精妙工具。当然也正因为它的高杠杆和高波动性,很多人把它看作是无监管的、24小时不打烊的赌场,这评价褒贬不一,但确实点出了它的双刃剑特性。

长期以来,中心化交易所(CEX)凭借用户友好的操作界面一直占据着市场主导地位。但这种便利背后藏着一个致命的阿喀琉斯之踵——资金托管。你的钱得交给交易所保管,风险巨大。还记得2022年FTX那个大雷吗?一夜之间多少人的财富灰飞烟灭。这事儿血淋淋地告诉我们,加密世界里那句老话有多真:不是你的私钥,就不是你的币。资金到底怎么管的,黑箱操作谁也说不清,监管呢要么缺位,要么跟不上,再加上中心化平台本身就存在单点故障的风险,一旦出事,整个系统都可能瘫痪。

正是在这样的背景下,去中心化永续合约交易所应运而生。它们的目标很明确,就是要解决CEX那些让人头疼的资金托管和信任问题。怎么解决?靠的是区块链技术和智能合约。简单来说,交易直接在链上通过代码执行,不需要任何中间人,你的资产始终在你自己的钱包里,你才是真正的主人。交易规则全都写在公开透明的智能合约里,谁也改不了,想耍赖门都没有,这就从根本上杜绝了交易所跑路或者作恶的可能性。对于那些既想保持对自己资金的绝对控制权,又不想放弃高杠杆、复杂衍生品交易带来的机会的加密货币玩家来说,Perp DEX提供了一种前所未有的选择。它不仅仅是一个交易平台,更是一种价值主张的体现。

二、永续合约的核心机制

永续合约到底是个啥?简单粗暴地说,它就是一种没有到期日的期货合约。传统期货到期了得交割实物或者现货,麻烦得很,但永续合约不一样,你可以一直持有,不用担心到期结算,这极大地提高了交易的灵活性,所以它成了加密市场里最受欢迎的衍生品之一。

永续合约的核心玩法主要靠两个机制:一个是杠杆,另一个是资金费率。杠杆大家都懂,就是借钱炒股,用小钱撬动大额头寸,收益可能翻倍,亏起来也更快。另一个是资金费率,这个有点意思,它是定期在多头和空头之间收钱的。如果市场看涨的人多,做空的人就得付钱给做多的人,反之亦然。这个机制的目的就是让永续合约的价格尽量贴近现货价格,避免出现太大的偏离。理解这个资金费率,对控制你的持仓成本至关重要。

永续合约之所以能在加密市场掀起这么大的风浪,原因可远不止让大家玩乐和投机那么简单。它实际上为整个市场提供了非常关键的功能:

第一,它极大地提升了市场效率和流动性。 24小时不间断的杠杆交易,随时都能进出场,这大大增加了市场的活跃度。而且因为没有到期日,交易者可以更灵活地进行长期策略,比如趋势跟踪什么的。

第二,对于专业投资者和机构来说,永续合约是管理风险的好帮手。 举个例子,你手里拿着一大堆比特币现货,但又担心短期价格会跌怎么办?很简单,你可以同时做空比特币的永续合约,万一价格真跌了,现货亏的钱可能正好被永续合约赚回来,帮你锁定了价值。

第三,它促进了价格发现和套利。 前面提到的资金费率机制,就是确保永续合约价格和现货价格紧密挂钩的关键。一旦两者价格出现偏差,比如现货比永续贵太多或者便宜太多,就会产生套利机会。聪明的交易者会利用这种价差进行现货到永续套利,赚取无风险利润。而这种套利行为本身也在不断地把价格往均衡的方向拉,提高了市场的效率和价格发现能力。

三、技术发展历程

去中心化永续合约的发展历程,简直就是一部技术革新的编年史。最早的时候,想在像以太坊这样的区块链上搞出类似CEX那种订单簿模式,简直是噩梦。为啥?因为每笔交易都要付高昂的gas费,还得等半天才能确认,速度慢得让人抓狂。

为了克服这些困难,行业里就开始探索各种不同的技术路径:

dYdX V3走了一条混合路线,叫链下订单簿、链上结算。 简单说就是高频的交易撮合在Layer2上快速完成,最后的结果再回到主链上确认。这样既保证了速度,又兼顾了安全性。

GMX则另辟蹊径,开创了池化流动性模式。 它搞了个流动性池GLP,所有交易者都跟这个池子交易,相当于这个池子成了所有人的对手方。这样一来交易深度就上来了,滑点也能降到最低,用户体验更好。

还有一类更激进的,像Hyperliquid这样的新一代平台,直接自建了一条L1公链。 它们的目标是极致性能,不惜一切代价追求速度和低延迟。结果就是它们实现了堪比CEX的速度,甚至还有0 gas费的体验。

四、市场规模与增长

咱们来看看Perp DEX这个市场的规模和增长情况,用一个词形容,那就是爆炸式增长。数据说话:2025年上半年,整个加密货币市场的总交易量达到了惊人的9.36万亿美元。而在这一大盘子里,Perp DEX的表现也非常抢眼。单单2025年第二季度,去中心化永续合约的交易量就突破了8980亿美元。

更有意思的是,Perp DEX和CEX之间的交易量对比,它们的比率已经达到了0.23的历史新高。这是什么意思呢?就是说每发生100美元的CEX交易,就有23美元是在Perp DEX上完成的。这说明什么?说明去中心化的力量正在稳步侵蚀中心化的地盘。这种增长很大程度上得益于像FTX破产这样的事件,它们加剧了用户对中心化平台的信任危机,促使大家转向更安全的去中心化选择。

具体到各个平台,2025年7月,所有Perp DEX的总交易额达到了创纪录的4870亿美元,其中Hyperliquid一家就贡献了大约3190亿美元,占了差不多65%的份额。到了2025年9月23日那天,所有Perp DEX的日交易量加起来大概是429亿美元,其中Hyperliquid贡献了152亿,Aether贡献了86亿。

还有一个指标叫未平仓合约量,也就是OI,它是衡量市场成熟度的一个重要信号。有意思的是,Hyperliquid的OI增长速度明显超过了它的交易量增长,这暗示着什么?很可能意味着越来越多的高净值用户和机构正在Perp DEX上建立并持有长期的大额头寸,这预示着未来会有更多机构资金流入这个去中心化的生态。

五、四大头部协议深度解析

目前在去中心化永续合约这个赛道上,有四大头部协议撑起了半边天,它们分别是dYdX、GMX、Hyperliquid以及后来者Aether。这四位选手各有各的绝活,也各有各的挑战。

1. dYdX - 去中心化先驱

dYdX可是去中心化衍生品领域的老大哥了,它给自己定下的目标是端到端完全去中心化,听起来就霸气十足。为了实现这个目标,它做了一个非常大胆的决定:从以太坊二层网络搬家,搞了一条完全属于自己的、基于Cosmos SDK构建的应用链。这一下子就把链上的订单簿匹配引擎,甚至连前端界面都彻底去中心化了,彻底摆脱了对任何中心化中介的依赖,这决心没得说。

再看它的财务表现:截至2025年9月,累计交易量已经超过了1.5万亿美元,这可是行业第一。虽然日活跃用户数看起来不多,大概2900人左右,但年化收入也有1500多万美元。特别值得一提的是,dYdX把100%的交易费用都奖励给了验证者和质押者,这充分体现了它社区驱动和完全去中心化的价值观。

当然没有完美的英雄,dYdX也有它的软肋。比如日活用户相对较低,而且它正在进行的V4迁移过程比较复杂,可能会面临用户流失的风险。不过它也看到了新的机会,比如通过和Coinbase这样的大厂合作,把原生代币集成到它们的钱包里,吸引更多传统交易者。当然来自Hyperliquid和Aether这些新秀的竞争压力也是实实在在的。

2. GMX - LP模式忠实粉丝

GMX是LP模式的忠实粉丝,它的核心竞争力在于那个独特的共享流动性池GLP。简单说就是用户把自己的蓝筹资产,比如ETH什么的,存到这个池子里,变成流动性提供者(LP)。这些LP提供的流动性就成了所有交易者的对手方,保证了交易的深度和低滑点。

GMX最吸引人的地方就是它那个真实收益模型:LP可以获得协议收入的63%作为回报,这听起来是不是很诱人?感觉像是在做一个持续赚钱的平台。所以GMX的财务模式也很特别,它只拿走总费用的30%作为协议收入,剩下的大部分都分给了LP。

不过GMX也有它的烦恼。比如它的交易量和收入增长似乎有点乏力,用户基础也相对较小。更重要的是,LP在这个模式下其实是直接暴露在交易者的盈亏面前的。如果市场上交易者总体是盈利的,那LP可能就要亏钱,这就是所谓的无偿损失风险。

当然GMX也在寻找出路,比如通过和LayerZero这样的跨链基础设施合作,它有机会把业务扩展到更多的链上。但同时它也面临着来自订单簿模式平台的崛起,以及其他平台提供更高杠杆或更好交易体验的挑战。

3. Hyperliquid - 性能怪兽

Hyperliquid绝对是性能怪兽级别的存在,它选择了一条非常激进的道路:自建一条专为交易优化的L1公链,用了HyperBFT共识机制,据说TPS能飙到每秒10万笔,交易确认几乎是瞬间完成,这速度简直逆天。

它的核心优势在于那个完全链上中央限价订单簿(CLOB),这意味着每一笔订单、撤单、成交都直接记录在区块链的共识状态里,既保证了完全的透明度和安全性,又实现了0 gas费交易。这对交易员来说简直是梦寐以求的体验。

Hyperliquid的财务表现也非常亮眼。2025年9月,它的日交易量在96亿到152亿美元之间波动,年化收入超过10亿美元。更惊人的是,它的日活跃用户数高达65900人,把这个数字甩开其他所有竞争对手几条街。

Hyperliquid的代币经济模型也很有特色,它把高达97%的交易手续费收入都用来公开市场回购它的原生代币HYPE,这创造了强大的通缩压力,理论上有利于代币价值的提升。

当然Hyperliquid也不是完美无缺。它的L1公链目前只有16个验证者,这引发了潜在的中心化争议,毕竟验证者数量少,理论上更容易被攻击或控制。而且作为一个相对年轻的协议,它还没经历过大型网络攻击或者极端市场崩溃的实战考验,这一点还需要时间来验证。

4. Aether - 后起之秀

Aether是一个典型的后起之秀,靠着空投激励和多链聚合迅速崛起。它不像dYdX、Hyperliquid那样自己建链,而是部署在BNB Chain、Solana这些现成的高性能链上。这样做的好处是,用户可以在同一个平台上交易不同链上的资产,不用自己费劲去跨链,用户体验一下子就上去了。它还搞了个隐藏订单功能,据说能防止MEV机器人抢跑,保护大额交易者的利益。

Aether的崛起很大程度上得益于它在2025年9月进行的代币发行(TGE),再加上Binance创始人CZ的公开背书,一下子就把名气打出去了。它的日交易量一度飙升到86亿到135亿美元,甚至超过了Hyperliquid。协议的日收入也达到了712万美元。可以说,空投激励策略是它短期内引爆交易量的核心驱动力。

但是Aether的模式也带来了不少问题。首先它的交易量看起来很猛,但可能存在泡沫风险。你看它的OI除以Volume比率只有可怜的12%,而Hyperliquid是287%。这强烈暗示着Aether的大部分交易量很可能是由追求空投奖励的短期行为驱动的,刷量缺乏真正的长期用户留存。

另外Aether的代币供应量比较大,而且还有持续解锁的风险,这都可能影响代币的长期价值。尽管如此,作为一个新项目,Aether的增长空间还是很大的。只要它能持续推出新的空投活动,就能维持短期的热度。但长远来看,一旦空投激励结束,它的交易量和用户基础可能会大幅下滑,届时将面临Hyperliquid等拥有真实收入和稳固用户基础的平台的激烈竞争。

六、核心数据对比

为了让大家更直观地看到这几家平台的差异,我们来做个核心数据对比(截至2025年9月):

Hyperliquid: L1链上订单簿模式,日交易量在96亿到152亿美元之间,日收入275万美元,日活用户高达65900人,而且OI除以Volume比率高达287%,说明它的交易量比较健康,有较多的长期持仓。

Aether: 多链聚合器模式,日交易量也很猛,86亿到135亿美元,日收入712万美元,新增日活用户也达到了53332人,这主要是空投带来的爆发。但它的OI除以Volume比率只有12%,这个数字非常低,再次印证了我们刚才的分析——它的交易量可能有很多是短期刷量。

dYdX: 同样是L1链上订单簿模式,但日交易量只有2.84亿美元,日收入6.28万美元,日活用户2900人。这个规模和活跃度跟前两者比起来就差远了。

GMX: LP模式,日交易量1.01亿美元,日收入13.5万美元,日活用户1600人,规模最小。

这张表清晰地揭示了当前市场的竞争态势:Hyperliquid凭借惊人的日活和健康的OI除以Volume比率,稳坐行业领袖的位置。Aether虽然交易量看起来很唬人,但极低的OI除以Volume比率暴露了它增长的脆弱性,它的交易量很大程度上是靠空投激励堆出来的。

七、三大主流范式

从这几家代表性的平台来看,我们可以总结出去中心化永续合约市场的三大主流范式:

第一种是订单簿模式。 dYdX和Hyperliquid是这方面的代表,这种模式基本上是模仿了传统金融市场的交易结构,提供了精确的价格发现和灵活的挂单方式。它的优点很明显,但代价是对底层公链的性能要求极高。这种模式最适合那些对交易细节有要求的专业交易者。

第二种是LP模式。 GMX是这方面的典型,它通过GLP把流动性集中起来管理。优点是流动性深度好,大额交易时滑点更低。但缺点也很明显,就是LP面临着无偿损失的风险。如果市场上交易者总体是盈利的,那LP反而可能亏钱。

第三种是聚合器模式。 Aether就是这个路子,它更像是一个服务层,本身不创造流动性,而是通过技术手段把不同链上的流动性整合起来。这种模式的关键在于前端的用户体验,能不能解决用户跨链交易的繁琐问题。

这三种模式各有优劣,也代表了不同的发展方向。

八、竞争要素

在Perp DEX这个赛道上,要想脱颖而出,打赢这场战争,有几个关键要素是绕不开的:

首先是速度。 Hyperliquid和dYdX都在把交易性能作为核心竞争点来抓,这反映了整个行业都在向CEX那种极致的用户体验看齐。对于高频交易者来说,亚秒级的延迟和0 gas费简直就是刚需。谁能做到这一点,谁就能吸引到这部分核心用户。

其次是流动性来源的可持续性。 GMX的LP模式通过真实收益吸引用户存流动性,相对来说比较内生,有一定的可持续性。而Aether的聚合模式很大程度上是靠代币激励来聚合流动性,这种模式对外部激励的依赖性很强。一旦激励没了,流动性可能就跟着跑了,可持续性就值得打个问号。

第三是代币经济学模型的优劣。 Hyperliquid搞的那个收入回购飞轮模型,把绝大部分收入(97%)都拿去回购代币,这使得代币的价值直接跟协议的交易量和收入挂钩,形成一个可持续的价值捕获机制。相比之下,Aether那种空投刷量的激励模型,虽然短期内能拉高交易量,但很多交易都是追求短期利益的行为,缺乏长期的用户粘性,风险就比较大。

九、未来发展趋势

1. 意图交易革命

展望未来,Perp DEX的下一个战场很可能是一场用户体验的革命。坦白说,现在的传统DEX操作起来还是太复杂了,各种gas费、滑点、MEV攻击,门槛太高,挡住了不少新用户。但好消息是,一种叫做意图交易的新系统正在兴起,有望从根本上解决这个问题。

意图交易是怎么回事呢?简单说就是把复杂的链上操作给抽象化了。以前你要做一笔交易,得一步一步精确指定,还得手动付gas费,提心吊胆怕被MEV机器人抢跑。但在意图交易系统里,你只需要告诉系统你的最终意图,比如”我要获得价值1000美元的BTC永续合约多头头寸”,至于具体怎么实现你就不用管了。

这时候系统背后的求解者(通常是专业的算法或者做市商)会出来干活,他们会在链下竞争,找出最优的交易路径,然后把结果打包成一笔交易提交到链上。这种方式的好处太多了:操作大大简化,新手也能轻松上手;求解者负责支付gas费,最终成本会算进你的成交价里,实现无感gas体验;而且因为意图处理是在链下进行的,还能有效对抗MEV攻击。

像Aevo和Apex这些平台已经把意图交易系统作为核心创新之一了。可以预见,随着更多平台采用这种模式,它很可能会成为未来Perp DEX的用户体验新标准。再加上原生移动应用的普及,比如Apex已经推出了iOS和Android应用,让用户像用CEX一样随时随地无缝交易,这将彻底改变用户的使用习惯。

2. RWA深度融合

除了用户体验,Perp DEX的另一个重要发展方向是与现实世界资产(RWA)的深度融合。RWA是啥?就是把那些传统的金融资产,比如房地产、股票、外汇、国债、黄金等等,通过代币化的方式搬到链上。

把这些资产引入链上,意义非常重大。它能为DeFi带来传统金融市场的巨大流动性、稳定性和多样性。你想想全球外汇市场的日交易量是多少?6万亿美元,是整个加密市场日交易额的几十倍。哪怕只有1%的交易量被迁移到链上,对Perp DEX来说也是数千亿美元的增量市场。

所以一些Perp DEX已经开始积极探索RWA永续合约。比如dYdX计划上线特斯拉这种股票的合成资产永续合约,还有像Avantis这样的项目,更是专注于提供外汇(比如USD/JPY)和主要股指(比如纳斯达克指数)的RWA永续合约。

但是RWA永续合约这条路绝对是高门槛、高天花板,潜力巨大,但挑战也极其严峻。最大的挑战有两个:

一是报价和预言机问题。 传统资产的价格需要依赖像Chainlink、Pyth这样的专业预言机来提供准确、低延迟的实时数据,这不仅成本高,技术要求也极高。

二是合规压力。 交易比特币主要关注投机风险,但一旦涉及到USD/JPY或者纳斯达克指数这种资产,那就直接进入了传统金融的监管核心地带,面临着证券和商品交易的严格监管。

正因为这些挑战,大多数项目要么不敢做,要么做不了。所以谁能率先成功攻克这些难关,谁就能获得巨大的差异化竞争优势。未来的增长天花板也会远高于那些只在加密原生资产领域内卷的平台。

3. 技术与监管双轮驱动

未来的Perp DEX注定会是技术创新和合规发展这两股力量相互博弈、共同塑造的结果。

在技术层面, 像零知识证明(ZKP)这样的前沿技术将会扮演越来越重要的角色。ZKP不仅能提升Layer2的交易吞吐量和可扩展性,比如StarkNet就用到了,还能在不泄露任何交易细节的情况下证明交易的有效性。Aether那个隐形订单功能,就是利用了ZKP的原理来隐藏订单信息,保护用户隐私。

在监管层面, 行业的未来走向充满不确定性。在美国,SEC批准比特币和以太坊ETF算是个积极信号,但Kraken因为担心美国商品期货交易委员会(CFTC)的态度,暂停了其DEX计划,这也说明监管的不确定性依然是悬在Perp DEX头上的一把达摩克利斯之剑。

而在欧洲,MiCA为加密行业提供了第一个全面的监管框架。这个框架的建立,一方面可能会增加Perp DEX的合规成本,但另一方面,它也为行业提供了急需的法律清晰度,有助于吸引机构资金的入场,从而把挑战转化为机遇。所以Perp DEX的未来很大程度上取决于如何在这两者之间找到一个平衡点。

4. 社交与交易融合

最后一个趋势是社交与交易的边界融合。未来的Perp DEX可能不再仅仅是一个冷冰冰的交易工具,而会演变成一个充满活力的、由社区驱动的生态系统。

我们可以借鉴一下传统金融里已经很成熟的社交交易和

跟单交易模式。在Web3的世界里,这些模式可以通过智能合约来实现自动化和无许可。比如跟单交易,就是新人可以自动复制那些经验丰富的交易员的策略,这对于刚入门的小白来说非常友好。

像Hyperliquid推出的Builder Codes,还有Aether在社区代币分配上采取的高比例策略,都是为了鼓励用户更积极地参与到生态共建中来。这些机制试图把交易者、开发者、流动性提供者紧密连接在一起,让大家共同分享协议的价值。最终的目标是把一个单一的交易平台转变成一个具有强大网络效应的、由社区共同维护和发展的交易生态。

十、风险与挑战

回顾一下,去中心化永续合约交易所(Perp DEX)从一个有点稚嫩的概念,到现在已经成为一个不可忽视的重要赛道,经历了非常快速的演进。它提供的独特价值主张——资产自托管、链上透明度、抗审查性——正在吸引越来越多的用户。

当然我们也必须清醒地认识到伴随的风险:

智能合约可能存在漏洞。 尽管代码是公开透明的,但复杂的智能合约系统仍然可能存在未被发现的漏洞,一旦被黑客利用,可能造成巨大损失。

高杠杆交易带来的清算风险。 永续合约本身就是高风险工具,加上高杠杆,价格的小幅波动就可能导致仓位被强制平仓,投资者需要有充分的风险意识。

流动性可能出现的剧烈波动。 特别是在极端市场条件下,去中心化平台的流动性可能不如大型CEX那么稳定,这可能导致滑点加大或者无法及时平仓。

十一、成功的三个关键维度

展望未来,Perp DEX要想取得更大的成功,关键在于三个维度:

第一,通过意图交易这样的技术创新,把复杂的技术路径抽象化,为用户提供丝滑无感知的交易体验。 只有降低使用门槛,才能吸引更多主流用户进入去中心化交易的世界。移动端应用的普及、零gas费体验、瞬时确认等特性,都将成为未来竞争的标配。

第二,积极拥抱并努力解决RWA永续合约所带来的技术和合规挑战,打开传统金融这个巨大的增量市场。 这不仅仅是技术问题,更是如何在保持去中心化特性的同时,满足传统金融监管要求的平衡艺术。谁能在这个领域率先突破,谁就能获得远超加密原生市场的增长空间。能够提供股票、外汇、大宗商品等传统资产的永续合约交易,将为Perp DEX打开一个全新的万亿级市场。

第三,在清晰的法律框架内发展,为机构和主流资金入场铺平道路。 这需要行业与监管机构进行积极的对话和合作。欧洲的MiCA框架已经提供了一个参考范例,虽然合规成本会上升,但法律的确定性将极大降低机构投资者的顾虑。同时,通过零知识证明等隐私保护技术,可以在满足监管透明度要求的同时,保护用户的交易隐私。

十二、展望与总结

Perp DEX的旅程才刚刚开始。随着技术的不断突破和生态的日益成熟,它将继续在加密金融的演变中扮演核心角色。

从技术演进来看, 我们已经看到了从以太坊Layer2到专用应用链,从简单的AMM模式到复杂的链上订单簿系统的快速迭代。未来,随着模块化区块链、零知识证明、意图中心架构等新技术的成熟,Perp DEX的性能和用户体验还将有质的飞跃。

从市场格局来看, 虽然目前Hyperliquid以其卓越的性能和用户体验占据领先地位,但竞争远未尘埃落定。dYdX凭借其完全去中心化的理念和先发优势仍有巨大潜力,GMX的LP模式在特定场景下也有其不可替代的价值,而Aether等新秀则在用创新的方式挑战现有格局。这种多元化的竞争格局对整个行业的发展是有利的。

从产品创新来看, RWA永续合约的引入将是一个分水岭。它不仅意味着市场规模的数量级扩张,更代表着加密金融与传统金融的深度融合。当一个交易者可以在同一个去中心化平台上,用同一个钱包,同时交易BTC、EUR/USD和特斯拉股票的永续合约时,这种无缝的跨资产类别交易体验将彻底改变金融市场的面貌。

从生态建设来看, 社交交易、跟单功能、DAO治理、社区代币激励等机制的引入,将把Perp DEX从单纯的交易工具升级为一个有机的金融生态系统。在这个生态中,每个参与者——无论是交易者、流动性提供者、开发者还是验证者——都能找到自己的价值定位,并分享协议增长的红利。

最终的目标或许不仅仅是加密圈内的内卷,而是参与到全球金融体系的重塑之中。 通过提供更透明、更公平、更高效的金融基础设施,Perp DEX有潜力挑战甚至重新定义传统金融市场的游戏规则。这不是乌托邦式的幻想,而是正在发生的现实。

当然,这条道路充满荆棘。技术风险、监管不确定性、市场波动、竞争压力,每一个因素都可能成为发展路上的绊脚石。但正是这些挑战,吸引着最优秀的建设者、最有远见的投资者和最有冒险精神的用户,共同参与到这场金融革命之中。

Perp DEX不仅仅是一个交易平台,它代表着一种新的金融范式——一个不需要信任中介、不受地理限制、永不停歇的全球金融市场。在这个市场中,任何人只要有一个钱包和网络连接,就能参与到复杂的金融衍生品交易中,享受到曾经只有机构投资者才能获得的金融服务。

这就是去中心化永续合约交易所的魅力所在,也是它的使命所在。未来已来,只是尚未流行。而Perp DEX,正站在这场金融变革的最前沿。

一个视频搞懂什么是期权

前言

欢迎来到张兮兮的价格行为学。我们的专题课已经好久没有录制了,我一直在录制进阶课的内容。在录制进阶课的过程当中,有很多内容涉及到期权方面的交易。因为很多时候如果我们买正股,或者是做加密货币的朋友,如果单纯地买加密货币的现货或者开合约的话,你会发现你的盈亏比非常不好,或者说你的风险非常大,或者说你在这个时候买入正股或者买入一些加密货币的话,你的收入是非常少的。

在这种情况下,我们一定要使用期权作为一个手段来增大我们的收益率。我自己平时在加密货币或者股票的操作过程中,也经常会运用到期权,让我的收益率几乎是能够多一个零。比如说原本我只能赚10%的收益率,那么我用到期权之后,我的收益率能够达到100%。

但是我就发现有很多学习我专题课的朋友,或者是在我的会员群中的朋友,他们对期权几乎没有任何概念,所以说他们学这一块就会非常难。那么他们就希望说我能够提前录制一下期权的基础课内容。本来这个基础课的专题课,我是打算放在最后来讲的,因为期权是一个很复杂也很难的东西。但是既然我们后面的专题课,或者说平时我们的实操已经涉及到了期权,那么这种情况下,我就只能够先提前把期权拿出来讲。

当然这一期视频我会讲得非常非常浅显易懂,让大家能够至少能够对期权有这么一个概念。至于你会不会做期权,那就另当别论了。我们仅仅只是做一个科普。

一、期权的基本概念

好,我们一起来看一看期权究竟是什么。期权,它其实就是一个合同,这个合同规定在一个特定的时间,以一定的价格可以选择性地成交某件物品,比如说成交股票,比如说成交加密货币、房产,只要任何东西都可以,只要是一个商品,它能够交易的,我们都可以把它用一个期权来作为交易。

那么期权这两个字分别是什么意思呢?期,它其实就是未来的意思;权就是权利。那么这个期权组合在一起,就说你如果买了这么一个期权的话,你就会在未来的某一个时间,有权利选择性成交或者不成交某一件物品。

就比如说我们规定我们在明年的时候,以100块钱成交谷歌这个股票,你可以选择去执行这个权利,就说我拿100块钱去买这个股票,我也可以选择我不要这个权利了,就说我不买了,那么都可以。就说看你自己,你愿意行权就行权,你不愿意行权也可以,对不对。那么这个就叫做期权。

这个期权它里面有规定的时间、规定的价格,规定了这个标的物,然后同时还有一个选择的权利。

二、四合院买卖案例详解

我们来举一个例子。我们假设今天是2026年1月1号,那么企鹅先生他有一个北京二环的四合院,这个四合院在这一天它价值100万。那么企鹅现在就拥有这么100万的这么一套四合院的房子。

企鹅现在说他想把这套房子给卖掉,但不是立刻把它卖掉,而是希望在2026年12月31号把它给卖掉,也就是一年之后,也就是从年初到年底隔了整整一年,他就希望在年底把它给卖掉。

但是企鹅先生发现,最近的北京的房价一直在往上面涨,他认为如果说今天这个四合院的价值是100万,到了12月31号,也就是一年之后,这个四合院那肯定不可能是100万了,应该能够卖110万。

这个时候还出现了一个人,这个人叫牛牛先生,他正好又想买一套四合院,他希望能够在今年年底的时候买一套四合院。那么他们俩是不是就正好撞上了,一个想在12月31号卖,一个想在12月31号买,那么他们就可以做一笔交易。

牛牛也发现了北京的房价一直在涨,那么牛牛自己认为,四合院的价值在今年年底的时候绝对不止价值110万,他认为有可能会涨到150万,而不是像企鹅先生认为的是110万。那么他认为,如果现在我要是能够付一个定金给这个企鹅,就说我们规定年底的时候110万这套房子你卖给我,那么我这个时候到年底我把房子买下来,那我肯定能发财。因为他认为年底的时候房子150万,但是他却以110万的价格把它给买下来了,那我买下来就赚到了嘛,对不对。我付了这个定金,那我这个定金就说我有权利我要去买这个房子。

合同条款

所以说牛牛和企鹅它们之间就签订了一个合同,合同规定:

在2026年12月31号,牛牛可以选择在12月31号以110万的价格把房子给买下来
牛牛也可以选择在12月31号放弃这个交易
他可以选择买,也可以选择不买
但是牛牛必须要在今天,也就是2026年1月1号,付5万块钱的定金作为他的一个保证金

我这个地方,不同的颜色代表不同的日期:橘黄色是1月1号(也就是当下),蓝色12月31号(也就是交割日期)。我后面全部会用这样的颜色来标注这个日期,让大家更醒目地能够看到这个日期和价格。

签订合同当天的情况

他们之间签了这么一个合同,我们来看一看签完这个合同之后会发生一些什么样的事情。

首先在签订合同当天:

企鹅: 拥有一套四合院,同时收了5万块钱的定金,这是他的一个收入
牛牛: 拿到了一张合同(这个合同是有法律效应的,他是不能够毁约的,企鹅和牛牛两边都不能毁约),同时支付了5万块钱的定金

也就是说在1月1号,企鹅先生收入了5万,牛牛掏出了5万块钱。

情况一:房价涨至150万

我们来看一看在之后会发生什么事情。一年之后到了这个12月31号,企鹅和牛牛各自的收入会怎么样,我们来分类讨论一下。

首先我们假设到了12月31号,房子涨价了,它涨到了150万。它比企鹅的预期要高,它完全符合牛牛的预期。

我们来看一下企鹅:

收入了5万块钱
但是房子卖飞了40万
他以110万的价格把这套房子卖给了牛牛,他是不是卖飞了40万,等于说他亏了这40万
企鹅如果没有以110万卖给牛牛的话,他原本可以卖150万的
所以说他其实是亏了40万
但是由于他有一个定金的5万块钱收入,所以说企鹅它其实是亏损了35万

牛牛呢:

牛牛在1月1号支付了5万块钱的定金
但是他在12月31号以110万买下了这么个150万的房子
他就赚了房子的这40万,扣除了那5万块钱的定金
牛牛是不是就赚了35万

大家可以发现,当房价涨到150万的时候,牛牛赚了35万,企鹅亏了35万。

情况二:房价涨至1000万

我们再来看一看还有什么事情可能会发生。假设到了年底,房子不是涨到了150万,它涨到了1000万,它完全超乎了所有人的想象,超出了企鹅的想象,也超出了牛牛的想象。那么涨到1000万之后会发生什么事情呢?

企鹅:

他还是收入了5万块钱的这么一个定金
但是他房子卖飞了,原本他可以卖1000万的房子,他只卖了110万
他是不是亏了890万,他少赚了890万
扣除5万块钱的这么一个收入之后,他的实际亏损是885万

牛牛:

那他就赚大发了
他只支付了5万块钱的定金,就以110万的价格买了个1000万的房子
他是不是就赚了890万,刨去5万块钱的定金
他就收入了885万

看见没有,当房子涨上天了之后,牛牛的收益也涨上天了。牛牛赚885万,企鹅亏885万。

情况三:房价涨至115万(盈亏平衡点)

我们继续来看,还有什么情况。假设到了年底,房价涨到了115万,也就是说从100万涨到了115万,只涨了15万,在这种情况下会发生什么呢?

企鹅:

定金收入了5万块钱
房子卖飞了5万块钱,对不对
他房子以110万卖给了牛牛,但原本可以卖115万
也就是说他少赚了5万块钱
但是定金弥补了这5万块钱
所以说企鹅的收入为零

牛牛:

他买房子他赚了5万,他以110万的价格买了115万的房子
但是他却支付了5万块钱的这么一个定金给企鹅
所以说牛牛他的盈利也是零

比如说这一轮他们打平了,房子如果涨到115万,他们是一个平手。

情况四:房价维持100万不变

我们再来看,假设到了12月31日,房价维持不变还是100万,这个时候会发生什么情况?

这个时候:

企鹅先生收入了5万块钱的定金
但是牛牛发现,他如果说以110万的价格买了这么个100万的房子,他就会亏10万块钱
那他觉得我还不如不买这个房子,他放弃行使自己的权利

大家记得,刚刚立的这个合同,牛牛是可以选择性地买或不买的,他想买就买,他不想买就不买。当房价往下跌或者维持不变的时候,他是可以选择不买这个房子的。他顶多就亏了那5万块钱的定金,他认栽,他就说我这5万块钱我不要了,那你这个房子你再便宜我都不买,对不对。那我这样子的话,我能够避免损失。

所以说:

牛牛亏了5万块钱
企鹅赚了5万块钱 - 他赚的就是这么一个权利金(我们把合同的定金叫权利金)

情况五:房价跌至50万

我们再来假设,假设这个房价跌了,它没有涨,它也没有不变,它跌到了50万,这个时候又会发生什么事情呢?

我们看它跌了:

牛牛: 当然还是不愿意去买这个房子,他还是认栽那5万块钱
企鹅: 还是只收入了那5万块钱

看见没有,企鹅还是收5万,牛牛还是亏5万。

情况六:房价归零

还有些情况会出现什么,就比如说到了年底12月31号的时候,房价归零了,没有人愿意要这个房子,觉得变成了一个烫手的山芋。那么这个时候:

牛牛: 还是一样的,他放弃了行权,他支付了5万的定金,他认栽了,认亏5万
企鹅: 收入了5万块钱

看见没有,就说只要房子往下跌,那么这个牛牛亏的都是5万,企鹅赚的都是5万块钱。

三、关于房价下跌时的特殊说明

这个时候可能会有人有问题了,他说为什么当房价下跌的时候,我就不考虑企鹅房子价值的亏损,但是当我这个房子涨起来的时候,我却要考虑牛牛这个房价上涨给他带来的收益呢?这个问题非常关键。

原因是什么呢? 原因是因为在股票市场中,我们可以在手中没有任何股票的时候,就和别人签订一个卖股票的合同。就是你手中假设你现在想卖特斯拉的股票,比如说100块钱卖特斯拉的股票,但是你手中并没有那个股票,我只是单纯地跟别人签了个合同,我就是想拿这么一个定金回来。

到了交割日的时候,如果说假设这个特斯拉的股票涨上天了,然后这个对方就假设是牛牛,他想把这个股票以100块钱价格把它给买回来,买回来,这样子的话牛牛它不就可以赚钱吗。这个时候企鹅,他手中没有特斯拉的股票,他可以直接在市场上买回来对应的股票交过去就可以了,对不对。

那如果说到了交割日的时候,价格没有涨,比如说它跌到了这个特斯拉跌到50块钱了,那么这个时候牛牛他不想行权,那么这个时候企鹅的话,他就不用去这个股票市场中去买这个股票,那么他是不是就可以空手套白狼。他就仅仅只是说我签了一个合同跟你,那我就签了合同之后,我收了你的定金。但是我就赌什么呢?赌你到了这个交割日的时候,你不行权,你不想买这个股票了,那这样子的话,我就没必要去准备这么一个股票给你。

房子也是同理。 假设这个企鹅签订了一个合同和牛牛,但是他签订合同的时候,企鹅本身没有这么一套房子,那么他就是希望这个牛牛在这个12月31号,他放弃他的行使权利。那么这种情况下,这个企鹅它就完全不用考虑他有没有这个房子准备,他就不用准备有这么一套房子了,那么这样子的话,他就可以白拿那个5万块钱的定金。

但是如果房子假设真的涨起来了的话,那这个时候企鹅怎么办?那他必须要有一个房子和牛牛交割,因为这是一个合同,对不对。那企鹅怎么办呢?企鹅就在这个市场上去买同样的一套房子,比如说一个小区里面,可能差不多的房子他就买过来,然后就说我给你这套房子,那他就是在12月31号的时候赶紧买套房子,买了之后给给牛牛,这样就可以了。

股票市场中跟房子不一样, 因为房子可能有什么朝向的问题、什么地段的问题,但是股票他就没有这些问题了。就是股票和股票之间,你只要是同一个公司的股票,它都是一个价格,那么就不存在这些什么朝向的问题、楼层的问题了。所以说在股票中,我们手中可以没有任何股票的时候,就和别人签订这么一个合同去卖股票。那么在这种时候,如果说股价下跌,那我就不考虑这个股价下跌带给我的这个损失了,对不对。那么这个就是原因。

为什么房价上涨的时候,就要考虑牛牛赚到的房产价值呢? 刚刚也说过了,理论上来说,在股票中,假设你是在股票中交易这个期权的话,股票价格上涨,总有人会去高位接盘,我们可以看见总有买一卖一的价格,对不对。这个买一卖一的价格决定了我们这个股票当前的价值。

当这个股票价格推高的时候,那牛牛他假设他行权了,他这个股票他可以转手把它给卖掉,对不对。那么他假设他有一个房子1000万了,然后他把这个房子以110万价格买过来之后,他可以扭头1000万就卖掉。我们假设房子的这个流动性非常的好,和股票一样的情况下,那总有人高位接盘,那他扭头就能变现了,对不对。

所以说这种时候,我们就要考虑房子它本身的一个价值了。这就是为什么房子下跌的时候我们不考虑价值,房子上涨的时候我们需要考虑这个房子的价值。这个是由于股票本身它的这个高流通性导致的。房子本身可能就没有这种情况出现了,由于我现在只是举个例子,所以说我就用房子这个例子来给大家演示。

四、买入看涨期权分析

那么我们就以牛牛的视角来看一下,就说这个房价的涨跌会给他带来造成一些什么样的影响。

如果说房价在12月31号涨到了115万,那么牛牛就能够保本。 我们刚刚已经举了那个例子了,就是12月31号涨到115万。为什么115万他能够保本呢?因为他要在12月31号以110万的价格买这个房子,同时他还交了5万块钱定金,那他总成本是不是就是115万。他如果说这个房子正好价值115万,他扭头再把这个房子给卖掉,他可以把那115万给完全收回来,那么他就是正好保本了。

但是房价如果低于115万的话,牛牛他就会亏钱。 他会亏什么呢?他只亏那5万块钱的定金。因为它只要低于115万,比如说这个房子100万或者50万,他就大不了我不行权了,我不要这个房子了,我认栽那5万块钱。所以他最多只是亏那5万块钱。

但是如果说高于115万呢? 比如说我们刚刚举个例子,150万、1000万,是不是房子涨得越多,牛牛就赚得越多?他是赚钱无上限,但是亏就只亏那5万块钱。大家有没有发现盈亏比相当的好,对不对。

那么这个行为我们把它叫做买入看涨期权, 也就是说牛牛他要赌,他赌什么?赌未来的房价能够涨超过115万。这个115万就是房价和定金的总和(这个原本房价指的是110万,这是他们这个行权价;那个定金就是5万块钱,就是签这个合同所需要的成本)。这个叫做买入看涨期权。

买入看涨期权的盈亏图

我们来看一看,如果把它用这个坐标把它表示出来的话,它会长成什么样子呢?

就说这个房价在115万的时候,这个牛牛他是不亏不赚的。但是这个房子的价格一旦开始疯狂往上涨,那他的这个收益就会越来越多越来越多。但是如果说这个房子低于115万的话,你看他最多也就只亏这5万块钱的一个定金而已,他不会亏再多了。

那么这个就是一个非常好的一个盈亏比 - 买入看涨期权。

五、卖出看涨期权分析

我们再来以企鹅的视角来看一下,就是企鹅他这个到底是一个什么样的行为。

那么无论房价怎么变化,是不是企鹅总能拿到那5万块钱?那么这是一个固定收入,是不变的。但是房价会影响他的另外一个收入:

当房价无限上涨的时候,它会面临无限大的亏损。 比如说我们刚刚举的例子,房价涨到了1000万,那他就要亏800多万块钱,对不对。因为他只能够拿回来房子的这个110万和5万块钱的定金,剩下的都是他卖飞的一个价格了,那么他就是面临无限大的亏损。房子涨了一个亿的时候,那他就亏了多少?亏了9000多万了。

但是房价它如果说下跌的时候, 那么它就会怎么样?他就是只拿了5万块钱定金。发现没有,我们刚刚不是说房价归零,他也是只拿了5万块钱定金吗。

我们把这个行为把它叫做卖出看涨期权。 他就和这个牛牛,他是对赌的。牛牛是买这个房子,他就是买看涨期权;企鹅是卖房子,他就是卖看涨期权。为什么叫看涨期权呢?就是因为这个买家他是赌房子上涨,所以说叫看涨期权。

卖出看涨期权的盈亏图

我们来以坐标系来看一下企鹅他这个收入会是怎么样的。

当这个房子的价格低于115万的时候,他最多也就只能赚5万块钱的权利金,看见没有。但是当这个房子价格无限往上涨的时候,他的这个亏损就会无限的大。

我们把它叫做有限的收入,无限的亏损。那这个盈亏比怎么样呢?那这个我也不知道,就是你亏可能会让你亏得倾家荡产。

六、看跌期权

那么有看涨期权,其实就有看跌期权。那么看跌期权是什么呢?

看跌期权其实和看涨期权就完全反过来了, 它是赌这个房价会下跌。就是比如说牛牛他要买看跌期权的话,他就是希望这个房价会下跌的,它和看涨期权不一样,看涨期权就是牛牛希望这个房价上涨。

那么看跌期权的话, 你如果是买看跌期权的,比如说牛牛,那么就是房价跌得越多,你就赚得越多,但是你最大的亏损就是你签合同的那个定金,所以最大亏损额度就只有那个权利金。

但是你如果是卖看跌期权的人的话, 房价跌得越多,你等于是对赌嘛,那么这个他就亏得越多了。那么他的这个最大的盈利的额度,那就只有这个权利金。

它和这个看涨期权就完完全全是反过来的了。

那么看跌期权它本质是通过做空来实现的, 但是做空它等于说是又是另外一个专题了。我以后可能会专门开一个专题课来讲做空。那么如果说大家对做空不了解的话,大家就跳过这一趴,就只是心里有个概念,就说看跌期权,你要买看跌期权,签这个合同的话,那你就希望那个标的物价格跌得越多,你就越赚钱就好了。他跟看涨期权是完全相反的。你也不用管什么做空之类的,就只要知道有这么个概念就行了。

美股中的收租策略

在美股,美股里面它是一个长期的牛市,它美股不是天天创新高吗,纳斯达克、标普500天天创新高。有些人他就会定期去卖看跌期权,因为你卖看跌期权的话,你就等于说是怎么样?他就说他认为这个股票不会下跌,它会往上涨,他就赌股票永远不会下跌得太多。

那么这样子的话,他定期地去卖这个期权,他每卖一次他就能收一次权利金。那么这个行为我们把它戏称为收租,因为他可能每个星期都会卖一张看跌期权,那么他每个星期就能赚一笔权利金回来。

那么这个就是在美股中非常常见的一个收入的一个方式。当然这个方式其实是风险特别高的,因为我们说你只要是卖期权,你就有无限的风险,你可能会亏得倾家荡产。但是这个收租在这个美股中,由于它是一个长期的牛市,所以说很多人他就觉得这个很爽,因为你可能100次收租行为99次你都是赚钱的,只亏那一次,但是有的时候亏那一次也会让你亏得倾家荡产。

如果说你对做空不了解的话,看跌期权这一趴你就可以跳过。

七、期权合同的转让交易

我们来看一看期权本身他也是能交易的,也就是说这个合同本身,他也是能交易的。怎么交易呢?我们来举例子。

假设现在是10月1号,它不是12月1号,也不是1月1号,它是在中间,10月1号(我用绿颜色来表示了)。

这个还是那

个房子,企鹅,他这个房子,那么它涨到了1000万了,他不是跟牛牛签了一个这个合同吗。但是在10月1号就已经涨到1000万了,这个时候企鹅他是浮亏890万。这个时候他还没把房子卖给牛牛,因为他这个房子规定是12月31号卖,那么现在还没到这个日期嘛,我们把它叫浮亏,浮亏890万。

这个牛牛呢,他就浮盈了890万。为什么是890万呢?就是因为这个牛牛应该是以110万的价格买吗,现在1000万了,他是不是就浮盈890万,对不对。他只是浮盈,没有实际盈利。

这个时候这张合同价值多少钱? 是不是价值890万?因为牛牛能够靠着这个合同能够赚890万。我们假设,假设到了12月31号,这个房价还是1000万的话,牛牛是不是他就可以赚890万,那么这个合同他就价值890万,因为他能靠这张合同能够变现出来890万。

隔壁老王登场

这个时候隔壁老王出现了。这个老王出现他要干嘛?他就说:”牛牛,你等等,我想买这个房子,我认为到了12月31号,这个房子不可能1000万,还有可能涨到一个亿,我要把它给买下来。”

这个时候牛牛呢,他也觉得:”诶,挺好的,老王,你想买我这个房子,对不对。我但是我现在是个合同,我没法卖你房子,那要不我把这个合同卖给你吧,对不对。”

那个合同原本是签的企鹅和牛牛的名字吗,现在我把这个牛牛名字给划掉,我把它改成老王的名字就好了。那到时候呢,你就跟这个老王和企鹅之间,你们俩去做交易,那跟我就没啥事了,我不掺和。

那么这个时候呢,牛牛他就把这张合同以890万就可以卖给老王, 因为这张合同已经价值890万了嘛,老王当然愿意以890万把这张合同给买回来、买下来。那么这个时候呢,其实就是仅仅只是把这个合同改了个名字而已,就把这个牛牛的名字改成了老王的名字。

10月1号的盈亏情况

同时在10月1号,由于这个把这个合同改名了:

牛牛就瞬间赚了885万 - 因为这个老王就在10月1号给了牛牛890万改了这个合同名字,那么牛牛刨去那5万块钱的这个定金,对不对,那么他就赚了885万。885万落地了,已经存到银行里面去了。
老王 - 他就有权利在12月31号以110万的价格从企鹅那里买下这套房,同时他在10月1号为此付出了890万的代价,这个890万是给了牛牛。

假设房价涨到2000万

到了12月31号,我们假设房价如老王所愿涨到了2000万了,这个时候会发生什么事情呢?

老王:

他是不是赚了1000万
因为他以110万的价格买了2000万的这么一套房子
同时他还给了牛牛890万
那么等于说他总支出是1000万,但是他买到了2000万的房子
他赚了1000万

企鹅:

他亏了1885万
为什么1885万?因为他以110万的价格卖飞了一套2000万的房产
同时他又收到了5万块钱权利金
那么这么1+1减,正好就是亏1885万

牛牛:

他其实在10月1号就已经赚了885万了
到了12月31号跟他没事了
所以说牛牛还是赚了885万

看见没有,那么这种情况下,他就把这个期权或者说合同做了一笔交易,那么这笔交易可以让更多的人带来收益或者亏损。

假设房价跌到500万

我们再来看一下,假设到了12月31号,房价跌到了500万,而不是如老王所愿涨到了2000万,这个时候老王就会非常的苦逼。

老王:

因为他以110万的价格虽然买到了500万的房子
但是他之前却付了890万给了牛牛
这个时候老王他只有1+1减,亏了500万

企鹅:

他也亏了
企鹅他是以110万的价格把房子卖给了老王
但是其实这个房子现在值500万
那么企鹅他亏了385万(要把这个权利金5万块钱给算上)

牛牛:

却能够独善其身
他就赚到钱了,因为他在10月1号就已经提前离场了嘛
那么这个时候呢,老王的亏损、企鹅的亏损,那都跟牛牛没关系了
牛牛他就捞了一笔钱就走了

大家有没有发现牛牛做了个什么事? 他仅仅只是花了5万块钱签了个合同,他啥也没干,他就赚了885万,看见没有。这个就是期权的魅力 - 以小博大。

八、买入看涨期权的优势分析

那么作为看涨期权的买家牛牛,那么他有什么好处呢?

1. 高杠杆

我们首先来看一下:

牛牛的本金是5万块钱
他在行权日房价超过110万时,那么他就可以拿100万的房产的收益率,对不对
就是超过110万的时候,他就可以开始行权了,或者是115万,他就可以拿到100万房产的这个收益率
那么这个时候他的杠杆是多少?杠杆是20倍
他最多只亏5万,收益率其实却是无限的

就像我刚刚举的那个例子,牛牛他就只花了5万块钱签了个合同,他啥事没干,他就赚了885万。那么他这个就是拿着5万块钱的本金赚了885万,他其实是有20倍的杠杆。

你如果说在1月1号拿着这个100万去买那个房子,那这样子的话,你其实是花了100万的这个本金去赚那么一笔钱。但是他呢却是用5万块钱的本金去赚的那么一笔钱。5万赚885万和100万赚885万,这是不同的杠杆倍数的。

所以说这个牛牛的好处之一,就是高杠杆。

2. 收益无限,亏损有限

第二个好处就是这个收益无限,亏损有限。

3. 不会爆仓

还有什么好处呢?如果说是股票交易的话,股票如果说中途下跌,比如说10月1号房子归零了,这个股票归零了,那么这个期权的价值它只是暂时的下跌,期权也就可能归零了。但是如果到12月31号,这个房子从零块钱又涨到了假设1000万的话,那这个期权又变得很有价值了,因为到了这个12月31号,房子又变成1000万了嘛,那他还是可以赚钱。

所以只要股价最终能够涨到这个盈利点,在这个交割日的话,那么最终看涨期权的买家始终都能赚钱。

但是如果你是开杠杆做股票交易,你比如说这个牛牛,他不是期权有20倍杠杆吗,你如果在股票炒股票过程中开20倍杠杆的话,你跌5%就爆仓了,对不对。但是你如果买期权的话,你归零你都不会爆仓,你顶多就是亏了这个期权的权利金。但是你如果开杠杆的话,你就有爆仓的风险,那你爆仓就破产了吗,永无翻身之日。期权它却有翻身之日的。

这个就是很多好处 - 期权买看涨期权。

坏处

但是呢他有个坏处,坏处就是你总有5万块钱的预算成本,这个就看你就是怎么去想了。

九、卖出看涨期权的优劣分析

我们再来看一下作为看涨期权的卖家企鹅,他有什么好处和坏处呢?

好处

企鹅的好处就是:

他总能够赚到那5万块钱的权利金
不管房子上涨还是下跌

坏处

但是它有一个坏处:

就是有限的收入,无限的亏损
这个房子涨得越多,它就亏得越多
在股票中股票涨得越多,你如果作为一个看涨期权卖家的话,你就亏得越多
因为在行权日那个时候,你要用更多的钱去买回股票来交给这个合同的对方
这种时候你就会亏非常多的钱了

十、欧式期权与美式期权

我们来讲一讲,就说期权有两种,一种叫做欧式期权,一种叫做美式期权。

欧式期权

什么是欧式期权呢? 就说欧式期权,就是只能在规定的交割日交割。比如说我们刚刚讲的那个例子,就是欧式期权的例子,就是12月31号我们来交个房子。

那么这种,一般说来,就是在:

加密货币交易所
或者是欧洲期货交易所
或者是中国,这个上海或者是深圳的交易所里面的这个期权交易

都是欧式期权的。你要想交割必须在规定的日期交割,这个就是欧式期权。

美式期权

美式期权就不一样了, 美式期权就说你在行权之日之前的任何时候都可以随时要求交割。这个是买家,就是买看涨期权或看跌期权的人,你是可以随时交割的。

这个一般说来出现在什么地方呢?出现在美国的股票和ETF的期权交易所。你比如说我现在做美股的话,或者是做这个ETF,我有时候也会用到这个期权杠杆,我用的就是一个美式期权的这么一个杠杆。

美式期权案例

我们来举个例子,美式期权的例子。这个是美式期权的。

我们假设在2026年10月1号(不是31号,是10月1号),房子涨到了1000万:

这个时候房子企鹅浮亏890
这个牛牛他浮盈890,对不对
这个时候还没有到交割日(12月31号)

但是这个是美式期权,牛牛是可以选择在任何时候行权的,他可以在任何时候把这个房子以规定的价格买下来。

你看现在牛牛发现房子已经涨到1000万了,他怕这个从10月1号到12月31号之间,如果房子跌了怎么办呢?他受不了,他就希望说:”那我要不就今天就把这个房子给买下来吧。”

牛牛要求现在就交割, 这个是美式期权可以有的哦,在12月31号之前你都是可以随时交割的。

他如果交割了之后:

这个浮亏就变成了真实亏损了
那么企鹅就是正儿八经的亏损了890万了
牛牛他就落袋了890万
那么只要交割,这个盈利和亏损就已经实现了

假设到了12月31号,房价又跌回到了100万:

那这个时候呢,由于房子已经交割了
企鹅那个时候以110万的价格卖了套1000万的房子
那么等于说是他亏了900万,对不对
但是就算12月31号跌回到了100万,企鹅也没有办法弥补他的亏损,因为已经交割了
所以呢企鹅无力回天

然后牛牛呢:

他就怎么样,落袋了890万
他可能预判到了12月份房子会大跌,他就提前盈利了

那么这个就是美式期权。

美式期权的额外风险

这个作为这个期权的卖家,就额外又多了一个风险,就是买家有可能会要求提前行权。

所以说一般说来,在这个美式期权的交易所,这个交易所它可能会要求你不断地补保证金。如果说这个股票价格如果说往上涨的话,那你就得不停地补,要不然的话,他就怕你就说中途买家要是行权的话,你就没有办法去交割。所以他要求你不断地补保证金,这个就非常的可怕了。

十一、期权链介绍

我们来看一下,一般说来你要买期权的话,它就会有一个期权链。

比如说这个地方,我是截的一个谷歌的2025年(今天是10月31号),我一看见这个地方,你可以选择:

看涨期权
或者是看跌期权

那么你可以选择日期,就说比如说我希望买一张看涨期权,这个期权我们可以假设在12月19号交割,那么我们就点开这个12月19号。

你看我这个地方点开的是10月31号,那么就说我希望我买一张看涨的10月31号交割的谷歌的美式期权,这个是谷歌美式期权。

行权价选择

那么我可以看见你有行权价,就说:

我可以在这个10月31号,我要求280块钱买谷歌的这个股票
我也可以282块钱买
285块钱买
287块钱买

都有,你可以选不同的价格。

不同行权价的权利金

不同的这个行权价有不同的这个定金:

你看你如果说想在10月31号以280块钱买下谷歌的股票的话,你的定金每股就是3块5毛5
你如果想285块钱买这个谷歌的股票的话呢,那就变成了1块3毛9了

就说这个看涨期权,你这个行权价越高的话,那你这个定金他就会越少, 因为它越难嘛,越难往上涨,所以说他的这个行权价就会越来越便宜。

那么这个呢就是一个期权链。期权链一般说来是看涨、看跌都会同时出现的。这个地方为了方便让大家理解,我就只点了一个看涨。其实正常情况下是左边看涨,右边看跌的,这样子看的话,就会比较简单一点点。

十二、总结与课程推荐

那么这个呢就是所有的关于这个期权的一个科普的一个内容。

如果说大家对于这个期权怎么做交易,能够让你能够最大化你的收益率的话,欢迎大家去看我的进阶课的课程。

如果说你是对加密货币特别感兴趣,平常总在做加密货币的交易,而同时也希望通过这个加密货币的期权来能够让你收益最大化呢,我也希望你能够看我的这个进阶课的内容。

我这边还有一个Discord的会员群,在这个会员群中,我会及时地给大家看我所有的加密货币的操作,包括:

合约的
现货的
以及期权的

在这个过程中我会给大家详细的解释,为什么我会在这个地方有这么一些交易,以及这些交易可能给我们带来的风险以及好处。

那么这个就是本期的所有视频,欢迎大家来点赞、转发、关注、留言,我们一起来学习价格行为学。拜拜!

如何在 2025 年打造一个盈利的加密货币套利机器人

区块链的绝对最佳之处之一是你可以创建基于套利并使用闪电贷的加密交易机器人,他们在你睡觉时绝对会印钞般赚钱,就像这个开发者在过去七天内赚了超过23美元一样,全部在区块链上可百分比验证。但你如何制造一个真正有利润的这样的机器人呢?好吧,这正是我今天作为一个亲自做过这件事的区块链开发者,在这个视频里要展示的内容。

所以如果你是新来的,Hi,我是GREGORY,在我的频道我会把你培养成区块链大师。所以如果这正是你感兴趣的内容,那就在下面猛击那个赞按钮并订阅。好吧,我们开始吧。

什么是套利交易机器人

让我们谈谈如何创建一个基于套利的加密交易机器人。如果你点开了这个视频,我打赌你可能已经理解什么是套利,基本上就是在一个交易所买入加密货币,然后在另一个交易所卖出以获取利润。但你不想在像BINANCE或coinbase这样的中心化交易所上这么做,因为当你完成交易时,价格可能已经移动,交易可能不再有利可图。

所以你想要做的是使用去中心化交易所,比如uniswap或pancakeswap,并创建一个在这些类型的交易所之间进行交换的链上交易机器人。这就是为什么:第一,这些机器人不需要你自己的资金来交易,你可以完全用闪电贷免费借到他们;第二是你实际上不可能在这些交易上亏钱或亏掉你借来的钱,因为这个机器人由智能合约驱动,区块链就是不会让那种情况发生。

那么你到底如何做到这一点?好吧,我将在这个视频中分解每一步。但如果你想跳过所有这些步骤并真正偷走我的基于套利的加密交易机器人,那么确保你预留好下周4月的交易机器人大师班的位置。我将赠送我的闪电贷套利加密交易机器人,并逐步向你展示如何设置它。所以相信我,你不想错过这个,我会在下方放链接。

第一步:选择区块链

第一步是选择你要执行套利的区块链。你必须明白的是,每当你在区块链上做加密套利时,你必须在完全相同的区块链上进行操作。在我录制这段视频时,你不能有效地进行跨链套利。

所以让我们来看一些你要选择链式的不同标准:第一,链上必须有大量代币;第二,它必须支持大量交易,所以你实际上能找到可以套利的地方;第三,他必须支持闪电贷,这样你才能借出资金来做这件事;最后,他应该兼容EVM,这样你就可以把你的代码部署到许多不同的区块链。

如果你想获得一些想法,可以去像defillama.com这样的网站,点击chains选项卡,你就可以看到支持这些类型策略的不同区块链。显然第一名是ETHEREUM以太坊,它拥有最大的市场份额,它将支持主要的智能合约。但如果你能为ETHEREUM编写这个,你也可以为许多其他区块链编写,比如TRON、BSC币安智能链,任何以太坊的layer two,比如base、arbitrum等等。我刚才提到的所有这些都满足我刚才说的标准。

第二步:选择交易所

第二步是选择你想在期间套利的两个不同交易所。因为再次说明,你是在一个交易所买入,并在另一个交易所卖出以获取利润。再次强调,他们需要是由智能合约驱动的去中心化交易所,这样你可以完全在区块链上完成操作,并且价格不会对你产生移动。

我会给你两个例子:uniswap和pancakeswap。那么为什么我选择了这两个?首先,uniswap V3和pancakeswap基本上具有相同的代码接口。如果你学会了在uniswap V3上交易,你也可以在pancakeswap上实现相同操作。另外,他们有大量流动性和许多交易对,并且部署在多个不同区块链和layer two上。所以如果你理解如何在这些交易所上交易,你就有很多不同的地方可以去做这件事。

如果你想获得其他想法,你也可以回到DeFiLlama,点击forks选项卡,你就可以看到所有实现这种策略的不同去中心化交易所。所以再次说明,如果你能学会在一个去中心化交易所上交易并学会如何使用那份代码,那么你就能在多个不同交易所上交易。这就是forks的基本含义,forks只是从其他地方复制的软件。

如果你去那里并点击像uniswap V3,你会看到有超过134个不同的交易所使用完全相同的代码库,你可以在这些平台上潜在地应用这些策略之一。你可以把这个方法在该站点上列出的所有不同forks反复应用。

一旦你选择了一些交易所,你要做的基本上就是监视这些交易所发生的不同交易,看看他们是否导致了价格差异,从而让你可以在第二个交易所进行套利。那么你如何做到这一点?基本上你可以通过监控事件来监听去中心化交易所上每一笔交易的发生。事件本质上是区块链上发出的东西,任何人都可以订阅以获取该事件发生的通知。在这种情况下是swap事件。

例如,uniswap V3有一个swap事件,你可以订阅它。每一笔发生的swap,你都可以监控。如果它导致这两个交易所的价格出现足够大的差异,那就是一个套利机会,你就可以利用它。

第三步:选择代币

第三步是选择一个代币交易对。人们经常会问,嘿,我该如何研究代币开始做套利?第一个也是最简单的方法是只查看像etherscan这样的地方上的热门代币。好吧,我知道这只是针对以太坊区块链,但这些代币中的许多也会在其他区块链上可用,他们在以太坊上的市场份额可能也会与其他链相关联。

所以如果你去etherscan的tokens页面,你可以看到成千上万种代币列在这个页面上,这是开始寻找的一种方式。另一种方法是使用DEX浏览器,比如DEXSCREENER或dextools等,随你喜欢。但DEXSCREENER是一个不错的起点。

基本上你可以在你想要开始套利的链上选择,像我这里举例,我选了ETHEREUM,我按成交量排序,然后我就以chainlink为例,它排在顶部。所以你可以选择像chainlink这样的代币并搜索它。你要做的是确认它在至少一个交易所具有大量成交量,并且在同一条链上的许多其他交易所也有显著交易量。一旦你确认了这一点,那么你就可能找到了一个值得监视以尝试套利的代币。

关于你要套利的代币,最后要理解的一点是,当然第一点是他们必须都在完全相同的区块链上,就像我之前说的那样。但在这种策略中,他们都需要是ERC20代币。这是什么?基本上这只是一个规定代币如何工作的标准。如果你在我之前提到的任何区块链上,这些代币很可能都是ERC20代币。

你必须理解这些代码如何工作。基本上他们只是具有诸如transfer、transferFrom、totalSupply等函数的智能合约,这些是你在做套利时需要理解的函数类型。另外一点是你不能直接交换像以太坊这种链的原生gas代币,你需要使用这些代币的包装版本,比如WETH(wrapped ether)。如果你要做比特币之类的,也需要使用包装后的比特币版本。但这些都是这些底层加密货币的ERC20版本。

第四步:选择闪电贷提供方

第四步是选择一个闪电贷提供方。简要回顾一下闪电贷是什么,以防你不熟悉。基本上这是一种技术,允许你在区块链上免费借到高达数百万美元的加密货币,无需首付,只要你在完全相同的交易中偿还即可。

如果你不知道选择哪个闪电贷提供方,我偏好BALANCER。BALANCER是一个流动性协议,它有一个AMM,但他也支持闪电贷。我为什么喜欢BALANCER的闪电贷?因为它最容易设置。基本上这里有一个模板,你可以最小化定制地复制粘贴到你的智能合约中。他对闪电贷没有费用,最后他是多链的。虽然不做跨链,但他在多个不同区块链上工作。

所以它具有相当简单的功能。这里是你请求闪电贷时要调用的函数,以及你在智能合约中放入已接收闪电贷的函数。你只需在这些省略号处实现你的代码来实际执行套利交易。

第五步:创建智能合约

第五步是实际创建实现套利交易的智能合约。你要创建一个能发起闪电贷的智能合约,但一旦他拿到闪电贷,他还需要能够在两个不同的交易所之间进行交易。

之前我说过,你要尝试先选择两个使用完全相同代码接口的交易所,这就是我为什么提到uniswap和pancakeswap。然后你要学习如何在智能合约中用代码实现交易。我将以uniswap V3为例。

你可以去uniswap V3的文档问一下,我如何在智能合约中实现一次swap?答案就在那。基本上,你必须将uniswap的智能合约导入到你的合约中,以便你可以与他们对话。然后只需一些基本代码来设置swap的参数。你将使用exactInputSingle或swap这样的函数,exactInputSingle是uniswap V3用于交换的函数,并添加这些参数,比如你正在交易的代币、接收者、截止时间、你要投入的数量等,并把它添加到你的智能合约中,以在第一个交易所进行swap。然后你在另一个交易所做相反方向的操作,以获得比你开始时更多的代币回报。

第六步:创建搜索器机器人

第六步也是最后一步是创建一个搜索器机器人,它实际监视市场中的机会,然后调用你的智能合约来执行交易。你必须明白,一旦你创建了可以发起闪电贷并实际进行套利交易的智能合约,智能合约只会按指令行事。一旦你把它部署到区块链上,他并不会神奇地开始做套利。

你可能会看到一些YouTube视频说,只要复制粘贴这段代码并在remix上运行,它就会做套利。那些是骗局,会偷你的钱。所以你实际上要做的是把一个智能合约放到区块链上,然后创建第二个机器人,它运行在链下,在你的电脑上监视机会,然后调用你的智能合约去执行交易。

你可以在我屏幕上看到一个示意图。基本上你有一个链下机器人,然后链上有你的合约,它连接两个交易所,拿闪电贷,然后执行交易。

那么如何创建这些机器人?最简单的方法是在JavaScript里,用像Node.js这样的环境。什么是Node.js?基本上它只是一个让你在电脑上运行JavaScript的环境,因为它原生运行在你的web浏览器里。如果你使用Node.js,你可以编写一个单页脚本,本质上可以24/7运行监视这些机会,然后在发现盈利交易时调用你的智能合约。

那么你如何监视这些机会?回到我之前说的事件机制。每次在像uniswap或pancakeswap这样的自动做市商上发生swap时,它都会发出一个事件,同时也伴随着价格变化。如果价格变化足够,你就可以监听该事件做计算,以判断是否为盈利交易,然后调用你的智能合约。

你可以在你的Node.js脚本中使用像Ethers.js这样的库来做到这一点。你可以在这里看到用于监控事件的基本代码。基本上就是contract.on的用法,你只要指定你监听的事件和一些额外参数,然后在回调函数里监控传入的数据做计算,然后调用合约上的swap。当然你要计算包含gas费用后的价格差,来判断是否有利可图再去执行交易。

总结

好啦,这就是在2025年如何创建一个使用闪电贷的盈利套利加密交易机器人的概述。但再次强调,如果你想偷走我的套利机器人,那么确保你预留下周4月的交易机器人大师班名额。我会把我的闪电贷套利交易机器人送给你,并逐步展示如何设置。相信我,你不想错过这个,下方有链接预留你的位置。

这就是我今天要说的全部内容,确保在下面猛击赞并订阅,下次见,感谢观看!

DeFi知识体系全景解析

一、DeFi基础概念

DeFi的发展历程

DeFi赛道从2021年开始火爆,在2022年达到黄金时期,这可以从DeFi Llama上面的总锁仓量(TVL)看出来。后来沉寂了一段时间,但现在随着整个币圈又火起来,锁仓量又再次升高。目前有一个前沿方向叫RWA(现实世界资产),也是属于DeFi的其中一个分支,现在是一个很火的方向。

DeFi的定义

DeFi是去中心化金融(Decentralized Finance),与它对应的是中心化金融(CeFi,Centralized Finance),也就是传统金融。DeFi基于区块链技术,最主要的是智能合约技术。通过在区块链上运行的程序(智能合约)实现无需中心机构就可以完成的各种金融交易。

传统金融的各种业务——存款、贷款、股票、债券、保险、彩票等,基本上都可以搬到区块链上来实现。

DeFi的核心优势

1. 去中心化
没有中心机构掌控,可以防止跑路等问题。

2. 开放透明

区块链是完全开源的,尤其像以太坊
以太坊的源码开源,上面的各种DeFi智能合约都开源
所有人都可以看到底层逻辑、源码,以及所有交易
谁投资了多少钱、什么时候投的、谁赎回了,所有人都能看到
与传统金融的”黑盒”完全不同——传统金融你不知道谁在银行存了多少钱、谁来贷款,也不知道银行是否挪用存款

3. 无需信任

不用担心运营方会跑路或卷款潜逃
前提是合约经过审计,确定没有后门
普通人做DeFi项目需要公开源码,投资人会审计源码
懂行的人会检查代码是否有漏洞、后门
如果发现有超级管理员能任意提款等问题,项目就无法融资
这是一个不成文的规定,做DeFi都会把源码开源

4. 传统金融的局限性

传统银行、股票基金都是黑盒子
受政策和各种监管限制
需要满足各种条件:风险评估、KYC认证
有地域限制,比如在中国不能直接开户买港股、美股
有各种投资人限制

5. DeFi的开放性

面向全球的匿名用户
很多都是匿名的,不需要任何认证
不关心用户是哪个国家的人
只要有币就可以直接使用金融产品
例如Uniswap,只要有币就可以换另外一个币

DeFi优势总结

开放性:全球用户都可以参与,不关心是中国大陆用户、美国用户还是其他国家用户。只要发布在互联网或区块链上,就是全球可以访问的。

透明性:所有交易记录公开在区块链上,任何人都可以查看谁买了什么、谁卖了什么。

无需信任:不需要因为是名气大的基金公司或国有银行而信任它们。纯粹基于智能合约,看了智能合约源码,确认没有漏洞、没有后门,就可以信任这个合约。这是一个无需第三方的机制。

智能合约的核心特性

DeFi执行的底层环境主要靠区块链上的智能合约来保证。智能合约对于普通人来说就是一个程序。

智能合约的关键特点:

1. 不可篡改性
一旦交易被打包上链,这笔交易就永远不可更改,不存在覆盖的可能。这里特别强调是”打包上链之后”。

2. 交易流程
从手机或MetaMask这种浏览器插件钱包构造的交易发送出去后:

先进入交易池(MemPool)
等待被打包
等待时间可能长可能短,取决于给的gas费(手续费)
手续费越高,优先级越高,因为矿工优先打包手续费高的交易来赚更多钱

3. 交易排序机制

不关心交易发送的时间先后
只按照gas费从高到低排序
新来的交易如果gas费更高,会优先被打包
每个节点收到交易的时间都不一样(通过P2P网络广播)

4. 交易加速机制
如果发送的交易gas price设置太低,长时间不被打包,可以:

重新发送同一笔交易,但提高gas price
通过Nonce值来识别是同一笔交易还是不同交易
Nonce值相同表示是同一笔交易,新交易会覆盖旧交易
Nonce值不同表示是不同的交易

5. Nonce值机制

从0开始,代表发送方的第一笔交易
每个地址的Nonce值从零开始计数
Nonce值必须按顺序递增
打包时必须先打包Nonce为N的交易,才能打包Nonce为N+1的交易
不能跳过中间的Nonce值

6. 透明性
通过以太坊区块链浏览器可以随时查看所有交易。

二、区块链基础架构

交易生命周期

交易发送流程:

用私钥构造交易并签名
广播到区块链网络
连接到节点服务器(手机钱包的服务器上有区块链节点)
节点收到交易后再广播出去
进入各个节点的交易池(内存池/缓存)
等待打包

打包机制(以以太坊为例):

以太坊每12秒出一个块
一个块大概能打包200-300笔交易
如果12秒内发送了3000笔甚至30000笔交易,都会先进入交易池等待
负责打包新区块的节点(矿工)会优先选择gas费高的交易

区块链数据结构

区块的组成:

区块头:包含上一区块哈希值
交易数据:打包的所有交易
通过哈希算法连接形成链式结构

为什么叫”区块链”:
因为交易被打包成一个个区块,每个区块都包含上一区块的哈希值,形成链式连接,所以叫区块链。

不可篡改的原理:

交易被打包进区块后就不可篡改
如果修改了交易,哈希就会变
区块头的哈希会变,导致链式反应
下一个区块保留的上一区块哈希值就对不上了

状态数据库

概念:
区块链是一个分布式数据库,由区块、交易和状态数据库组成。

状态数据库的作用:

根据打包的交易执行后构建的可更新数据库
每个节点都有
加入区块链网络后,同步账本和区块交易,同时构建状态数据库
记录余额等信息

状态数据库与交易的关系:

交易一旦被打包就不可变
状态数据库根据交易更新
查询余额时,是从状态数据库查出来的
通过节点运行智能合约读取状态数据库

智能合约详解

定义:
智能合约是一个运行在区块链上的程序,数据来自区块链,可以被所有节点重复运行。

执行的确定性:

所有节点执行结果必须一致
例如转账100元,所有节点执行后结果都应该是发送方减少、接收方增加相同的金额
不能在不同机器上算出不同结果

智能合约的限制:

没有浮点数:因为不同机器的浮点数运算可能产生误差(如10÷3×3可能不等于10)
不能产生随机数:因为会导致结果不一致
不能获取当前系统时间:因为不同节点时间可能不同
必须保证所有节点执行结果完全一致

随机数的解决方案:

方案一:伪随机(不推荐用于金融)

使用上一区块的哈希值(具有较大随机性)
但可以被矿工操纵
矿工可以选择性打包满足条件的区块
对于博彩等涉及大量资金的应用不安全

方案二:预言机(推荐)

通过Oracle将链下数据喂到链上
可以产生物理世界的随机数源
将随机数放到区块链上供合约使用

预言机(Oracle)

定义:
将现实世界(链下)的数据投喂到区块链上的技术。

主要用途:

汇率数据:如比特币换成USDT的汇率,是DeFi的重要参考数据
随机数生成:提供物理世界的随机数源
其他链下数据:各种现实世界的数据上链

工作原理:

从各个交易所抓取最新价格
通过固定算法处理
将价格放到以太坊智能合约里
所有智能合约就可以读取这个价格

为什么叫”预言机”:
英文是Oracle,不能翻译成”甲骨文”,所以翻译成”预言机”,纯粹是翻译问题。

三、智能合约开发与部署

Solidity编程语言

特点:

以太坊智能合约主要用Solidity编写
很像JavaScript的语言
由软件工程师编写

部署流程:

编写Solidity代码
编译成二进制
发送交易,将二进制数据放在input字段
向区块链网络广播,相当于”安装”智能合约
所有节点都知道这个智能合约的程序
系统分配一个合约地址

调用智能合约

调用方式:

也是通过发送交易
to字段填写合约地址
input data包含:
- 调用哪个函数
- 函数的参数
- 编码后的数据

Gas Limit设置:

限制智能合约不能是死循环
给一个gas上限
如果是死循环,消耗完gas后直接退出,交易失败
钱包会调用节点的预估gas API自动计算
可以在预估基础上加一点点

交易构造完成后:

发送交易
等待打包
打包时执行合约:
- 根据合约地址获取二进制程序
- 知道调用哪个函数和参数
- 执行程序
执行后更新状态数据库
从区块链浏览器可以看到状态变化

状态变化:

余额变化:接收方余额增加,发送方余额减少
ETH余额变化:因为需要支付gas费,发送方的ETH会减少
Nonce变化:会加1
可以在区块链浏览器看到所有这些信息

事件(Event)机制

作用:
让应用程序知道交易是否成功,以及交易的具体信息。

为什么需要事件:

发送方可以看到交易被打包到哪个区块
接收方如何知道收到了钱?通过事件
智能合约转账成功后会产生一个事件
事件包含:谁给谁转了多少钱

应用程序订阅事件:

应用程序可以订阅(监听)事件
钱包可以监听指定合约的事件
例如添加USDT代币时,实际是监听USDT合约的事件

事件的编码:

事件有topic(主题)字段
topic是事件名称行的编码
包含from、to、value等信息
钱包监听到事件后可以刷新余额

三个关键部分:

交易:用户发出
状态变化:执行后导致
事件通知:状态变化后产生

四、以太坊Layer 2

Layer 1的问题

以太坊主网(Layer 1)很慢很贵。

Layer 2的概念

定义:
二层网络,相当于对以太坊Layer 1进行分片,看上去像一个新的区块链,但使用以太坊的安全性。

与自建链的区别:
自己用以太坊源码随便搭的链不是Layer 2,Layer 2使用了以太坊的安全性。

安全性机制:

Layer 2上的交易最终会通过压缩或零知识证明技术放到以太坊主网上
即使Layer 2运营方跑路,用户仍然能够通过找回技术在以太坊主网上证明应该有多少ETH
可以从以太坊主网把钱找回来

类比:
像授权加盟商,加盟商跑路了,但钱在总店,还可以去总店消费或找回。

Layer 2的优势

1. 速度快

秒级出块
不用等十多秒

2. Gas费低

不需要投入那么多机器
交易通过压缩后上到以太坊主网
占用的存储成本低
最终gas费低

3. 同样的安全性

继承以太坊主网的安全性
即使运营方跑路也能找回资金

Layer 2的两种类型

1. ZK Rollup(零知识证明)

优点:从Layer 2提现回以太坊主网速度快,因为使用密码学实现
缺点:运算慢,需要生成零知识证明;投入成本高,需要更多硬件来计算零知识证明

2. Optimistic Rollup(乐观Rollup)

特点:默认大家不会作恶(“乐观”)
提现流程:从Layer 2转回主链需要等很久,让大家挑刺,看有没有作恶,需要做防欺诈证明
优点:投入的硬件成本低
缺点:提现时间成本高

常见的Layer 2:

OP(Optimism)
Arbitrum
等都是Layer 2

五、钱包与账户体系

私钥、公钥与地址

基本概念:

私钥(Private Key):核心,自己掌握,不能告诉任何人
公钥(Public Key):可以公开给任何人
地址(Address):由公钥哈希算出

派生关系:
私钥 → 公钥 → 地址

交易签名:

用私钥对交易进行签名
交易包含:发起人(公钥或地址)、行为(调用合约、转账等)、签名
签名由钱包用私钥生成

助记词

概念:

助记词不等于私钥
是一个种子,一个随机数
将随机数编码成常见的英文单词形式

与私钥的关系:

一对多关系:一个助记词可以派生出无数个私钥
通过既定规则派生私钥
知道助记词和规则,可以随时恢复私钥

重要性:

私钥和助记词都不能丢失、不能泄露
如果私钥是从助记词派生的,可以不记录私钥,通过助记词随时恢复
但并非所有私钥都是通过助记词生成的,有些工具直接生成私钥

历史:
助记词是后来改进出来的,早期只有私钥,没有助记词。

Gas费机制

Gas的作用:

衡量执行智能合约的复杂性
执行越久、运算越复杂,消耗的gas越多
也计算存储占用量,存储数据越多,gas费越高

基础值:
ETH转账(不调用智能合约)的gas是21000

Gas计算:

智能合约编译后都是一个个操作
每个操作消耗特定的gas
EVM(以太坊虚拟机)执行时实际计算消耗的gas

Layer 2上的Gas:

可以使用零知识证明(ZK Rollup)
对普通用户使用没有区别

账户类型

两种地址:

1. 外部账户(EOA)

普通用户账户
通过私钥→公钥→地址派生
有私钥控制

2. 合约账户

部署合约后产生的地址
每个合约对应一个地址
没有私钥,由合约代码控制

识别方法:
从URL或区块链浏览器可以看出地址类型。

多签机制

以太坊的限制:

以太坊交易只能有一个签名(交易结构决定的)
比特币天然支持多签,但比特币上很难做DeFi

实现方式:
通过智能合约实现多签功能

多签合约原理:

部署一个多签合约(合约也有地址,相当于”法人”)
大家把钱(USDT、ETH等)打到这个合约地址
合约逻辑判断转账条件
例如:3个人2/3多签,任意2人同意就可以动用资金

链上多签:

A用户发送交易到合约:要转账多少钱,包含标识
B用户也发送交易到合约:同样的标识
智能合约识别出这是对同一笔转账的两个签名
满足条件后执行转账
通过智能合约在链上运算实现

链下多签:

先在应用程序构造交易意图
各方用多签钱包对这个意图签名
收集所有签名
将所有签名放在一笔交易的input data中
用自己的私钥签名后发送
多签合约解析input data
验证所有签名,满足条件后放款
链下先收集好签名,最后一次性上链

应用场景:

合伙人基金管理
提高资金安全性
防止单点风险

六、代币标准

ERC-20标准

概念:

最常见的同质化代币标准
每个代币都一样

本质:

智能合约的接口规范
定义了标准的函数和方法
包括:transfer、transferFrom、balanceOf等

意义:

所有ERC-20代币接口一致
钱包可以用统一方式处理所有ERC-20代币
DeFi协议可以互操作所有ERC-20代币
例如Uniswap可以交换任何ERC-20代币

ERC-721标准

概念:
NFT标准,每个代币都是独一无二的。

与ERC-20的区别:

接口不同
代表不可替代的资产
每个token都有唯一ID

ERC-1155标准

概念:
混合标准,结合了ERC-20和ERC-721的特性。

特点:

既有ERC-20的特性(可分)
又有ERC-721的特性(独特)

应用场景:邮票

每种邮票设计独特(像NFT)
但每种邮票发行多张(像ERC-20)
例如:十二生肖邮票
- 猴票、鸡票、狗票、猪票等(12种独特设计)
- 每种票发行1000张
用ERC-1155定义最合适

七、DeFi应用架构

DApp基础架构

前端:

使用Vue、React等前端框架
本质上是JavaScript和HTML页面

后端:

可以用Java、Go、Node.js等编写
功能:
- 连接预言机查询价格
- 查询各种信息(如币价、交易对)
- 处理业务逻辑

去中心化存储(IPFS):

用于存储NFT图片等大文件
不能存在中心化服务器(服务器崩溃数据就丢失)
IPFS是去中心化的云存储
全球任何节点都可以访问
例如:在中国上传到IPFS,美国用户可以从当地IPFS节点访问同一文件

前端交互:

1. 与钱包交互

需要连接钱包(如MetaMask)
钱包进行交易签名

2. 与以太坊节点API交互

连接Infura或QuickNode等节点服务
查询链上数据:
- 有没有对应的交易对
- 各种状态信息
通过节点运行智能合约查询状态数据库

交易发送流程:

前端构造交易请求
发给钱包(如MetaMask)
钱包对交易签名(只有签名才形成完整交易)
钱包连接节点(Infura或QuickNode)
广播到以太坊网络
等待打包

后端监听:

后端持续监听链上事件
监听到交易完成后做数据库记录

DeFi特有架构

DeFi在DApp基础上增加了三个关键组件:

1. Graph Node(子图节点)

专门查询合约内部业务数据
以太坊节点提供的API是通用的,不针对特定应用
Graph Node针对特定业务数据建立查询机制

功能:

查询质押情况
查询交易池的币数量、交易对数量
查询交易历史、走势
这些都是具体业务数据,以太坊不提供

工作原理:

监听各种常见合约
收集合约的事件数据
建立业务数据库
提供业务查询接口

2. Keeper Service(守护者服务)

监听需要触发智能合约的情况
在满足特定条件时主动发起交易调用合约

为什么需要:

智能合约不能自动运行
智能合约必须由交易触发
合约不会自己在节点上持续运行
只有交易来了,节点打包时才会执行对应的合约代码
执行完后,合约又变回二进制放回去

应用场景:爆仓清算

监听抵押情况
发现抵押不足(达到爆仓线)
需要强制平仓
用户不会主动平仓
Keeper Service检测到后主动发起交易
触发智能合约执行平仓

本质:

运营商自己部署的服务器程序
不是智能合约
是智能合约的触发器和执行器

3. 预言机(Oracle)

定期向合约投喂数据
两种方式:
- 主动查询:合约调用预言机,预言机返回数据
- 定期投喂:预言机定期将数据上链

重要性:

智能合约不能调用外部API
不同节点访问外部API可能得到不同结果
会导致执行结果不一致
必须通过预言机将链下数据上链

八、主要DeFi应用类型

1. 去中心化交易所(DEX)

Uniswap:

使用固定乘积公式:X × Y = K
自动做市商(AMM)机制

流动性提供:

用户将两种币(如ETH和USDT)放入Uniswap提供流动性
赚取交易手续费

价格机制:

买ETH时,ETH价格上涨(因为固定乘积公式)
卖ETH时,ETH价格下跌
简单粗暴但有效

改进版本:

Curve:

不是直线,而是曲线
更稳定
减少滑点
对用户更友好

Uniswap V3:

集中流动性
用户自定义价格区间
提高资金利用率

迭代:
现在Uniswap已经迭代到V4,不断增加新功能。

2. 借贷协议

代表项目:Compound、Aave

本质:
类似银行的存款和贷款机制。

运作方式:

持有ETH但长期看好
不想ETH躺在钱包里
将ETH存入Compound
其他人需要ETH时从里面贷款
还款时支付利息
存款人分得利息

3. 稳定币

法币抵押型:
USDC、USDT(这里不详细说明)

算法稳定币(超额抵押):

MakerDAO的DAI:

超额抵押机制:抵押率150%
例如:抵押1个ETH(价值4000 USDT)
可以发行/贷出约3000个DAI
用这3000 DAI去做其他投资
想赎回ETH时,销毁对应的DAI
通过加密资产超额抵押实现

算法稳定币的风险

DAI的波动性:

虽然抵押率达到150%
但因为抵押资产(如ETH)涨跌太夸张
不像抵押1美元那样基本固定
波动率还是挺大的
有时候0.98,有时候1.03美元
与USDT比例有3%到5%的波动
使用上确实不够广泛
大家更多还是用USDC和USDT

算法稳定币的失败案例:

UST(Terra Luna)直接崩盘
这种纯算法稳定币不靠谱
Luna和UST彻底崩溃

4. 预言机详解

核心功能:
实现链下数据上链。

为什么需要预言机:

智能合约的执行结果必须是确定性的
不能调用外部API
不同节点调用同一API可能得到不同结果
API服务器可能挂掉或返回结果不一样
会导致整个执行结果不一致
智能合约不允许调用区块链以外的东西

Chainlink(主流预言机):

去中心化机制:

部署很多台服务器
从网络中获取各种数据源
通过多签机制保证去中心化

为什么需要多节点:

单台服务器可能作恶
可能喂假数据
假数据导致DeFi读取错误,造成资金损失
通过多数据源上报防止单方控制

价格数据的获取:

不只读取币安一个交易所的API
会读取多个交易所:Coinbase、Binance、Bybit等
进行汇总
得出价格区间
所有预言机节点得出的合理范围
达成共识得出最终结果

与传统数据服务商的区别:

Bloomberg或Wind只是数据汇总,完全中心化
靠自己的信用背书
Chainlink实现去中心化
抓取多个交易所数据
不需要信任单一机构
提供20个交易所的数据供选择

应用:
各种DeFi需要用到的币价、汇率等都会通过预言机读取。

5. DEX聚合器

核心功能:
在多个去中心化交易所之间比价和聚合交易。

为什么需要:

面对各种DeFi投资,用户很难选择
如何获取更合理的报价?
如果只在Uniswap交易,大家都在Uniswap买,币价会虚高
在其他DEX价格可能低很多

工作原理:

不仅比价
直接聚合交易
可以把一单拆成多个交易所
在多个DEX同时下单

优势:

减少滑点
获得更好价格
虽然gas费会多一些(因为调用多个合约)
但交易金额大时,gas费是固定的,总体更划算

6. 收益聚合器(Yield Aggregator)

本质:
相当于基金,自动调整资产配置。

功能:

类似传统股票基金或综合基金
资金分配到不同资产:股票、债券、理财等
在DeFi中,通过智能合约自动投资到各种DeFi协议
自动选择收益更高的项目
动态调整资产配置

7. 衍生品(Derivatives)

概念:
将中心化交易所的杠杆交易搬到链上。

包括:

永续合约
期权
各种杠杆
通过去中心化智能合约实现

8. 闪电贷(Flash Loan)

原理:
在一笔交易中完成借款和还款的整套操作。

操作流程示例:

质押ETH借出大量USDT
用USDT在Uniswap买入ETH
进行其他操作赚取差价
将ETH卖掉换回USDT
还款到借贷合约
赎回质押的ETH
整个过程在一笔交易中完成

特点:

对于以太坊,只发送了一笔交易
一笔交易把整个过程全部完成
贷款和还款在同一笔交易中完成

与传统金融的区别:

传统金融借款还款至少需要一天
T+0已经很不错
闪电贷是在一笔交易内实现各种金融产品的互操作
不是多笔交易(多笔交易之间价格可能变化)
直接在一笔交易里完成

本质:
一种套利机制,利用DeFi的可组合性和原子性。

神奇之处:

借贷时间可以短到几秒甚至瞬间
不需要等待时间
在同一个区块内完成所有操作
这是DeFi非常独特和有意思的地方

9. 跨链桥(Cross-Chain Bridge)

为什么需要跨链:

不同的智能合约在不同的链上
有的在Solana,有的在以太坊,有的在Layer 2
需要将资产从一条链转移到另一条链

实现机制:锁定+铸造

从A链跨到以太坊:

在A链上部署锁仓合约
用户将资产转入锁仓合约(用户失去这笔钱的控制)
在以太坊上部署对应的1:1合约
A链锁定多少,以太坊就mint(铸造)多少
实现资产跨链

从以太坊跨回A链:燃烧+释放

将以太坊上的ERC-20代币burn(销毁)
A链上的锁仓合约释放资产
从锁定合约转回给用户
用户又拥有了原资产

WBTC案例:

Wrapped BTC(包装比特币)
比特币链上有锁仓地址(WBTC运营方的地址)
用户将BTC转到那个地址
以太坊上对应发行WBTC
比特币就在以太坊上了
可以在以太坊做各种DeFi操作:Uniswap交换、闪电贷等
锁仓了127,000个比特币(数量相当大)

安全性:

锁仓和发行都写在智能合约上
实现无需信任
没有人能突然把十几万比特币提出来
合约保证了资金安全

九、DeFi前沿技术

1. Layer 2详细机制

ZK Rollup(零知识证明Rollup):

优点:

从Layer 2提现回主链速度快
使用密码学实现
不需要等待挑战期

缺点:

生成零知识证明的运算很慢
投入成本高,需要更多硬件来计算零知识证明
平时交易影响不大,但硬件成本高

Optimistic Rollup(乐观Rollup):

特点:

默认大家不会作恶(“乐观”)
从Layer 2转回主链需要等很久
需要防欺诈证明机制

流程:

提交提现请求
等待挑战期(通常7-14天)
让所有人挑刺,检查是否作恶
如果没人发现问题,才能最终转回主链

优点:

投入的硬件成本低
实现相对简单

缺点:

提现时间成本高(等待期长)

对比:

ZK Rollup:硬件成本高,时间成本低
Optimistic Rollup:时间成本高,硬件成本低

2. 账户抽象(Account Abstraction)

传统账户的问题:

用户地址依赖私钥
私钥→公钥→地址
私钥丢失,所有资产(ETH、USDT、NFT等)都找不回来

账户抽象的解决方案:

核心思想:
给每个用户创建一个智能合约账户(抽象账户)。

工作原理:

用合约作为用户的账户
用户是合约的owner/admin
平时收款、转账都通过这个合约
对用户来说使用体验没区别

私钥丢失的恢复机制:

社交恢复:

合约中设置恢复机制(reset admin方法)
设置时指定恢复账号(如5个朋友的账号)
设定恢复条件(如5个中的3个同意)
私钥丢失后,线下联系这些朋友
收集足够的签名
调用reset admin
用新私钥重新设置admin
恢复账户控制权

优势:

防止私钥丢失导致资产永久丢失
降低用户门槛
更接近Web2用户习惯(可以重置密码)
提高DeFi的用户友好性

Paymaster机制:

问题:

现在gas费都用ETH支付
对用户不友好
比如想投资稳定币的用户,还必须先买ETH

解决方案:

通过智能合约账户实现代付机制
可以用其他代币(如DAI)支付gas费
本质上是在支付时先用其他币买一点ETH支付gas
对用户来说可以用任何代币支付
无需单独持有ETH

意义:

大幅降低DeFi使用门槛
提高用户体验
让Web2用户更容易过渡到Web3

3. 再质押(Restaking)

概念:
用一份资产进行两次质押。

运作机制:

第一次质押:

质押ETH参与以太坊共识(POS机制)
成为验证节点
获得产块收益
收到质押凭证(如stETH或BETH)

第二次质押:

用质押凭证再次质押到其他协议(如预言机服务)
获得第二份收益
用户获得两份收益

质押凭证的价值:

可以取回产块收益
可以赎回原本质押的ETH
本身很值钱
可以作为新的抵押品

风险机制:

惩罚(Slashing):

如果预言机提供错误数据(被攻击或作恶)
或者不作为
链上交易可以证明作恶
会扣除质押的资金

风险传导:

质押32个ETH,获得32个质押凭证
再质押获得32个再质押凭证
预言机服务出问题,扣除10个再质押凭证
只剩22个再质押凭证
最后只能取回22个质押凭证
只能赎回22个ETH
本质上直接扣除了底层ETH

风险收益平衡:

享受更高收益
承担更大风险
任何一层出问题都会影响底层资产

4. RWA(Real World Assets,现实世界资产)

定义:
将现实世界的资产代币化(tokenize)。

目的:
主要用于融资。

应用场景:

1. 房地产

将房地产权益代币化
投资者购买代币
分享房地产收益

2. 绿色能源(光伏)

发展光伏需要大量资金
将光伏电站代币化
每个代币代表光伏收益的一部分
投资者用稳定币购买token
项目方获得资金,提高产能
投资者持有token,分享后续收益分红

3. 充电桩

已在香港上线的实际案例
每笔充电订单的收益都上链
可以检查真实性
投资者可以投资充电桩的收益权

本质:

类似股权投资(分红型)
也可以做债权投资(借贷型)
取决于发行RWA时的协议设计

优势:

降低投资门槛
提高资产流动性
增加融资渠道
收益透明可查

5. MEV(Maximal Extractable Value,最大可提取价值)

概念:
矿工或验证者通过重排、插入或审查交易来获取额外价值。

最常见的攻击:三明治攻击

原理:

用户要买某个币,会导致币价上升(固定乘积公式)
矿工看到交易池中的大额买单
在用户交易之前打包自己的买单(抬高价格)
打包用户的买单(用户以更高价格买入)
在用户交易之后打包自己的卖单(高价卖出)
在一个区块内完成套利

为什么能实现:

矿工可以决定打包交易的顺序
可以看到交易池中所有待打包的交易
发现大额买单时,可以提前操作

套利过程:

矿工先买(价格上涨)
用户买(价格进一步上涨)
矿工卖(高价卖出获利)
一个区块内盈利

影响:

用户遭受损失(买入价格更高)
矿工/验证者获得额外收益
市场公平性受损

防范措施:

以太坊目前没有特别好的办法
Solana等其他链有相对更好的机制
可以使用私有交易池
设置滑点保护

十、DeFi安全与风险

常见攻击方式

1. 重入攻击(Reentrancy Attack)

多次调用合约函数
导致合约状态被多次修改
原因:合约检查不够严格
在转账后才更新状态,导致余额检查失效

2. 溢出攻击(Overflow/Underflow)

整数超过上限变成很小的数
或减到负数变成超大的数
如果没有检查,会导致余额异常

3. 价格操纵攻击

通过闪电贷操纵价格
抬高价格后快速贷款买入
然后卖出获利
利用预言机价格滞后或单一价格源

4. 合约设计漏洞

逻辑错误
权限控制不当
缺少输入验证
未考虑边界条件

安全措施

1. 代码审计

专业审计公司:

CertiK等知名审计公司
提交代码进行全面审计
出具审计报告
确认没有问题后才能上线

上线要求:

很多交易所或项目上线都需要审计报告
已成为DeFi项目的标准流程

2. 自动化安全工具

开发阶段使用:

自动漏洞扫描工具
静态代码分析
形式化验证

3. 使用安全库

OpenZeppelin:

成熟的智能合约库
经过大量审计和实战检验
不要完全自己写代码
尽量使用现成的安全工具库

4. 多签机制

关键操作需要多方签名
防止单点风险
提高安全性

5. 时间锁(Timelock)

重要操作设置延迟执行
给社区审查时间
防止管理员恶意操作

风险总结

技术风险:

智能合约漏洞
预言机失效
网络拥堵

经济风险:

价格波动
流动性不足
套利攻击(MEV)

运营风险:

私钥管理
团队跑路(已通过智能合约大幅降低)
监管政策变化

用户风险:

私钥丢失
误操作(发送到错误地址)
钓鱼攻击

十一、DeFi应用总结

核心应用类型

1. 去中心化交易所(DEX)

Uniswap、Curve等
自动做市商机制

2. 借贷协议

Compound、Aave
超额抵押、利息收益

3. 稳定币

法币抵押型:USDC、USDT
加密资产抵押型:DAI
算法型(已有失败案例)

4. 衍生品

永续合约
期权
杠杆交易

5. 预言机

Chainlink为主
提供价格数据、随机数等

6. 聚合器

DEX聚合器
收益聚合器(Yield Aggregator)

7. 保险

DeFi保险协议
覆盖智能合约风险

8. 彩票

基于智能合约的透明彩票
可验证的随机性

9. NFT金融化

NFT借贷
NFT碎片化

技术栈总结

底层链:

以太坊(主流)
Solana
Arbitrum、Optimism(Layer 2)
Polygon、BSC等

合约层:

Solidity编程
智能合约执行
状态管理

应用层:

DApp前端
钱包集成
用户交互界面

基础设施:

预言机(Chainlink等)
Graph Node(数据查询)
Keeper Service(自动触发)
IPFS(去中心化存储)

未来展望

Layer 2的发展:

ZK技术成熟
更低的gas费
更快的确认速度

账户抽象的普及:

降低使用门槛
更好的用户体验
社交恢复机制

RWA的扩展:

更多现实资产上链
传统金融与DeFi融合
监管框架逐步完善

跨链互操作:

更成熟的跨链桥
多链生态互联
资产自由流动

总结

DeFi概念很大,只要是将现实世界的金融产品搬到区块链上,都可以算是DeFi范畴。还有很多应用没有详细讲到,如彩票、保险等,但核心原理和架构都是相通的。

DeFi的本质:
通过智能合约实现传统金融功能的去中心化、透明化、无需许可的金融系统。

关键要素:

智能合约
区块链基础设施
预言机
代币标准
安全机制

发展方向:

技术优化(Layer 2、账户抽象)
应用创新(RWA、新型DeFi协议)
用户体验改善
与传统金融融合

https://space.bilibili.com/10642220

复盘三年的CEX套利策略实战，价值过亿的教训与经验

一、DEX和CEX价差套利的现状

2025年第一季度，全球去中心化交易所的交易量已经达到了1.2万亿美元，比去年同期增长了82%，占整个加密货币市场总交易量的35%。DEX的增长非常迅猛。

在这样的背景下，量化交易者开始关注DEX和CEX之间的价格差进行套利操作。比如有一个25个基点的价差，扣除掉23个基点的费用之后，还可以获得2个基点的收益。如果交易量是1000万美元，每天就可以有2000美元的收入。但这样的策略看似简单，却让很多交易者付出了惨痛的代价。

二、统计套利的实战案例

有一个团队做Avalanche生态，对比Binance订单簿的价格和Trader Joe上面流动性池的价格。当价差超过一定基点（需要覆盖手续费和gas费）时，他们就会进行交易。

在2024年第四季度，他们的JOE/USDT策略平均每笔交易赚23.7美元，胜率58.3%，但单次最大亏损是1200美元。这是因为DEX上面的交易回滚，导致CEX上面的反向平仓。这个风险非常大，是一个薄利但风险集中的事情。

三、跨链套利的机会与风险

随着多链生态的发展，以太坊上面的WETH和Avalanche上面的WETH.e这种孪生代币之间的价格经常会出现偏离，产生套利机会。

2025年第一季度，USDC在不同链上的价差最高达到了2.3%，平均套利周期是47天。但跨链套利需要支付桥接费用，平均在0.15%到0.5%之间，还要面临确认延迟和智能合约的风险。

2023年发生了非常多起跨链桥被攻击的事件，损失金额超过了10亿美元。2024年11月，有一个对冲基金因为Multichain暂停提款，导致370万美元的头寸没有办法平仓，最终损失120万美元。

四、重大风险事件案例

案例一：Hyperliquid清算套利事件（2025年3月13日）

一个巨鲸存入15,230,000 USDC，开了一个非常大的ETH多头头寸，杠杆在13.5到19.2倍之间，成功提取了17,090,000 USDC的利润。但当ETH价格下跌到1915美元时，HLP Vault接盘这些清算头寸后损失了400万美元，占平台历史累计利润的6.6%。

这个事件暴露出几个问题：

过度使用杠杆（19倍杠杆，价格只要下跌5.26%就会爆仓）
DEX上大额头寸平仓的流动性不足，滑点达到3.7%
HLP Vault没有办法很好地隔离用户资金和清算风险

案例二：Solana上的MEV事件（2024年1月10日）

一个巨鲸想要用86,739 SOL兑换1,720,000 WAVE，因为流动性不足，WAVE的价格在非常短的时间内从0.14美元涨到3.99美元。这吸引了127个套利机器人进行抢跑，这些机器人平均每笔交易获利38美元，最大单笔获利1200美元。

Jito的验证者通过捆绑包的方式赚了190万美元，Figment的验证者收到了890 SOL的小费。这暴露出Solana的无内存池设计让普通用户没有办法防范MEV攻击。

五、市场竞争格局

头部机构的优势

Jump Trading：控制了Solana上面42%的MEV提取，通过自己的验证者节点优先获取交易
Wintermute：在以太坊Layer 2上占据35%的套利交易量，单笔交易延迟小于10ms
Amber Group：通过同时持有CeFi和DeFi的牌照，可以迅速在不同市场之间进行套利

长尾玩家的策略

没有办法跟头部机构竞争主流市场机会的长尾玩家，会采取以下策略：

专注小众链，比如Avalanche或Fantom
抓住特殊事件机会，比如代币空投、合约升级、交易所上新币
通过跨品种套利降低风险，同时交易现货、期货和期权，通过组合方式获取稳健收益

六、惨痛的教训

教训一：参数未及时更新

2024年3月，有一个团队因为没有及时更新Uniswap V3的池的费率参数，导致120万美元的套利利润全部被手续费吃光。

教训二：Gas费预测错误

2024年7月，有一个团队因为Gas费预测错误，在以太坊网络非常拥堵的时候进行交易，导致Gas费花了17万美元，但预期利润只有几千美元，非常得不偿失。

七、策略优化和风险管理要点

根据交易对的流动性动态调整价差阈值
建立精准的Gas费预测模型
控制订单规模在一定范围内
单策略最大回撤控制在5%以内
跨链套利仓位不要超过总资产的20%

八、未来趋势

AI应用

已有团队使用强化学习来开发套利系统。

监管政策变化

美国SEC对质押规则的调整，让一些机构可以通过ETF的方式参与市场，获得了高达8.7%的综合收益。

总结

DEX和CEX之间的套利是一个充满机会但同时暗藏很多风险的领域。从策略到风险，从竞争格局到未来趋势，都需要交易者深入理解和谨慎操作。

MEV101，你确定不和我们一起链上掘金吗？【科普向】

一、什么是MEV（矿工可提取价值）

在以太坊上，由于DeFi协议的崛起，出现了大量的套利机器人。这些机器人从普通用户和DeFi协议中套取的利润已经达到6.09亿美元。从2021年DeFi Summer开始，链上可获取的价值疯狂上涨。目前以太坊上平均每天约有7-10万美元的套利利润。除了以太坊，BSC、Polygon、Arbitrum、Solana等链上都存在MEV Bot。

二、链上套利的四大策略

根据帝国理工研究论文的分类，链上套利策略主要分为四大类：

1. 套利（Arbitrage）

2. 清算（Liquidation）

3. 三明治攻击（Sandwich Attack）

4. 一般性抢跑（General Front-running）

三、DEX的运作原理

传统CEX vs DEX

传统中心化交易所采用订单簿模式，用户挂买单卖单，交易所负责撮合。但这套模式在区块链上不太适用，因为：

以太坊每十几秒才能更新一次状态
每笔交易需要花费高额Gas费（10-300美元）

AMM恒定乘积算法

Uniswap V2采用恒定乘积算法（x * y = k）：

流动性提供者按比例放入代币形成池子
价格随交易动态调整
好处：操作简单，自动调价
问题：滑点大，资金利用率低（只有一半资金被实际使用）

Uniswap V3的改进

允许做市商选择特定价格区间提供流动性：

降低交易滑点
提高资金利用率
形成类似订单簿的深度

四、套利策略详解

空间套利（Spatial Arbitrage）

也叫”搬砖”，利用不同交易所的价差：

在A交易所1500美元买入ETH
在B交易所1600美元卖出ETH
赚取100美元差价

三角套利（Triangular Arbitrage）

涉及多种代币的循环交易：

用0.729 ETH换3940.3 BAT（Uniswap V3）
用3940.3 BAT换8450 REQ（Bancor）
用8450 REQ换0.735 ETH（Uniswap V2）
净赚0.006 ETH（约10美元）

链上套利的优势：原子性

链上交易的智能合约保证原子性：

要么所有交易全部执行成功
要么状态回滚到最初
没有中心化交易所的单边风险

五、清算策略

DeFi借贷协议

用户可以超额抵押贷款：

抵押价值150美元的ETH
借出价值100美元的稳定币

清算机制

当抵押品价格下跌到风险阈值（如120美元），任何人都可以：

用100美元替债务人还款
拿走价值120美元的抵押品
赚取20美元差价

预言机的作用

Chainlink等预言机从多个中心化交易所获取价格数据：

汇聚多个数据源
使用中位数等算法过滤异常
将价格数据上链

套利者只需监听预言机的价格更新信号，发现用户健康因子（Health Factor）低于阈值时立即执行清算。

清算案例

某用户还了1360个DAI，拿走了3.34个COMP：

用其中3.25个COMP在Uniswap V2换回1336个DAI
净赚0.12个COMP的差价

六、三明治攻击（恶性套利）

攻击原理

当检测到受害者要在DEX上交易时：

Front-run：攻击者提前买入，推高价格
受害者交易：在更高价格成交，换到更少代币
Back-run：攻击者卖出，以更高价格获利

攻击案例

攻击者用6.57个X token抢先买入
受害者交易推高价格
攻击者卖出，净赚0.0088 WETH

为什么链上容易被抢跑

区块链的P2P网络特性：

交易在确认前会在网络中广播
任何节点都能监听到待处理交易
攻击者部署节点提前布局
没有中心化服务器保护

七、通用抢跑攻击

攻击场景

密码泄露：当用户提交密码取款时，攻击者看到密码后抢先提取
漏洞利用：黑客发现DeFi协议漏洞构造攻击交易，被其他Bot监听并复制攻击，原始黑客只赚100万，抢跑者赚走数百万

攻击方法

攻击者在本地运行全节点：

监听mempool中的待确认交易
模拟执行判断是否有利可图
修改参数后抢先发送交易

八、比特币vs以太坊：为什么以太坊更容易被攻击

数据模型差异

比特币（UTXO模型）：

每个比特币是独立的数据空间
只有持有者能使用
不会与其他人发生冲突
不支持复杂智能合约

以太坊（Account模型）：

智能合约有共享的代码和状态存储
不同用户都可以读写同一合约
存在读写冲突问题

交易排序

以太坊通过矿工对交易排序解决冲突：

矿工决定哪个交易先执行
按顺序挨个执行保证一致性
性能低下但保证正确性

九、Gas费竞价战（PGA - Priority Gas Auction）

原始丛林阶段

两个Bot竞争同一套利机会：

Bot A出价25.1 Gwei
Bot B出价25.0 Gwei
Bot B发现后加价到28.75 Gwei
Bot A继续加价到28.81 Gwei
无尽循环直到矿工出块
最终价格可能翻几百倍

失败的代价

BSC上套利交易成功率只有9%，失败率高达91%：

失败的交易仍需支付Gas费
竞争者越多，成本越高
内卷严重

十、Flashbots的出现

解决方案

套利者不再支付常规Gas费，而是：

发送Gas费为0的交易
在智能合约中承诺：成功则转账给矿工，失败则不付费
避免失败交易的成本损失

工作机制

套利者直接与矿工达成协议：

矿工尽力让交易成功
尝试不同排序方案最大化收益
绕过以太坊原有的Gas竞价机制

十一、EIP-1559的影响

Base Fee机制

协议层面强制收取Base Fee：

Base Fee会被燃烧销毁
通过通缩机制让剩余ETH更值钱
矿工额外收取小费（Priority Fee）

实际案例

总费用20.87 ETH：

Base Fee：20.79 ETH（被燃烧）
矿工小费：0.47 ETH

以太坊已进入通缩时代，每天燃烧量大于发行量。

十二、Flashbots的角色演变

中间商模式

Flashbots作为中间商：

收集套利者的交易Bundle
优化排序方案
承诺两点：
1. 成功才付费，失败不收Base Fee
2. 不向其他人泄露交易内容

对矿工的好处

不需要自己优化排序
直接获得最优方案
省心省力还能赚更多

十三、PBS（Proposer-Builder Separation）协议

角色拆分

Searcher（搜索者）：发现套利机会，提交Bundle
Builder（构建者）：打包最优区块，提取部分利润
Relayer（中继者）：连接Builder和Validator
Validator（验证者）：签名出块

密封拍卖

从公开竞价变为密封拍卖：

套利者不知道其他人出价
必须盲目提高报价才可能获胜
对Searcher非常不友好

十四、PoS时代的巨变

经济激励

PoW时代Flashbots市场占有率不到50%，PoS后飙升到93-96%。原因：

PoS收益下降：

质押32 ETH年化收益仅3.6%
出块奖励大幅减少

Flashbots额外收益：

接入Flashbots可增加0.5-1%年化
对质押者非常有吸引力

公地悲剧

质押服务商（Lido、Coinbase、Binance）竞争：

散户选择年化高的平台
必须接入Flashbots才有竞争力
无人关心对系统的整体影响
导致高度中心化

十五、利润分配的真相

矿工获利最大

On-chain Five数据显示：

套利者赚1美分，给矿工8美元
套利者赚100美元，给矿工200多美元
套利者自己只能留10-20%利润

BSC vs 以太坊对比

BSC（无Flashbots）：

套利者保留90-99%利润
只需支付少量Gas费

以太坊（有Flashbots）：

套利者只能保留50%以下利润
竞争激烈时只能留1-10%

竞争激烈度

利润分成取决于竞争：

通用策略：所有人都会做，必须给99%利润
独有资源：没人竞争，可以保留更多利润

十六、如何在黑暗森林中生存

方向性建议

1. 关注长尾策略

避开已被充分竞争的主流套利
寻找新的套利机会

2. 选择新兴生态

非EVM兼容链（Near、Solana）
没有Flashbots的链
Bot迁移困难，竞争少

3. 新协议机会

新的DEX协议
NFT市场套利
链上衍生品（如GMX）
在其他套利者未支持前获利

十七、黑暗森林中的攻击与反攻击

针对Bot的钓鱼攻击

貔貅币陷阱：

创建只有发行者能卖的代币
伪造高利润交易诱饵
Bot本地模拟成功，链上执行失败
前端买入成功，后端卖出失败

技术手段：

检测COINBASE地址：全零表示模拟，非零表示链上
模拟时返回成功，链上时返回失败

案例

某Bot因钓鱼损失100 ETH
持有者复现漏洞，反向攻击其他Bot赚回300 ETH

竞争者攻击

Discord频道案例：

发现竞争对手合约漏洞
在套利机会出现时，帮竞争对手把合约资金转回自己账户
对方没有损失金钱，但失去所有交易机会
频繁操作使其无法参与竞争

信息战

社区充斥谎言和误导：

声称”服务器每月只花80美元”
实际需要高性能基础设施
故意误导潜在竞争者

十八、防御措施

用户防护

设置紧密的滑点限制：

设定最小接收价格
攻击者抢跑会导致交易失败
权衡：可能因正常波动而失败
大额交易建议设置严格滑点

Bot防护

验证回调函数：确认是合法协议调用，而非恶意合约
安全检查：即使是把钱转回自己账户也要验证
资金管理：避免在合约中保留过多资金

十九、团队招聘要求

专注MEV研究的团队寻找实习生，三个核心特质：

Hungry（渴望）：有强烈赚钱欲望，愿意与人竞争挖掘Alpha
Smart（聪明）：能深刻理解复杂机制和技巧
Loyal（忠诚）：寻求长期合作伙伴，而非频繁变动

工作地点：北京

总结

MEV是区块链黑暗森林中的生存游戏。从最初的自由竞争，到Gas费竞价战，再到Flashbots主导的密封拍卖，游戏规则不断演变。如今矿工/验证者获取了绝大部分利润，套利者只能保留10-20%甚至更少。想要在这个领域生存，必须寻找长尾策略、新兴生态和独特资源，同时防范各种钓鱼和攻击。这是一个充满机会但更充满风险的残酷战场。

flashbots 技术架构及其实现原理

一、MEV 的产生背景

Flashbots 出现的根本原因是链上 MEV（Maximal Extractable Value）问题亟待解决。MEV 并非只有消极影响，实际上具有两方面的作用：

正面影响：

帮助 DeFi 运行。链上很多交易所的价格更新、借贷协议以及稳定币的运行都需要依赖套利者。
由于智能合约的动作必须依赖外部交易去触发才能进行数据更新，MEV 套利者的出现会帮助这些 DeFi 稳定运行，套利者也能获得收入。
根据 Flashbots 浏览器数据显示，从 2020 年开始就有玩家在链上获取收益，到 2022 年收益已达到千万级甚至上亿水平。

负面影响：

Gas War 问题： 很多 MEV 套利者互不相让，同样的套利机会大家都能看到，就比拼谁给的小费多。这导致 2021 年以太坊 Gas 费高得要死，发一笔交易可能需要十几 U 甚至几十 U。
在极端情况下（如抢 NFT、链上清算），会发生严重的 Gas War，快速拉高 Gas 费，造成 Gas 不稳定。
普通用户不参与 MEV 战争，低 Gas 交易会卡在链上，导致大量失败交易上链，许多交易堵在 Mempool 里。

二、现有的解决方案

1. EIP-1559

EIP-1559 将基本 Gas 费分成了新的计算公式，引入了 Base Fee 和 Priority Fee：

Base Fee： 根据当前区块的拥堵情况决定，会随着网络拥堵动态调整。
Priority Fee： 用户可选的优先费用。

这个方案的优点：

普通用户如果交易不急，看到当前 Base Fee 很高可以把交易往后放。
如果需要立即发出交易，接受当前高 Base Fee 也可以发送。
可以解决一部分 Gas War 问题。
以太坊的设计在经济学和工程学两方面都有考虑，既让用户用得舒服，也要让矿工收入增加。
增加了 Block 里面的 Gas 空间。

2. Flashbots 方案

Flashbots 的解决方案是把交易排序引入到链下，引入了 Sequencer。整个方案可以理解为：矿工把交易的排序权外包给了一个中心化的机构。

这个中心化机构把收到的所有交易以及 MEV Bot 的交易排好序后发给矿工。前提是矿工必须加装这个中心化机构提供的插件，才能收到分发机构发来的排好序的区块。

三、Flashbots 架构详解

整个区块生成流程涉及以下角色：

1. Searcher（搜索者/套利者）

Searcher 的交易来自两个地方：

从 Mempool 打包成 Bundle： 搜集 Mempool 里的交易，打包成 Bundle。一个 Bundle 包含多个 Transaction，类似于交易里的 Call，这些交易要么同时执行，要么同时失败，保证交易的原子性。
私有订单： 不走 Mempool，直接发给中心化机构（Builder）。

Searcher 的主要 MEV 策略包括：

原子套利： Token A 换 Token B，再换回 Token A，可能需要多笔交易。必须保证这些交易连续执行才有利可图，一旦被打断就没有利润。
清算（Liquidation）： 一般是一到两笔交易，监听到有利可图后发出清算交易。
抢跑和反跑（Front-run & Back-run）： 需要把交易插在目标交易的前面或后面，需要保证多笔交易的原子性。

搜索策略的关键点：

Gas 优化
延迟最小化
优化网络，减少 RPC 调用

2. Builder（构建者）

Builder 是中心化机构，负责通过算法决定区块里包含哪些交易。

交易来源：

Mempool：Builder 自己收集 Mempool 的交易
Searcher：收集来自 Searcher 的 Bundle
私有订单簿：钱包和 RPC 直接发给 Builder 的交易

核心竞争力：

足够快的区块排序算法： 在 12 秒内找到最有价值、利润最高的区块排序。
足够多的私有订单： 这是核心竞争力，因为 Searcher 通常会把交易发给全网所有 Builder。
足够多的 P2P 订单： 如果 Builder 位于以太坊节点集群的中心位置，在 P2P 环境下可以搜集到更多 Mempool 里的订单。

Builder 通过这些优势出的区块利润更大，可以付给 Validator 更多小费，从而有更多机会出块。

竞价机制：

多个 Builder 会竞拍同一个区块号（如第 1000 个区块）。
不同 Builder 不断提升小费来竞拍区块的出块权。
用户想让自己的交易或 Bundle 更有竞争力，需要给 Builder 提供更多 Tips（小费）。
这个提升 Tips 的过程放到了链下，不走以太坊节点。

3. Relay（中继）

Relay 的作用是防止 Validator 作恶。

工作机制：

Builder 出完块后，先把交易发给 Relay。
发给 Relay 的是盲块（Blind Block）：只包含交易头，告诉你包含哪些交易以及每笔交易的利润，但不包含交易体的具体内容（调用哪个合约、调用链路等）。
Relay 再把盲块转发给 Validator。
Validator 看不到区块体的内容，即使想作恶也无法实现。

关键特点：

Relay 是中心化的，目前以太坊主网只有 6-7 个 Relay。
Relay 可以看到整个区块体的内容，所以必须对 Relay 足够信任。
一般由大型机构运行 Relay。
Validator 节点必须连接 Relay 才能收到排好序的区块。

4. Validator（验证者）

Validator 通过安装 MEV-Boost 插件连接到 Relay。
Validator 只负责出块，不参与交易排序过程。
收益提高了很多，因为之前提升 Gas Price 变成了直接收小费（直接转以太坊）。

四、交易执行流程

完整流程：

Searcher 从 Mempool 或私有订单提取交易，打包成 Bundle。
Builder 收集三方面的交易：Mempool 交易、Searcher 的 Bundle、私有订单。
Builder 对这些交易进行排序，形成完整区块。
Builder 把完整区块发给 Relay。
Relay 把盲块转发给 Validator。
Validator 出块。

五、Flashbots 的优势

1. 对用户的好处

隐私保护： 交易不走公共 Mempool，其他用户看不到你的交易。
防夹机制： 钱包提供防夹模式，交易直接到 Builder 手里，别人无法夹你的交易。

2. 对链的好处

减少 Gas War： 交易排序权交给 Builder，节点不参与排序过程，减少链上公开竞价。
降低 Gas 费波动： 不再一味拉高出价进行拍卖。

3. 对矿工/验证者的好处

收益提高：直接收取小费而非只依赖 Gas Price。
Builder 之间竞拍区块，不断提升给 Validator 的小费。

六、使用方式

1. 普通用户

改用 Builder 提供的 RPC。
例如可以把钱包（如 MetaMask）的 RPC 改成 Builder 的 RPC。
交易不会走公共 Mempool，具有隐私性，不会被监控到。
对用户来说使用是无感的。

2. 开发者

可以通过 Builder 的 RPC 发送交易或 Bundle。
Searcher 发送 Bundle 时，为了保证上链率，一般会发给全网的 Builder。

七、Mempool 机制

传统机制

每个节点都维护着自己的 Mempool，没有全局的 Mempool。
每个节点的 Mempool 都不一样，同一时刻不同节点收到的交易数量不同。
交易来源有两个：P2P 和 RPC。
节点默认优先处理本地交易，把本地交易排在区块最上面，其他节点的交易（P2P 来的）放在后面。

MEV 相关

做 MEV 时选择不同地区的节点很重要，因为能更早看到交易。
节点位置越靠近中心，能收到更多交易，有更多时间处理。

八、Builder 的盈利模式

收益来源

Builder 收到的小费（如 10 笔交易，每笔 1 ETH 小费，总共 10 ETH）。
Builder 把大部分小费（如 90%）给 Validator，剩余部分是自己的利润。
Coinbase 设置为 Builder 自己的地址，再转一部分给 Validator。

Flashbots 公司盈利

运行自己的 Builder。
运行 Relay（具体收费模式不详）。
获得了大量 VC 融资（数千万美金）。

九、当前现状与问题

1. 普及率

目前 80-90% 的区块都通过 Flashbots 这套体系产生。
相比传统方式（交易进 Mempool → Validator 打包出块），现在加入了 Builder 和 Relay 两个核心角色。

2. 中心化问题

前三家 Builder（包括 Titan）占据了 70-80% 的区块。
整个以太坊的区块排序权掌握在少数几家公司手里。
这是目前被诟病的主要问题：虽然解决了 Gas War，但区块排序权集中在一小撮人手中。

3. 赢家通吃现象

大的 Builder 有更多私有订单、离 P2P 更近、给的小费更多，能保证更快的上链速度。
小 Builder 没有私有订单、P2P 订单也少，导致上不了链，无法盈利，最终被淘汰。

十、技术实现

1. MEV-Geth

最早的实现，在原有 Geth 客户端上加了两个字段。
允许多笔交易以原子化形式执行（Bundle）。
后来基本不再使用。

2. 当前实现

MEV-Boost： 开源代码，不需要高性能，主要负责交易转发。
Builder： 有 Rust 版本，Flashbots 开源了一套高性能的 Builder 基础设施。
Builder 是去中心化的，任何人都可以根据文档运行自己的 Builder。
核心性能要求在 Builder：P2P 速度、交易快速排序等。

3. 开发者可以做的

运行自己的 Builder，实现更优秀的区块排序算法。
获取足够多的私有订单和 P2P 订单。
很多 Searcher 在做套利的同时也在跑自己的 Builder，避免把小费全部给公开的 Builder。

十一、与 Layer2 的关系

Rollup 的排序算法不像以太坊主网那么严重的 MEV 问题，因为：

排序不是由节点决定的。
采用标准的 FIFO（First In First Out）排序。
可以避免 MEV 影响，难以进行夹子攻击。
例如 Base 链基本不存在传统意义上的 MEV，很难做夹子（但仍有 Backrun）。

十二、潜在风险

1. Builder 作恶

Builder 可以看到私有交易的完整内容。
如果交易有利润，Builder 有可能抢跑。
缓解方法：把交易发给多个 Builder，让他们竞争，看哪个不作恶。

2. 中心化风险

Relay 是中心化的，必须足够信任。
如果 Relay 作恶，虽然看到的是盲块，但仍有风险。
Builder 集中化严重，几家大 Builder 把持了大部分出块权。

十三、未来发展

Flashbots 正在攻克 Builder 中心化问题，但具体解决方案尚未明确。以太坊 2.0 可能会将一些机制做到协议层（如 PEPC - Protocol-Enforced Proposer Commitments），直接做到底层。

Solana 审计训练营第一讲 | Anchor 入门与高级

课程介绍

欢迎来到 Solana 审计员训练营。我们是 Solana 基金会的关键合作伙伴，也是教育合作伙伴。这是课程的第一讲，本讲座将致力于介绍这门课程，同时也会深入探讨 Anchor。

我叫安德烈，我是一名审计员，我也是 Key 公司的开发人员，在本课程中我将担任讲师。你可以在用户名 Andre19 下找到我，可以给我发私信。但是请为了获取关于训练营的信息或者关于训练营的问题，使用我们 Discord 中的频道。

下一个想要自我介绍的人，并且告诉我们更多关于我们公司的人是我们的 CEO，约瑟夫。

公司介绍

我是约瑟夫，我是 Aki 区块链的联合创始人。我很高兴你能加入我们的训练营。也许问题是，什么是智能合约审计？我们是智能合约审计公司，这意味着我们提供安全审计评估。但我总是说，好的审计员审计，最好的审计员会创建开源工具。

所以我们也在尝试为这个领域做出贡献，并且我们正在创造一个非常令人兴奋的工具，其中一项将在本课程中讨论。第一项是 Solana 的第一速审计。而且我们也很高兴我们能够在区块链行业中进行培训和引入新的人才。这是我们正在做的三个支柱。

我们很高兴能够与一些行业领导者合作，例如 1inch、Safe、XLR 或 Mina Finance，来自 Coinbase，当然还有来自 Solana 基金会。感谢 Solana 基金会，你也可以参加这个训练营，因为这是由 Solana 基金会资助的。所以感谢 Solana 的支持，这么好的倡议，所以我们可以在这个训练营里为每个人免费提供。我希望你会在这里享受，我期待着我们带来的结果。我希望我们能为更安全的区块链生态系统做出贡献。

课程议程

感谢约瑟夫的介绍。现在我们来谈谈这门课程是关于什么的。课程的议程如下：

高级 Anchor 内容 - 这将在本次讲座中涵盖
集成测试和单元测试 - 这些测试方法实际上非常普遍，不仅限于 Solana，但在另一方面，它们对于测试您的 Solana 程序非常重要
模糊测试 - 我们会有两节关于模糊测试的讲座，模糊测试是一种更先进的测试方法
安全最佳实践
常见的漏洞向量 - 在 Anchor 环境中
捕获旗帜（CTF） - 最后但并非最不重要的

课程目标

因为我们是安全公司，我们希望向您展示很多 Solana 区块链的安全性，很多关于 Anchor 安全。这是第一部分。

第二部分，我们非常相信工具，主要是模糊测试。我们也有 Vague 框架，这是以太坊快速测试框架。是的，这就是为什么我们有两个关于模糊测试的课程。

最后但也不是最后，我们希望你们玩得开心。这就是为什么我们在最后准备捕获旗帜。如果你喜欢破坏东西，如果你喜欢黑客攻击，我们希望你一定会享受这个过程。

课程范围说明

另一方面，这门课程并不在于：

这门课程在任何意义上都不是关于 Rust 的介绍
不是关于 Solana 或区块链的介绍
不是关于 Anchor 框架的介绍

我们将讨论所有这些，可能在这个训练营中，但我们相信你对所有这些至少有一些经验。所有的一切都会在 Solana 学校中被覆盖。如果你想学习 Rust、Solana、区块链或 Anchor 框架，可以去那里学习。

高级 Anchor 框架详解

现在让我们直接进入，跳入高级 Anchor 框架。

课程内容概览

首先我们将触及：

Anchor 如何改进原生 - 什么是真正的意思，什么是区别
程序宏（Program Macro）
账户宏（Accounts Macro） - 它如何实际上改进了测试序列化，或者让我们说不是改进，但使开发人员更容易
账户类型（Account Types） - 这对安全性真的很重要，因为你需要正确指定账户类型以便进行正确的检查。正确的检查账户类型意味着你需要正确检查你的指令所期望的账户
约束（Constraints） - 这些对程序的安全性也非常重要，这些约束可以用于上下文中指定的账户
IDL（接口定义语言） - 这也是一个重要话题

关于安全性的更多信息在前面的讨论中。

Anchor vs 原生 Solana

让我们谈谈原生。我们可以说，每个 Solana 程序实际上都有这种基础的 Solana 格式。我会说原生 Solana 和 Anchor 之间有区别，在某种意义上，Anchor 实际上改善了程序的安全性，正如它使得编写 Solana 程序更加容易。

Vanilla Solana（原生版本）

你可以看到这款 Vanilla Solana 是初始化了没有使用 Anchor 的普通 Solana 程序。你可以看到那里有入口点（entry point），这是 process，已经明确指出 process_instruction 实际上是你程序的入口点。

这意味着每次有人调用你的程序时，运行时将实际调用此 process_instruction。此 process_instruction 期望三个参数：

指令数据（Instruction Data） - 即基本字节数组
账户数组（Accounts Array） - 即原始账户数组
程序 ID（Program ID）

这两项是完全原始的，这意味着这是字节数组，这是原始账户数组的数组。

安全检查的必要性：

为了确保程序的安全性，你需要正确地检查这里所有的账户。例如，假设你的程序期望第三个账户是 Metaplex 程序，你需要进行这样的检查：

确保账户是可执行的
并且地址实际上对应于 Metaplex

同样，对于你的程序需要处理的指令数据，需要确定哪条指令将要被涉及。

其次，需要将实际的指令数据序列化。假设你的程序，你的指令是 swap（交换），如果你正在从事某种 DEX 项目，你的 swap 指令期望无符号 64 位长整数（unsigned integer），这意味着你需要正确序列化指令数据，即原始数据。

Anchor 版本

另一方面，实际上 Anchor 是建立在这之上的。Anchor 框架使开发过程更加容易，也更安全，因为你不会忘记一些检查。

从第一眼看，Anchor 部分可能看起来像这样。这基本上是刚初始化的 Anchor 项目，Hello World，没有逻辑。它看起来完全与 Vanilla Solana 版本不同。

但我们将看到，在最后，这些宏 - 它们是编程的 Derive Accounts、Accounts 宏 - 扩展到版本，真的很像这个原始的 Solana。

为了上下文，我们将在下一个幻灯片上谈论，我们的程序指定了这个初始化上下文，这是为初始化指令而设计的。而且程序也仅支持一个指令，不支持多个，但这不太重要，只是为了上下文。

程序宏（Program Macro）详解

所以让我们继续。那么程序宏实际上用于什么？

核心功能：

首先，它封装了你的程序支持的所有指令处理程序（instruction handlers）。所以你可以在右边看到，这不是我写的源代码，这是扩展的源代码，或者说扩展的程序宏。

你也可以自己扩展它，只需：

创建一个新的 Anchor 程序
在 CLI 中调用 anchor expand
这将展开宏并将生成的源代码存储在 .dot anchor 文件夹中

这不是我写的，它只是更新了，所以源代码看起来更短，但它是完全由 Anchor 框架衍生。

扩展后的代码分析：

封装所有指令处理程序。你可以看到，从这里开始的逻辑几乎与原生的逻辑相同。这是入口点规范，我们调用 entry 函数，它期望的参数与手动解决方案中的参数相同。

从这里开始，开始有所不同。这些检查，再次由 Anchor 自动衍生：

首先检查程序 ID 是否实际匹配你的程序的 ID
然后检查数据长度（data length），指令数据至少 8 个字节，这是由于指令的判别符（discriminator）

可以在这里看到这个在第一个函数中。如果这些检查通过，那么我们调用 dispatch。

Dispatch 函数：

这个 dispatch 函数实际上处理多个指令。所以你可以在第一行看到，我们定义了 sig 变量，这实际上是指令数据的前 8 个字节的数组。这里是输入，基于 sig 哈希，该程序处理指令。

这种逻辑完全是由 Anchor 框架推导出来的。在我们这个案例中，我们的程序只支持一个指令，该指令被初始化。因此，match 语句只有两个分支，但只有一条分支处理指令初始化。如果我们支持 update，那将出现第二条分支处理指令 update。

我们可以看到，还有一个处理 IDL 的。我们稍后会讨论。

总结：

总之，它最终：

封装了所有指令处理程序
封装了所有指令处理程序以进行 IDL 操作
你可以看到有自定义错误，例如声明程序 ID 不匹配、指令缺失
它也支持自定义错误类型，这可以提高 Solana 程序的开发和调试体验，因为你可以更好地了解程序实际崩溃的地方
它与 Derive Accounts 宏协同工作

Accounts 宏（Derive Accounts）详解

所以 Derive Accounts 宏，正如我之前提到的，指令或指定在 entry point 宏中的函数，该函数实际上期望三个参数：程序 ID、账户和指令数据。

原生 Solana 的账户处理：

例如，关注账户。我说过，账户字段期望一个数组，每个元素是一个账户结构。这意味着账户的实现是完全原始的。

你的程序期望，例如，如果你想为你的程序创建任何类型的代币创建元数据账户，这是可能的，如果你使用 Metaplex 创建元数据。你的程序实际上需要，或者你的指令需要期望 Metaplex 元数据程序作为账户数组的一个元素。

这意味着如果你使用 Vanilla Solana 编写程序，而没有使用 Anchor，你需要确保你正确检查该账户。这意味着如果你的指令期望第三个账户是元数据程序，你需要检查：

该账户是否可执行
并且该账户的地址实际上与 Metaplex 的程序 ID 匹配，该 ID 在 Metaplex 的文档中可以找到

我认为你也可以使用一些浏览器来检查它。这是为其中之一。

Anchor 的简化方式：

另一方面，然后你也可以使用 Anchor 框架，这使得开发过程更容易。因为你可以指定上下文，我将快速跳回，你可以指定这个上下文，这基本上与初始化你的初始化相同。

期望这个上下文，哪一个初始化结构体。在这个结构体中，你可以指定这个指令所期望的账户。正如我所说，如果指令期望元数据 Metaplex 程序，你将在这里指定它。

宏的作用：

这就是宏出现的地方，派上用场。因为它衍生了验证账户的代码，这种代码通过了指令处理程序，根据你在结构体中指定的内容。

因此，在这种情况下，假设你期望签名者（signer），第一个账户在账户信息数组中应该是签名者。所以它实际上创建了 signer 字段并调用 Anchor 的 try_accounts，这是 Anchor 的功能，实际上检查账户是否实际是签名者。

系统程序也是如此，但在这种情况下，它期望它是一个程序，这应该是系统程序。所以它在内部检查账户是否实际可执行，并且是系统程序。

简化开发：

因此，而不是指定所有 Vanilla Solana 的检查，你可以只写一行，我的意思是，例如 pub signer，你期望类型作为一个签名者账户类型。我们将稍后讨论这个。

并且 Anchor 实际衍生代码检查你所指定的所有字段。所以：

如果它应该是签名者，它检查这个账户实际上已经签署了该交易
如果它是系统程序，它检查这个位置的账户实际上是可执行的，并且是系统程序

例如，如果你的程序期望任何类型的数据账户，你可以指定带有类型和 Derive Accounts。或者扩展的代码将执行此类检查。

核心功能总结：

正如我所说，它：

验证传递给指令处理程序的账户 - 传递给指令
序列化账户数据 - 所以如果你期望，如我所说，有一些账户数据，假设是某种账户，或者你程序期望的任何账户，那么它可以序列化账户数据
允许指定各种约束 - 如 init，所以如果你的程序，或者如果上下文指定了任何种类的检查，例如，这里是 init 的例子。如果有 init，那么这个 Accounts 宏将确保账户确实已初始化。所以你不需要手动做，在 Vanilla Solana 中，但 Anchor 将生成可以这样做的代码
生成账户的 CPI 跟踪 - 所以如果你希望使用 CPI 调用你的程序，你可以将其作为依赖项使用。我认为它被称为 CPI 特性，并且你可以使用这个结构

所以这是从 Accounts 衍生的视角。

Account 宏详解

接下来是 Account 宏。所以最后我们在谈论关于 Anchor 框架的宏链中，我们谈论了这个 Account 宏。

主要功能：

这个宏用于将要存储在我们程序的数据账户中的结构。其主要目标是处理账户的序列化和反序列化，或者结构的序列化和反序列化。

这意味着最终，数据存储在账户中的基本上是字节数组，即字节数组，8 位长的字段。

Vanilla Solana 的处理方式：

如果你有经验，写 Solana 程序没有 Anchor，使用 Vanilla Solana，你知道你必须手动处理这一点。所以你必须为序列化和反序列化实现结构：

从结构到字节数组
从字节数组到结构

Anchor 的自动化：

如果你使用 Anchor 框架，Anchor 可以自动处理这一点，为你创建，并且它会衍生源代码。

所以使用此宏的结构可以被：

序列化和反序列化
从字节数组序列化
反序列化到字节数组

所以你不需要自己做。

实现细节：

第二点，或者让我们说，关于序列化和反序列化，我们可以看到在右边的源代码。这又是扩展 Account 宏，但在我的源代码中，我指定了我想将这个结构存储在数据账户中。

这个代码数据账户，它包含一个字段，这是公钥（PublicKey），它被称为 authority（权威）。这不重要，如何命名，以及字段名称如何。重要的部分是字段是公钥，所以 32 字节。

这里派生宏，或者这里派生部分，自动由 Anchor 生成。这是序列化和反序列化的重要实现。我不会详细讲解，它实际上处理 try_serialize 函数，这是很重要的。

但重要的是第一部分，让我们说，我们在这种情况下还没有谈论这个，但那是账户的判别符（discriminator）。然后是序列化，基本上将结构转换为字节数组进行序列化。

这是一样的，但在这种情况下它也检查判别符。如果前 8 个字节等于账户的判别符，我们将在本次演示中讨论这一点，判别符意味着什么。如果不匹配，则账户判别符不匹配，你将收到错误（bad account），然后它尝试从二进制中初始化基本结构。

判别符（Discriminator）详解

关于判别符，当我在谈论或者我们正在谈论某种判别符：

指令判别符：

在程序宏和指令、调用和处理程序的上下文中，使用简单的 Solana 原生、Solana 版本或格式，你可以创建，或者预期第一个字节将是指令的判别符。

我正在谈论这个，如果它是 0，那么它是，你将处理、调用初始化。如果它是 1，你将调用它，或者你将处理它，这个 update 等等。

账户判别符的重要性：

对于这个账户判别符，这很重要，因为这个判别符确保了：

你程序中的每个账户
或者你程序中的每个数据账户
每种类型的数据
你程序中的每个数据账户都有独特的判别符

没有判别符的安全问题：

没有判别符，这可以创建安全问题。如果数据账户，你程序使用，有相同的长度，假设 32 个字节，它也可以是不同的字段，但长度必须相同。

然后可以有账户之间的不匹配，因为一个结构可以从字节数组序列化，因为它包含 32 个字节。第二个结构也可以从数组序列化，它可以是 32 字节。

所以你需要确保你不会接收或期望，或者在你的指令输入中，账户之间没有匹配错误。这就是为什么我们有判别符，以便唯一区分两种账户类型。

常见实践：

编写你的 Solana 程序，你可能已经经历过这一点。我不说是行为，但是实际上当你初始化新的数据账户时，你指定，这很常见，不是常识，这是常见的做法来指定账户的大小，比如 8 加上一些长度。

实际上，这个 8 是为了判别符。Anchor 会自动在数据账户中存储，首先 8 个字节，这个判别符以便唯一区分数据账户。

源代码分析：

实际上根据源代码你可以看到在序列化中，这里是逻辑，Anchor 实际上指定代码，我们写了，我的意思是，如果你在第一个数据字节中写这个判别符，存储在账户中用于序列化。

这是一样的，但它没有写，但它只是检查数据长度是至少判别符的长度。如果这样，那么它会检查判别符是否匹配。

所以如果是的，那么它确认这个数据账户是正确的如预期，然后我们可以继续反序列化。

其他功能：

然后这个 Account 宏也定义了账户所有者（owner），所以你可以正确地进行检查，这个账户实际上是由我们的程序拥有。因为这是为数据账户的。

问题环节

最后一个宏。如果你有任何关于宏的问题，就在 Discord 上 ping 我或者周末，你可以在任何频道创建讨论。

账户类型（Account Types）

让我们谈谈可用的账户类型，可以在每个指令的上下文中使用。

文档参考：

只是提醒，你可以看到二维码，我看到它很大，所以我可能稍微缩小了一点。这只是一个到文档的 QR 码，所以如果你将来会开发一些东西，或者如何做某事，这可能，这份文档可能会有所帮助。

这只是账户类型的文档，所以你可能，你可能现在会用到它。你可以看到账户类型的列表，我想我可能会说你大概知道其中的大部分，但我们可以逐一查看。

主要账户类型

1. Account

首先，是 Account。我在上一张幻灯片中提到过 Account。

Account 类型实际上可以进行序列化，序列化实际上由 Account 宏确保。这意味着从字节数组它可以被反序列化，然后结构可以恢复，序列化为字节数组。

它还检查判别符是否正确，根据账户类型。然后也进行所有权检查（ownership check）。

所以你看到 Account 存储你的程序数据，是的，Account 必须由你的程序拥有。

2. AccountInfo

然后是 AccountInfo，这不，这种类型不进行任何检查。所以考虑到 Account 在那里，它不反序列化，所以没有反序列化东西的额外开销。

3. Box

有 Box 类型，实际上不进行任何检查，它只确保字段实际分配，或字段的内容，结构实际上在堆（heap）上分配，不在栈（stack）上。

那就是，让我们说你的程序使用了关于存储的所有数据，大量的数据，并且栈不足以存储所有数据，这意味着数据将不会存储在栈上，数据将存储在堆上。这会导致性能问题。

4. Interface

然后有 Interface，这个 Interface 用于程序验证，但是，从集合中的意思是，我会用例子来解释。

好的榜样是 Token，Token 2022。Token 2022 基本上是 Token 的延伸，是的。

所以如果你希望支持不仅仅是 Token，不仅支持 Token 2022，如果你希望在你的项目中支持两者，你可以定义你在指令中预期的 Token 程序作为 Interface。

这意味着，而不是检查确切的 Token 的程序 ID 或 2022 年 Token，它将检查从集合中获取程序 ID，在这种情况下，为 Token 和 2022 年 Token，我们实际上支持这两种程序。

同样适用于 Token 账户，但在这种情况下，所有权来自集合。

这意味着，例如，对于 Token 和 Mint，你不想支持 Mint 账户和 Token 账户来自 Token 或 Token 2022，但来自两个程序。所以你可以指定而不是期望类型为 Account Mint，但你可以期望其为 Interface Account Mint。

这意味着你正在期望，或者你支持所有来自 Token 程序的 Mint，和来自 Token 2022 程序。

5. Option

有 Option，这是几乎和 Box 一样，而不是 Option。Option 没有在堆上分配任何东西，它只是表示账户是可选的。

所以它可以指定，当它未被指定时，它可能不会，实际上它是 None。如果它被指定，那么它包含在 Option 内部，这是内部的类型。

Option 基于内部类型，让我们说 Account。

6. Program

然后 Program 类似于 Interface，但这次类型，对不起，程序验证不是来自集合，但它必须与精确的程序匹配。

它期望，所以让我们说在这种情况下系统程序或 Metaplex 程序等，或者可能是 Token 程序，但只是有一个 Token 程序，不是 Token 2022。

7. Signer

Signer，我会说这相当直观，这是最常见的类型。

8. SystemAccount

那么我们有一个 SystemAccount，这种类型我并不常见，但是该账户指定或检查该账户类型检查普通系统程序，让我们说一个普通的钱包。

9. Sysvar

然后我们有 Sysvar，这是系统变量，并且该类型检查实际上该账户是系统变量，并且序列化它。

10. UncheckedAccount

然后我们有 AccountInfo 的包装器，这是没有检查的账户，并且它是一个更真实的选项来说明没有在该账户上进行检查。

所以这基本上是原始的 AccountInfo，并且你可以将该账户传递给下一个指令或程序，在那里进行检查，或者你在程序中手动进行检查，所以在你的指令中手动进行。

这些是我们可以使用的账户类型，我们可以继续。

账户约束（Account Constraints）

让我们继续账户约束。这些分为两个部分：

第一部分是关于正常约束
第二部分是关于 SPL 约束

所以你也可以使用约束对于

SPL Token 账户或账户。

文档提醒：

风提醒，在文档中的 QR 码中也有约束，所以你可能会在未来找到帮助，在开发过程或审计期间，如果你想要检查约束的确切含义。

所以让我们快速浏览它们。

正常约束（Normal Constraints）

1. signer

首先是 signer，这些检查该账户实际上签署了交易。这与 Signer 类型相似，并且我会说 Signer 类型更常见。

2. mut（mutable）

然后是 mutable 或简写为 mut，这指定该账户实际上是可变的，并且可以更改账户中的数据。

3. init、space 和 payer

然后我们有常见的 space 和 payer 约束，这将初始化账户，payer 将支付租金，并且有将要分配的空间。

在这种情况下你可以看到有 8 加 8。从之前的幻灯片，我正在谈论判别符（discriminator），在这种情况下你可以看到它。

第一个 8 字节是判别符，并且第二个 8 字节是存储在账户中的数据字段。

4. init_if_needed

然后我们有一个 init_if_needed 约束，在常见的攻击向量中，这就是为什么这个功能，对不起，这个限制实际上是导致该功能启动的原因。

是的，你只能初始化一个账户，如果该账户尚未初始化。你可以明确指定付款人（payer）和需要分配的空间，如果账户尚未初始化。

5. seeds 和 bump

让我们继续，然后我们有 seeds，这是 PDA 衍生中很常见的。

这里有一个有趣的事实，而不是或者，你可能知道，PDA 衍生中的一个 seed 通常是程序 ID。在大多数情况下，这将是你的程序，正如你所做的，因为你将要为你的数据账户指定 PDA。

但是，你可以选择，你可以看到你可以指定，也可以指定其他程序用于 PDA 衍生。因此你可以期待，或者你可以支持来自不同程序的程序衍生地址（Program Derived Address）。

6. has_one

这在安全方面很常见，安全检查。这个限制实际上检查，你的数据账户有这个字段，它检查该字段是否与上下文中指定的权限（authority）相匹配。

这意味着如果你的上下文包含一个名为或账户的字段，它称为 authority，假设它是 Signer 类型，那么在你的数据中，你需要指定 authority，假设是 PublicKey。

那么它必须是 PublicKey，如果你将其指定为 has_one。这是指定 4 个约束的更短版本，即 authority，签名密钥与账户中存储的 authority 相匹配。

这就是更短的选项，以检查这两个字段是否匹配。

7. address

然后，我们有地址约束（address constraint）。这，我会说，相当直观，它只是检查账户的地址。

账户地址等于这个，指定的约束中。在这个情况下它是某个 ID，但它可以是任何公钥想要检查的。

8. owner

然后，我们有所有者检查（owner check），我们可以检查数据或账户是否由某个特定程序拥有。

这里有一个有趣的事实是，你可以，这也是对所有剩余的约束，你可以指定要发生的错误，显示，如果约束没有被满足。

所以如果约束失败，那么它会显示这个错误。

9. executable

然后另一个正常的约束，executable（可执行）。这不是一个常见的约束，但是是的，它可以被使用。

但我会说更常见的是你会看到 Program 类型有一些特定的程序或 Interface。

10. rent_exempt

然后我们有一个 rent_exempt（租金豁免）。这也不是很常见。

所有的 Solana 数据账户，或所有的数据，所有的账户都需要包含租金豁免。所以这是租金我想两年。

所以但对于一些临时的临时账户，你可能需要这个约束。

11. zero

然后我们有 zero，这告诉它不会执行判别符检查。这也不是一个常见的约束。

12. close

我们有最后，这不是最后，因为我们有一个剩余的幻灯片，但是有一个 close 约束。

这会实际上关闭数据账户。我强烈建议使用这个约束而不是手动关闭账户。

因为如果手动关闭账户，也有一个安全问题，我会说你可以用不正确的方式关闭账户。所以我会强烈建议使用这个约束。

但是有可能有你不能使用这个约束的情况，所以然后你需要，或者你需要手动关闭它。但是用它，我会说尽可能多地使用。

13. constraint

最后，最后两个普通约束，但并非最后。我们有 constraint 约束。

这是，我认为这可以是你想要的任何约束。你看到了吗，在这个例子中，约束被指定得如此。

我的一个数据，我的账户，或者数据账户存储我的数据结构，检查某种字段是相等的。某种字段 h 是等于某个值，或者 point.apple.h，其中这是另一个我的账户。

14. realloc

然后我们看看可以用来重新分配空间的，那就是数据账户被分配的。

所以假设你的数据账户数据部分被分配为 100 字节，你可以使用这个约束，你可以重新分配并增加数据账户的大小。

这些是普通约束。

SPL 约束（SPL Constraints）

现在让我们谈谈 SPL 约束。

可用的账户类型：

在幻灯片上，你可以看到基本三种账户类型，SPL 约束可以用于：

1. Token Account（代币账户）

首先，这是 Token Account。你知道的，它存储代币。我的意思是，像代币金额，它有一个拥有者（owner），并且你在这里存储你的代币，对于相应的铸造账户（Mint Account），或相应的铸造，或者我们也可以说相应的代币。

2. Mint Account（铸造账户）

然后在中间是 Mint Account。这又对应，正如你所知，对应的是代币。

3. Associated Token Account（关联代币账户）

然后在右边，你可以看到 Associated Token Account（关联代币账户）。这又，你已经知道，这个关联代币账户有其地址与所有者（owner）和铸造（mint）相关联。

这就是为什么它被称为关联（associated）。

约束的使用：

所以对于这些类型你也可以指定约束或使用约束。并且此外，你可以使用这些约束，也与我之前在幻灯片上展示的正常约束一起使用。

Token Account 的约束：

所以例如你可以看到对于 Token Account，你可以使用：

payer - 支付者
init - 如果你正在初始化代币，你需要指定代币将要初始化的 mint（铸造）
authority - 将要对代币账户具有像权限一样的东西

然后例如，你可以也与之前的约束混合。

让我们说，例如与 constraint 约束混合，你可以检查代币金额实际上大于一些，也许指令参数金额。

或者让我们说，如果你在做交换（swap）并且某人想要购买一些代币，你可以使用这个指令输入参数检查代币账户实际上有这个用户想要购买的金额。

Mint Account 的约束：

然后对于 Mint，基本上这是一样的，但是正如你所知，Mint 在其账户内有不同的字段，正如 Token Account 一样。

所以你可以看到例如：

decimals（小数位数）设置为 9，这是最常见的数字，我认为在 Solana
或者可能不要忘记，你可以设置 freeze_authority（冻结权限）和其他字段给铸造

Associated Token Account 的约束：

然后关联代币账户，如果你想初始化关联代币账户，那么你需要指定 mint 和 authority 以便检查，或者在这个情况下是为了推导出地址，在哪个账户将被初始化。

如果你不初始化关联代币账户，那么你就，或者如果你想检查地址，你只指定 associated_token mint 和 authority。

并且在后台，Anchor 会自动推导出关联代币账户的 PDA，并检查地址实际上是正确的。

审计的重要性：

这真的很重要以便正确审计智能合约，抱歉，在这个情况下，程序。

因为为了正确审计程序，你总是需要检查：

让说 mint 是正确的
或者 authority 是正确的
或者 decimals 是正确的
等等

所以最好是熟悉这些约束，并且也了解这个约束可以被使用，也正常的约束。

你不需要必须知道每一个，但是你至少应该熟悉每一个类型，或者每一个约束并且完全理解。

IDL（接口定义语言）

现在我们可以继续到这个讲座的最后部分，将致力于 Anchor IDL（Interface Definition Language，接口定义语言）。

IDL 的基本概念

什么是 IDL：

在原则上名字实际上是非常自解释的。它是种标准化的 JSON Schema 被用作接口定义语言。

所以为了知道如何与你的链上 Solana 程序通信，你可以定义这个 IDL，并且用这个 JSON Schema 在你的前端，例如，或者你可以上传到链上。

IDL 的自动生成：

我已经稍微提到过这个。我认为它在这个幻灯片上，致力于程序宏。

你可能注意到，这里有逻辑，在 dispatch 函数中，这里有一个分支用于 IDL 逻辑。

这是因为 Anchor 自动推导出逻辑，为了在链上部署这个 IDL。

我不知道 Anchor 推导出的所有源代码，但是你可以检查它。这里有逻辑，或者你可以检查 Anchor 实际上如何，假设推导出 IDL 账户的地址。

IDL 地址的推导：

这很简单，这里有确定性的 seeds：

我会说这是 “anchor”
然后是 “idl”
我会说，然后为你的项目

IDL 的用途：

这个 IDL 被创建，这像是接口，它包含所有可以用于前端通信的信息或重要信息，与 Solana 程序通信。

然后这 JSON Schema，然后这 JSON 文件实际上是二进制，存储在链上账户中。

IDL 包含的内容

你可以在幻灯片上看到，正如我所说，IDL 文件包括：

1. 每条指令的详细信息

所以，正如你可能知道的，指令在最后，如果你可能尝试了 listen 或尝试了获取最新块（latest block），例如从 CLI，你可以看到，指令的最后是字节的数组。

而这个 IDL 可以帮助这一点，因为字节的数组可以被，假设解码为某些无符号 64 位整数。不是整数，当它是无符号时解码为无符号整数。或者可能是其他结构或自定义类型。

为了知道在指令输入中期望什么，或者实际上将什么发送到指令输入，你可以使用这个 IDL。

2. 每种账户类型的描述

然后还提供了每种账户类型的描述，在程序中再次使用它。

我不确定所有字段，但了解这个功能真的很重要。

3. 查看 IDL 的方式

你可以通过 Solscan 或其他 Solana 浏览器，或者用 Solana 浏览器或其他浏览器，你可以看到那里有，你知道，账户中存储的 IDL。

但并非每个程序实际上都在链上存储这个 IDL，但一些程序有。

所以你可以看到基本逻辑，你可以看到程序使用的账户来存储数据，等等。

4. 与前端的交互

最后一点是关于前端，应用程序和其他客户端工具可以使用 IDL 与 Solana 程序交互，无需手动定义程序的接口。

基本上像我说的，所以客户端和前端可以，或者通过 IDL 知道：

如何与程序交互
期望什么
数据实际如何，我意思是数据的布局
账户数据的布局实际上看起来如何
如何尝试解析字段
等等

文档参考：

二维码指向 Anchor 文档，进入 IDL 部分。或专门谈论 CLI，IDL 部分：

如何创建 IDL 账户
如何与它交互
这里有种逻辑
如何设置权限
如何升级它
等等

安全角度：

所以这很重要，从，我不说安全角度，我认为你不需要，这个程序是怎么运行的。

你应该对这个很熟悉。正如你所见，这个程序会自动运行，对不起，Anchor 会自动从其宏中推导出这部分逻辑。

所以当你阅读或扩展的宏时，有时在未来，你应该熟悉这些逻辑应该存在，因为它们是由 Anchor 自动推导的。

总结

所以总结一下，本讲座在前三个，让我们说，不是幻灯片，或者我们可以称之为，在前三张幻灯片中我们谈论了：

1. 最重要的宏

我会说，最重要的宏是可用的，从 Anchor 框架。

这些宏或我们在实际上谈论，这些宏扩展什么。

对审计员的意义：

这是你，我们的审计员。这不仅意味着你现在阅读所有的约束，你阅读所有的 Solana 级别攻击可用的某处在 GitHub。

从我们的角度来看，你可以持有它。好的审计员实际上理解整个程序。

不仅仅是：

你应该检查所有者（owner）
你应该检查账户无法重新初始化
或者你应该检查这个程序账户正确检查
没有 CPI 漏洞这种东西

我认为好的审计员实际上必须理解整个程序。

而且我经常需要扩展一些程序并检查实际在什么上下文中执行，或者我的意思是，在 try_accounts 功能中，为了正确检查，如果所有都正确检查，并且每个检查都正确进行。

这就是为什么我们在谈论这个扩展的代码。

2. 账户类型和约束

然后，是的，肯定，账户类型。我说过，仅仅学习约束是不够的。是的，我们正在谈论约束和类型。

因为：

一方面，这不重要，对不起，仅仅知道它们是不够的
但是另一方面，了解所有所有类型和约束是很重要的

所以你知道：

在审计中你可以期待任何类型
在审计中你可以期待任何约束
你知道约束
你知道类型
所以你知道什么可以期待

类型的行为，你知道有 SPL 约束，你知道有正常约束等等。

3. IDL（接口定义语言）

最后，我认为，或者我们认为，关于接口定义语言没有很多材料。

这是第一部分。第二部分是 IDL 实际上是由 Anchor 宏定义的。所以了解这一点也很重要。

也，这一部分，正如我所说，将来，你可能尝试扩展一些程序，你会看到 IDL 逻辑，你会问，为什么它在那里。

你应该知道它，它是由 Anchor 自动衍生的，以便将 IDL 存储在链上。

4. Anchor Expand 命令

最后，我有 Anchor Expand。

除了关于宏展开代码的信息，所有账户类型的约束，这些类型的约束可以在文档中找到。所以你至少应该，你应该理解它们所有。

最重要的收获：

但是这个 Anchor Expand 宏，对不起，这个 Anchor Expand 命令实际上，可能是我想让你从这节课中学到的第一件事。

因为这可能非常有用，如果你不知道程序中实际发生了什么，或者你对宏下程序的实际情况不确定。

你可以使用这个命令，你可以检查，检查展开的代码看起来如何。然后基于这一点，你可以审计或继续审计程序。

理解扩展代码的重要性：

在结束时你对程序有更好的理解，如果你想想：

这个扩展的代码然后编译成二进制
到 sBPF 目标
然后这个二进制文件然后部署到链上

所以你实际上是，如果你看未扩展的程序，你看，或者对，宏最终会被展开。

但我想说，如果你看，如果你在看展开的程序，这意味着我们看的是编译之前的最终版本。

所以你有所有可能获取的信息，就像从程序中获取宏展开的信息。

所以我发现这个 Anchor Expand 真的很有帮助。

5. Trident 框架

也许还有一点，例如，我们有 Trident 框架，我多次使用过它，也用于模糊测试。所以这是一个真的很好，很好的命令。

课程结束

这就是这节课的全部内容。感谢您的注意。

至于下一节课，您可以期待关于单元测试和集成测试的课程。我可能会说这些测试被低估了，因为测试真的很重要。

所以是的，感谢您的注意，下次课见。

https://space.bilibili.com/1520840543

01.区块链与 Web3 基础

会议介绍了Web3数据分析的入门知识，重点讲解了区块链的核心概念、链上交互机制以及Web3生态系统的主要组成部分。内容涵盖分布式账本、区块结构、共识算法、哈希算法等基础原理，进一步探讨了账户体系、智能合约和交易流程，并扩展到钱包、去中心化应用（DApp）、DAO、DeFi和NFT等典型应用场景，旨在帮助学员建立对链上数据的整体认知和分析基础。

一、区块链基本概念

分布式账本

分布式账本是存储在多个节点上的共享数据库，所有节点共同维护账本副本。
具有抗单点故障特性，即使部分节点失效，系统仍可正常运行。
数据公开透明，所有参与者均可访问并验证账本内容的真实性。
没有单一实体能控制或篡改数据，具备抗审查能力。
所有用户对数据的访问权限平等，体现公平性。
数据一旦记录难以篡改，任何修改尝试都会被其他节点检测到。
所有数据变更历史可追溯，便于审计和验证。

区块结构与生成

区块是区块链的基本组成单位，包含交易数据和状态信息。
区块由区块头和区块体两部分构成：区块头含前一区块哈希、时间戳、Merkle根等元信息；区块体存储实际交易数据。
区块生成分为三个阶段：交易收集（用户发起交易并广播至内存池）、打包（矿工/验证节点选取合法交易组成区块）、验证与上链（网络节点验证后将新区块加入链中）。
区块的作用包括记录交易、连接前后区块以确保连续性、通过哈希值和时间戳提供防篡改证明。

共识算法

共识算法用于确保去中心化网络中各节点对数据状态达成一致。
工作量证明（PoW）要求节点通过复杂计算竞争记账权，比特币采用此机制，优点是安全性高，缺点是能耗大、交易速度慢。
权益证明（PoS）根据节点质押代币数量决定其成为验证者的概率，以太坊已转向该机制，优点是能耗低、验证快，但存在因代币集中导致的中心化风险。

哈希算法

哈希算法将任意长度输入转换为固定长度输出，广泛用于数据完整性校验和唯一性验证。
具备单向性，无法从哈希值反推原始数据。
输入数据的微小变化会导致输出哈希值完全不同，体现高敏感性。
不同输入生成相同哈希值的概率极低，具有抗碰撞性。

二、链上交互机制

Web3账户体系

Web3账户是用户与区块链交互的基础，具有去中心化、无中介、自主可控的特点。
账户由私钥、地址和交互功能三部分组成：私钥用于签名和授权，丢失即失去控制权；地址是从私钥生成的公开标识符，用于接收资产；同一账户可跨多个去中心化应用使用。
常见账户类型包括外部拥有账户（EOA），由用户私钥直接控制，可主动发起交易，如转账或调用智能合约；智能合约账户由代码控制，不能主动发起交易，只能响应外部调用。

账户模型

UTXO（未花费交易输出）模型将资产视为不可分割的硬币，每次交易消耗已有UTXO并创建新的UTXO，比特币采用此模型。
账户余额模型直接记录账户余额，类似于传统银行账户，以太坊及EVM兼容链使用该模型。

智能合约

智能合约是部署在区块链上的自执行程序，依据预设条件自动执行操作，无需人工干预。
具备不可篡改性、透明性和去中心化特征，代码一经部署无法修改，若有漏洞只能部署新合约替代。
所有合约代码和执行过程公开可见，任何人都可验证逻辑是否正确执行。
智能合约工作流程包括部署（生成固定合约地址并写入区块链）、调用（用户通过钱包或DApp触发函数执行）、验证与状态更新（节点验证交易合法性并更新链上状态）。
主要开发语言包括Solidity（以太坊主流语言，类似JavaScript/C++）、Rust（适用于高性能链如Solana）、Move（专注资产安全，用于Sui和Aptos）。

链上交易流程

链上交易是改变区块链状态的主要方式，生命周期包括创建、广播、打包和确认。
用户通过钱包或与智能合约交互生成交易，指定发送方、接收方和金额。
交易提交后被广播至网络，节点持续监听并验证其合法性（如余额充足）。
矿工或验证节点将合法交易打包成区块，添加区块头信息后上链。
所有节点确认后，交易完成，链上状态正式更新。

三、Web3生态系统组成

钱包

钱包是管理Web3账户的基础工具，用于存储私钥、生成地址、进行交易签名和与DApp交互。
基本功能包括管理私钥与地址、交易签名（如授权登录）、与智能合约交互（如存款、借贷）。
分为托管钱包（由第三方保管私钥，如交易所钱包）和非托管钱包（用户自行保管私钥，如MetaMask、Trust Wallet）。
非托管钱包又可分为热钱包（联网使用，方便交互）和冷钱包（离线存储，如Ledger，适合大额资产安全管理）。

去中心化应用（DApp）

DApp构建于区块链之上，数据存储在链上，用户通过Web3账户通用登录。
与Web2应用不同，DApp的数据公开可访问，任何人可通过智能合约地址查询活跃用户、交易类型和金额等信息。
开发者无法擅自更改链上数据或限制数据访问权限，保证透明性和用户主权。
部分项目尝试将区块链作为数据库使用，如Filecoin提供分布式文件存储服务。

DAO（去中心化自治组织）

DAO是基于区块链的组织治理形式，通过智能合约实现成员投票决策。
投票权通常与代币持有量挂钩，类似公司股东机制，持币越多话语权越大。
社区成员可对资金分配、协议升级等事务发起链上提案并投票表决，达到门槛后自动执行。
应用于项目治理，如Optimism基金会资金分配、Uniswap费用调整等重大决策均通过DAO完成。

DeFi（去中心化金融）

DeFi是在区块链上构建的金融系统，无需银行等中介机构，由智能合约自动化执行借贷、交易等服务。
特点包括无中介（用户直接控制资金）、时效性强（交易确认依赖区块时间，远快于传统跨境汇款）、抗审查（全球用户均可参与，无地域或身份限制）。
主要应用包括去中心化交易所（DEX），如Uniswap，支持用户通过流动性池自由兑换代币；借贷平台如Aave和Compound，允许抵押数字资产借出其他资产，并支持闪电贷（在同一交易内完成借款与还款）；稳定币如USDT、USDC，锚定法币价格以降低市场波动；衍生品如质押和流动性挖矿，用户通过锁定资产获得奖励，提升协议流动性和稳定性。

NFT（非同质化代币）

NFT是独一无二的数字资产凭证，用于证明所有权，具有唯一性、不可替代性和可验证性。
每个NFT有唯一ID，链上记录确保其真实性和稀缺性，防止复制或盗版。
可在二级市场（如OpenSea）自由交易，所有转让记录和价格公开可查。
广泛应用于数字艺术品、游戏资产（如武器、皮肤）、身份验证（如ENS域名）和数字证书（如课程 completion 证明），作为可信的所有权标识。

claude:

课程介绍

大家好,欢迎来到Web3数据分析师系列公开课的入门基础课程。在这一个系列的课程当中,我们将从零开始,逐步去了解Web3数据分析的核心概念、技术工具以及一些具体的实际应用。希望通过这一个系列的课程能够帮助大家打开Web3数据世界的大门,也帮助大家对未来的职业发展去奠定一个良好的基础。

这一讲呢,是整个系列的起点,也是整个入门课程的基础部分。主要的目的是为了带大家去逐步了解区块链的一些核心概念、基本原理,以及整个Web3生态系统的一些重要的组成部分和应用。希望帮助大家去建立对链上数据的一个整体认知和对链上数据分析的一些必要基础。

我是今天的讲师王烨,很高兴能负责这一个系列课程前两讲的主讲。我目前呢是在清华大学和美国南加州大学传媒数据科学双硕士在读,目前是研究生三年级。我过去呢是在链上数据分析有两年的工作经验,主要是负责DeFi和MEV策略相关的研究。我之前是在清华大学学生区块链协会研究部担任负责人,也在Optimism的数据分析师集体作为核心贡献者。以下呢是我的个人联系方式,所以大家如果对于这一些系列的课程有什么感兴趣的问题,或者是有建议,欢迎随时通过这些联系方式与我讨论。

课程结构

今天这一讲呢,主要是分成三个部分:

第一部分:区块链的基本概念
我们将从区块链的一些核心概念开始,带大家去逐步了解分布式账本、区块结构、共识算法以及哈希算法等内容,主要是帮助大家去理解区块链它的一些基础的运作原理。

第二部分:链上交互机制
我们会去进一步探讨链上的交互机制,主要会涉及到账户体系、智能合约的一些核心逻辑,以及链上交易的流程和特点。这一部分呢,主要是帮助大家去掌握区块链当中用户互动的这样的一个核心逻辑和流程。

第三部分:Web3生态系统
我们会进一步拓展到更广的Web3世界,主要去了解Web3生态系统下面一些独特的应用,它们的特点,包括钱包、去中心化应用、DeFi、NFT等等重要的Web3生态组成部分的功能,还有它的作用。

第一部分:区块链基本概念

1. 分布式账本

在传统的Web2世界当中呢,数据它通常是由一个中心化实体,比如银行、云服务提供商去管理。也就是说如果你在银行A和银行B开了两个账户的话,银行A跟银行B的账户它是不互通的。那么他们的账户体系和账户的交易记录都是由银行A和银行B分开进行管理的。

在这种情况下呢,数据的安全性和完整性完全是依赖这一个实体的管理能力。而在Web3或者说在区块链当中呢,我们用的是分布式账本的概念。分布式账本它是一个存储在多个节点上的共享数据库。在这个账本当中,数据是同步到多个节点,而且这些节点是共同去维护这个账本。任何单个节点的故障或者恶意行为,他都没有办法去轻易篡改这个账本上的记录。

这种去中心化的分布式账本,它是通过多个节点共同维护和验证的,每一个节点都会持有这一个账本的完整副本。

分布式账本的特点:

去中心化特性:

抗单点故障:即使当有一些网络当中的节点出现了故障,这个系统还是能够正常运行
抗审查:没有一个实体,或者说任何一个节点,它能够控制或者干预这个分布式账本的数据更新或者记录的修改

透明性:

在这一个网络当中,所有的节点都会持有这个账本的完整副本,也就是说这个账本当中的数据对所有的参与者都是公开可见的
这也是我们经常所说的区块链的数据是人人都可以访问的,所以任何人都是可以通过去运行节点去验证这个账本内容的真实性
用户不需要去依赖第三方中介的验证,就可以自行去验证这个数据的完整性和真实性

公平性:

所有的网络参与者,他对数据的访问权限都是平等的
不存在说有一个中心化的实体,它有个更高的权限去知道更深入的数据

不可篡改性:

所有节点都会存储相同的记录
任何人或者说网络当中的任何节点,他去试图篡改这个数据,都会被网络当中的其他节点所检测到
它相对于Web2来说,它对数据的安全的保障程度是更高的

可追溯性:

数据修改的历史,就是任何有一个节点想要去试图修改这个数据,它的这个历史都是公开的
可以供网络上所有节点验证

2. 区块结构

如果说分布式账本是区块链的一个基本的底层设计,那么区块呢,它就是区块链的基本组成单位,或者说一个基本结构。区块是记录交易和数据的一个容器。一个区块它就是区块链当中的一个数据包,它包含一组经过验证的交易,以及其他与区块链状态相关的信息。

区块它去存储数据,并且连接到区块链上的前一个区块,由此来形成一个连续的不可篡改的链条,也就是我们所说的区块链。它也以此来保障这个区块链上数据的完整性。

区块的基本结构:

区块头(Header):

提供这个区块的元信息
连接到前面的其他区块,去确保区块链的顺序性以及数据的完整性
包含前一个区块的哈希值、时间戳、哈希值数、Merkle根等等这些基本的元信息

区块体(Body):

存储区块数据的核心内容
包含了这一组经过验证的交易以及其他的一些用户记录

区块的生成过程:

第一阶段:交易收集

用户在链上提出了一笔交易,比如说Alice想给Bob转一笔账
这样的一笔交易通过钱包或者是一些去中心化应用生成,并且广播到内存池(mempool)当中
这个内存池当中会包含很多很多笔像Alice转账这样的交易

第二阶段:交易打包

矿工或者说网络的验证节点,按照一定的共识算法去内存池当中寻找交易
把这一组交易组成我们所说的区块体
将这些合法交易打包成区块

第三阶段:区块验证与上链

包含了区块头和区块体的这样的一个区块的数据会被进一步广播到这个网络当中
其他节点去验证这个区块的合法性
验证通过的话,那么这个区块就是成功的加入了区块链
这样的过程循环往复,就会形成一条链条,并且持续下去

区块在区块链当中的作用:

记录交易:存储用户交易,为网络的完整运行去提供基本的数据基础
连接节点:区块头确保整个网络之间的连续性和安全性
防篡改证明:区块头当中的哈希值和时间戳会使得数据的篡改难度非常非常高,而且也帮助这些节点方便进行验证

3. 共识算法

在讨论区块的生成过程当中,有说到矿工和验证节点,他们会基于一套共识算法去选取一组合法的交易并且打包成块。那么谁去负责打包这个区块呢?

共识算法,它其实就是分布式系统当中用来确保所有节点对这个数据状态以及选取这个矿工和验证者达成一致或者共识的机制。它去确保网络当中在没有一个中心化权威的情况下仍然能够安全的记录和更新数据。

常见的共识算法:

工作量证明(PoW - Proof of Work):

目前比特币网络BTC网络采取的方式
节点或者说矿工,通过解决复杂的数学问题,或者说哈希值计算(挖矿),去竞争这个区块的打包权
最先完成这个计算的节点,会获得记账权和这个区块提供的奖励
优点:具有高安全性,抵抗恶意节点攻击的能力非常强
缺点:因为要完成非常复杂的数学计算,能耗消耗是巨大的,而且交易速度会相对来说比较慢

权益证明(PoS - Proof of Stake):

节点通过锁定一定数量的代币或者说权益代币,去获得参与网络验证的资格
选取验证者的概率与质押的代币数量成正比,也就是说质押的代币越多,越有可能会成为打包区块的人
以太坊之前是在采用工作量证明,在2023年的时候转移到了权益证明
优点:能耗低,验证速度快,因为不需要复杂的数学计算
缺点:持有的代币越多,越有可能获得验证资格和区块打包权,因此会有一定的中心化的风险,大户更有可能会获得成为打包区块的人

4. 哈希算法

关于哈希算法的概念呢,其实是它是一个在数据转换当中所运用到的。因为我们其实平时看到的一些区块链的数据,包括我们说查交易哈希、账户地址可能会看到经常是0X开头的一组值。那么其实它都是可理解的数据通过哈希函数之后输出的结果。

哈希算法它是一种加密的算法,它可以将任意长度的输入数据映射成一组固定长度的输出值,它是经常用于数据完整性的校验和唯一性的验证。

哈希算法的特点:

单向性:

哈希算法是不可逆的
不可以通过哈希之后的哈希值去反向推演出原始数据

高敏感性:

输入数据的一点点微小变化都会导致最后输出的哈希值完全不一样
比如说Alice123和Alice124,通过哈希函数转换之后生成的输出值是完全不一样的

抗碰撞性:

不同的输入去生成相同一个哈希值的可能性是非常非常低的
因此经常会用于数据的校验

第二部分:链上交互机制

聊完了基本的一些区块链相关的核心概念呢,我们接下来聊一聊什么是链上交互,以及它的整体流程。在区块链当中,它的信息存储和交互方式与传统的Web2数据库有显著不一样的地方。与中心化的数据库依赖单一的服务器架构不一样,它其实是以分布式的方式去记录信息,具有透明性和去中心化的特点。

在这一部分我们将围绕账户、智能合约和链上交易流程三个核心要素去展开讨论,他们是如何构成这个区块链交互的基础的。

1. Web3账户体系

Web3的账户体系是用户和区块链交互的基础,也是可以说是用户去进入到Web3世界的一个大门。与Web2的账户模型相比,Web3的账户具有去中心化、无中介和自主可控的特点。用户可以通过这种加密技术直接去管理资产和自己的用户数据。

Web3账户的组件:

私钥:

控制Web3账户的核心工具
由用户自己直接存储,用于交易的签名和授权
丢失私钥相当于丢失了这个账户的控制权
我们可能看到有一些加密货币的古早的钱包,他们可能忘记了这个私钥,那么其实就相当于丢掉了这个账户

地址:

从私钥生成的一个公开标识符,也就是公开地址
大家可以通过这个地址去查到,这是一个账户的地址
用于接收和识别资产
我们经常看到的0X开头的以太坊地址,其实就是我们所说的账户地址

跨应用交互:

和Web2的账户不一样的地方:银行A开户和银行B开户,是两个户头
如果在银行A开户,但没有在银行B开户,银行A的账户交易是没有办法同步给银行B,账户的余额也不会在银行B当中反映
但是在Web3世界当中,因为这些账本都是去中心化、统一和实时一起更新的
同一个Web3账户,可以跨多个去中心化应用登录签名使用
因为所有的去中心化应用,都可以访问区块链上的数据,也都知道你这个账户余额是什么
Web3账户一个很重要的特点就是它可以作为通用身份和资产管理工具

常见的账户类型(以太坊):

外部拥有账户(EOA - Externally Owned Account):

用户私钥直接控制的账户
通常通过钱包(比如MetaMask)进行管理
能够主动发起交易,比如用户转账或者调用智能合约
只能存储代币和支付gas费用
不能够存储合约代码或者基本的一些运行的逻辑和函数

智能合约账户:

由区块链上代码所控制
账户行为都是由预定义好的函数逻辑决定的
没有办法主动去发起交易
只有在收到EOA外部账户地址或者其他智能合约调用的时候去发起响应,然后再进行下一步的操作

2. 账户模型

账户模型主要是用于去存储和管理用户资产和交易记录的这样的一种记账形式。

UTXO模型(未使用交易输出模型):

将资产视为不可分割的硬币
账户中的余额是未消费交易输出的集合
每一次交易都会花费已有的UTXO,并且创建新的UTXO
目前BTC采用的账户模型
举例:Alice想要给Bob转账,她账户下面持有两个UTXO,一个是3BTC,另一个是2BTC。当她想要给Bob支付4个BTC的时候,系统会去自动消费他持有的两个UTXO(3和2会同时被消费掉),并且会生成一个新的1个BTC的找零UTXO

账户余额模型:

类似于现在银行账户的记账形式
直接存储账户地址的余额和状态
目前以太坊以及其他EVM兼容链的记账形式
举例:Alice想要给Bob转账,如果账户余额当中有10ETH,她想要给Bob转账2个ETH的话,那么她的余额就会变成8个ETH,Bob的余额就会增加2个ETH

3. 智能合约

智能合约呢,它其实就是部署在区块链上的一组自执行的程序,它能够根据之前写好的函数和代码,根据预设条件去自动执行操作,而不需要人为的干预。智能合约它可以读取和写入区块链,因此在区块链的这样的特性加成下,它能够保证这个代码的执行结果透明且不可篡改。

智能合约的特点:

区块链基本特性:

不可篡改性
透明性
去中心化

自动化:

完全自动化,不需要人工的去做任何的操作
可以基于预设条件去自动完成复杂的交易或者流程
比如说借贷清算,都可以在同一笔交易当中通过智能合约去执行和验证

不可篡改:

智能合约一旦部署到区块链,会生成一组智能合约地址
一旦部署到区块链,代码和规则都是没有办法再进一步修改的
如果代码当中有一个bug或者说存在漏洞,被攻击的话,开发者发现这个漏洞,只能通过部署一个新的合约
在之前调用合约的基础上去修改这个指向的合约地址,去完成新合约的部署
之前存在漏洞的智能合约,代码和规则一旦部署到了区块链,没有办法再进行修改,只能废弃

透明性:

所有智能合约的代码和操作过程都对公众是可见的
比如说如果一个用户A调用了智能合约B,完成了一组借贷的操作,那么这样的一个操作在区块链上的交易记录都是公开可见的,我们都是可以访问的
这也就是为什么我们要去做链上数据分析,以及去分析EOA账户和智能合约账户,他们这些执行操作的活动的频率和操作执行的流程和特点
所有人看到了这一段代码和执行结果之后,都可以验证这个智能合约的逻辑是否被正确执行了,或者说是否遇到了错误

智能合约的工作机制:

合约部署:

合约经过部署,会生成一个固定的合约地址
这个合约地址可以通过在链上的函数或者用户去调用它
所有代码规则都会被写入区块链,无法再进行更改或者删除

合约调用:

用户可以通过钱包或者去中心化应用(dApp)去调用智能合约当中的某一个函数
提交相应对应的交易,或者说触发相对应的逻辑
这些交易同样是会被发到内存池当中
区块链的节点进一步的去验证这些交易的合法性,比如说余额是否充足去完成这样一笔转账,或者说所有目前存在的用户所有的资产是可以作为充足的抵押品去进行下一步的借贷和清算
区块链节点去验证这些交易是否合法,并且根据智能合约的逻辑去更新对应的链上的状态

常见的智能合约编程语言:

Solidity:

目前以太坊上开发智能合约的主要语言
是目前最流行的智能合约开发语言
一种面向对象的开发语言
有点类似JavaScript和C++

Rust:

比较适用于面向高性能、内存安全和高吞吐量的区块链应用
目前是Solana和Near Protocol这些链和协议所运用的开发语言

Move:

主要是去关注资产管理和资产安全
目前是Sui和Aptos链开发的智能合约编程语言

4. 链上交易流程

在我们知道了账户和智能合约之后,接下来就来看链上交易这个过程它是怎么样被完成的。链上交易它其实就是区块链状态改变的一个主要方式。每笔交易的创建过程,包括交易的创建、交易的广播、交易打包以及最终被各个节点确认上链。

交易的生命周期:

第一步:交易创建

用户通过钱包或者智能合约的交互去生成这样的一笔交易
无论是转账也好,授权去签名交易也好,会去指定这样的一笔交易当中的发送方和接收方以及对应的转账金额
也有可能转账金额是0,但可能会执行一些其他的操作,比如说借贷和清算等等

第二步:交易广播

当用户提交交易之后,这些交易会被发送到区块链网络
所有的区块链网络节点,会去持续的监听
当它们收到交易之后,就会去验证这个交易的合法性,比如说余额是否充足去进行转账

第三步:交易打包

当交易被验证之后,矿工和验证节点,会把这一组交易打包成区块
包含区块头的元信息,然后再添加到区块链上

第四步:交易确认

当所有的验证节点都确认了这笔交易之后,那么也就是说这一笔链上交易就彻底的完成了它的使命
修改了链上状态

第三部分:Web3生态系统

相信大家到现在这个阶段就已经对区块链的基本概念和它的一些核心的运行逻辑有了一定的了解,那么我们可以来进一步的讨论Web3生态系统当中有哪些独特的应用和它们的使用场景。

和传统的Web2生态相比,Web3的生态它更强调用户数据的所有权、自主性和透明性。所以这一节我们会去简单的介绍一些核心的应用,包括钱包、去中心化应用(dApp)、DAO、DeFi、NFT等等核心的基本组成部分。

1. 钱包

当我们去聊到Web3的生态系统的时候,第一个绕不开的工具就是钱包。因为钱包它其实是跟我们Web3的账户是挂钩的,它其实本质上就是我们去管理Web3账户的一个基础工具。

因为本身如果说我们要去在链上做交易,然后直接用原生的语言去和链上的区块链进行交互的话,学习成本是非常高的。这也是为什么钱包它的诞生就是为了去管理Web3账户以及账户当中的加密货币,以及帮助用户怎么样去存储他的私钥,并且生成对应的公钥,以便大家去进行转账、发起交易以及和一些去中心化应用交互和授权签名的这些操作。

钱包的基础操作:

管理私钥地址:

通过私钥去生成公钥地址
私钥可以是用户在这个钱包当中直接创建的
也可以是已经有了自己的私钥,在这个钱包当中去导入私钥
钱包读取之后,会基于你的私钥,根据哈希算法,重新让你获得这个Web3账户的管理权限
可以通过这个公钥地址去向其他人去发起交易,或者是向对方发起接收资产的交易

交易签名:

更多的是说怎么样去进行链上交互
比如我们最基础的,可能会在一些去中心化应用当中看到你可能需要去登录
那么你就会收到一条message或者收到一条信息说你是否批准登录这个网站
当你通过钱包选择approve或者授权了,那么这个网站就能够通过对应的接口去获取你这个公钥地址
那个时候你就可以看到在网页上你的公钥地址就能够显现在那个去中心化应用的主页上

应用交互:

不仅仅是涉及到sign in登录这种操作
可能会更多的会有连接到去中心化应用,并且授权这个智能合约替你去发起一笔交易
比如说你可能想要去进行在DeFi当中进行借贷或者deposit,想要把你的资产存进某一个合约
他们都会有生成一条对应的信息,然后用户可以在钱包的那个组件当中看到这条信息
当你选择批准交易之后,那么其实这个去中心化应用就执行了这条智能合约
也就是你通过钱包去批准的这个行为,也就是你Web3账户去授权这个智能合约进行执行,调用这个智能合约的这样的一个操作

钱包的类型:

托管钱包 vs 非托管钱包:

托管钱包:就像是你把你的钥匙托管给了别人,可以通过一个用户名和密码去访问你的钱包。托管钱包大多数都是在中心化交易所,在交易所当中,可能不一定会有一个具体的私钥地址
非托管钱包:用户需要自己去保管私钥,或者说是保管你的密码。如果私钥丢了,那么资产找不回来了。平常看到的小狐狸(MetaMask)或者Trust Wallet这种比较常见的非托管钱包

冷钱包 vs 热钱包(非托管钱包的分类):

热钱包:大家经常去和链上应用进行交互,然后去进行登录和授权交易的这样操作的钱包,比如MetaMask或者Trust Wallet以及一系列的基于浏览器插件的这种工具
冷钱包:主要用于大额资产的管理。大家会比较担心大额资产的安全性,所以一般来讲冷钱包都是硬件钱包,可以将你的私钥离线存储,并且提

高你的安全性,比如说Ledger

2. 去中心化应用(dApp)

如果说钱包是普通用户和Web3世界进行连接的一个最基础的桥梁的话,那么去中心化应用就是这一个整个生态当中最重要的基本构成部分。也就是说像在我们传统的互联网当中,这些各种各样的互联网应用程序,它们所执行的不同功能,满足了用户的不同需求,也就构成了这一个Web2世界的生态。

那么在Web3的生态当中,去中心化应用的存在,它其实和Web2应用类似,但是它最核心的区别就是:

Web2应用的特点:

在Web2的世界当中,像微信和微博这样的应用,他们的数据都是存储在中心化的服务器上的
这就意味着在微信上创建的账户和密码是没有办法在微博上进行登录的
用户数据包括用户的登录记录、发布的贴文和用户关系的这样的一些数据,都是没有办法被外界所获得的
因为这些数据的修改和访问权限都是在平台的控制之下

去中心化应用的特点:

去中心化应用的构建和数据存储都是在区块链上
用户的交互、用户的登录以及授权,都是在区块链上有对应的生成的记录
这样的数据,它其实就会成为一种公共产品,因为每一个人都可以去访问

数据访问的差异:

在传统Web2世界当中:

想要去计算微信过往一年当中用户的月活量或者是用户的交易的一些活跃程度
包括说可能想知道某一个微信用户和另外一个微信用户每一个月沟通有多少条
这些数据都是需要微信官方批准授权之后,用户才能够去获得
或者说可能需要一些单独的API才能够去访问
这些数据的控制权都是在平台手上

在区块链上的去中心化应用:

所有人只要说掌握了这个去中心化应用它所部署的智能合约地址
就可以找到这个智能合约地址被调用的生成的记录
包括说用户在登录或者授权批准某一笔交易当中都会可能生成这样的一个对应的交易
这些交易当中又会有对应的生成的日志
通过访问这些日志,就能查询到这一个去中心化应用当中的活跃用户数量、活跃用户地址,以及这些活跃用户他们所执行的交易都有哪些种类,然后对应他们的转账到底有多少金额

去中心化应用的核心特征:

用户数据自主管理:

用户的数据存储在区块链上,是由用户自行管理的
有一个Web3账户,就可以访问和登录所有的去中心化应用
这个账户本身是通用的
数据又是大家都可以公开访问的

开发者无法篡改数据:

去中心化应用的开发者,在他部署了这一个去中心化应用的智能合约之后
没有办法擅自去改变这个链上的数据
或者是限制大家对这个应用去进行调查的数据访问权限

分布式存储探索:

现在有一些生态链当中会有一些产品,想要尝试用区块链真正作为数据库去使用
比如说像Filecoin,可能想要去创建一个分布式的网络,这样每一个网络当中的节点都可以承担一个文件存储的功能

3. DAO(去中心化自治组织)

区块链带来的变革,它不仅仅是在Web3账户和去中心化应用,与此同时,它还带来了一个全新的,在组织上面或者说是治理上面的一个全新的概念,叫DAO。

DAO的概念:

DAO的全称是Decentralized Autonomous Organization,叫做去中心化自治组织
是一种基于区块链投票的组织形式
更多的是由智能合约去写定,比如说成员的投票权的大小是由持有代币的数量来决定的
有一点点类似于在传统公司治理当中的董事会还有股东
股东所持有的股票越多,话语权就越高,也就更能够去影响整个公司的决策
DAO的概念有一点点类似公司治理的流程

DAO的运作方式:

拥有投票权的社区成员,可以对协议或者是社区的事务进行公开的链上投票表决

DAO的应用场景:

项目方资金分配:

比如说像Optimism,它是一个Layer 2的公链
从一开始发行代币的时候,就会有很大一部分留给了它的基金会
这个基金会的目的,就是为了去持续不断的激励社区和开发者去为这个生态做贡献
这个资金到底怎么分配?每一期分配多少?又分给哪些项目和哪些开发者和核心贡献者?
这些决策都是要有整个组织或者是社区成员的集体智慧去进行治理的
他们在每一个月都会定期召开组织会议,或者说在链上,像在Agora或者在Snapshot这样的平台上去进行投票
会发布这种proposal(提案)
社区成员,拥有代币的持有者都可以去对这些提案进行投票
最后,超过了比如说一个门槛,比如说2/3的代币持有量的持有者都进行了投票,达到了一定的门槛之后,这个提案通过了,那么它就会得到执行

协议参数调整:

可能会对这个项目本身进行投票
比如说像去中心化交易所Uniswap,可能想要对一些资金池的费用管理进行调整
可能需要基于市场行情,可能会提高一部分的费用,或者说对某一些池子的费用进行降低
这样的决策,也是要通过社区成员集体投票来决定的
因为这个决定了可能会在某种程度上去影响这个社区的回报
比如说某一个协议它是基于费用去进行盈利的,这些盈利的利润最后可能都会反映到代币最后的分红上面
这种时候,代币的持有者更多的就可能会像传统公司金融当中的股东
他们可能会去投票去执行哪一些提案,或者说哪一些新的流程会更好的去优化这个协议的发展

4. DeFi(去中心化金融)

接下来,想要讲一讲DeFi,也就是Decentralized Finance去中心化金融。去中心化金融,其实是目前Web3生态当中应用最广、最大,用户数量以及交易量是最大的这样的一个应用领域。

DeFi的核心概念:

建立在区块链上的金融系统
不需要像银行这样的传统中介机构、传统金融中介去介入
基于智能合约,去中心化金融的软件或者说应用,可以提供借贷、交易、收益聚合等服务
所有的交易都是通过智能合约自动化执行

DeFi的特点:

无需中介:

第一个特点就是不需要银行等中介机构去进行介入,资金是由用户直接控制的

举例说明传统金融 vs DeFi:

传统金融转账:

小A想要给小B去转账100元
如果小A跟小B两个人不在同一个地方,没有办法见面去把这笔钱给另外一个人,没有办法进行现金交易
只有去打电话给银行,或者是小A需要给他所在的银行发一个信息,说我想要转账给小B
这个时候银行接到了小A的授权,就会联系小B开设账户的银行说:我这边收到了小A的一个要求,要给小B去转账100元
相当于就是小A的银行给小B的银行去转账了100元
这个时候款就到了小B的银行的账户上
在这种情况下,银行就承担了一个金融中介的职能

传统金融的风险:

一旦银行(小A的银行)拒绝了小A的请求
或者可能银行的数据库出现了问题,或者说网络出现了故障
那么在这种情况下,小A的钱是没有办法转给小B的
还有一种情况也有可能会出现一些其他的,比如说银行破产这种中心化的风险
资金其实用户没有办法直接控制,因为如果想要转账,小A想要转账给小B的话,必须把自己的钱存进银行,然后通过银行之间的转账去实现让小B去提款

DeFi的转账方式:

在DeFi当中,这种转账是及时且无中介的
通过Web3的钱包,用户可以直接发起一笔转账给小B的地址
只要小B和小A同样都有公钥地址,小A知道自己的私钥
小A可以通过私钥去管理他的资金
小A可以直接通过钱包去发起一笔转账给小B的公钥地址

时效性:

因为银行有金融中介的职能,所以这种转账,国际间的转账或者异地的转账以及借贷交易,严重依赖银行这种中介机构去处理交易的速度
也就意味着可能会,我们在传统金融当中可能会听到说为了安全会有T+1,以及可能有一些国际间的清算的话,可能要等3到5个工作日
在区块链当中,因为区块链的交易都是根据数据库的更新的时间来决定的
交易和清算都是由智能合约自动完成,时间就是每一个区块的确认时间
这个时效性的话,相对于国际间或者是异地转账来说是非常非常方便的

抗审查:

抗审查意味着任何人都可以参与到这个过程当中,而不需要传统金融的准入条件,包括说审查或者地域限制
举个例子,像不同国家的公民,在异国去开户的话,会存在很多的身份验证的限制
很多国家不允许第三方国家的公民去对他们的银行进行开户,因为很难去验证这个开户人的身份信息和信用信息
包括还有一些银行账户,开户可能会有资产要求
在这种情况下,它可以非常方便的、便利的去为两个用户之间进行一些金融传统的金融交易和一些金融操作
可以带来很大的便捷性

DeFi的常见应用:

去中心化交易所(DEX - Decentralized Exchange):

允许用户基于代币对或者是自动的做市商去自行的买卖和交易加密货币
代表的应用有Uniswap和SushiSwap
不需要一个传统的像股票或者是中心化的交易所
用户A可以自行的说:我想要用A代币去换B代币
B说我刚好也有B代币换A代币的需求
这个时候只要再找到一个流动性的资金池当中,两个用户去发起这样的一笔执行交易、执行兑换的交易,那么它就可以被智能合约自动执行

借贷平台:

允许用户在没有传统银行的情况下进行借款或者放贷

传统金融借贷的特点:

在传统的金融当中,借贷是严重依赖于申请借款人的信用值
银行可能要很谨慎的去验证你这个借款人的资产情况、之前过往的信用记录,再去判断是否要借款给你,你能够借到多少钱

DeFi借贷的特点:

在区块链当中,或者说在DeFi当中,这种去中心化的借贷,更多的是依赖于智能合约去对用户的资产进行直接定价模型的评估
完全是严格的依照按照链上的资产价格去进行抵押品的计算
用户将自己的数字资产存入到这些借贷平台当中,可以赚取利息
也可以把自己的一些其他的数字资产抵押品存到这个平台上,从而借出其他的数字资产
常见的借贷平台有Aave和Compound

闪电贷(Flash Loan):

DeFi的借贷可以支持闪电贷
因为区块链的交易具有原子性的特点
也就意味着在同一笔交易当中,你可以执行十个操作,但是只要保证你最后的状态是一致的就可以
举个例子,可以在某一笔区块链的交易当中,同时实现借款和还款的操作
只要保证在这笔交易的执行前,余额是1,执行后余额还是1,它并没有变化
那么就可以无痛的,或者说完全不需要任何资金成本、借贷成本的在同一笔交易当中完成借款1万美元和还款1万美元这样的操作
只需要付一点点的交易费或者手续费,就可以有一笔大笔的资金介入到用户的账户当中去执行其他的,比如说兑换或者套利的操作

稳定币:

稳定币的发明,主要是为了方便传统金融和去中心化金融的桥接作用
稳定币的概念,就是与法定货币,比如说美元或者现在目前还有一些欧元稳定币,与这些法币的价格挂钩的加密货币
用于去降低加密货币或者说去中心化金融市场的波动性,以及方便大家去支付
因为这样的话会非常直观的知道某一个加密货币的资产价格,到底是一个什么样的情况
目前代表的稳定币有USDT和USDC

衍生品 - 质押和流动性挖矿:

质押(Staking):

用户可以选择把自己持有的一部分的加密货币去锁定在某个区块链的网络,或者在某一个协议当中
通过提供这种流动性到协议的话,可以保证,相对来说稳定这一个协议的币价波动以及保证这个协议的流动性
这些协议又会提供相应的代币奖励或者利息给用户

举例 - 以太坊质押:

像以太坊的网络运行是需要每一个节点去质押32个以太坊的
在这种质押的协议当中,比如说Lido,允许用户说:我可能自己一个人没有32个以太坊,但是我又想参与到保证或者维护这个网络的运行
可以选择质押1个以太坊
当有32个这样的用户同时质押了1个以太坊,他们就可以一起去实现一个节点的支持这个节点的运行
他们也可以获得这个节点运行获得的矿工奖励或者矿工小费,可以平分这个奖励
在这样的一个机制下面,去中心化金融或者说DeFi可以很便利性的去给市场提供很多样化的流动性产品
这也是它和传统金融相比,有许多非常非常有创造性的应用场景

5. NFT(非同质化代币)

最后,我们来聊一聊NFT。相信大家对这个概念都没有特别陌生了,因为在过往两年当中,数字藏品这个概念其实一直被反复的提及。

NFT出现的背景:

在传统的Web2世界当中,像数字艺术或者是游戏当中的一些稀有资产,可以被复制,或者说可以被盗版
所以很难,这些藏品的拥有者,或者说这些数字资产的持有者,很难去证明说我所拥有的这样的一个作品,它就是唯一的,且是真品

NFT的概念:

NFT的存在,可以去验证这一个数字资产的所有权
全称是叫做非同质化代币(Non-Fungible Token)
也就是说它是独一无二的,并没有办法有另外一个可以在链上找到和它一样的资产证明
它的所有权,用户对这个NFT的所有权或者声明的所有权,以及这个NFT的真实性都是由区块链来验证的
具有唯一性、不可替代性和可证明的所有权
NFT被广泛用于艺术品、数字身份,还有游戏资产的这些各种需要验证的领域

NFT的特点:

不可复制:

唯一性是由链上数据来保证的
每一个NFT都有一个对应的唯一的ID
想要去证明说我所拥有的这个资产它是独一无二且是真品的话,只要提供这个NFT所对应的ID
就可以在链上知道用户A持有了这个NFT

可交易:

意味着这个TOKEN或者说代币,是可以转让的
因此有衍生的交易的市场
有些NFT可以在二级市场,比如说像OpenSea这样的平台当中进行交易
用户可以选择出价,进行NFT的转让
每一笔这样的交易,或者说是转让的记录,以及它所对应转让的价格,都是可以在链上被查询到的
作为数字藏品或者说数字资产的唯一识别符号,是非常非常有作用,或者说是非常有效的
因为大家都会很清楚的知道它过往的交易记录以及所对应的价格

NFT的应用领域:

数字藏品:

像画作,或者是NFT形式所发布的游戏的资产,比如说武器
资产的稀有性属性还有所有权都是在区块链上被记录的
没有办法被任何一个实体删改或者是进行盗用

身份验证:

可以给用户提供一个唯一的、不可变更的标识符
比如说可能看到有一些用户的地址,可能会又对应一个ENS的域名,就比如说以.ETH后缀的域名
他们可以用这样的声明域名作为自己的数字身份
基于这些数字身份,有一些网站就会知道你是属于某一个特殊的会员,因为你持有这样的一个NFT

数字证书:

可以去认证一些学习成就、获奖或者参与某一些活动的证明
就是我们说的Proof of Attendance
比如说参与某一个活动或者是会议这样的记录
以及说完成了某一项成就,或者说完成了某一项课程
包括说像完成我们今天的链上数据分析公开课,完成某些课程之后,就可以声明这样的一个NFT存到账户上面
在未来有雇主,或者是在一些其他的领域当中大家想要知道你是否真的是完成了这样的一个成就的话,只要需要在这个账户下面查询到这个NFT就可以被验证

课程总结与延伸阅读

课程最后,想给大家分享一些可以参考的阅读资料:

推荐阅读资料:

第一篇比较推荐大家去读一读,就是关于去中心化应用的整体的框架,或者说架构。它是和Web2有存在哪些不一样的地方,然后它有详细的去讲这样的一个用户的交易提交,然后以及和智能合约交互,最后被写上链这样的整一个操作流程。我们在第二节课也会涉及到这一部分,就是整一个链上交易的生命周期是什么样的。

接下来三篇,就更多的是涉及到Web3的术语,以及一些基础知识和关键技术。更多的是我们这边这节课程当中已经涵盖到了一些概念的详细的解释。

非常感谢大家能够完整的倾听完这一节课程。这节课,我们主要是讨论了一遍区块链的一些基础概念以及它的对应的生态当中的一些组成部分。

下一节课,我们会更多的涉及到链上数据结构,以及链上交易的流程的解析,以及最后链上数据分析所需要的一些基础知识。

我们下一期再见!

02.Web3 数据分析基础与工具使用

链上数据分析课程介绍了区块链数据的基本结构、核心指标及分析工具。课程首先讲解了链上数据的三种基本类型：交易数据、区块数据和合约数据，详细说明了各类数据的构成字段及其在区块链中的存储与作用机制。随后，课程重点解析了总锁仓量（TVL）、活跃地址数、交易数、交易量和gas费用等关键链上指标的定义、计算方式与实际应用价值。最后，课程系统梳理了链上数据分析的ETL流程，并介绍了从数据源工具（如The Graph、Alchemy）、数据开发平台（如Dune）到数据应用层（如Nansen、DeBank、Defi Lama）的完整工具生态，帮助学习者理解如何进行数据提取、转换、加载与可视化分析。

一、链上数据结构

交易数据

交易数据是区块链中最基本的数据单位，记录用户之间的转账或与智能合约的交互。
包含字段包括交易哈希（唯一标识）、交易状态（成功或失败）、所在区块号、时间戳、收发方地址、转账金额、交易费与gas费用、nonce（防止重放攻击的计数器）。
交易需经历创建、广播、打包、确认四个阶段才能被永久记录在链上。

区块数据

区块是链上信息的基本存储单元，包含多个交易及其他元数据。
主要字段包括区块高度（即区块号）、区块哈希（唯一标识）、时间戳、矿工或验证者地址、交易列表及总gas消耗量。
区块通过哈希链接形成链式结构，确保数据不可篡改。

智能合约数据

智能合约是部署在区块链上的自动化程序代码，控制去中心化应用的运行逻辑。
合约数据包括合约地址（唯一标识）、函数定义（由Solidity等语言编写）、事件（用于记录执行日志）和状态变量（存储余额、流动性等关键信息）。
合约事件是链上分析的重要线索，可用于追踪用户行为，如Uniswap的swap事件。

二、链上数据指标

总锁仓量（TVL）

TVL衡量DeFi协议中锁定的资产总价值，反映协议的资金规模与用户信任度。
包括流动性池、抵押贷款、收益聚合等类型的资产。
TVL上升表示市场信心增强，下降则可能意味着资金流出或风险加剧。
计算方式为所有存入资产按美元或以太坊计价的总和。

活跃地址数

指在特定时间段内至少执行一次交易的钱包地址数量，反映协议的用户活跃度。
可通过distinct地址统计得出，常用于评估项目增长趋势。
与Web2不同，链上地址公开可查，便于进行透明化分析。

交易数与交易量

交易数指一定时间内发生的交易总数，反映网络活动频率。
交易量指交易涉及的资产价值总额，通常以美元或以太坊计量。
两者结合可判断网络是否健康活跃，高交易量代表大量资金流动。

gas费用

gas费用是用户为交易上链支付的成本，激励矿工或验证者处理交易。
费用由gas使用量乘以gas价格决定，后者包含基础费用（base fee）和优先费用（priority fee）。
网络拥堵时gas费用上升，可通过观察gas中位数判断网络状态。

三、链上数据分析流程与工具

数据ETL流程

数据抽取（Extract）：从RPC节点或区块链浏览器获取原始交易、区块、日志等非结构化数据。
数据转换（Transform）：利用智能合约ABI将十六进制格式的输入数据解码为可读的函数参数与事件信息。
数据加载（Load）：将结构化数据存入SQL等数据库，供后续查询与分析使用。

工具分类

数据源工具

提供对原始链上数据的访问接口，是分析的基础层。
典型工具包括The Graph（通过子图提供索引服务）和Alchemy（提供多链API支持）。

数据开发工具

面向开发者与分析师，支持自定义查询与数据处理。
Dune是代表性平台，支持SQL查询、结果可视化及看板搭建，并允许共享“spellbook”数据集。
支持多条公链与Layer2网络，具备强大社区生态。

数据应用工具

面向普通用户，提供预设指标与可视化看板，降低使用门槛。
Nansen以钱包标签功能著称，可识别“聪明钱”（smart money）等地址类型，辅助投资决策。
DeBank用于跨链资产追踪，Defi Lama专注于DeFi协议TVL监控。

内容总结

本课程系统讲解了链上数据分析的核心知识体系。首先从数据结构入手，明确交易、区块和智能合约三类基本数据的组成与作用机制，帮助理解链上信息的生成与存储逻辑。接着深入介绍TVL、活跃地址数、交易数、交易量和gas费用五大核心指标，阐明其经济意义与计算方法，为量化分析提供基础。最后，课程构建了完整的分析流程框架——ETL，并据此划分出数据源、数据开发与数据应用三层工具生态，分别对应The Graph/Alchemy、Dune和Nansen/DeBank/Defi Lama等典型工具，展示了从原始数据获取到最终洞察输出的全链路路径。整体内容旨在为初学者建立清晰的链上数据分析认知模型，奠定实践基础。

claude:

Web3数据分析师系列公开课 - 链上数据结构与分析实践

课程介绍

大家好，欢迎来到Web3数据分析师系列公开课的入门基础课程。在这个系列课程当中，我们将从零开始，逐步了解Web3数据分析的核心概念、技术工具以及实际应用场景。希望通过这次课程可以帮助大家打开Web3数据世界的大门，也为大家未来的职业发展奠定一个良好的开端。

如果说第一讲是打开区块链世界的大门，那么这一讲主要是帮助大家进一步去理解链上数据的构成和链上数据分析的基础知识以及具体的操作路径。具体来说，这一讲内容主要是带大家去深入了解区块链的核心的数据结构，探索链上数据的存储和交互方式，同时我们也会一起梳理常见的数据指标，并且去对一些主流的链上数据分析工具做一些概览。

我是今天的讲师王烨，也很高兴能负责这一系列课程前两讲的主讲。我目前是清华和南加州大学传媒数据科学双硕士在读，曾经有两年链上数据分析工作经验，在清华学生区块链协会Tuba和南加大的学生区块链组织都曾负责过数据分析和搭建看板的工作。我还曾在Optimism官方的数据分析师集体作为核心贡献者。无论是从技术上还是做策略的研究，我都希望用扎实的数据支持去解读区块链活动的复杂性。我的一些个人主页都在下方，欢迎大家如果有问题或者有想要探讨的，可以随时与我联系。

课程结构

这一讲主要分成三个部分：

第一部分：链上数据结构的介绍
包括链上数据的基本类型，比如交易数据、区块数据、合约数据，以及这些数据在区块链当中的存储方式。我们可能会通过一些具体事例去帮助大家更直观的理解链上数据涉及到哪些字段，以及他们是如何组织、存储和呈现的。

第二部分：常见的链上数据指标介绍
他们和传统互联网的数据分析指标还是有着比较大的不同，大部分要么是Web3独有的指标，要么是只有在Web3的世界才能够被公开进行分析的指标。例如总锁仓量、活跃地址数、交易量、gas费用等等。我们不仅会讲解这些指标的含义，还会探讨他们在链上数据分析当中的实际应用。

第三部分：链上数据分析流程和工具的介绍
我们可能会聚焦到链上数据分析这个ETL的过程，包括数据的抽取、转换和加载。同时我们可能会介绍几个常用工具，包括Etherscan、Nansen和Dune，然后我们也希望能够通过几个例子去展示怎么样去利用这些工具来进行链上数据分析。

第一部分：链上数据结构

链上数据结构它定义了区块链当中信息的存储和交互方式，与传统的Web2数据库还是有着显著的不同。这一部分主要是对链上数据本身的存在类型进行一个讲解。

链上数据的三种基本类型

1. 交易数据

交易数据是区块链当中最基本的数据类型之一，它包含了区块链上所有交易的详细信息。

以Alice和Bob之间的一笔转账为例，当Alice将一定数量的以太坊发送给Bob的时候，这个交易数据就包含Alice和Bob的地址、发送的转账的金额，以及这个交易的手续费以及交易时间等等。

2. 区块数据

区块数据包含了区块链上每个区块的基本信息。这个区块当中，不仅是记录了这个区块的时间戳、这个区块的验证者(也就是矿工或者是验证节点本身)，还包括区块内所有交易的详细信息和这些交易的排序。

在区块数据当中，时间戳就是这个区块生成的时间，而交易排序则保证了这个区块链的顺序一致性。通过区块数据，我们就能够还原出这个区块链的历史，了解每个区块它是如何以及按什么样的顺序构成的，以及其中的交易是如何被验证和记录上链的。

3. 合约数据

合约数据指的是区块链上部署的智能合约代码，这些合约并不是用户交互产生的，而是这些开发者提前就部署好的程序化代码。智能合约的执行逻辑是自动化的，而且是不可以更改的。

合约数据主要是去处理一些链上自动执行的程序，比如说一些去中心化应用(dApp)的交互，以及可能是用户自己发生或者提交的转账等等。像一些DeFi的平台，比如说去中心化交易所或者DeFi借贷，智能合约就控制着这个链上的资产流动和操作的运行规则。

链上交易的生命周期

具体来说，这些交易它是如何产生？又为何会以这样的形式和这样的顺序被记录下来呢？我们需要回顾一下在第一讲当中关于链上交易的机制介绍。

链上交易，它其实就是区块链状态改变的一种主要方式，每一笔交易它都会有一个完整的生命周期，包括创建交易、广播交易、打包交易和确认交易四个关键步骤。

交易创建

用户通过钱包或者是和智能合约交互生成交易的请求
这个阶段，这个交易会包括一些基本信息，包括发送方、接收方以及转账金额等等
这样的一个交易数据会被广播到区块链网络当中

交易广播与验证

所有的节点都会收到这个交易，并且去验证这个交易是否合法
比如说余额是否足够去进行下一步的转账，交易格式是否正确，签名是否有效
如果验证通过了，交易就会被进一步的处理
如果验证失败，交易就会被拒绝

交易打包

当交易收到了，达到了一定的节点验证之后，它就会被进行确认
最终打包到新的区块当中

交易确认

每当区块被成功挖掘并且添加到区块链上的时候，这笔交易才算是真正的完成了最终的确认
这个时候这笔交易的状态就会从未确认变成已确认
也就意味着这个交易被永久记录到区块链上，并且不能够更改或者撤销

因此在这样的一个机制或者说生命周期当中，一条条的交易就构成了链上数据的基本单位。链上数据分析其实也就是基于每条交易数据的基本内容，除了像这个收发方、转账、合约代码，还有一些包括说日志和状态变化等等这样的一个具体的数据内容去进行的分析。

交易数据的详细字段

接下来，我们来详细讲一讲交易数据它可能都包含哪些字段。它其实就是区块链上最基础和最关键的部分，它包含每一笔交易的详细信息。

1. 交易哈希(Transaction Hash)

每一笔交易的唯一标识符
由交易内容本身去生成的一个哈希值
可以把它视作这笔交易的唯一的身份证
有了这个交易哈希，就可以去在区块链浏览器上去查询和追踪这笔交易的详细信息
交易哈希一旦生成，就不能更改，它确保了这个交易的不可篡改性和可追溯性

2. 交易状态(Transaction Status)

表示这个交易是否已经确认和完成，并且成功打包上链
通常会有两种状态：成功和失败(或者说是revert)
成功表示这个交易已经被打包进区块链并且被确认，同时修改了这个区块链的状态
如果是失败或者表现为revert的话，意味着这笔交易并没有通过这个网络节点的验证
可能会由于余额不足或者签名错误等原因导致交易无效，也没有对区块链的状态进行任何改变

3. 区块(Block)

这个交易本身所在的这一个区块的信息
也就是区块号，说明这笔交易被包含在哪一个区块被打包上链的
区块是链上信息的基本单元，每一个区块都会包含若干笔交易和其他的区块数据

4. 时间戳(Timestamp)

表示这个交易被生成或者说被区块链网络接收和确认的具体时间
这个时间戳本身，也就是区块的时间戳
因为在这个区块当中的所有交易，其实都是在同时被囊括进这个区块链上的
通过这个交易我们可以去了解到这个交易发生的时间点，然后可以对它进行一个时间序列分析

5. 收发双方的地址

发送方地址(From)：通常是这个交易的发起者的公钥地址
接收方地址(To)：这笔交易的目标地址
如果只是一笔转账的话，可以很明确的了解到这个交易就是从from地址转移到to地址
但很多时候，其实是用户去和智能合约进行交互所发起的一笔交易
在这个时候，from地址就是用户自己的公钥地址，而to地址大概率是这个智能合约部署的合约地址
这是我们未来在进行具体的链上数据分析的时候，可能要注意的一个很关键的字段

6. 转账金额(Value)

这笔交易转账的以太坊的数量
有的时候如果是这笔交易本身是转账的话，它会有明确的value，也就是这个值
但很多时候如果只是一个用户去和智能合约交互的话，它其实是没有这个转账的以太坊数量的

7. 交易费和Gas费

交易费(Transaction Fee)：用户为发起这笔交易而去支付的网络费用
在以太坊当中，交易费主要是由gas费和矿工费两个组成的，去激励矿工去处理交易
交易费用的高低，直接会影响到这个交易的确认速度
如果希望交易能够更快的被矿工打包上链的话，最好在发送交易的过程当中，可能需要添加更多的优先费用，也叫做Max Priority Fee

8. Nonce

交易发起者账户的一个交易计数器
用于确保每笔交易的唯一性，防止用户在网络当中重复去发起相同的交易
它的值会随着每笔交易而递增，从而避免这个交易的顺序错乱或者是重放攻击

区块数据的详细字段

第二种数据类型，就是区块数据。区块数据是记录交易的基本单元，每个区块可能会包含若干笔交易和其他的一些关键的区块数据，包括说这个区块的哈希、时间戳，以及一系列这个区块头信息，去确保区块链的完整性和数据性。

1. 区块高度(Block Height/Block Number)

一般也就是我们所说的区块号
从零开始，每增加一个区块，这个高度就会增加一
通过这个区块高度，我们就可以确定这个区块在整个区块链上的位置
区块高度越大，代表它在链上就是越深，也可能就是说最新

2. 区块哈希(Block Hash)

这个区块的唯一标识符
和交易哈希有点类似，交易哈希是去识别那笔交易的唯一标识，而区块哈希是识别这个区块的唯一标识
由区块当中的所有信息，包括交易的每笔信息、时间戳，还有前一个区块的哈希等等，通过一个哈希算法去生成的值
区块哈希一旦计算出来，也是一样不可改变的
它是保证区块链不可篡改的关键
通过区块哈希，我们可以去追溯区块的具体内容，并且验证这个区块的合法性

3. 时间戳(Timestamp)

记录了这个区块被创建的时间
区块的时间戳也就是这个区块当中所有交易的时间戳

4. 验证者和矿工地址

完成这个区块挖掘的节点地址
在基于工作量证明(PoW)的区块链当中，矿工是通过去计算哈希解题来争夺新区块的生成权
而在权益证明(就是现在以太坊所采用的PoS)这种共识机制当中，验证者(也就是质押以太坊的验证者)去负责验证这个新区块的有效性
他们可以通过新区块来获得区块奖励，这个奖励本身也就是来自于用户提交交易的时候所支付的交易费用

5. 区块当中的交易列表

每一个区块当中可能会有一系列的交易
比如说我们在区块当中可以看到它一共有80笔交易和有一个合约内部交易、内部转账
这个区块本身包含了这80笔交易
在区块数据当中，它就包含了这80个交易的列表，去记录了这个区块当中所有的成功交易

6. 区块的Gas费

记录了所有交易的总gas的消耗量
通过这个gas费用的计算，我们也能够去更好的分析这个区块链的网络状态
也就是说它是否拥堵，因为在网络拥堵的时候，用户可能会要去支付更高的gas费，去确保这个交易能够被矿工尽快的打包上链

智能合约数据的详细字段

第三类数据，就是智能合约数据。正如我们在第一讲当中所介绍的，智能合约它的本质就是代码上链，也就是开发者把自己已经写好的这些合约代码部署在区块链上，然后可以在区块链上自动执行。

也因此，智能合约数据它是区块链上的一类特殊数据，因为我们是没有办法在Web2的世界当中看到这种存在数据库当中的代码。它其实就是通过预先定义好的代码，在区块链上自动去执行一些合约条款，然后还能够在网络当中去实现去中心化的交易和服务。

1. 合约地址(Contract Address)

智能合约数据当中的唯一标识符
开发者在部署这个智能合约的时候，就会生成一个合约地址
通过这样的一个哈希，我们就能够找到指向这个存储合约代码和数据的地址位置
用户也可以通过这个合约地址在区块链上与它进行交互
比如说用户想要和某一个智能合约进行交互的话，在交易当中呈现出来的from地址就是用户的钱包地址，而to地址就是这个智能合约的合约地址

2. 合约的定义逻辑/函数

合约当中包含的函数，通常是由Solidity或者是其他智能合约编程语言编写的
每一个函数都会负责某一个特定的任务，比如转账、修改状态，或者与其他合约进行交互、调用等等
智能合约的函数通常包括对状态的变更，比如说存储、转账、提款等一系列操作

3. 智能合约定义的事件(Events)

用于合约内部执行时，去记录合约执行的日志信息，并且去允许外部去监听这些事件
当合约执行某一些特定预先定义好的函数或者操作，比如说转账等等，这个事件就会被触发，并且记录下来
这些事件或者说日志会被发送到外部，我们就可以通过这个日志去分析这个交易本身它在做什么

合约事件的重要性
合约事件，它其实就是链上分析当中的一个重要线索，因为我们可以通过去分析这些事件去找到用户和合约交互的关键。

比如说像Uniswap V3这样的一个去中心化交易所，我们可以去监听这个swap(也就是用代币之间的互换)这样的一个事件，去找到这个用户的活跃程度。比如说我想知道用户是怎么样去对USDC和WETH这两个代币之间去做这样的互换，他们互换了多少次？然后他们是在什么时候会达到一个非常活跃的状态。我们就可以通过去监听这个swap事件它所释放出来的日志，去追踪这一个交易操作本身的行为变化。

4. 智能合约定义的变量

智能合约当中存储数据本身的位置
通常是用来存储智能合约的状态，或者说与其他合约交互的时候所需要的中间变量
可以是合约的内部数据，比如说余额、流动性资金池的资金量、借贷池的余额等等
也可以是外部和其他合约交互用的一些参数

变量的应用示例
比如说我们在分析DeFi的协议当中，这个流动性池子合约，我们可以知道这个total supply的变量，可以帮助我们去了解这个池子当中的总资产，并且去预测这个流动性的变化。或者说像有一些借贷合约当中，我们可以去了解到这个loan balance的变量，也可以去监控这个借贷市场的整体的运行情况和借贷者行为。

智能合约数据在分析中的重要性

智能合约数据在链上数据分析当中，它最重要的用途并不仅限于去说这个合约本身的基本信息，而是更多的我们去通过去解析它的函数、监听它的事件以及这些变量，我们可以去更好的获得关于这个用户和合约交互的这样的一些行为，以及这个市场的动态变化，还有资金流动的这些模式的洞察。

所以其实这个智能合约的数据是大家在做链上数据分析进行到更深阶段的时候，一定是要掌握的一个必备的分析技能，或者说关注的数据指标。

第二部分：链上数据分析的核心指标

在了解了链上数据有哪些，包含哪些字段之后，我们接下来要探讨的是链上数据分析当中经常使用的一些核心指标。这些指标能够更好的帮助我们去理解区块链的网络活动、经济行为以及生态系统的健康状况。

在这个部分我们主要介绍四个重要的链上数据指标，包括总锁仓量(TVL)、活跃地址数、交易数以及gas费用。

1. 总锁仓量(TVL - Total Value Locked)

TVL是衡量DeFi(或者说是去中心化金融)生态系统当中资金总量的一个重要指标。它通常表示在某一个协议或者说在整个区块链的生态系统当中被锁定的加密资产的总价值。

TVL通常包括以下几类资产:

流动性池

去中心化交易所当中的资金池
用于支持交易对，比如说像USDC去换WETH这样的一个流动性池
我们可以去监控这个流动性池当中的流动性，到底有多少人在为这个资金池提供流动性

抵押贷款

存入协议当中的抵押资产
有点类似于到底有多少储户在这个银行当中存了钱
存的钱本身就是总锁仓量

收益聚合

用于Yield Farming的协议
通过一些自动化策略去优化收益的资金
有点像我们传统金融当中的比如说ETF基金，或者是一些私募或者公募基金类似
用户把这些钱存到一些协议当中，这些协议去自动实现一些策略或者是自动执行的这些收益聚合
我们就可以通过这样的一个总锁仓量去判断，比如说这个资金规模有多大，或者说这个协议的规模到底有多大

为什么TVL很重要?

流动性与信任度

TVL越高，说明资金的流动性越强
协议的受欢迎程度和用户的信任度越高
有点类似银行或者说基金，储户越多，或者存储的资金量越大，意味着它相对于其他一些小规模的协议或者是项目来说会更有可靠性

增长指标

TVL增加本身也代表着协议的增长和吸引力的增长

市场信号

可以用来作为一种市场信号的衡量
当TVL上升的时候，反映市场对这个生态的信心增强，也就是说大家会急着把钱存到这个协议当中
相反，当这个协议的或者是某一个生态的TVL下降也就意味着资金在流出，或者说市场情绪开始转冷

通过观察TVL的变化，我们就可以从宏观的角度去了解区块链网络的经济活动，以及观察用户行为。这样也可以为投资或者分析决策去提供依据。

TVL的计算公式

简单来说，它就是所有存入这一个协议的资产价值的总额，包含这个币种价值本身，通常会用USD美元或者说用以太坊来计价。

举例说明:
在某一个质押协议上面，用户Alice存入了10个以太坊，而用户Bob存入了20个以太坊，那么这个协议的TVL就是Alice和Bob存入的以太坊总和，也就是30个以太坊。

实际计算的时候，有的时候我们可能会对一些跨链协议进行比较，比如说我们可能要比较一个以太坊的协议和一个比特币或者说BTC的协议。这个时候为了方便比较，我们通常就会用美元，就是统一的法币，比如说USD或者说用人民币去进行计量。这个时候我们就要去实时的查询这个以太坊和BTC价格本身，并且把它换算成等值的USD或者说法币的价值，然后进行跨链的比较。

2. 活跃地址数(Active Addresses)

这个在Web2世界当中，其实就是和活跃用户数是一致的，它是指在一定时间段内至少执行过一次交易的钱包地址数量。

与Web2的区别

和Web2不一样的点在于，Web2的用户的新的注册的用户和最近活跃的用户，一般来说是只有这一个应用程序的开发者，他有数据库，他才能知道。但是在Web3的世界里面，因为这个钱包地址它是链上公开可查的，所以我们可以通过Web3的链上数据分析去找到跟某一个协议或者某一个合约交互的所有的钱包地址，并且对它进行一个分析。

应用场景

在应用当中，活跃地址的数量就能够去反映这个区块链和应用的用户基础，以及去追踪它这个协议的受欢迎的增长趋势。通常也就是说这个活跃地址数的增加，也就代表着这个协议的使用频率增加。

对于一些DeFi协议来说，活跃地址可能就是参与质押、参与一些交易或者借贷活动的用户地址。

计算公式

等于在一定时间段内进行过交易的唯一地址数量。因为可能在某一个时间段内，这个用户可能会重复交易，那么在写SQL查询的时候，我们就要用到distinct这样的一个语句去筛选出唯一的地址数。

举例说明:
比如说在某一个去中心化交易所，或者说某一个DEX的活动当中，Alex、Bob和Charlie他各自进行了一笔交易，那么在这个时间段内，我们就获得了三个活跃的用户地址。

3. 交易数(Transaction Count)与交易量(Transaction Volume)

另外两个衡量某一个链上协议或者说区块链生态活跃程度的指标，就是基于交易哈希和交易资产额的这样的两个聚合的指标。一个是交易数，另外一个是交易量。

核心区别

交易数：关注某一个链上交易的发生频率
交易量：更多的是关注这个交易所涉及到的资产价值

具体定义

交易数：在一定时间段内，在某一个链上发生的所有交易的数量
交易量：这些交易所涉及到的资产价值的总额

如何应用这两个指标?

交易数很好理解，就是说发生的交易数越多，说明它越活跃。

而交易量，其实是更多情况下我们去关注某一个链上协议，特别是DeFi协议。交易量通常会用来衡量区块链网络的活跃程度，它反映了有多少资

产被转移或者是交换。

特别是对于DeFi协议来说，交易量可能包括：

通过这个协议所进行的代币交换(特指像一些去中心化交易所上的在资金池当中的代币交换)
或者有一些质押协议所涉及到的质押操作

交易量，它是评估区块链或者说链上协议的流行程度、区块链网络健康，以及去衡量市场情绪的重要指标。通常而言，越高的交易量，它就反映着网络的需求在增加，也反映着有更多的资金在涌入某一个链上协议。

计算方法

交易数的计算:
比较简单，我们只需要去关注在特定时间段内去统计所有交易哈希的数量就可以了。也就是说对于像一些SQL查询的话，我们只要写一个count函数就可以。

交易量的计算:
这个是指在特定时间段内，所有交易所涉及到的代币数量的价值总和。我们通常可能会用美元这种法币或者用以太坊来进行计价。这个时候特别是像涉及到这种法币的价值，我们就可能还需要去引入这个代币的美元计价，然后进行相乘去计算。

举例说明:
假设Alice、Bob在某一个区块链上进行了三笔交易，也就是三笔转账，分别是转账了2个以太坊、3个以太坊和1个以太坊。那么无论这三笔交易是Alice转给Bob还是Bob转回给Alice，这个时间段内的交易量就是总共是6个以太坊。这也就是交易量，它是不管收发的方向的。

4. 交易费用(Transaction Fee / Gas费)

最后一个想要分享的链上数据指标就是交易费用。在区块链网络当中，每一笔交易都需要用户去支付一定的费用，以激励矿工或者是验证者去将用户的交易打包到区块链上，并且确保这笔交易能够顺利的完成。

在以太坊系列链上，这笔费用通常会以gas为单位进行计量，也因此这笔交易费用会通常被称之为gas费。

交易费用的特点

这笔费用是区块链交易当中不可避免的一部分，它其实也是用户在进行链上操作的时候需要承担的一笔成本。它与以下因素有关：

这笔交易的复杂程度
这一个区块链网络的拥堵程度
用户想要支付为这笔交易的优先级所支付的费用

当网络当中这个交易量增加的时候，这个网络会变得拥堵，那交易费用也会随之上涨。因为用户需要去支付更多的费用，才能够让自己的交易尽快被矿工或者是验证者验证，并且打包进区块。

分析价值

所以我们通常可以去通过观察一定时间内的交易费用的中位数或者是均值的变化，以了解：

这个区块链网络的拥堵程度
它的交易成本
我们还可以进一步的去衡量这个网络的健康状况和用户活跃的趋势

交易费用的计算

以以太坊为例，交易费等于交易使用的gas数量乘以gas的价格。

我们用Etherscan上某一笔交易的数据来解释一下这个交易费用是怎么计算的：

Gas Price的组成:

Base Fee(基础费用):

这个费用是会在区块被铸造之后就会被burn掉，或者说是会被销毁掉的
比如这笔费用是48.81 Gwei

Priority Fee(优先费用):

用户希望说我交更多的这样的一笔类似于小费一样的优先费
让我的交易更快的被这些矿工或者是验证者所接受
比如在这笔交易当中，这个Priority Fee可能是36 Gwei

那么在这笔交易当中，这个Gas Price就会等于Base Fee加上Priority Fee，最后的价格是84.81 Gwei。

最终交易费用的计算:

我们知道了这个gas的价格之后，我们再看这笔交易本身它到底用了多少的gas。假设这笔交易它其实是用了21,000个单位的gas，那么最后它的交易费用就是Gas Price乘以21,000个gas的使用量。

最后算出来的这个Transaction Fee(交易费用)，最后会等于约等于5.94美元。

交易费用分析的价值

通过这个交易费用的计算，我们就可以去：

判断每一笔交易用户所承担的成本
更可以更好的去根据这个交易费用的变化去判断这个区块链网络目前的状态
优化之后的交易策略
我们还可以去进一步的去预测未来这个市场的动态和交易成本的变化趋势

第三部分：链上数据分析流程与工具

在了解了什么是链上数据，它的字段有哪些，以及一些常用的链上数据的分析指标之后，我们现在就正式进入到链上数据分析的实操的流程介绍，以及在这个过程当中我们可能会涉及到或者说使用的一些工具。

特别是什么叫做数据ETL，也就是数据的抽取、清洗、转换和加载过程，以及如何去借用一些主流分析工具，比如说Etherscan、Dune来进行一个数据分析。

数据ETL流程

其实链上数据分析和传统在Web2世界的数据分析的流程相似，我们还是需要进行一个完整的ETL的过程：

Extract(数据抽取)
Transform(数据清洗转换)
Load(加载到数据仓库)

然后最后，我们获得这样的一个数据集之后，就可以依据不同的业务线和观测指标去分析数据，比如说我想要计算这个交易量，或者是去统计这个gas费用的均值，或者是它的中位数。最后去输出一个量化结果，它可以是一个可视化的图表，也可以就是一个数据表，最后可以被用户或者说是被团队内部的一些分析师所解读。

1. 数据抽取(Extract)

数据抽取部分，是整个数据ETL过程的第一步。这个部分包括从区块链的RPC节点，或者是像一些区块链浏览器，比如说Etherscan当中去获取最原始的交易数据、区块数据、日志等等。

这些数据通常是非结构化的日志，它会包含大量的交易信息、区块的状态，还有一些各种各样的event log changes这样的事件日志。这些原始的数据格式，它其实不太适合用来直接进行分析，所以我们还是需要进行一些后续的数据清洗和转换。

2. 数据转换(Transform)

在第二个部分，也就是Transform的部分，由于智能合约在区块链上执行的时候，交易的输入输出和日志的数据，它通常会以16进制，也就是一个hex的格式进行存储，它是没有办法直接去进行分析的。

所以我们这个时候要进行一个叫做合约解析的步骤。

合约解析的过程:

具体来说，它其实是基于这个智能合约的ABI(Application Binary Interface)。也就是在开发者在写这个合约的时候，他就会有一个对应的ABI的生成。

我们可以通过：

如果这个智能合约是开源的话，我们可以在区块链浏览器上读取它这个智能合约的ABI
然后基于这个ABI去把这些hex格式的输入数据进行解码
最后恢复成一些原始的函数、原始的函数参数等等

比如说就像是transfer或者是一些带有签名的这样的一个交易的method。

解码步骤:

第一步：需要找到这个智能合约的ABI
第二步：对它进行一个解码

解码之后，我们就可以获得一个结构化的数据形式，比如说它可能是一个数字，它也可能是一个EOA地址或者是一个智能合约地址，以及可能是涉及到一些字符串等等。

我们获得了这一些解码后的数据之后，才可以进行到最后一步，也就是数据的加载和分析的部分。

3. 数据加载与分析(Load)

我们获得了这些数据之后，我们就可以把它加载到数据仓库中：

可以是SQL或者是关系型数据库
也可能会是非关系型数据库

这个会依不同的业务线或者是分析的指标而定。通常情况下我们可能现在目前用的比较多的还是关系型数据库，所以也都是一般来说会基于SQL进行查询。

然后在区块链的数据分析当中，加载的数据通常是：

智能合约相关的交易记录
或者是事件日志

然后最后我们去基于我们想要观测的不同的指标去进行下一步的筛选和聚合。

实际应用示例:

比如说我们想去分析某一个合约的TVL，也就是它的总锁仓量：

首先我们需要获得这一个智能合约的合约地址
知道这个合约地址之后，我们就可以去这个区块链的RPC节点，或者说从Etherscan当中去拉取这个合约相关的所有的交易信息
然后再通过智能合约的ABI解码，找到所有触发了这个deposit事件的交易的记录
然后进行筛选，我就可以找到所有向这个合约当中进行存款的交易数到底有多少
以及往这个合约当中存款的资金量到底有多少
然后最后我们可以对它进行一个结果的观测、结果的输出

我们可以把它做成图表或者是数据表等等各种各样的分析形式。

链上数据分析工具的分类

基于链上数据的ETL流程，我们就可以把目前已有的链上数据分析工具分成三大部分：

数据源工具(Data Source)
数据开发工具(Data Development)
数据应用(Data App)

每一类工具，都有它特定的作用和它对应的目标用户。

1. 数据源工具(Data Source)

数据源工具，它其实对应的就是数据提取的步骤，它是链上数据生态的一个基础，去提供对原始区块链数据的一个索引。

工作方式:
主要的办法，是通过区块链节点或者是API去访问到这个区块链的网络，然后获得到原生的交易数据、事件日志以及合约信息等这样的一系列非常原始的数据集。

核心任务:
他们的任务就是把这种复杂的原生的链上数据提取出来，并且进行初步的存储和整理，以便后续的分析。

常见的数据源产品:

The Graph:

通过一个去中心化的协议去提供对多个区块链网络的原始数据的访问
开发者可以去快速的对某一个协议进行解析
去建立对应的一个叫做子图(Subgraph)的东西
他们也可以基于这个子图创建API，供后续的这些分析开发人员去写查询，然后获得对应的聚合的指标

Alchemy:

它也是一样的，可以提供类似的区块链节点的服务和API
方便开发者去访问像以太坊网络以及其他像Solana类似这样的大的公链网络的数据

2. 数据开发工具(Data Development)

在完成这个数据源的获取之后，我们要进一步对它进行清洗和转换，那么这部分我们就要依赖到数据开发工具，也就是Data Development。

目标用户:
主要是面向目前有的数据分析师和开发者。

核心功能:
主要是帮助这些开发者去完成数据的ETL流程，也就是把数据源获取的原始数据进行解析、清洗和转换。

在这个部分，我们可能会涉及到：

对传统的智能合约的解析，比如说像基于ABI去解析这个原始的hex格式的数据
我们可以把这些交易状态和事件日志解析成可以用SQL或者是GraphQL这种传统的查询语言可查询的格式
并且去存储在一个大的新的表当中

然后大家可以去后续的进行查询、聚合以及生成最后的数据分析结果。

特点:
这一类的数据开发工具，它可以自由定制的程度会相对来说比较高，因为开发者可以自由的去定义他想基于他自己想要去查询的指标，去写它对应的查询语言。

常见的数据开发工具:

Dune:

主要是基于SQL查询去完成的数据开发工具
允许用户去把区块链上的数据进行加载、查询
最后去转化为一个新的结构化的数据
并且输出成多种各种各样的查询结果，可以是数据表，也可以是图表

Flipside:

也是类似的基于SQL的数据开发工具

当我们去完成了这样的一个提取、清洗和转换之后，成熟的分析结果就可以直接面向普通的用户发布。

3. 数据应用层(Data App)

用户看到的，更多的还是叫做数据应用层，也就是Data App。

目标用户:
主要就是面向普通的用户。

核心功能:
可以将一些复杂的链上数据和分析结果直接转化成一个最后的聚合类的指标，或者是可视化的信息，帮助用户去进行投资决策。

特点:

这类工具主要是以看板的形式去提供它的服务
它的自由定制程度非常低
用户只能去阅读预先定义好的分析的输出结果
很难够说去像数据开发工具一样，用户说我想要自己去定义一个不同的，比如说交易量或者是交易的特定根据特定的交易类型进行筛选和聚合

更多的情况下，它已经就是输出好一个，比如说目前的市场TVL、某一个协议的TVL是什么样的。

应用价值:
这样的工具，它更多的是辅助用户进行投资决策，也是最面向C端用户的应用。

典型的应用:

Nansen:

主要是提供链上地址的行为分析
帮助用户去理解目前的市场动态
广泛的应用于DeFi和NFT领域

DeBank:

主要是帮助用户去追踪目前的链上和跨链的资产的查询
去提供资产概览和账户下面的具体拥有的聚合的数据

DeFi Llama:

主要是提供DeFi协议的TVL这样的一个关键指标
帮助用户去快速了解不同的链上项目的资金状况和目前的市场动态和流向

工具生态总结

通过这三类——数据源、数据开发工具和数据应用，这三类工具，我们可以更好的去了解到目前链上数据的产品生态。根据这样的产品生态，大家也可以去自由的去找到自己比较适合的开发工具所在的赛道。

这些工具，他们目标还是殊途同归，主要是为用户来带来更大的价值。

基于刚刚所说的这三类链上数据产品的形态，其实目前在链上数据分析领域已经有很多不同的玩家和数据产品。他们面向对应的用户类型和所聚焦的赛道已经形成了非常多元化的生态布局。而且目前，其实链上数据分析的生态还在快速发展，不同的工具和产品正在根据其面向的用户群体和需求不断的细分和演化。

无论是数据源、数据开发工具还是数据应用，它们有对应的不同的角色，但是他们的目的还是共同推动链上数据分析的应用和发展。

主流工具详解

基于我们刚刚所提到的三种链上数据分析的工具生态，或者说是赛道的话，我想基于每一个赛道去分享几个它最典型的应用。

1. Etherscan - 区块链浏览器

Etherscan是目前，无论说是开发者或者说是普通的用户，都可以非常方便的去查询和分析区块链上的交易、区块、地址等信息。

主要功能:

交易查询:

用户可以通过输入交易哈希去查看某一笔交易的详细信息
包括说像交易金额、手续费、收发地址等等
对于普通用户来说可以追踪资金流动，还有分析交易的本身的行为

区块查询:

我们可以通过去输入这个区块的高度，或者说区块号
去找到这个区块对应的一些信息，包括它的交易列表、生成时间或者说是时间戳
这个区块的矿工信息，以及一系列的，比如说他所燃烧的gas费用等等
去了解整一个区块链的目前的健康情况以及它目前所消耗的成本，对这部分来讲会非常重要

地址查询:

我们可以去查看某一个钱包账户或者是合约地址相关的信息
比如说我们可以去看到某一个钱包它所目前所进行的交易的记录和它目前当前持有的资产余额
我们可以去跟踪这一个账户下面的资金流向和他的账户情况

智能合约查询:

对于某一个智能合约，通过查询智能合约的地址
我们可以知道这个智能合约当中的一些参数、函数
以及它的，如果这个合约被开源的话，我们还可以看到这个合约的源代码，以及它对应的一些智能合约的ABI
拥有这个ABI之后，我们就可以用一些比如说链上数据的分析工具、一些开发工具去对这个智能合约本身的hex格式的数据进行解析
然后去进一步的分析这个合约本身的这些交互和对应的交易

2. Dune - 数据开发平台

在数据开发赛道，一个最典型的应用就是Dune。Dune它是目前非常受欢迎的一个链上数据分析平台。

与Etherscan的区别:
与Etherscan这样的区块链浏览器不同的是，它能够提供更加灵活和深入的数据分析功能，也是目前在链上数据分析师之间非常非常流行的一个链上数据分析工具。

核心特点:
它目前是一个基于SQL查询的数据分析平台，用户可以去写SQL查询去访问和分析链上的原始数据。

支持的区块链:
目前Dune支持除了以太坊之外，多个Layer 1和Layer 2区块链，比如像Polygon、Arbitrum、Optimism等等链的数据分析。

主要功能:

SQL查询分析:

链上数据分析师可以通过写SQL查询，从链上数据当中去提取和分析
我们可以去自定义查询语句，去针对我们想要分析的具体的链上数据分析的指标
比如说像查询TVL、交易量或者是gas费用等等
我们可以去写，比如说像count、sum这样的聚合的语句
然后用where这样的筛选语句去筛选某一个时间段，或者说针对某一个交易行为的数据结果
它可以帮助我们去获取像交易、区块、智能合约事件和日志等等这样的一个高度自定义化的查询需求
我们也可以根据自己的需求去写更加复杂的，包括说嵌套子函数等等这样的复杂查询

数据可视化:

Dune还支持去把SQL查询的结果去进行可视化
我们可以把这样获取的一个新的数据表去转化成像柱状图、折线图和饼图等等这样的可视化的结果
然后基于这些可视化的结果，我们还可以去搭建一个看板
这样可以去方便向面向用户去进行一个像数据展示或者是趋势分析等等

公共数据库与Spellbook:

Dune还为用户提供了一系列预设的公共数据库
这些数据库除了包含常用的不同的区块链的原始数据之外
用户还可以去开发自定义的叫Spellbook这样的表
我们可以去写好一个已有的查询，然后这样的查询它会定期去自动的运行
就可以针对某一个具体的协议去开发特定的数据集
比如说像Uniswap或者是Compound、Aave这一些特定的DeFi协议
然后基于他们的智能合约的ABI，我们可以去开发一个特定的数据集
然后就方便后续的查询，这样后面的链上数据分析师，他也不需要说重新去写一个新的查询去针对某一个协议进行分析了

社区共享:

我们在创建了这样的一个看板，或者是创建了一个公共数据库之后
我们也可以在社区共享
所以Dune它其实一个比较热门的应用，或者说之所以它这么流行，也是因为它支持这样的一个用户之间的共享
所以它有个非常强大的开发者生态

3. Nansen - 数据应用平台

最后一类在面向普通用户的数据应用层，最突出的一个数据分析工具，就是Nansen。

核心定位:
它是一款典型的面向投资者和分析师的链上数据可视化工具。

核心功能 - 钱包标签:
Nansen，它是以链上地址标签，也就是Wallet Labels这样的一个功能而出名。它提供对各种各样钱包地址的标记和识别，目前也是具有最大的钱包地址的标签库。

通过将钱包进行分类，原本匿名的链上地址会被打上多个标签，比如说像：

智能合约
交易所
Smart Money
基金
重度DEX交易者
NFT收藏家
等等这样的标签。

标签的价值:
通过这些标签，用户可以快速的知道某一笔交易执行的发起的钱包类型是什么样子的，然后方便对一些合约或者项目去进行尽职调查。

同时，是通过追踪一些聪明钱或者是巨鲸的钱包地址的活动，也可以发现更多的市场交易机会。

主要功能界面:
目前可以看到在Nansen的主界面上可以去：

查询某一个钱包的投资组合
看到一些公链或者项目以及代币的市场宏观数据
然后还可以看到一些像DeFi的市场数据等等

此外，Nansen它还提供像这种代币的资金流动以及图表等等，我们就可以快速的知道目前市场的资金流向和目前热的一些交易趋势。

Smart Money - 聪明钱功能:
然后在Nansen的诸多功能里面，它最知名的就是它钱包标签当中的聪明钱，也叫做Smart Money。

拥有聪明钱标签的钱包地址，是指一些在Crypto世界当中精英们的钱包地址，包括：

巨鲸
VC
等用户或者是大户的钱包地址

我们可以通过去追踪这些聪明钱地址的动向，然后去追踪这些巨鲸、重度DeFi玩家或者说一些较大的机构用户，他们的资金的实时动向。然后也就因此可以去优化我们的交易策略。

课程总结

我们本讲的内容大致就是这些。在这一讲当中，我们回顾了：

链上数据大概有哪些类型
他们的数据结构和字段是什么样子的
以及目前常见的一些链上分析的数据指标有哪些
最后，我们回顾了一下链上数据的分析的一些基本流程，以及目前常用的一些链上数据分析工具

参考资料

最后是本讲的一些参考的文章和资源，包括我之前写过一篇关于链上数据分析的市场研报和Dune分析的实操教程，大家感兴趣的话可以进一步的阅读了解。

感谢大家的聆听!

03.数据分析平台精讲_ Dune Analytics

会议介绍了Dune平台作为链上数据分析工具的使用方法，重点讲解了如何查看和创建数据看板、编写SQL查询分析以太坊交易数据，并通过实例演示了交易数、交易地址数和交易费用的查询构建与可视化过程，同时强调了数据验证的重要性以及利用已有查询进行学习和优化的方法。

一、课程介绍与背景

课程目标

帮助具备基础链上数据知识的学员掌握使用Dune进行数据分析的能力。
通过一节课的时间引导学员完成从查看到创建数据看板的全流程。

二、查看Dune数据看板

访问与搜索功能

Dune主页默认展示按趋势排序的数据看板，反映近期用户关注热点。
可通过关键词（如“Bitcoin ETF”）在搜索框中查找相关分析内容。

数据看板示例

展示排名第一的比特币ETF数据看板，包含各机构管理的比特币数量及其市场份额随时间变化的趋势。
支持单独查看特定机构（如Blackrock）的数据走势。

数据交叉验证

建议结合Social Warrior等外部网站对比数据，确保结果准确性。
强调不同分析师可能因统计口径差异导致数据不一致，需多源验证。

三、创建个人数据看板

新建看板流程

在Dune上可创建空白数据看板并命名。
初始状态为空白面板，支持添加自定义或他人公开的查询结果。

组合数据展示

可通过添加多个查询结果（如WBTC供应量、比特币ETF资金流）构建综合看板。
支持调整布局，优化图表显示效果（如放大柱状图）。

扩展学习建议

鼓励学员将自制看板分享至Twitter，并@讲师或OpenBuild账号交流。

四、编写Dune查询

前置知识：区块浏览器使用

以Etherscan为例，了解交易、Gas费用、合约调用等基本信息结构。
关注高频调用合约（如Uniswap、MetaMask Swap）。

查询构建步骤

创建新查询，设定分析目标为“以太坊主网过去30天交易数据”。
使用 ethereum.transactions表作为数据源，包含交易哈希、发起地址、接收地址、Gas价格与使用量等字段。

核心指标计算

日交易数：使用 COUNT("hash")按 block_date分组统计。
日活跃地址数：使用 COUNT(DISTINCT "from")避免重复计数同一地址多次交易。
日交易费用：通过 SUM("gas_price" * "gas_used") / 1E18计算总费用（单位：ETH）。

查询优化技巧

使用 WHERE block_date >= NOW() - INTERVAL '7 days'先测试小范围数据提升调试效率。
添加 GROUP BY block_date并按日期倒序排列结果。
运行后可通过可视化功能生成柱状图、折线图等形式。

五、数据可视化与组合分析

单一指标可视化

将交易数、交易地址数分别绘制成柱状图，观察趋势分布。
发现日均交易约120万笔，活跃地址约45万，表明平均每个地址每日发起2-3笔交易。

多指标对比展示

同时展示交易数与交易费用，采用双Y轴解决数值量级差异问题。
将交易数设为右侧Y轴的折线图，交易费用为左侧Y轴的柱状图，便于比较波动关系。

数据异常处理

当前日期数据不完整可能导致异常低值，可通过 AND block_date < CURRENT_DATE过滤未完结日期。

数值格式化

使用Label Format功能将大数字转换为“1.26M”形式，提升可读性。

六、AI辅助查询的局限性

AI生成SQL测试

Dune提供AI辅助编写SQL功能，但生成的语句可能存在错误（如引用不存在的虚拟表或字段）。
AI可能误认为存在预定义字段（如“transaction_fee”），实际需手动计算。

实际应用建议

AI可作为参考起点，最终仍需人工校验和修改逻辑以确保正确性。

七、扩展学习路径

学习资料推荐

菜鸟教程：提供常用SQL语法（尤其是JOIN操作）详解。
Dune官方文档：介绍平台特有函数及Trino查询引擎使用方法。

底层技术理解

Dune基于Trino（原PrestoDB）引擎，建议遇到复杂问题时查阅Trino文档或向AI模型明确指定Trino语法提问。

八、课后练习任务

练习内容

创建Avalanche和Optimism两条链最近90天的交易数与活跃地址数分析查询。
创建以太坊过去90天的Gas消耗（交易费用）分析查询。
将上述两个查询结果整合至一个Dune看板中进行对比。

分析思考方向

比较Layer2网络与以太坊主网在交易活跃度与Gas消耗之间的关系。
探讨Layer2对主网扩容的实际影响。

提交方式建议

可通过搜索讲师已发布的查询编号（如4475949）获取模板并修改。
完成后可通过私信推特或@讲师/OpenBuild账号提交成果。

Claude:

Web3数据分析师入门基础课程 - Dune使用教程

讲师介绍

欢迎大家来到 Openbuild Web3 数据分析师系列公开课的入门基础课程。我是今天的分享讲师,我的推特中文名叫做表人小郭,是一个链上数据分析师。过去也是我们今天课程主要介绍的产品 Dune 的 Spellbook 贡献者。Spellbook 是 Dune 在 GitHub 上开源的一个关于区块链数据的抽象解析的数据库。

这是我个人在 Dune 的数据看板页面,可以看到我过去做过的一些数据看板,比较早的可能都有像一两年前的 Layer2 的一些数据。大家可以从这个数据看板中看到我过去做的一些数据看板和数据分析。当然很多有一些因为可能比较早了,数据运行可能会有一些问题,但没关系,我们可以从最新的开始看。

今天这个课程的内容会引用一些其他数据网站的教程和数据内容。首先我特别要介绍 Six Degree 之前做的”成为链上数据分析师”这样的教程和课程。这对于很多新了解区块链链上数据的朋友来说,其实是有很大帮助的。可以看到他写的除了从整个链上数据的介绍和内容,包括如何制作 Dune 看板,以及一些 SQL 的写法,还有查询的案例,都制作得非常详细。同学们在课后也可以详细地把这个教程看得更仔细一些。

课程目标与目录

本讲的目标是用一节课的时间让对链上数据有一定基础的同学们,除了平常使用区块浏览器或其他数据产品之外,还能使用 Dune 这个常见的数据分析工具来进行链上数据的数据分析。

课程目录总共分为四块:

如何查看 Dune 上的数据看板
如何在 Dune 上创建一个数据分析看板,组合我们想看的数据
如何在 Dune 里编写我们自己想做的查询,构建数据分析结果
课后习题,作为课程的总结和巩固内容

第一章:如何查看 Dune 上的数据看板

我们先通过访问 Dune 的页面来进行这一章节的学习。

首先可以看到 Dune 的主页自动跳转到了 Discovery,就是数据分析看板发现页面。可以看到它默认的排序是有一个趋势的,会根据最近一段时间内大家可能点击或访问比较多的数据看板来做前排排序。大家可以看到不同的数据展示看板的内容。我有时也会经常从首页里的数据展示看板内容来挑选,或者寻找可能最近今天的热度,包括一些用户关心的数据层面。

我们通过搜索框可以搜索一些关键词,来找到我们想要的数据分析。比如说搜索”Bitcoin ETF”这个关键词。可以看到搜索的查询结果都是相关于比特币 ETF 的数据。左边它其实跟 GitHub 有点像,除了默认的排序外,我们可以通过点赞数对数据看板的点赞数做排序。特别是我们还可以通过创建时间来做排序,来获得其他想要找的数据。

我们看看排名第一的这个数据看板,它展示的比特币数据内容是什么。可以看到这个数据其实做了非常全面并且非常详细的关于所有美国比特币 ETF 现货的数据,包括这些基金运营方管理的所有比特币,按照时间和市场占有率做了数据分析。

在这个数据看板中,我们除了看到这些数据分析结果,还可以研究出什么呢?比如说”Onchain Holding”展示了所有这些机构管理比特币的数字。如果我们想专门看 Blackrock(贝莱德)管理的规模,以及他的时间趋势是什么样的,我们可以先点掉其他选项,单独点开 Blackrock。可以看到从1月10号开始的统计,从200多个直到最新的10月23号,从200个到54万个比特币的管理规模。包括右边关于这个 ETF 的统计,像 Blackrock 贝莱德管理的比特币 ETF 现在在所有现货的市占率已经达到了接近50%。

下面还有更多相关的数据结果,大家都可以从这个数据看板里找到。当然还有不一定是比特币 ETF,还有其他的数据结果,大家都可以从不同的数据分析看板里去看,或者寻找自己想要的数据分析结果。

扩展学习

除了比特币的 ETF,我们可以看一下以太坊的 ETF 数据看板,也是同样的数据分析师 Heliosdobe 做的以太坊数据规模看板。大家看到其实内容有一些相似,但是以太坊的整体增长趋势相对来说还是没有比特币那么波澜壮阔。

从这两个数据之后,我们还要做一个什么事呢?就是可以通过其他的数据网站来做一些数据校验和对比。比如说我们可以看有一个 Social Warrior 这个网站,它也有比特币现货的所有数据,可以看到同样排在第一的也是贝莱德,大概的数据情况。我们可以通过它提供的一些数据,去跟 Dune 上 Heliosdobe 制作的数据看板做一些数据校验和对比,来保证数据的可信度。

为什么这样说呢?因为在使用 Dune 的过程中,这些数据看板的提供者其实都是普通的数据分析师用户。有些数据分析师在进行数据看板制作的时候,可能因为统计口径的不同,或者因为数据结果分析的逻辑不同,导致数据可能跟你实际想要的数据结果是不一样的。这时候就需要去做一些多层次的数据校验,来保证数据的真实性。

比如说像一些其他 DeFi 的数据看板,我们可能会更多地去用 DeFi Llama 或者其他数据平台去跟 Dune 这边想要的数据做一些对比。从这个对比中获取到更真实的数据。这也是我们未来在使用 Dune 这个产品中需要去注意的一个环节。

第二章:如何在 Dune 上创建数据分析看板

我已经先制作了一个看板,我们可以看一下。这边介绍一个小技巧,就是如何搜索某一个作者创作的看板关键词?通过”author”这个关键词,然后去寻找。

这是我们自己新创建的一个数据看板,创建的时候是在这边来完成的,我们可以对看板做一个命名。创建完之后,它其实是一个空的板。我们可以先移除掉这两个数据,来看一下创建完之后它是一个空的数据看板。

但是我们可以通过增加数据分析,除了自己创建的查询之外,也可以添加别人的查询来做数据分析。比如说它默认会添加我们自己的这一块,我们先添加一个我自己制作的 WBTC 的 Supply。我们把柱状图填上。

然后我们可以通过查询别人的数据分析结果,在我们自己没有做很多查询的情况下,也可以通过添加别人的数据分析结果来组合成我们想要的看板。比如说我们还是查”Bitcoin ETF”,可以看到有比较多的数据结果。我们可以加一下 Heliosdobe 之前做的比特币数据结果,比如说加这个地址数的统计。

我们现在等于是已经创建了自己的数据看板,其实可以在他的数据看板中把他现在目前数据看板中已经有的数据结果添加到我们自己的数据看板,来做一个结合。比如说把比特币的数据看板和以太坊的数据看板做一个结合。怎么做这个数据结合呢?我们可以先打开它的数据查询结果,我们想要的是这个数据可视化的结果来添加到我们的内容里。

可以看到,我们可以通过添加不同人的数据查询结果来组合成我们自己想要的数据看板。当然大部分时候,其实我们还是会使用自己的数据查询结果来组合,这边只是对整个数据看板的制作来做一个学习。

我们还可以在看板中调整它的布局,来达到我们更想要的结果。比如说我们可以把数据结果做一个调整,把柱状图调整为更大的数据结果来看,展示效果会更好。这就是我们数据看板的内容,如何通过已有的数据查询结果来组合成我们自己想要的数据看板。

扩展学习路径是,如果你有一些比较好的通过自己想法来创建的组合数据看板,可以在推特上留言,把数据看板制作出来的链接或数据看板最后结果来艾特 Openbuild 和我,这是我的推特 handle。

第三章:如何编写 Dune 查询

这也是本节课程中比较重要的部分,就是如何来编写 Dune 查询,来制作你自己想要的数据。

在编写 Dune 查询的前提下,比较重要的前置学习是如何使用区块浏览器。我们通过访问 Etherscan,就是以太坊上最流行的区块浏览器来看一下区块浏览器的数据结构。比较简单的结构还是通过搜索框来搜索地址和交易数,包括 Token 的名字来寻找数据结果。

我们可以看一下,比如说在 Gas 这个页面,Gas 是以太坊上对于整个网络支付使用的以太坊作为本身费用的场景。可以看到这边做了一个被调用最多的,就是花费最多 Gas 调用的这些合约数据,可能是一些什么样的 Token。并且把合约做了一些标签备注。可以看到比较活跃的都是跟交易相关的,比如说 Uniswap 的两个交易路由合约,还有 MetaMask 自己做的 Swap 合约。

我们回到 Dune 这边,今天来做一个什么样的查询呢?我们接下来做一个以太坊链上的数据分析查询。首先点到”Create”创建一个新的查询,前面是创建一个新的数据分析看板,这两个是不同的。我们点到”New Query”创建一个新的查询。

今天查询的内容,先给它写个备注:”分析以太坊主网网络过去30天的交易数据情况”。这里面大概包含什么内容呢?

过去30天每天的交易数是多少(日交易数)
日交易地址数,就是有多少个地址每天发起的交易
日交易费用,就是我们前面介绍的以太坊的 Gas 这一块

如何编写查询

接下来如何编写这个查询是比较重要的环节。我们可以用左边的数据浏览器,这边是比较活跃的一些数据表,比如关于 Trading 的数据或 DEX 的数据,或者还有一些资产的数据都在这边。

我们今天要用的一个表是 Raw Blockchain Data,就是原始的区块链数据。可以看到它有很多很多的链,不同的链都可以使用它的原始数据表来进行数据抽象和解析。我们今天教程里用的是以太坊,点开 Ethereum,可以看到这边有八张表。但是实际上里面真实的表只有五张,因为有一些是 Decoded 的表,就是在原始表上做了数据解析的过程。还有 Creation Trace 就是对一些创建的 Trace 内部交易进行了数据解析。

因为以太坊有 Beacon 链的情况,所以多了一张提款数据表。除了这张是以太坊比较独特的表之外,其他的 EVM,比如说 Arbitrum、Optimism,或者说不是 Layer2 的 EVM 像 BSC 或 Polygon,他们原始的表其实只有四张:

Blocks 表(区块表):把所有区块的大致数据情况做了解析
Transactions 表(交易表):把每一个区块里所有交易的细节做了数据解析
Trace 表(内部交易表):把每笔交易里除了交易发起方之外,一笔交易里产生的内部转账也做了更细致的数据解析
Logs 表(日志表):关于一些合约方法的记录,比如我们常用的以太坊 ERC20 的 Transfer(转账)或 Swap(交易),都是要用 Logs 表来进行数据解析

我们今天因为分析的是以太坊主网的交易数据,所以用到的是 Transactions 表。

可以看到我们可以快速阅读这些表的结构和表的数据,它大概长什么样子。大家可以看到,比如说我们可以看到用这个哈希值,然后在区块浏览器迅速找到这笔交易的详情。比如说我们可以看到发生的时间、发生的区块,包括当时转账的费用和使用的网络费用花费了多少,还有报的 Gas Price 就是发起交易时候的网络费用报价。特别是区块链浏览器还提供了一个很有意思的数据,就是当时这个区块交易发生时以太坊本身的价格,可以看到当时是1.39美金,这是2015年的数据。

我们对这个表进行一个初步的每一个数据的理解,可能需要大家花一点时间。我们回到交易课程的内容,这个交易数和交易地址数和日交易费用这一块。

编写查询语句

如何做一个这样的普通查询呢?

1
2
3

SELECT *
FROM ethereum.transactions
WHERE block_date >= now() - interval '7' day

我们现在首先要分析过去30天的情况,所以要先做一个过滤,通过 WHERE 这个函数来做过滤。可以看到它这边有两个时间函数,一个是 block_date,它的参数是日期;还有一个是 block_time,特别是这个是它的分区索引,我们可以通过分区索引来达到更快的过滤效果。为了今天比较好理解,我们其实可以先用 block_date 来过滤,会比较简单一些。

block_date 大于等于,有一个函数叫 now(),通过 now() 来控制。比如说过去30天,我们可以先写一个7天,来达到一个比较快的调试程度。这个是 Format Query,可以把它快速格式化一下,我平常比较爱编写完 SQL 来调整一下,这样我们能阅读得更清晰一些。

我们回到主题来,就是以太坊主网网络30天的交易数据情况:

首先想知道每一天发生了多少笔交易,所以要先把 block_date 放在上面,每一天发生了多少笔交易。交易数是通过什么呢?通过 COUNT 函数来 count 这个 hash,来知道每一天发生了多少笔交易。我们用双引号,Dune 的 SQL 引擎底层是 Trino,所以定义列名用双引号。有一些其他查询引擎可能用单引号来控制,当然要根据不同的使用平台,使用不同的查询引擎,可能在函数和格式上要做一些微调。但是大差不差,我们可以通过普通的 SQL 来达到一样的效果。我们给它写成”日交易数”。

第二个是日交易地址数,如何来定义呢?我们可以看到每一笔交易都有一个 from 和 to,就是发起的地址和接收的地址。我们通过不同的 from 来定义。因为有些地址一天可能发300条或500条交易,但从用户数角度来说,其实只能算一个用户。所以我们通过不同的 from 来分析每一天以太坊主网上有多少活跃的地址。

这里面要用一个 DISTINCT 函数来做区分。我们看 from 这里有个小的注意细节,这个 from 跟其他函数一样都显示成绿色,在编译器里显示成绿色是因为 from 本身是 SQL 的查询里的表来源函数。所以它在查询里会被识别为 SQL 的查询函数,导致运行没办法正确完成,所以我们要给它加一个标注,把它定义成一个列名。我们写成”交易地址数”。

第三个是日交易费用,这个需要对以太坊数据结构有一些理解。我们回过头看一下这笔交易,可以看到这笔交易当时总共花了0.00670093个以太坊。

以太坊的交易费用是从哪里得来呢?它其实是从 Gas Price 的报价乘以 Gas Used,就是 Usage by TXN。可以看到 Gas Limit 是在申报这笔交易时填写了90万个,这个是 Wei,是以太坊更小的数据格式。这个怎么理解呢?我们可以看到像50 GWei,它其实为了让以太坊显示得更齐全,本身等于零点后面8个0然后一个5的以太坊。为了显示得更容易阅读,所以把不同的单位做了区分。包括这边也是,它其实也是一个很小的值,但为了扩展显示,为了方便阅读来显示比较大的扩展。

我们回到这里来,它这个0.0067093是怎么得来呢?是通过 Gas Price 乘以 Gas Used 得来的。比如说我们可以看一下50乘以134186,可以看到是6709300,跟我们这个0.00670930差的是多少呢?其实它差了1E18,除以1E18,它其实就是除以9个0,得到的结果就是0.0067093。这就是这笔交易当时使用的费用。

可以看到,当时的费用其实就是以太坊交易费用不是说它的交易费用贵,而是以太坊本身的价值现在在不断提高。可以看当年发起一笔转账交易的费用,其实是远小于0.01的。

我们回到 query 里来,它其实是运用一个什么呢?是 SUM 这个函数,就是统计所有的每笔交易的 Gas Price 和 Gas Used 的乘积,然后来得到以太坊数量。因为它有一个数量的转换,所以我们要除以1E18,因为是两个9,所以是除以18。除了这个除以18这种比较简约的函数,其实我们还可以写成这样的格式,它其实也是18个0的格式。我们写成”交易费用(ETH)”。

目前看上去是写完了,但是这里有一个注意细节,需要先 GROUP 一下。为什么呢?因为我们需要统计每一天的,因为用到了这些函数的话,需要先去把每一个天作为一个单独的组别去看待,所以这里需要用到 GROUP BY。

然后我们再进行一个排序:

1	ORDER BY block_date DESC

让数据查询结果显示得更容易阅读。最后我们还是一样格式化一下这个 query,让数据情况更容易阅读。我们检查一下,没问题,然后运行一下。

这里为什么先写7天呢?因为7天的数据更小,可以看到我们这样运行的话,3秒就运行出来了,因为它总共在数据结果上花的时间更少。可以看到不同七天的数据情况。看我们这个查询是没有比较大的问题的时候,我们来调试一下这个查询。我们现在可以把这个7天改成30天,然后再运行一下。

因为如果你超过30天或者使用整张表扫描的话,它的整个数据结果会更大。所以当有些时候数据运行不出来的时候,其实可以多用这个 WHERE 或者过滤函数来调整你想要的数据结果,因为有些时候数据运行的结果过大,导致它没有办法查询出来。

可以看到它现在查询的结果是一个表格的状态显示。那我们如何让它形成一个可视化呢?通过这个按钮,就是新的可视化的选项。

创建可视化

首先先用一个柱状图 Bar Chart 来显示,可以看到这个是交易数的形式。可以看到比较平均,以太坊每一天大概交易数量大概在120万到130万之间,是一个比较平均的状态。我们可以把这个表重新命名一下,叫”交易数”。可以看到它整个的命名就变了。

我们再新生成一个柱状图表,把 Y 轴的交易数调成交易地址数。可以看到不同的情况,就是说前面我们可以看大概是120万左右,但是日交易地址数只有46万或47万、40几万左右,那就是说如果按平均来看,其实每一个地址大概平均每天要发三笔交易左右。所以可以看到这个数据分析的结果是比较有意思的。

所以可以看到,包括还有一些很多其他区块链说自己每一天活跃有几百万真人或几千万真人,其实我们可以看到从以太坊这个相对活跃的网络来看,它每天活跃的地址数才40多万。这个地址背后其实还有可能是同一个实体操作的不同地址,比如说之前的空投工作室或者一些归集的程序。所以它本身日常活跃在区块链上,可能大概只有10万到20万之间的活跃用户情况。

当然其他的链,目前来看以太坊还是在公链这个层面,虽然说从价格和市值层面跟比特币还是有差距,但是从公链这个层面来说,以太坊目前来说还是一个最大的区块链,它的活跃数相对来说还是一个比较不是在宣传中有那么多的数量的。这是一个交易地址数的情况。

然后我们再来创建一个新的数据分析查询结果。把这个改成交易费用。可以看到每天的交易费用产生了一些波动,因为每天的网络负载情况是不一样的。我们把这个改成”交易费用”。

接下来我们做一个数据组合,就是把交易费用和交易数来做一个组合,来看看它的展现情况是什么样。同样也是添加一个 Bar Chart 柱状图。

这时候我们把交易数和交易费用同样放在 Y 轴,它呈现了一个这样的状态,其实看起来是不太好阅读的。这是因为什么呢?因为两个柱都是产生了放在了一起。其实我们这时候可以通过下面的前端调节代码,把交易数这一行这一列来调成线(Line),把柱调成线。可以看到做了一个区分,但是其实也是产生了只看到线没有看到柱的情况。这是因为什么呢?这是因为这两个数据的坐标轴差距太大,可以看交易数有100多万,但是每一天的交易费用以太坊数只有3000多。

我们怎么样来调整让它更好阅读呢?通过添加一个嵌入一个新的 Y 轴,可以看到这边就出现了 Y 轴的左右调节。我们把交易数调成右边的 Y 轴,添加两个对比轴,可以看到它就出来了一个比较容易阅读的结果,就是通过这个我们可以让交易数比较平均的情况下,但是交易费用产生了波动。

这边出现一个什么问题呢?就是25号就是我们今天课程录制的时间,因为他没有完结,所以说现在只运行了一半,这一天的数据结果是不完全的,所以它进行了一个比较大的下降。

那我们怎么来调整掉这个值呢?就是我们在这里再加一个过滤结果,在查询里:

1	AND block_date < current_date

可以看到就是我们把 block_date 这个日期这一列,来小于今天,来得到所有昨天和之前几天之内的结果。

我们重新格式化一下,调整一下,然后重新运行一下。可以看到就把这个比较极端的过滤值调整掉,我们可以看到交易数就比较正常的情况。我们对这个查询结果做一个命名,叫”交易数和交易费用组合分析”。可以看到,这边就得到了一个这样的数据查询结果。

我们可以看这边还有一个小小的技巧,就是如何让这个比较大的值,我们可以看128万这个数字,其实它有时候如果数字太长,其实不好阅读。这边有一个 Label Format,就是对于这个整个函数做一个格式化处理。我们可以用一个常见的数据格式化函数来处理,处理完之后它就变成了1.26 million,其实就是100多万这样的值。当然每个人可能因为刚开始接触这种格式化,可能在阅读上可能有一些不是那么快理解。每个人可以根据不同习惯来做格式化的阅读。

最后的最后就是不要忘记把这个 Query 做一个查询的保留。做一个命名,比如”Openbuild Test”,我们对这个查询结果可以放一下内容。它就可以变成了一个这样的查询,我们未来就可以在自己的数据里查到这样的结果。

当然 Dune

上也提供了一个通过 AI 的方式来运行你的 SQL。我用得比较少这个功能,但我们也可以做一个测试,看一下它这个 AI 是不是那么智能。

我们同样放到这里来,让它来运行一下试一下。可以看到它给的一个结果,其实还是比较不错,但是这里出现了一个问题是什么呢?可以看到它这个表名其实是虚拟的,根本不存在的。并且因为它是英文的结果,其实可以看还有这个 Transaction Fee,它很快速地理解成这个表里默认就有这个字段。当然就是说这个只能说这个 AI 目前来说只能给我们一个数据书写的参考,但是最后的命名还有最后的数据结果,都还是需要我们自己个人去研究这个数据结果来进行分析。比较有意思的。

当然就是大家可以看个写法,对吧?实际上它是运行不出来的,所以说这个 AI 目前来说可能还没有达到那么智能的一个状态,在 Dune 这边来说。

生成可视化之后,我们其实在前面的内容中介绍得比较多了,然后到我们下一站。

扩展学习路径

扩展的学习之路是什么呢?

第一个,这些 Dune 的或者说 SQL 的函数,其实我们可以用菜鸟教程。我刚开始学习 SQL 也比较常用,就是这个菜鸟教程会介绍非常多 SQL 的使用方法。当然在 Dune 上我们只能用查询语句,是没有办法用到插入和删除语句的。大家可以,当有一些函数记不起来,或者说有些方法记不起来,除了问 GPT 或者说问其他的 AI 模型之外,也可以来这个菜鸟教程里去查一查自己想要的一些数据结果。特别是这个 JOIN 这一块,其实它给的这张表是非常有意思的,就是告诉你不同的 JOIN 它最后得到的数据表结果是如何去获取的。

第二个,还有一个就是 Dune 的产品文档。可以看到不同的函数有不同的很多方法,像我们前面用这个 COUNT 函数,我们就可以通过这里面去找它函数的使用方法,还有一些其他的,最后出来的结果。可以通过 Dune 的文档。

第三个,我们在前面查询的时候也介绍了,就是 Dune 它的数据查询的底层,目前现在查询的底层用的版本是 Trino 这样的开源查询引擎。它是 Facebook 开源的 Presto,通过 Presto 做了一个开源版本,现在目前比较流行的大数据分析引擎。当遇到一些查询有问题的时候,其实也可以通过 Trino 的文档里来寻找一下你问题的情况。包括你在给 GPT 提问的时候,你也可以特地去,因为有些 GPT 它可能并不太清楚 Dune 的查询引擎,但是你可以用 Trino 的查询引擎的语法来问问他,应该如何在 Trino 的查询引擎下,如何使用这个大致的查询数据的描述,来得到一个 SQL 的数据示例。

章节回顾

最后我们回到最后的章节回顾,就是如何使用区块链浏览器来查阅技术数据,通过 Dune 使用 SQL 来编写查询,最后生成数据分析。

大家一开始可能从零开始写,可能对大家来说都有一些困难,那其实没关系,我们可以通过其他分析师的数据结果,通过复制来修改它里面的一些函数或者说参数,来达到自己想要的数据分析。一步步通过这样的训练来达到最后会有更多自己的思考结果,或者说想要拿到自己可能有更多想分析结果的逻辑上,会逐步地成长。

课后小习题

最后来到我们课后小习题的内容。小习题大概是什么呢?其实跟我们过去第三节的时候介绍的如何做数据分析查询的情况是比较类似的。

小习题的内容是:

创建 Arbitrum 和 Optimism 最近90天的链上交易数和地址数分析,并把它们进行对比
创建以太坊过去最近90天的 Gas 使用量(交易费用)分析
创建一个 Dune 看板,把这两个查询形成的数据可视化放在一起来进行数据对比

最后我们得到一个什么样的逻辑呢?就是思考一下这些 Layer2 的数据活跃跟以太坊主网之间 Gas 消耗和交易费用之间的关系。

大家如果在练习的过程中不知道怎么写,或者说不知道怎么开始写,其实可以回到我们这个课程,甚至说在我们的搜索框里来搜索我们目前的查询。这个查询的结果可以通过查询编号 4475949 来获得到我们这个查询。同样也可以通过我们前面介绍的方法,通过搜索我这个分析师的名字,”author:”然后分析师名字,然后搜”openbuild”。

可能命名上有一些问题,它可能太长了,我们就把它改成”test one”。它可能刚保存,所以可能还没进入搜索库。没关系,我们可以通过搜索这个 4475949 这个 Query 来找到我们今天课程的数据编写情况,然后可以通过对我这个 SQL 进行改写来获得我们这个课程的小习题。

最后这个小习题的提交,因为现在我在录制的过程中并不是太清楚最后提交的方向,这个可能可以在课程最后可以去询问一下最后提交的可能是表单,也有可能是在课程的页面上可以提交。

也没关系,甚至来说你可以私信我的推特,或者说在推特上做完之后也可以来艾特我,来艾特 Openbuild 来分享给我们,都可以的。

课程结束

好,今天的数据分析,Openbuild 的数据分析师公开课,Dune 的使用教程就到这里。谢谢大家。

这是我的推特 handle,大家也可以关注我,或者说遇到一些数据分析,或者说区块链相关的行业内容,有些疑问的也可以随时在推特上私信我,或者说推文中艾特我都是可以的。只要我看到一定会为大家解答。

谢谢大家!

04. 数据分析平台精讲_ Zan 简介与应用

05.以太坊数据分析

会议介绍了以太坊的基本概念、数据结构及数据分析方法，重点讲解了区块链作为链式数据结构的特性、智能合约与以太坊虚拟机（EVM）的作用机制、交易执行流程以及gas在计算资源消耗中的衡量作用，并演示了如何通过ethers.js和ECRM ETL等工具读取并处理链上原始数据，实现对区块、交易、日志及ERC20代币转移的结构化提取。

一、以太坊基础概念

区块链数据结构

区块链是一种按时间顺序打包交易并通过密码学哈希算法连接形成的不可篡改链式结构。
数据由P2P网络中的节点通过共识算法共同维护，确保对新增区块或分叉选择达成一致。

智能合约与EVM

智能合约是用Solidity等语言编写、编译为字节码后部署在区块链上可执行的功能模块。
以太坊虚拟机（EVM）是一个基于堆栈的虚拟机，用于保证代码在不同节点上执行结果一致。
EVM支持图灵完备的指令集，允许循环等复杂逻辑，因此需引入gas机制防止无限执行。

原生代币与激励机制

ETH是以太坊的原生代币，作为参与共识过程（如验证者质押）的奖励，激励用户贡献计算与带宽资源。
ERC20代币是基于智能合约创建的应用层代币，遵循特定协议标准，与共识激励无关。

二、交易与数据变更机制

用户参与方式

参与区块链数据维护或修改的唯一途径是发送transaction。
节点运行需下载全部历史数据并可能质押ETH成为验证者，方可参与区块提议与投票。

交易传播与执行

用户发起的transaction在网络中传播并进入各节点的内存池（memory pool）。
节点从内存池选取交易构建候选区块，但只有经共识确认的区块才会被接受并写入本地数据库。
未被选中的候选区块及其包含的交易将被丢弃，不产生状态变更。

内部交易说明

内部交易并非独立交易，而是用户transaction在执行过程中调用多个智能合约时产生的中间步骤。
所有内部交易均由外部transaction触发，不能凭空生成。

三、区块与数据结构分析

区块组成

每个block由header和body两部分构成。
Header包含parent hash、transaction hash、receipt hash和storage hash等字段，用于验证合法性。
Body主要包含transaction列表，其余两个列表在分析中较少关注。

关键哈希字段

transaction hash是交易列表的Merkle根哈希，用于验证交易完整性。
receipt hash是交易执行收据的根哈希，记录执行结果。
storage hash反映世界状态（world state）的变化，是后续分析的重要目标。

四、Gas机制与执行成本

Gas的作用

gas用于衡量交易在EVM中执行所需的计算量，防止因图灵完备性导致的死循环问题。
比特币使用脚本大小限制计算量，而以太坊采用gas机制进行更精细的控制。

Gas消耗与费用

每个操作码（opcode）对应固定gas消耗值，总消耗为所有执行步骤之和。
gas price表示每个gas对应的ETH价格，结合gas limit设定最大可消耗资源。
实际费用由gas used × gas price决定，并可能包含额外支付给矿工的优先费。

执行环境组件

program counter指向当前执行的操作码位置，类似CPU指令指针。
stack用于存储执行过程中的临时变量，memory保存运行时数据，二者均不持久化。
Virtual room存放智能合约字节码，world state保存账户余额、合约变量等全局状态。

存储成本差异

对storage（world state）进行读写操作（sload/sstore）消耗较高gas（如100单位）。
memory操作（mstore/mcopy）仅消耗少量gas（如3单位），适合临时数据处理。

五、链上数据分析实践

数据读取工具

推荐使用ethers.js（TypeScript/JavaScript库）和ECRM ETL（Python工具）进行链上数据提取。
其他常用工具包括web3.py和The Graph，适用于流式数据处理场景。

API接入方式

可通过本地运行Geth节点获取JSON-RPC接口，或使用Infura、Alchemy等第三方服务商提供的API端点。
使用.env文件隐藏敏感信息如API key，保障安全性。

数据获取示例

利用ethers.js的provider对象调用getBlock、getTransactionReceipt等方法获取原始数据。
获取latest区块可查看实时链上信息，解析结果包含header、body及交易收据等内容。

结构化数据导出

ECRM ETL支持批量导出指定区间内的区块与交易数据为CSV格式，便于进一步分析。
支持导出transaction receipt与logs（即内部交易），需提供交易哈希列表文本文件作为输入。
工具特别优化了对ERC20代币transfer事件的支持，可筛选特定合约的所有转账记录。

环境配置建议

推荐使用Python 3.9创建虚拟环境运行ECRM ETL，避免高版本Python带来的兼容性问题。
安装依赖包后可通过命令行执行数据导出任务，忽略非关键警告信息即可。

claude:

以太坊基础概念与数据分析方法

课程介绍

大家好,欢迎来到Web3数据分析师系列公开课。我是陈璇,目前在复旦大学大数据学院可视分析与智能决策实验室做博士生。我的研究方向是区块链数据分析与可视分析。今天由我来跟大家讲一下关于以太坊的基本概念,以及在以太坊上做数据分析的常用方法。

今天的内容分三个部分,第一部分是先给大家介绍一下以太坊的一些基本概念。

区块链的三个层面

当我们说区块链的时候,在不同的语境场景下可能会指向三个不同的概念:

1. 区块链作为数据结构

首先,区块链指的是一种数据结构,它是一种按时间顺序打包交易,并通过密码学哈希算法前后连接起来,形成一个不可篡改的链式数据结构。这个数据结构里面的数据不是凭空产生的,而是由区块链网络来共同维护的。

2. 区块链网络

在一个P2P网络里面,不同的电脑或者节点之间通过共识算法去达成一致。这个达成的一致是指我们要对这个区块链数据结构做哪些改变,比如说要给它添加一个新的block,这个block里面包含一些数据、一些交易;或者说在出现分叉的时候,要去决定哪个分叉才是最长链,我们就沿着它继续往下做,另外的分叉就不管了、丢弃掉。这些都属于共识算法要在P2P网络、在区块链网络里面达成的共识。通过共识算法来共同维护区块链这个数据结构。

这个就是最开始比特币的一个基本概念。

3. 以太坊平台

以太坊在这个基本的区块链基础功能上,拓展了智能合约的功能。智能合约是使用Solidity、Vyper等编程语言去写代码,然后把编译后的二进制bytecode部署在区块链上,可以被执行的一个功能。因此以太坊被叫做区块链平台,它的主要作用、主要功能是可以去承载一些代码。通过这些代码就可以去实现一些我们现在常听到的DeFi、NFT这些区块链应用。

以太坊虚拟机(EVM)

我们可以想到一个代码在不同的机器上执行的话,可能会出现一些执行结果不一致的情况。那么为了保证区块链上面的代码在不同的机器上都能够得到相同的执行结果,为了保证共识算法的一致性,我们就需要一个虚拟机来去执行这些区块链上代码,就是所谓的以太坊虚拟机EVM(Ethereum Virtual Machine)。它是一个基于堆栈的虚拟机。

代币机制

又一个问题是:我要去参与到这个共识算法里面,参与到区块链网络里面,要去付出设备成本、网络带宽、计算成本。谁会愿意平白无故地付出这么多成本参与到这个网络中来呢?于是在共识算法诞生之下有了代币之说,就是当用户参与到这个共识算法过程之后,可以给一些TOKEN、一些代币来作为激励。这个也就是ETH这个原生代币产生的背景。

不同于ETH,我们后续分析可能会分析到的所谓的ERC20 TOKEN,它和原生代币不一样,它是使用智能合约来遵守ERC20这个protocol而建立起来的一个应用,它和共识算法的激励没有什么关系。

如何参与到区块链

参与区块链网络

要如何参与到区块链网络中,有两个不同的说法。第一个是你要去如何参与到P2P的网络里面。参与到P2P网络里面的话,首先要去运行一个节点,将所有的历史数据下载下来,然后你才能够基于历史的数据去判断当前的,或者说判断下一个block它是否是合法的。有了这样的一个判断的能力之后,才能够参与到这个共识过程中去。

以太坊现在的一个客户端其实是分为两个部分:一个是共识层客户端,一个是执行层客户端。当你把所有的历史数据都打包下来之后,还需要质押一定的ETH,现在是32个,然后成为validator。成为validator之后,才能够在区块链网络、在这个P2P网络里面去发表自己的意见,才可以去propose一个block,才可以去对别人propose出来的block做一些投票、发attestation。

参与区块链数据维护

第二个说法是我其实不太想把所有的数据都拔下来,我就想去对现有的区块链数据做一些改变。这个所谓对数据做改变是我想要去对上面的一些应用修改一些数据,或者是参与到这些应用里面。现在说要参与到区块链数据的维护中,或者说要对链上数据做某些改变,唯一的途径是发一个transaction。

交易与内部交易

后面有些同学可能会问,智能合约它也可以去发一些transaction。这个我们后面会看到,它是一些内部交易。但是内部交易并不是凭空产生的,它也一定是某一些用户为了改变区块链上的数据发了一笔交易,这个transaction的执行可能会被分为不同的执行步骤,每一个执行步骤就是一个所谓的内部交易。所以内部交易首先不是交易,它是用户发送的transaction的不同的执行步骤;其次内部交易也不是凭空产生的,它一定是由用户发送交易带动起来的。

交易的处理流程

当用户去发送了一笔交易之后,这笔交易会在区块链网络、就是P2P网络里面去传播,然后汇入节点的交易池memory pool里面。谁收到了这个transaction,就把这个transaction放进自己本地的memory pool里面。

然后节点会从自己的交易池里面去选取部分交易构造区块。这个事情是每一个节点都会做的。但是并不是每一个节点自己构造出来的block就会被大家所认可,后面大家还要通过共识协议。

通过比如说proof of work的共识协议,大家所有人去计算一个复杂的哈希,也就是所谓的挖矿。计算完这些哈希之后,谁首先计算出一个符合条件的哈希值,那么他所创造的block就可以被别人所认可。

proof of stake共识算法是通过一些伪随机数算法去指定下一个proposal是谁,那么这个人所构造的区块就会被大家所认可。

当你这个节点作为一个节点在整个P2P网里面,收到了一个符合共识要求的block的时候,通过验证,这个新的block就会被放进你本地的、通过客户端所维护的数据库里面。然后这个block里面所包含的那些交易会被执行,它会改变区块链上的数据。

那么我自己刚才所构造的那个block去哪里了呢?它就被丢弃掉了,因为它没有达成共识,它里面即便包含了一些交易也不算数。

区块数据结构

对于一个区块链来说,最重要的是它的区块里面的结构,我们后续的数据分析也是去分析这些结构。我们以go Ethereum geth为例来说明一下它上面的一些数据结构。

Block结构

一个block分为两个部分:一个header,一个body。

在header里面,它包含了很多的一些来标注这个block它是否是合法的字段,比如说parent hash,它记录了我的父区块的哈希值是什么。只有你的父区块哈希值能够和前一个区块的哈希对上,那么你这个block才能够是一个合法的、被加入到整个区块链链式结构里面。

在这里面我们有几个需要注意的:一个是transaction hash,它是交易树的根哈希;receipt hash是交易执行的收据的根哈希;还有一个storage hash。这三个hash是我们后续将要去分析的目标。

在block body里面,它目前包含有三个list,但是这三个list我们最重要看的就是transaction,另外两个我们不太关心。

Transaction结构

对一个transaction来说,它就是用户用来发送一个交易、用来改变链上结构的一个最基本单位。我们去做数据分析,分析的也是这些transaction的data。

在这些data里面,有一个就是所有gas相关的。

Gas机制

gas是用来衡量以太坊上我发一笔交易,这笔交易要被传播到所有的节点上,如果这笔交易被包含到了一个合法的block里面,它会被所有的节点去执行,它是去衡量这个执行所需要的计算量的。

相比比特币来说,gas是以太坊独有的一个概念。比特币不太用gas来衡量一个交易的计算量,因为比特币所用的Bitcoin script它不是图灵完备的。简单来说,举个例子就是它没有办法写循环,所以它的代码量或者说交易的大小大概就能够衡量它执行所需要的计算量。所以比特币用来限制一个block里面最多能包含多少计算量的方法是去限制它的block大小。

但是以太坊不一样,因为它上面有在EVM里面执行的bytecode,它是图灵完备的。比如说它有循环,我可以用一个非常短的一段代码,让所有的节点陷入死循环里面。那么这个时候我们就不能用代码的大小来限定一个block里面它的计算量多少,所以我们就去使用了gas这个方式。

当你的交易在EVM里面去执行的时候,它会被分为不同的执行步骤,每一个步骤都会标记着它消耗多少个gas。根据它的一个类似于汇编码的OP code(operation code),给每一个operation code都标注了这一步它消耗多少gas。然后在每一个block里面还有一个gas price,就是在这个block的这个时间点,每一个gas它需要消耗多少的ETH。

通过这样的方式,通过限制gas limit,就限制了在这一个block里面,当它被传播到所有的节点上,它的最大的计算量不会太离谱,不会陷入死循环。

Transaction的其他字段

还有一些比较常规的,这个transaction是谁发的,然后发给谁,以及我们需要注意的有一个data。这个data里面它可以包含很多的不同的步骤,每一个步骤、data里面的每一个步骤被拆解出来,它就会形成一个internal transaction。所有的步骤是去,当你要在一笔交易里面去调取不同的智能合约的时候,就需要不同的internal transaction去对合约进行调用。

状态(State)

接下来我们通过block里面的这些哈希,我们就会构造出一个状态。这个状态指的是我们通过执行上面所有block里面的所有的交易数据,最终得到了一个什么样的结果。这个结果包含着某一个人的账户上的余额是多少,它包含着某一个智能合约里面的代码、代码里面某一个变量它的值是多少,这些所有的东西集合起来叫做state。

我们从以太坊的Genesis block开始,它创造了一个最初的state,然后每一个合法的block在它里面的transaction被执行之后,它都会对这个state tree或者说世界状态做一些改变。每一个block它都会对这个世界状态做一些改变,或者是改变某一个人的余额,或者是改变某一个智能合约里面的参数的值,都会对整个世界状态做一些改变。

在区块链网络里面,不同的节点对于共识的达成,它的本质上是大家要达成一个共识来决定这个world state向下一步向哪个方向去改变。

账户类型

这个所谓的world state包含着几个重要的部分,其中有两个部分:

EOA (External Owner Account)

一个是EOA(external owner account),它就是用户用私钥来控制的账户。

合约账户

另外一个是合约账户,是用户因为部署了一个代码之后,这段智能合约代码就拥有了一个地址。

对于所谓的EOA来说,它和我们Web2使用的那些账户不太一样,它的本质上就是一个私钥和公钥的pair,你可以在任何的地方去创建它。比如说我们这里有一段非常简单的代码,就是我用ethers这个库来创建一个EOA的address。

(演示创建EOA地址)

我这样就创建了一个EOA的address。创建这个地址的过程是:首先随机生成一段私钥,然后通过这个私钥在椭圆曲线上计算出来一个公钥,然后取公钥的后面20个byte,那么这个就是一个account。

为了大家方便去记忆自己的私钥(这个私钥千万不能泄露,如果一旦你的私钥被泄露,别人就可以拿着你的私钥,你这个私钥所绑定的EOA account里面的所有的东西都是别人的了,谁有这个私钥就是谁的),为了方便大家记忆这种私钥,我们有一个简单的方法,就是把私钥去分割成11段,每一段通过一个table对应到了一个英文单词里面,所以这样我们就把这样一长串的词对应成了一个助记词。我们也可以通过这个助记词的table,就是单词和这个单词之间的顺序来还原出你的私钥,然后再次计算出你的EOA。

我这里所创建的私钥为什么不害怕泄露呢?因为我只是创建了一个key value pair,这个key value pair没有在以太坊上发生过任何交易,所以在以太坊的这个世界状态里面,根本没有这个EOA所对应、这个key所对应的value。我现在创造出来的这个公钥不存在于以太坊的状态树上。当然也不排除瞎猫碰上死耗子的概率,但是这个概率太太太太太低了。所以我甚至可以在这里多创建几个账户,它每一个账户都是一个key value pair。

对于智能合约来说,也是,以太坊EVM会自己给你智能合约创建一个账户。

EVM执行过程

我们讲了这么多,还是要回到以太坊核心就是EVM上面来说。当我们去部署一个智能合约的时候,我们这边以Uniswap为例,当我写了一段这样的一些智能合约,使用Solidity去编译,我们会把它编译成这样的一些bytecode。你在区块链上部署的东西就是这个bytecode。

这个bytecode每两个byte对应着一个EVM的code,它代表着一定的功能。当然它里面还有一些数据。每一个执行步骤对应着一个gas,就是我们之前说的gas相关的。如果一个transaction的执行过程可以被分割成非常非常多不同的OP code,那么这些OP code加起来的gas消耗加起来就是你的这个transaction消耗的gas,然后再乘以当时的gas price就是你需要付的执行的费用。当然这个费用,这个gas price就是你需要付出的费用中的一部分,还有其他的拍卖机制,你肯定需要多付一些钱来给矿工。

EVM执行机制

对于一个执行的过程来说,面对这样的非常多的bytecode,我需要一个指针来指向现在这个transaction它到底执行到了哪一个地方,那么这个就是program counter。它类似于CPU的指令指针,指向当前执行的OP code到哪个地方了。

执行的过程或者说计算的过程完全是在一个堆栈里面去进行的,所以说EVM它是一个基于堆栈的虚拟机。

gas available是用户在发一个交易的时候,会声明我这个交易最多使用多少gas。在stack里面去执行的时候,每执行一步就在gas available里面去扣除掉。如果扣完了,这里的gas available为0了,那么整个transaction就会回滚,整个transaction就会报错,说你的gas不足,你要么多声明一些gas。

memory是在你的堆栈里面去执行的过程中,会有一些临时的数据存储。当一个transaction被执行过程中产生的memory数据,它是不会被存储到区块链的世界状态上的,它随着交易执行的结束就丢弃掉了。

Virtual ROM存的就是智能合约的这个字节码。

world state就是我们刚才讲的,你的世界状态。所有需要对区块链上的数据进行改变的操作都要去指向world state,要去修改world state上的一些东西,它才能够反映在区块链的数据上。而你的stack里面的执行结果,如果只是存在memory里面的话,它对整个world state是没有什么影响的。

所以我们可以去看一下,跟world state相关的一些计算,它是非常贵的。这个s load、s store就是storage store的意思,给你的storage里面去存储一个什么数据,它的gas price消耗是100;但是你对memory store,就是m copy、m store,对m store的话,它的gas price只需要3个gas。100比3,所以说你对一个memory去操作的话它是很便宜的,你对一个storage去操作的话它是很贵的。

实际操作:读取区块链数据

接下来我们用实际演示一下我们如何去读取区块链上的一些数据。我们读取数据的话,这里介绍两个比较常用的库:

ethers.js - 这个库
ETL - 这个工具

除了我们提到的这两个,还有别的,比如说web3.py(web3加Python,这个是用Python写的一个库),还有比如说The Graph,它对于处理流式数据会比较方便。

我们今天就介绍ethers.js。注意的就是ethers它的版本到了6.0,大家不要再去用之前的5.0的版本了。

使用ethers.js

在我们与区块链上数据交互之前,你需要一个API端口。这个端口你可以去在自己本地去跑一个区块链的节点,使用geth在自己本地去跑一个节点,然后使用自己的本地端口。当然不是所有人都愿意去做这个麻烦的事情,这个时候你就可以使用别的一些提供API的服务商,比如说Infura、Alchemy。

(演示创建API key)

在这里你需要创建一个app,然后这个app就会有一个API的key,然后你把它填到这个API里边就可以了。

(代码演示)

我用Dotenv去隐藏我的API key。然后我们用ethers去创建一个JSON RPC的接口,然后这个时候你就可以用这个provider去读取一些方法来读取链上数据了。比如说它的方法在这里有汇总,你可以搜一下,在这里有说明。

比如get block number,我们运行一下。它返回了当前的block number。我的可能有点延后,我用的是自己跑的节点,它同步得没有太及时。这样的话就说明我们这个API、JSON RPC的端口provider连接是正确的。

然后我们可以去读取一些区块链上的一些交易。我们同样用这个provider去调了get block这个方法。get block方法会返回整个某一个block上面的数据,然后我们可以去用latest这个关键词来抓取最新的一个数据,然后我把这个结果存在了result底下。

(运行演示)

我们看到这里有一个数据,它就是这个block里面的所有的数据。上面部分是它的block header,底下的所有部分是它的block body。这样的话,这个就是一整个block它的样子。

同时我们还可以去读取一些transaction上的数据。我们用了get transaction receipt这个方法,把它写入到了result底下。然后我们就从刚才抓取到的数据中随便选一个,然后读一下它的receipt。

(运行演示)

对于一个transaction来说,它包含了这么多信息。底下的logs就是所谓的internal transaction。它的这个log这么多,看样子是个arbitrage交易。每一个log的每一步都是一个internal transaction。但是还是要强调一下,所谓的internal transaction并不是transaction,它只是一个大的transaction中执行的中间的一个步骤。

使用Ethereum ETL

我们通过ethers去获得的这些block也好、transaction数据也好,它都是区块链上的raw data。我们自己去处理,当然可以从区块链上拿到一手的raw data自己去处理。当然我们也希望有一个更好的工具能够帮助我们把这个block上一些数据整理一下,整理成更加有structure的一些数据,那么这个就是Ethereum ETL这个工具要做的事情。

它是一个开源的工具,是一个Python的包。所以我们首先要装一下这个包。

(演示安装)

先创建一个3.9的虚拟环境。这个库我用3.12去跑了一下,它中间会有一些兼容性的问题,所以大家不要用那么高的版本去跑,用3.9就可以。然后我们进入这个虚拟环境,装一下所需要的,主要是装下这个库。

然后我们现在就可以去运行这个命令。它的命令做的事情是export blocks and transactions,去导出在我们指定的这一段block里面的所有的block和transaction数据。

(运行演示)

把这个block里面的数据,把block information导出到block.csv,把这个block里面transaction信息导出到transaction.csv里面。

我们忽略掉这些warning,然后我们可以看到我们就多了一个block.csv。它就把这些所有的block原始信息整理成了一个CSV文件,这个是这个block里面所包含的所有的transaction。

同时我们也可以批量导出交易的receipt和logs的一些方法,就在这里export receipts and logs。但是这个的话,它需要你首先去构造一个transaction hash的txt文件。

(演示创建txt文件并运行)

那么它就会把receipt放在这里,这两个transaction的receipt,然后这个是在receipt里面所有的log。

这个工具我觉得最好用的一个地方就是它对合约、尤其是ERC20的合约有一些比较好的支持,它可以直接去导出所有跟TOKEN相关的transfer。

比如说我们就导出这81个block里面所有跟TOKEN相关的一些transfer交易。我们可以指定TOKEN,也可以指定多个TOKEN,通过这样的方法去指定多个TOKEN。我们这里就看一下所有跟Curve相关的一些TOKEN。

(运行演示)

在这81个block里面,它只有5条跟Curve相关的token transfer。

这个工具还有别的一些用法,包括一些trace,大家都可以去探索一下。

总结

那我今天就讲到这里,感谢大家。如果有什么问题的话,可以发我的邮箱或者访问我的个人主页。谢谢!

06.链上数据分析平台精讲

Hemera Protocol 是一个以账户为中心的可编程数据索引协议，旨在高效、低成本地处理以太坊链上数据。课程介绍了其核心概念 user-defined function（UDF），通过 Python 编写自定义逻辑，在数据索引过程中实时生成用户维度的数据特征。演示了如何在本地运行 Hemera Indexer，配置参数，并逐步构建一个 UDF 来追踪 ERC721 代币的 Mint 信息。进一步展示了更复杂的用例，如对 Eigenlayer 协议进行数据索引，生成交易事件表和地址维度的资产统计，并强调了从数据库读取历史状态以更新当前数据的能力。最后讨论了性能优化方向，包括批处理、缓存和并行计算。

一、Hemera Protocol 概述

核心特性与目标

是一个可编程的、以账户（地址）为中心的数据索引协议。
目标是简化和加速链上数据的拉取、索引与分析过程。
解决现有第三方工具效率低、成本高以及难以应对复杂合约的问题。

设计原则

将数据聚合到用户（地址）维度，满足大多数实际需求。
提供具有实时性的数据，通常延迟在秒级到分钟级内。
通过构建代码库（library）实现解析逻辑的复用，便于扩展支持新项目。

典型应用场景

区块链浏览器：展示地址维度的交易、资产和代币转移等数据。
资产管理工具：快速查询任意地址在不同项目的参与情况、TVL 和历史交易。
身份识别方案：基于地址行为分析，识别机器人账号或高频交易用户（Power User）。
已与多个 L1、L2 网络及 DeFi、GameFi、NFT 项目合作，拓展数据覆盖范围。

二、User-Defined Function (UDF) 核心概念

UDF 定义与作用

允许开发者编写自定义代码，嵌入到 Hemera Indexer 中。
在 indexer 运行时同步执行，将原始链上数据（如 transaction, log）转换为所需的目标数据格式。
极大降低了开发门槛，开发者只需关注数据转换逻辑，无需处理底层数据获取。

UDF 工作流程示例

Indexer 监测到交易中的 TOKEN transfer log 和 swap log。
触发相应的 UDF（如 balance 统计、巨鲸检测、交易量统计）。
UDF 运算后，实时更新对应地址的特征数据（如余额、是否为巨鲸、交易额）。

主要优势

显著降低开发成本，输入数据由系统自动准备。
效率高，UDF 与索引过程同步运行，结果伴随区块产生。
支持单一 UDF 的测试和针对历史区块的回溯验证。
使用 Python 编程，灵活性极高，可实现任意数据转换逻辑。

三、本地运行与参数配置

运行方式

可通过 Docker/Docker Compose 部署，适合生产环境，便于管理和维护。
也可直接从源码构建运行（build from source），更适合开发和调试阶段。

关键配置参数

provider_url: 必需，配置用于获取链上数据的 RPC 地址。
output: 指定输出格式，支持 Postgres 数据库、CSV 文件和 JSON 文件。
output_types: 指定要索引的数据类型，包括基础数据（block, transaction）和衍生数据（token transfer），也支持自定义的 data class。
postgresql_url: 当输出到数据库时，配置 PostgreSQL 的连接地址。
block_batch_size 和 batch_size: 用于优化性能，前者控制一次处理的区块数量，后者控制批量调用 RPC 的请求数。
config_file: 可将各项参数写入配置文件，方便管理和传入。

四、UDF 开发实践

UDF 基本结构

Data Class: 定义 UDF 的输出数据格式，是一个包含特定字段的类。
Model: （非必需）当需要将数据输出到数据库时，定义与 data class 对应的数据库表结构。
Job 逻辑: 包含依赖定义、过滤器（filter）、处理函数（process）等核心代码。

开发步骤详解

定义 Data Class 和 Model: 创建用于存储 ERC721 Token Mint 信息的 data class 和对应的数据库 model。
设置 Dependency 和 Output: 指定输入数据类型为 log，输出为自定义的 data class。
实现 Filter 方法: 通过指定合约地址和 log topic（如 ERC721 Transfer Event）来过滤出相关日志，减少不必要的数据处理。
编写 Process 函数: 遍历过滤后的日志，解码数据，当 from 地址为零地址时判定为 Mint 行为，并提取 to 地址、Token ID 等信息，构建 data class 实例。
收集与输出: 使用 collect 方法将处理好的数据收集起来，等待输出。

测试与部署

通过命令行运行 indexer，并指定自定义的 output type、起始区块和配置文件。
Indexer 自动处理数据，将结果存入数据库。
可通过 SQL 查询验证结果，例如查询每个 Token ID 的 Mint 地址或统计单个地址的 Mint 数量。

五、高级应用与未来展望

复杂案例：Indexing Eigenlayer

目标: 构建两个数据表，一是记录所有 deposit/withdraw 等操作的“事件表”，二是记录每个地址在各策略下的资产汇总。
多事件处理: UDF 能够同时监听来自多个合约（Strategy Manager, Delegation）的多种事件（Deposit, Withdraw Queued, Withdraw Complete）。
利用历史状态: 在处理新的 withdraw 事件时，从数据库中读取该地址的历史状态，以完整记录取款流程的不同阶段金额。
分组与累加: 将事件按地址和策略分组，并累加历史数据，生成最新的资产快照。

性能优化方向

高效数据结构: 鼓励使用更高效的 data class 结构以提升读写性能。
批处理与多调用: 通过增大 batch size 和使用 Multicall 批量请求，减少 RPC 调用次数，解决主要瓶颈。
缓存机制: 支持引入 Redis 等持久化缓存，避免重复获取相同数据。
并行计算: 支持将任务分发到多个 worker 上并行执行，充分利用多核 CPU 提升整体速度。

生态建设

已基于 Hemera Protocol 开发出区块链浏览器、链上社交关系图谱（Social Graph）和 DeFi 资产组合追踪器等多种应用。
推出 UDF Builder 计划，鼓励社区开发者贡献 UDF 或提出改进建议，并提供相应奖励。

claude:

Hemera Protocol 数据课程

课程介绍

大家好,欢迎大家来观看Hemera的数据课程。我叫闪烁,是Hemera的cofounder和CTO。今天的课程将深入介绍Hemera Protocol,并告诉大家Hemera Protocol是如何更加便捷高效地处理链上数据。

今天的课程主要分为以下四个部分:

简单介绍Hemera Protocol以及什么是account-centric indexing
详细介绍如何使用Hemera Protocol进行编程,编写自己的user define function(UDF)
讲解一个实际的例子,深入了解具体怎么在Hemera protocol里面实现对数据的解析与分析
介绍Hemera Protocol的高级用法,如何使用UDF开发更加复杂的应用

第一部分: Hemera Protocol简介

什么是Hemera Protocol

Hemera Protocol有几个关键特征:

Programmable(可编程的): 可以帮助我们拉取、索引并分析链上数据
Indexing Protocol: 这是一个索引协议
Account-centric indexing(以账户为中心): 这是Hemera protocol的一大亮点,我们会将数据集中到地址上面或账户上面,这样可以对账户进行更深入、更全面的分析

Hemera protocol的优势:

把数据处理的过程变得非常简单
非常高效
非常方便开发者去使用

为什么做Hemera Protocol

我们团队在成立初期也做过很多尝试,用过各种第三方的工具、第三方的成熟产品去调各种API,去其他地方拉数据。但是我们发现:

效率非常低: 不同的产品可能提供不同的数据,很难在一个产品里面找到所有想要的东西
成本相对较高: 尤其是当要查询的数据量以及要查询的链的数量到达一定程度的时候,要查询的API总数非常高,导致整个成本非常高
链上数据复杂程度显著升高: 最近一两年,越来越多的DeFi项目会写很复杂的合约,还有一些其他项目的合约也越来越复杂,这让indexing的整个过程变得更加困难

解决方案

我们确定了几个明确的目标:

数据聚合到用户维度: 在实际生产环境当中,绝大部分的需求都是需要将数据聚合到用户维度
实时性: 我们需要数据具有实时性。虽然可能不需要毫秒级的延迟,但通常秒级的延迟或者在一分钟内的延迟还是非常有必要的
代码复用: 在处理链上项目的时候,我们发现很多项目之间有很多共通性。通常在解析一个合约之后,可能很容易去解析很多类似项目的合约。我们会去构建一个library,方便代码去更好地复用

应用场景

Hemera protocol能够很好地支持这些常见的应用:

区块链浏览器: 除了展示transaction之外,展示地址维度的交易、资产,还有各种TOKEN transfer,以及各种各样地址维度的数据

资产管理工具: 对标的产品可能是像DeBank或者甚至是Nansen这样的产品。它可以比较准确、快速地帮你查询链上任意一个地址在各种项目里面的参与情况、整体的TVL还有历史的交易等

Identity Solution(身份解决方案): 基于一些账户或地址维度的个人身份分析,比如:

Anti-Sybil: 鉴别链上的一个地址是不是可能的机器人账号
Power user analysis: 分析哪些地址是链上交易比较多的、信誉比较好的账号

这些都可以通过Hemera protocol的indexing过程,在账户维度做各种各样的特征来实现。

合作伙伴

我们在过去两到三年时间,给很多区块链生态,包括L1、L2以及各种各样区块链上的DeFi项目、GameFi、NFT项目提供了很多数据服务。我们也在不断扩充community的list,在跟他们合作的同时,慢慢把数据的广度拓展得更广,以支持更多的区块链、支持更多的protocol的smart contract,方便后面的开发者能够更好地使用Hemera protocol的indexing。

第二部分: User Define Function (UDF)核心概念

什么是UDF

如果大家熟悉数据库或者传统的SQL、MySQL数据库的话,应该有听说过这个名词。当你想在数据库里面实现一些稍微复杂一点的计算,就是一些基本的比如Max、Sum等运算符不能满足你需求的时候,可以写一个自定义的方法。

这个方法可能涉及到一些稍微复杂一点的计算逻辑,然后通过这些计算逻辑可以把原有的数据做一些进一步的加工。这个跟我们的user define function是非常接近的。

我们希望开发者可以写一段自己自定义的代码,嵌入到我们Hemera protocol的indexer当中。这样在Hemera protocol indexer index数据的同时,它也可以运行你这段代码,然后把链上的一些比如现有的transaction、block数据或者log数据转化成你想用的数据。

这个其实给我们带来了非常大的开发自由度。基本上只要用Python代码能够满足的逻辑,你都可以嵌入到我们这个indexer当中。

UDF工作流程示例

左边这个方框里面表示了以太坊上一个简单的transaction。transaction里面有这个交易的from、to。from可能是一个EOA的钱包,to是比如一个Uniswap的router,就是Uniswap的一个smart contract。

这边有交易的金额。transaction里面会有一个input data,这个input data就是你调用链上合约的参数。

除了这个transaction之外,这个transaction里还会有几条我们叫log的数据。这些log是从smart contract在代码执行过程当中发出来的。

这个log可能会包括这样一条,比如说TOKEN transfer。TOKEN transfer一般是由ERC20或者ERC721的合约代码执行过程中发出来的。

这条TOKEN transfer可以看到从这个EOA钱包地址向Uniswap的合约转移了这么多数量的TOKEN。

第二条log可能是一个swap的log。这个swap log通常是由Uniswap的池子发出来的。这个swap里面包括交易的币对,还有交易的币对的具体金额。

这两条log都是跟这条交易紧密关联在一起的。

当我们Hemera的indexer(account-centric indexer)拿到、监测到这两条log的时候,它就会触发不同的UDF。

UDF层有三个UDF:

第一个UDF: 想统计TOKEN的balance
第二个UDF: 想统计以太坊持有TOKEN的巨鲸
第三个UDF: 想统计每个地址在Uniswap trade的trading volume

当Hemera indexer拿到第一条TOKEN transfer的log的时候,它就会触发balance和whale detector这两个UDF。这两个UDF进行运算之后,分别会更新TOKEN balance和是否是whale这两个具体的feature。

第二条log(swap)会触发Uniswap trading volume的UDF。这个UDF会更新每个地址对应的Uniswap的trading volume。

这基本上就是一个UDF如何在account-centric indexing当中发挥作用,如何监测链上数据,最终更新我们所产出的数据、产出的用户维度的feature这么一个基本流程。

UDF的主要好处

大大降低开发者的开发成本: 用户完全不需要关心输入的数据都有哪些。输入的数据我们已经准备好了,你只要直接用就可以
效率大大提升: UDF本身是嵌入在我们的indexer当中的。整个效率是大大提升的。在indexing的过程当中,同步地去运行你写的这些user defined function,然后它同步地就产出了相应的结果。这些结果都是伴随着每个区块的产生而同步产生的
方便测试: 整个protocol非常能够方便地去做单一UDF的测试,并且可以支持你快速地去回溯历史上的区块。你可以针对历史上区块跑特定的UDF,然后去检验特定的结果
灵活度非常高: 因为这个UDF的写法是用Python去编程,所以灵活度非常高。你基本上可以写任何想写的代码。我们唯一定义的就是这个代码的输入是一些定义好的链上的数据,然后你可以对这些数据做任意你想要做的转换,产出你任意想要的数据格式

我们也准备了非常多已经写好的UDF。这些UDF在我们文档里面也有所介绍。如果大家有兴趣的话,非常欢迎随时去我们的代码里面查看,可以把代码下载下来做一些本地的测试。也非常欢迎大家给我们提各种各样的意见。如果觉得代码中有一些潜在的问题,也非常欢迎给我们提issue或者提PR。

第三部分: 运行Hemera Indexer实践

运行方式

当前在我们现有的代码版本里面,主要有两种方法可以运行Hemera indexer:

方法一: 通过Docker和Docker compose

这种方案在生产环境运行是一个比较好的选择
非常方便你去运行和维护
Docker有一些自动重启的机制,非常方便管理
我们写好了相应的Dockerfile和Docker compose的file

方法二: Build from source

直接用我们代码,相当于有一个Python的环境去运行
在一般的开发流程当中应该是会更方便一些
在开发过程中可能需要不断地去调试、去本地调试、去改代码
这种方式可能会更适合开发

Docker运行步骤

如果选择用Docker去运行,可以参考文档中的这一部分。主要步骤包括:

安装Docker和Docker compose
Clone我们的代码库
准备一些参数
运行Docker compose
根据你的需求去调试各种各样的参数

代码直接运行步骤

基于代码直接运行也非常简单:

下载开发工具
运行make development
配置好虚拟环境
就可以运行了

在运行indexer的时候,一个非常方便的输出环境是可能需要有一个本地的PostgreSQL,或者在cloud的环境里面有一个PostgreSQL。这样会非常方便你去存储一些你output的数据、index的数据。

代码演示

因为我们代码完全是开源的,大家可以在代码库里面直接把代码clone下来。

(演示clone代码)

当前我们这个代码也是在快速开发的。我们目前的版本应该是一个5.0.5的版本。如果在课程播出的时候可能会有新的版本,大家也可以随时去用比较新的版本。

按照我们刚才的介绍,首先会安装开发工具。因为我电脑上已经有开发工具了,所以我就先跳过这一步。

然后第二步,先确定一下你的电脑上是否有Python环境。我相信大家一般因为用的也比较普遍,所以一般电脑上都会有Python安装。

如果确定没有问题,就可以运行make development。

(演示运行)

可以看到在这个过程当中,我们会自动帮你去set up虚拟环境,然后去下载一些相关的dependency,还有安装这些dependency。可以看到基本上就是完成了。

然后我们可以运行一下这个命令,这样当前的命令行就可以使用到这个搭建好的虚拟环境。

之后我们就可以做一个简单的运行。

(演示运行命令)

可以看到在刚才的命令行里,我指定了这么几个参数:

我们要使用的RPC的地址
一个起止块,这边我只index了一个块
我想要输出的数据类型,我只输出了block和transaction两种数据类型

可以看到这边在index过程当中,它会去拉取block还有transaction的数据,然后这个数据就会输出出来。

这样我们基本上就完成了一个基本的流程,这也就是indexer的一个基本流程。

主要参数说明

在Hemera indexer里面有非常多的参数可以去使用。为了满足不同的场景和不同的业务需求,我们设计了很多options可以去选择。这边简单罗列几个最常用的options:

provider URL

你要配置你的RPC
我们所有的数据来源都是来自于Blockchain的RPC
这是一个非常重要的参数

output

现在支持三种output format:
- 直接output到PostgreSQL数据库
- CSV文件
- JSON格式的文件
可以在output里面指定不同的格式或者多个格式,indexer都会帮助你进行output

output types

包括常用的Blockchain数据:block、transaction
以及一些衍生的数据:TOKEN transfer、TOKEN
还有一些常用的数据的data class
在我们的UDF里面,你也可以定义你想要用的data class,这些也可以作为output type出现在参数里面

PostgreSQL地址

配置不管是本地的还是云上面的PostgreSQL URL
如果前面指定了output type是PostgreSQL,数据也会直接被output到这个数据库里面

block batch size

主要用在大规模的回溯历史数据,或者想一次性跑多个块的时候

batch size

区分于block batch size
主要用在调用RPC的时候,可以将多个RPC的请求合在一起一起去调用
这样可以大大提高整个indexer的性能

config file

在实际运行indexer或者实际写自己的user define function的时候,会经常用到一些配置参数
这些都可以写在一个配置文件里面
在实际运行indexer的时候可以把这个文件作为配置传入进去

参数实践演示

(演示增加参数)

第一个,我指定了一个output,我将把数据output到PostgreSQL里面。

第二个参数是PostgreSQL URL,这是我配置的一个本地的PostgreSQL。

(展示数据库)

可以看到现在我是有transaction和blocks表,这些表里面现在都是没有数据的。

(演示运行indexer)

现在指定两个区块,运行这个命令。可以看到现在就开始index数据,它是一个块一块去index的,index了我这两个区块。

(查看数据库结果)

现在blocks表里面已经有两条数据,就是我刚才index的这两个区块。

可以看到transaction表里边现在有225条数据。这和我们这边对应的第一个区块里有120条数据,第二个区块里有105条数据,是完全吻合的。

刚才我们通过运行这个命令,将这两个区块里面的block和transaction数据已经index到了这个PostgreSQL里面。这个就是indexer的一个稍微复杂一点的用法。

UDF的基本结构

下面我将深入介绍如何去写一个自己的用户自己定义的UDF,然后能够嵌入到我们indexer当中,然后去实际运行。

UDF的基本结构大概包括三个部分:

1. Data Class(数据类)

最重要的,需要定义一个data class
可以认为是UDF的一个输出格式
我们希望把它定义成一个类,方便在代码里面调用,方便在代码里面output
这个data class并没有一个明确的特别的要求
可以指定任意多的参数,可以使用各种各样的数据类型,都是完全自由的

2. 代码逻辑

需要写业务逻辑去实现
基于其他的一些数据生成你想要输出的data class
这也就是所谓的UDF的核心代码逻辑

3. Models(模型)

不是必须的
只有在想要output到数据库里面的时候需要
需要建一个数据库的表,这个model是和表相对应的
代码里面内置了一些办法,帮你把data class可以直接转化成model
不用担心data class是如何转换成model并且输出到数据库的

具体步骤

定义data class: 需要定义UDF的输入和输出的data class
定义model: 如果新建了一些数据库的表,需要定义model
在job(UDF的逻辑)里面:
- 需要定义dependency
- 需要定义output
- 有一个filter方法
Filter方法: 需要定义用什么数据。当前的filter逻辑支持:
- 按照log的topic和log的地址做filter
- 按照transaction的address去filter
- Filter非常重要,能大大减少在index过程当中需要从RPC拉取的数据的数量
- 对UDF运行的效率非常有帮助
Process function: 在里面写代码逻辑
测试: 基于历史的区块或者一些过往的区块去做一些调试和测试
提交: 测试完成之后可以提交这个UDF

实际例子: ERC721 TOKEN Mint追踪

需求说明

这个简单的例子要实现的功能是:

Index一个ERC721 TOKEN
追踪每一个TOKEN ID的Mint时间
追踪它是被哪个地址Mint的

所有代码都在我们的代码库里面能够看到。

实现步骤

第一步: 定义data class

(展示代码)

可以看到定义了一个data class叫ERC721的TOKEN mint。在这个data class里面:

有一个地址,代表实际去Mint这个TOKEN的用户的地址
TOKEN address和token ID,对应了我实际想要关注的ERC721 TOKEN的token address和具体的token ID
其他的block number、timestamp、transaction还有index,相当于是其他一些想要关注的数据信息

这是非常简单的一个data class,可以把它打上data class的标签。

第二步: 定义model

(展示代码)

因为要输出到数据库里面,可以看到基本上是跟刚才data class一一对应的。但是数据类型有所不同,同时还加上了一些辅助的字段,帮助我们更好地track这个数据库的格式。

第三步: 实现代码逻辑

(展示代码)

可以看到这是基本的demo job。最上面首先定义了这个job的dependency type。

Dependency type可以认为是我们这个user define function的input data。这些input data是一个list,是一个list of data class。

这里面用的是系统一个默认的data class类型叫log,这也是以太坊的一个基础数据。

要output的data type,就是刚才定义的data class,也就是ERC721的token mint。

(展示config文件)

这边用到了一个config。这是一个标准的用法,可以帮助你从config文件里边直接去拉取一些配置。

这个config文件在config目录下面,是我将要用到的config文件。

(展示配置内容)

可以看到这边定义的TOKEN是一个ERC721的TOKEN。打开Etherscan的界面,可以看到这是一个BAYC的token。这个TOKEN是一个比较早的collection。

比如随便点开一个TOKEN,TOKEN ID是189,可以看到最早的mint时间大概是在12318153这么一个区块,是2021年的一个比较早的时间。

回到任务里面,可以看到在拿到了这么一个contract list。这边只有一个contract,但其实也可以同时兼容在一个job里面去跑多个contract的数据。

下一个重要的function是get filter

(展示代码)

在这个filter里面,指定了按log topic进行filter。log topic的地址来自于这个address和这些topic。

这个topic现在只指定了一个topic,就是定义好了一个ERC721 transfer event。这个也是ERC721标准里面的一个event,所以所有的ERC721 TOKEN transfer都会有这个event。

最后是核心逻辑

(展示代码)

这是我们想要实现的、相当于是代码的核心逻辑。首先把我拿到的依赖的数据(logs)基于这个logs执行了这个function。

假设这个function产出了我所想要的ERC721 TOKEN mint的数据,然后调用了collect的方法,把这个TOKEN mint数据收集起来。

核心function详解

(展示代码)

这个function的输入是一个list of logs,输出是一个list of 721 token mint。

这个function非常简单:

遍历了一遍每一条log
当log topic是token transfer的时候,使用了一个标准的方法,就是内置的decode log方法对log进行解析
Log解析之后,根据这个function的ABI可以拿到from、to还有TOKEN ID
可以直接调用decode data里面的from、to和TOKEN ID
当from address是零地址的时候,认为它是一个TOKEN的mint行为
可以找到这个TOKEN mint的to的地址以及对应的TOKEN ID
就可以完整地把这个data class构建出来

然后把每一条TOKEN mint的data都收集起来,做一个集中的返回。这就是完整的流程:

拿到底层的数据
对数据进行处理
把处理得到的数据进行收集

这就完成了UDF的一个完整流程。

运行演示

(展示运行命令)

可以看到在这里面指定了两个output type:

一个是ERC721的token mint,这是刚刚在代码里定义的data class
增加了一个参数block batch size,给了比较大的一个数字

因为想index历史的区块,在start block的参数里面也指定了一个比较早的区块。

最后一个增加的参数是config file,因为有一个自定义的config,所以指定了一个config file。

这个数据库还是使用刚才同样的数据库。可以看到这边定义了一个ERC721 TOKEN Mint的table,这是和刚才定义的model完全对应的。

(查看数据库)

可以看到现在里面是没有数据的。

(开始运行)

可以看到目前已经从1200多万块开始做index。因为一开始的区块里面数据不多,相关的block、transaction可能都有几十条。

可以看到数据index还是比较快的,因为每一个batch是index 1万个块的数据。

从这个区间开始,在这个区块范围里面相关的数据就变多了,因为这可能是我刚才看的NFT collection它在集中被Mint的这么一个区块范围。

(展示进度)

可以看到数据log里面展示了数据index的进度。

这边遇到了一个还挺有趣的现象。可以看到有一个报错,说reducing batch size to 5。这是说由于RPC可能我们访问的速度过快,我们内置了一个自动去调节RPC调用速率的方法。

可以看到这边做了一个临时的减少batch size,这样可以在短时间内降低RPC的调用量,能够让你顺利地去完成这个任务。虽然它运行的速度可能相对降低一些,但是它能保证整个indexer不会挂掉,可以继续去运行。这也算是我们对indexer的稳定性的一个提升。

可以看到在这一部分里面,一共是有9668条相应的记录被输出出来了。

(查看数据库结果)

现在可以看到数据表里已经有1万条记录了。

(执行查询)

1	SELECT address, token_id

可以看到每个TOKEN ID对应的address,就是哪个TOKEN ID到底是被哪个address mint出来的。

还可以做一些更复杂的查询,比如:

1 2	SELECT address, COUNT(*) GROUP BY address

可以看到每一个address到底mint了多少个token。比如这个地址,它一次性就mint了70个TOKEN。

有了这个数据表之后,就可以实现各种各样的应用、各种各样的API。这对后面的开发过程就非常容易了。

总结

以上就是对ERC721的TOKEN mint的UDF的一个比较全面的介绍。简单回顾一下:

首先定义data class: 定义输出数据的结构
定义model: 因为要输出到数据库,需要数据库的model
实现代码逻辑,几个关键点:
- 要定义好dependency和output
- 如果要用配置,可以以这种方式去载入配置
- 要定义filter,因为有filter可以使代码的indexing过程能够大大提速,也使RPC调用能够控制在一个比较合理的范围
- 实现代码逻辑,从data buffer里面去拿dependency的数据
- collect的方法可以帮助你export数据
- 中间的逻辑可以进行任何自定义的代码逻辑,只要你能够用Python实现的,都可以作为UDF的一部分

第四部分: UDF高级用法

欢迎大家回到我们的课程。在这一部分,我们将讲解如何使用Hemera的UDF的高级用法,以及举一个具体例子说明如何使用UDF去开发更复杂的应用。同时在课程的最后,我们也非常乐意跟大家分享我们Protocol正在进行的一些改进,也非常欢迎大家给我们提出更多宝贵的意见。

复杂案例: Eigenlayer数据索引

目标

在今天的章节里,首先我们会一起来看一个更加复杂的案例。我们将会index Eigenlayer。这是可能今年非常火热

的一个项目,它是一个叫restaking的protocol。我们会index Eigenlayer contract的数据,并且我们想提供一个非常详尽的数据总览。

同时我们想要index两个主要的数据:

1. 事件表(Event Table)

每一笔交易,每一笔在Eigenlayer上面涉及到的交易
包括deposit、withdraw
包括一些其他辅助的action
这是一个类似于事件表的结构

2. 地址维度统计

每一个用户历史上一共存入了多少资产
取出来多少资产
包括当前还持有多少资产

这就是我们今天要实现的功能。所有的code在链接当中可以看到。

代码结构

(展示代码)

可以看到这个代码和前一讲中介绍的结构基本上是完全一致的。首先可以看到有domains和models两个folder。

已经看过前面课程的同学应该了解,domains是这个任务需要输出的data class,相当于是这个任务的产出。

定义两个data class:

第一个: Eigenlayer Action(事件表)

(展示代码)

包括transaction、block等信息。也包括这笔交易、这个事件当中具体涉及到的:

TOKEN
Staker
Share
Withdrawer等信息

这些都会被存在事件表里面,每一个实际的事件都会单独存储一行。

第二个: Eigenlayer Address Current(用户维度表)

(展示代码)

这是一个用户维度的表。记录了每个address在每一种strategy下面:

存入的金额
取出来的金额

这边有一个特殊的定义,因为Eigenlayer这个取款并不是一次性完成的,它要涉及到一个退出的流程。所以这边有两个金额:

一个是开始取款的金额
一个是真正完成取款的金额

分成两个数字去统计。

定义Models

(展示代码)

可以看到有两个对应的model:

第一个: AF_Eigenlayer_Record表

字段基本上跟data class是完全对应的
主键包括了transaction hash、log以及一个internal的index
因为在Eigenlayer的实际事件当中,可能出现一个事件对应多个action的场景

第二个: Address的model

比较直接
主键是address加上strategy
就是每个address在每一个strategy下面相应的统计信息

合约事件定义

(展示代码)

这是我们会用到的所有合约里的事件,比较直观:

Deposit事件
退出有两种方式,一个是batch的event
Withdraw queued,但它有两个名字一样的方法,参数是不太一样的
这是两个不同的退出方法,对应的参数略有不同
最后一个事件是完成withdraw complete的事件

这些是在写代码的时候会用到的相应事件。

智能合约说明

(展示合约地址)

Eigenlayer目前在链上主网上面用到的smart contract:

Strategy Manager合约

主要用来做deposit
还有一个叫share withdraw queue的事件

Delegation合约

主要用来做取款和完成取款这个事件

实现代码逻辑

(展示代码)

定义dependency和output

在这里边,dependency设定为transaction。但其实transaction数据里面是包含了log的。如果大家熟悉以太坊的RPC,当我们调用get transaction receipt的时候,它会自动拿到transaction数据和所有logs,所以这边指定transaction就可以了。

Output输出的数据比较直观,是我们定义好的两个data class。

配置合约地址

(展示config)

可以看到配置的合约地址:

一个是strategy manager
一个是delegation的地址

这些在后面也会用到,所以赋予它一个变量名字。

定义Filter

(展示filter代码)

在上一讲里面,filter了单一contract和一个topic。但实际这个filter是支持多个topic一起,以及多个地址一起的。

这是什么意思呢?就是说所有满足任意一个topic或者且来自于任意一个地址的log都会被过滤出来。这是它的逻辑关系。

主体Function

(展示主体代码)

这个function主体大概有几个部分:

第一部分: 提取Action

首先从data buffer里面拿到transaction。遍历transaction的时候可以拿到transaction里的log。

首先要做的事情是从logs里边提取出对应的action。可以看到遍历这个log,然后根据log的topic以及它相应的地址做判断。

如果拿到的是deposit event,会把这个log进行decode,拿到log中的一些信息,然后创建对应的Eigenlayer的action。

如果是withdraw的event,也会做相同的事情。

(展示复杂场景处理)

这边有一个比较复杂的场景。可以看到这个withdrawer它是一个相对复杂的结构体。但是也不用担心,在decode log的时候,它会自动帮大家decode成一个字典的形式。所以还是比较容易可以拿到结构体当中的数据。这是一个从结构体中拿数据的用法。

还可以看到这边的strategies和shares它是一个数组。这个数组也不用担心,我们拿到的数据也是数组,可以直接对这个数组进行遍历。可以看到这边遍历strategy list,拿到每个strategy对应的share,然后同样创建相应的action。

下面也是大同小异,基本上就是对log进行处理。

最后一个单个的withdraw complete的事件也是比较容易进行处理。

以上就完成了一个action的获取,就是从log里面把所有涉及到的Eigenlayer的action完整地提取出来。

第二部分: 处理历史数据

(展示代码)

下一步可以看到collect domain是大家比较熟悉的方法,就是把拿到的Eigenlayer的action直接存入到数据库里面。

但在这之前还做了一步,就是对action做了一些处理。因为我们想要在每一个withdraw的事件里面,去找到相应的一些信息,让这个信息更加完整。

这边看到有一个用法,是会去历史的数据库里拿到一些数据。这是一个比较新的用法,大家之前可能没有见到过。

这个在indexing过程当中非常常用,因为我们经常会遇到,当你看到一个事件的时候,如果想要生成你的数据,你会依赖到当前之前数据库当中已经存储的数据。

所以这个时候非常需要我们从数据库里直接读取历史的数据,然后根据历史数据当中的信息把当前的数据变得更完整。这就是我们在做的一个事情。

它完成之后,就可以再把这个数据存回到数据库。

这就是第一块,我们生成了Eigenlayer的action,这个action是我们想要获取数据当中的第一个部分。

第三部分: 生成用户状态

(展示代码)

第二个部分是想获取用户的状态。

首先第一步,对action进行了batch,就是按照用户和strategy进行了group。

可以看到生成了一个字典,这个字典是每一个staker对应一个strategy会有一些信息。

第二步,因为我们之前定义的data class里面它是一个总计的deposit amount。因此也需要去数据库当中拿到每一个地址、每一个strategy当前的、历史的amount。

如果有数据,需要在这个历史数据上做一个累加。所以这个相当于是取到了数据库已经有的历史数据的状态。

之后比较简单,相当于是把两个字典进行遍历,找到它共同的key然后进行累加。如果existing的数据中没有,直接把新加入的数据做一个保存就可以了。

以上就是Eigenlayer的一个完整流程:

第一步是存log
第二步是存address

实际运行演示

话不多说,回到代码实际去跑一下。

创建数据表

在中间插入一个小知识点。我们需要帮用户创建数据表。因为刚才定义了model,但实际上在数据库里面并没有这个数据表。这是遇到的一个比较常见的问题。

(展示数据库)

可以看到数据库里面是没有这个数据表的,没有find这个数据表。

这个时候我们提供了一个比较方便的command line工具,可以帮大家创建数据表。

(展示命令)

它跟indexer用法非常像:

需要传入PostgreSQL的地址
需要传入需要创建table的名字,这个名字和构建的model是完全一致的

如果在model里面没有定义table name,它会直接把class name转成相应的underscore的case。

(运行命令)

可以看到现在数据表就已经被创建出来了。我们也可以在数据库里确认一下,这两个数据表都已经创建出来了。

开始数据拉取

(展示运行命令)

再回顾一下基本用法:

指定了一个RPC的endpoint
指定了开始和结束的block
指定了在job里面需要运行的output types,包括两个自定义的output types
这个是数据库的URL
Output type是想output的数据到PostgreSQL里面
这是指定的配置文件的路径
最后一个是区块的batch,设定了1000

(开始运行)

可以看到系统已经开始拉取数据。可以看到有个依赖关系,会先拉block、transaction,然后会执行Eigenlayer相应的job。

可以看到数据拉取还是比较顺利的。

查看数据库结果

(查询数据库)

回到数据库里,来看一眼数据。

首先count一下现在record表里面有多少数据:

1	SELECT COUNT(*) FROM record

可以看到record表里面已经有350条数据。

再看看不同的name到底对应了多少数据:

1 2	SELECT name, COUNT(*) GROUP BY name

可以看到有这么多deposit event,还有这么些withdraw queue的event。

再看一下address表:

1	SELECT COUNT(*) FROM address

现在address表里面已经有809条数据了。

统计一下不同strategy对应的amount是多少:

1 2	SELECT strategy, SUM(deposit_amount) GROUP BY strategy

可以看到不同的strategy已经产生了不同的deposit的amount。

基于这个,就可以做非常多各种各样不同的应用。比如可以按天做统计、按用户做统计,甚至是可以绘制各种各样的图表,这些都是不成问题的。

总结

基本上这就是这一讲当中想要给大家介绍的例子。简单总结一下,有几个比较新的知识点:

1. Command line工具

有一个command line的工具可以帮你比较容易地创建数据库的模型

2. 处理多种事件

在实际的job里面可以同时处理多个、多种event、多种log,都是非常便利的

3. 读取历史状态

在实际应用当中,可以从数据库里面拉取一些历史的状态
基于历史状态进行更新
这样方便一些比较复杂的任务,它是基于历史状态的任务,就可以通过这种方式来实现

实际应用展示

基于Hemera的protocol我们创建了各种各样的应用:

1. Blockchain Explorer(区块链浏览器)

(展示应用)

这是基于我们indexer做的一个Blockchain Explorer。可以看到所有的数据都是非常完整:

包括transaction
点到一条transaction里面
包括transaction里面的log
甚至是trace
这些都是基于我们indexer去完成的

也包括相关的token。可以看到涉及到token的转移,这些也都是通过我们的indexer可以很好地完成。

(展示应用)

我们开发了一个类似的应用,在Social Scan的页面当中,有一个demo的小游戏。

这是通过挖掘用户之间的一些关联,同时挖掘数据当中的一些潜在的特征。这是基于我们account-centric indexing的数据支持的类似于小游戏。大家有兴趣可以去我们的网站上面玩一下。

(展示图谱)

可以看到每个相邻的节点,都是不同的地址。这个地址之间是通过一些交易关联在一起的。

每一个用户,这边有一些特殊的用户,因为这个用户有一些特殊的trait,所以会被标记以不同的宝石。

3. DeFi Portfolio Tracker(资产管理工具)

(展示应用)

这边有一个例子,是我们基于IBC这个资产做的一个资产的,相当于是在不同链上、不同合约、不同protocol里面的资产展示。

可以看到:

有不同的链
下面还有不同每个链上不同的protocol
Protocol里有不同的金额

这是一个比较全面的资产管理工具。

做法包括几部分:

首先统计具体TOKEN,每个address里的TOKEN的balance
基于不同的protocol可能会创建不同的UDF
最后把UDF的结果进行汇总,就能生成这个dashboard

我们现在当前已经在Hemera上面创建了很多UDF,基于UDF也做了各式各样的应用。如果大家有任何数据的需求,非常欢迎随时跟我们取得联系。

Performance优化方向

最后一个部分,我们之前也多次提到,我们的protocol是一个非常actively building的protocol。我们一方面承认这个protocol还有很多不足之处,一方面也在不断去完善。

这可能是我们想要optimize performance的几个方向:

1. 高效的数据结构

我们在定义data structure或者叫data class的时候,自由度是非常高的。但我们也非常鼓励大家能够去创建一些更高效的数据结构:

一个是方便查询
另一个是写入的效率也能有所提高

2. 批量处理

前面提到有参数:

可以把多个区块在一个批次处理
可以把RPC的request给它batch起来
代码里面也引入了Multicall这种方法,可以在一个call里面同时调用多个smart contract的、调用多个不同的方法

根据我们的实验和研究,RPC的效率还是我们indexer的一个主要瓶颈。所以如果能尽可能减少RPC调用的时间,对我们是非常有帮助的。

3. Caching(缓存)

大家前面可以看到我们在代码里面有一个data buffer的概念。这个data buffer当前在每一个运行批次之间是会做一个清空的。

但是实际情况下,有的时候用户也会引入一些持久化的缓存方案。我们也是支持的,比如接入一些Redis。在代码里面我们也有所支持,后面可能会进一步加强去满足和完善这种caching的支持。这样避免同样的数据反复去调取。

4. 并行计算

我们现在代码里面在有一些场景下是可以把数据处理的任务分开到不同的worker上去执行的。这样的好处是相当于一个并行的计算。

如果你的机器有足够多的CPU,可能可以把任务分开到不同的CPU上去做。这样也可以提高整体的运行速度。

这是我们当前的一些想法和正在做的一些优化。如果大家有任何的建议或者好的想法,也非常欢迎给我们提出来。

UDF Builder计划

最后,我们有一个正在进行当中的UDF builder计划。我们非常欢迎大家给我们开发各种各样不同的UDF,或者帮我们去改进我们protocol。对这些我们都会给予不同程度的奖励。

所以大家有任何的想法或者任何的建议,都非常欢迎直接和我们取得联系。

联系方式

最后是一些我们的文档、我们的联系方式。大家可以直接联系,我相信这个课程里边也包括了我们的一些联系方式。

我们今天的课程就到这些。再次感谢大家的观看。如果有任何问题,千万不要犹豫,可以随时和我们取得联系。我们也非常期待大家的加入,和我们一同构建一个更便捷、更高效的indexing区块链数据的工具。

谢谢大家!

07.链上数据分析平台精讲

会议介绍了如何使用The Graph的子图技术解决Web3数据查询难题，通过实际演示展示了在10分钟内部署一个子图的完整流程，并讲解了如何查询The Graph Explorer上的公开子图数据，强调了子图作为去中心化数据层的优势以及The Graph网络的高可用性。

一、Web3数据挑战与The Graph解决方案

数据读取难题

区块链擅长写入但不擅长读取数据，直接从前端调用区块链需要编写大量代码。
智能合约产生的事件日志分散在各个区块中，像混杂的球池一样难以检索。

The Graph的子图方案

子图将分散的链上数据抽取、转换并加载到数据库中，提供结构化和可查询的数据格式。
使用GraphQL接口，前端只需发送一条查询语句即可获取所需的所有字段数据。
子图包含三个核心文件：subgraph.yaml（配置）、schema.graphql（数据模型）和mapping.ts（数据转换逻辑）。

去中心化的数据索引

引入多个索引者节点避免单点故障，确保数据服务的可靠性和去中心化特性。
全球已有超过100个索引者参与The Graph网络，保障查询的高效与稳定。

二、子图部署实操流程

环境准备

推荐使用Linux或Mac系统，Windows用户建议使用WSL。
需安装Node.js和Git，并登录MetaMask钱包。

创建子图项目

访问The Graph Studio（the-graph.com/studio），创建新子图并填写名称。
选择目标区块链网络（如Lidia），输入智能合约地址以自动获取ABI等信息。
使用默认设置生成schema，基于智能合约事件创建实体。

初始化与部署

使用CLI工具执行 graph init初始化项目，自动创建所需的文件结构和依赖。
运行 graph codegen生成代码，graph build编译项目。
执行部署命令并指定版本号（如0.0.1），完成子图发布。

数据查询与验证

部署后状态变为“sinking”，可在Playground中测试GraphQL查询。
通过选择实体和字段，自动生成查询语句并查看返回结果。
可将查询接口用于前端应用、数据分析或可视化工具。

三、查询公开子图的方法

浏览The Graph Explorer

访问the-graph.com/explorer查看所有公开子图，按查询量排序。
包括Uniswap、QuickSwap等主流协议的子图均可直接使用。

获取查询接口

在目标子图页面复制查询URL，用于后续的数据请求。
需要创建API密钥以进行身份验证和用量管理。

API密钥配置

在The Graph Studio中生成新的API密钥，并可设置每月消费上限。
将密钥添加到请求头中，结合GraphQL语句发起查询。

实际查询示例

使用JavaScript脚本向指定端点发送GraphQL查询，验证数据一致性。
支持对大型子图（如Graph Network子图）执行简单或复杂查询。

四、学习资源与社区支持

文档与翻译

官方文档为英文，可通过ChatGPT等工具辅助理解。
提供最佳实践指南和技术参考。

社区支持渠道

推荐加入The Graph官方Discord，获得24小时技术支持。
存在开发者微信群，需通过Open Build团队获取邀请链接。

claude:

The Graph 子图使用教程

自我介绍

大家好，今天我给大家讲一下怎么用The Graph的子图。我先自我介绍一下，我叫Ali Kim，我是Edge Node的一个工程师。Edge Node就是The Graph旗下的公司之一，我们有多个开发团队，子图相关的开源代码和Graph Node，还有thegraph.com的Studio都是来自于Edge Node。

我是韩国人，小时候住在北京，现在我在加拿大。我在Edge Node负责新链集成The Graph相关的工作。今天我会给大家看怎么样使用The Graph，怎么样可以在10分钟内部署一个新的子图。

课程内容

首先我会介绍一下Web3数据的问题和The Graph相应的方案。接下来我会实际操作给你看怎么样可以10分钟内部署一个子图，然后最终如何查询thegraph.com Explorer的子图。

Web3数据的问题

我们看这个之前先看一下最开始去中心化应用的架构，它本来是应用的前端直接跟区块链沟通。但在这里的问题是区块链它擅长于写入数据，但不擅长读取数据。因为写，你只需要调用一个写入函数就完事了，但是读取数据就复杂很多。

智能合约事件

区块链上智能合约会发出日志。简单复习一下，如果看这个例子，是个ERC20的代币，它的Solidity脚本里面有一个transfer转账的事件。里面会告诉你发送的地址、接收的地址和这个金额。这个转账完成之后，就会触发一个transfer的事件。

所以每个区块上都有很多不同的协议、很多不同的智能合约发出的事件。从这里面想要找你要的数据非常不容易，就像在一个儿童的球池一样，很多不同颜色都混在一起。

前端获取数据的困难

如果你的前端想要获取链上的数据，如果直接用RPC call，还是得写这么一大堆代码，而且每个字段都得调用一个函数来获取数据，代码就得写一大堆。

所以这些DApp都需要有序的数据。

The Graph的方案

The Graph的方案就是子图。用The Graph可以得到这样的效果，把一大堆乱七八糟的数据整理得非常整齐。

为了达到这个效果，我们需要:

先能够抽取链上的数据
转换成我们需要的格式
然后再加载到一个数据库
最终需要一个简单的方法查询这个数据

就是说把乱七八糟的这些区块上的数据整理好，方便查询。所以子图就是让你能够达到这个效果。

使用子图的优势

使用子图，你的应用的前端代码可以简单化很多。刚才看到调用一个字段需要用JavaScript需要写一大堆代码，但是用子图你只需要通过一个接口传进去一个GraphQL语句，一次就可以读取你想要的所有的字段。

子图的组成

子图是可执行的代码。一个子图项目里面有三个最主要的文件:

1. subgraph.yaml

这是个YAML文件
里面保存这个项目所有的配置

2. Mapping.ts

这个是子图转换数据需要的所有的逻辑
基本上就是JavaScript

3. schema.graphql

这个schema就是你在这里可以指定怎么样用什么格式去保存数据

子图的特性

同时，子图是个可定制的API接口:

你想要查询数据都是通过一个API
这个数据的转换和保存的逻辑都是自己可以定的
你也可以给已经存在的智能合约做一个子图
也可以拿人家已经做好的子图拿过来做一些升级，都可以的

工作流程

左边这三个文件代表一个子图，这个子图运行的时候:

可以把链上的数据，也可以把链下的IPFS的数据拿过来
运行这个数据转换逻辑
然后保存在一个Postgres数据库里

最终用户查询数据，这个语句会传给Graph Node，Graph Node从数据库拿过来。这样The Graph就成为应用的前端和区块链之间的一个数据层。

去中心化方案

但是这么做是不是引入了单点故障？

Web2.0的问题

Web2.0的方案是，你要是建一个索引者，前端从那里读取数据。可以是可以，但是索引者要是下了线，这个前端就无法读取数据了。

Web3的解决方案

Web3的方案是让你拥有多个索引者，这样其中有几个下线也没问题。这就可以让你实现真正去中心化的应用。

目前The Graph Network全球有超过100个索引者，这让你的GraphQL查询又快又靠谱。

10分钟部署子图实践

接下来我会给你看怎么样在10分钟内部署一个子图。

环境准备

首先讲一下你需要的环境:

OS没有关系，但是在Windows我经常出问题，所以建议用WSL
如果用Linux或Mac一般都不会有问题
你需要有Node和Git
然后你得选好一个智能合约，我们来给它做一个子图

部署步骤

这个步骤其实很简单:

第一，你用你的浏览器去thegraph.com/studio，在那里面建一个子图
完了之后那个页面上就会显示一大堆命令行的指令，你就按照那个指示去做就可以
第三，我们来看一下怎么去查询这个数据

实际操作演示

Step 1: 创建子图

首先我们要去Studio，这个网址thegraph.com/studio，连上你的MetaMask。如果是你第一次的话，可能得登记一下邮箱。

登录之后就会看到一个dashboard。我这边有很多子图，但在这点击”Create a Subgraph”来建一个新的子图。

Subgraph的名称: 大家得选好一个智能合约。我是在Linea上随便选了一个智能合约，它叫Liquidity Provider，我们就用那个名字。你取一个有意义的名字。

创建之后我先选一下这个链，我选的是Linea。

选好链之后，它就会显示命令行需要的所有的命令。现在就过去看吧，我们一个一个跟着去做就可以。

Step 2: 安装The Graph CLI

首先你得确保你安装好了The Graph的CLI。我是用npm，复制这个指令安装一下。

1	npm install -g @graphprotocol/graph-cli

我已经安装好了，但我还是跑一次，为了安装最新版本，以防它有更新。

Step 3: 初始化子图项目

完了之后就跑graph init，还是同样复制过来。

1	graph init

需要先选一下链，我是Linea，第一个就是了。

然后是智能合约的名字，我就用默认的。然后就得填智能合约的地址，我把它复制过来。

它就会自动获取它需要的各种信息，像ABI，还有智能合约的名字。Start block就是这个智能合约从哪一个区块开始，然后名字它也自动拿到了，用默认就可以。

它问要不要用默认的，默认用已存在的这些事件来建你的schema，我就说ok，yes。

它就会给你的这个子图项目安装所需要的插件dependencies。

然后我这个子图只用一个智能合约，不添加其他的智能合约。

OK，这样就完了。我们就cd进入它刚建的这个文件夹，就可以看到它自动建的子图所有需要的代码。

Step 4: 查看项目文件

我们就简单看一下这主要的三个文件:

第一是YAML文件: 里面有所有的配置

第二是schema: 它默认按照这个智能合约触发的事件来建的这些实体，就想象成一个数据表就可以

第三就是Mapping: 它就有这个逻辑，怎么去转换数据。它默认就不转换，就按照它给每一个事件建一个实体就是了

Step 5: 部署子图

我们回去这个浏览器看一下。建好之后，要用要跑这个，就是使用你Studio自己的key。

让我进去文件夹，我刚已经进来了，所以跳过这个。

1	graph codegen

它会自动生成，还有build你的这个项目。

1	graph build

完了就是部署，最后一个也是同样指令复制过来。

1	graph deploy

它会跟你要一个版本名字，我就按照它建议的0.0.1。

OK，完成了。这样我们回到这个页面，需要可能需要给它几秒钟的时间。

OK，就会看到它这个状态变成syncing。所以其实部署已经完成了。

Step 6: 验证数据

为了确认它是不是真的在索引这个智能合约，已经完成了。因为我故意选了一个比较新的智能合约，这样需要扫的区块就比较少。

所以我们看一下它里面的数据。它最主要的数据是liquidity added。

在右边你可以通过这个选你要的字段，它就自动在左边生成GraphQL的语句。你跑一下就可以看到它里面的数据了。

查询数据

所以查询这个数据，你在页面上，在这个Playground在这里可以测试，也可以拿过来它的语句，用在它的端口。

就在这，这是个测试端口，所以你可以把GraphQL语句传进去。这个接口它有速率的限制，所以适用于测试。

但是如果想要在正式环境使用，你需要publish。但为了这个，你会需要在Arbitrum链上有一点点的ETH，因为这会生成一个交易。

JavaScript调用示例

我这边给你看一个简单的例子，我是用JavaScript，把一个GraphQL语句传进去刚才那个测试接口。

所以就是这里点endpoints里面这里看到的这个接口。

(运行脚本)

好，这个query这个语句得到的数据就跟刚才在这个浏览器看到的一样。

数据用途

所以The Graph子图是用来获取链上的数据:

拿这个数据你要是想要做分析，你就把它放进去，如果是用pandas使用在pandas
如果是想要可视化，放到可视化软件
如果是你的应用，你的应用就可以直接拿到这个json，然后在你的前端可以使用

查询Explorer的子图

接下来我们看一下怎么样可以查询Explorer的子图。

Explorer就是这里，thegraph.com/explorer。在这里你可以看到The Graph Network上所有公开的子图。

刚才我们在Studio看到可以通过publish，这里在Studio你按publish就可以把你的子图变成公开的。

所以这里可以看到所有公开的子图，它是按照查询量排的:

第一就是Graph Network本身的子图
然后这当中你可以看到一些熟悉的名字，像Uniswap、QuickSwap等等

查询公开子图的步骤

假如你想查询Explorer上的这些公开的子图，很简单:

首先要找到你想要的子图
在那里获得查询的这个网址
然后准备好你自己的API密钥就可以开始使用了

实际操作

我们看一下，来我们选一个子图吧。就拿The Graph Network的子图。

点进去之后，最上面你就会看到它的查询URL，我们把它复制下来，放到刚才这个脚本里。但是它这里面需要一个密钥。

创建API密钥

我们得先去Studio准备这个密钥。在Studio，你看thegraph.com/studio，你会看到上面有一个API Keys。

我这边已经有一个，我再建一个。点”Create API Key”。

你也可以在这边设一个花费的上限，比方说这个是按照每个月，每月最多花100美金。所以你有免费10万个查询是免费的，以上就需要API key。

OK，刚建的这个我会复制过来放到这个脚本。

(添加API key到脚本)

OK，key放进来了，然后我们把这个key也加进去这个URL里。

OK，这样下来脚本跟刚才用测试的接口一模一样。我们跑一次看看。

但我得先有一个query，所以随便建一个。这个Graph Network的子图非常大，我就做个很简单的query。

(复制query到脚本)

OK，所以这里面有这个接口和它要传进去的语句。跑一次看看就可以了。

你可以用这个方式去查询任何一个子图。

总结

OK，所以今天的示范就到这里。

有用的资料

我这边列了几个有用的资料:

第一是查询的时候的最佳实践
虽然它都是英语，你可以用ChatGPT翻译一下就没问题

获取帮助

如果有任何技术上的问题，我非常建议用The Graph的Discord。那里的Discord里面总是有人在监督，所以24小时都有人在看，所以有技术上的问题我觉得问那边最快。

但也有一个开发者的微信群，但那个需要单独邀请的，所以建议跟Open Build还有这个团队要一下这个邀请。

谢谢大家，希望The Graph可以在你的项目有很大的帮助。

高质量AI量化策略模型构建

会议中分享了策略开发的完整流程，包括个人接触量化投资的经历、量化投资的优势、学习路径、高质量策略开发方法以及实盘操作注意事项。重点讲解了如何通过样本筛选、因子调整、持仓优化和风控机制提升策略表现，并结合实际代码演示了从基础策略到高收益策略的迭代过程，最后强调了实盘中分散策略、严格执行和持续优化的重要性。

一、量化投资认知与优势

接触量化起因

通过平台ID微姐2018进入B矿，结合软件开发背景开始策略研究。
与搭档安子合作开发，共享代码、共同讨论策略并相互监督实盘执行。

量化投资优势

纪律性：依据预设交易计划执行，避免情绪化操作导致“赚少亏多”。
及时性：策略可自动跟踪市场热点，快速响应变化。
系统性：能高效处理全市场数千只股票的分析，远超人工能力。
准确性：客观评估交易信号，消除主观判断偏差。
分散化：资金分配至多个策略，降低单一策略失效带来的整体风险。

二、量化学习路径

入门挑战

编程基础薄弱和思维局限是初学者常见障碍。
市面书籍多基于国外市场，如《阿布量化》对A股适用性差。

学习方法

参考社区中的策略模板进行修改实践。
将传统选股逻辑转化为代码实现，例如“红三兵”用连续三日收盘价递增表达。
逐步尝试修改持仓天数、仓位配置、训练时间范围及算法模型（如随机森林、排序法）。

三、高质量策略开发

策略框架理解

策略分为模型训练与回测两大部分。
训练阶段包括样本选择、数量确定、因子选取和模型构建。
回测阶段验证模型效果，观察收益曲线与回撤情况。

样本筛选与标注

类比图像识别，需对目标类型（如红三兵、均线金叉）集中训练以提高准确性。
避免混入无关样本，确保模型具备针对性。
使用函数实现特定形态筛选，如跳空高开（当日最低价 > 前日最高价）、成交量条件等。

策略优化实践

初始策略收益较低，经多次优化后收益提升3-4倍。
调整每日买入股票数量由2只减为1只，收益率从75.64%升至104%。
引入奇偶交易日判断变量，避免同日买卖冲突，收益进一步提升至188%。
加强跳空幅度限制（如最低价高于前日最高价2分以上），过滤无效信号，收益达230%。
增加冲高回落过滤条件（成交量比、价格波动），继续提升收益稳定性。

因子调试技巧

因子调整无固定公式，需逐一测试不同参数组合。
建议每类因子（技术、财务、基本面）初选2-3个组合测试，再精细调优。
持仓天数调整实验显示，当日买卖优于隔日持有，原策略保持为佳。

四、风控机制设计

大盘风控逻辑

监控上证指数涨幅、连续下跌情况及成交量变化。
触发条件包括：大盘放量下跌、连续两日下跌、三日跌幅超2%、突然放量上涨。
满足任一条件即标记卖出，清空所有持仓以控制回撤。

风控应用场景

当前策略为T+1操作，风控作用有限。
若持仓超过一天，风控可在后续交易日发挥作用。
可在主函数中直接加入风控判断，无需额外调用。

其他风控尝试

个股周线级别风控可通过增加筛选条件实现。
结合概念板块信息（如同花顺获取）辅助决策。

五、实盘操作原则

实盘注意事项

回测稳定不代表实盘必胜，需长期坚持才能体现优势。
不建议满仓跟随单一策略，单策略资金不超过总仓位三分之一。
必须严格执行交易计划，禁止因亏损而加仓或盈利不舍得卖。

资金管理策略

初始可用小资金试运行，逐步建立信心。
若首笔交易亏损，后续可适当加大仓位，但前提是前一笔已止损。
采用多策略组合方式，同时跟踪3-5个策略，平衡整体收益。

交易执行细节

买入：前一日挂涨停价委托，确保次日开盘成交。
卖出：当日14:57挂跌停价委托，锁定收盘价成交。
平台默认以开盘价买入、收盘价卖出计算模拟收益。

收益预期与现实

实盘收益无法保证，受市场环境与执行纪律影响。
分享者本人三个月实盘收益为31%，严格遵循策略执行。
熊市中也有表现良好策略，关键在于策略适配性与时效性。

六、经验总结与建议

策略开发理念

坚持不懈是成功关键，避免因短期亏损放弃策略。
策略具有时效性，需不断更新迭代，不可依赖单一长期有效模型。
自主编写策略最可靠，他人策略难以完全适应自身需求。

工具与资源

社区模板是最实用的学习资料，优于现有出版书籍。
Python为首选编程语言，入门门槛低且功能强大。
新手可通过菜鸟编程等网站快速掌握基础语法。

综合建议

因子选择应注重组合使用，而非追求单一“神奇因子”。
可视化工具虽有用，但核心仍在于逻辑与代码实现。
十万左右资金适合起步，可分配至多个策略进行实战锻炼。

claude:

自我介绍

今天由我来给大家讲一下我是怎么开发策略的。我的平台ID是微姐2018,然后我做策略开发应该差不多有两年了。

课程大纲

今天主讲内容有以下五点:

我是怎么接触到BigQuant的
我对量化投资优势的一些看法
如何开启量化学习——我是怎么学习量化的,一步一步是怎么学的
高质量策略开发(今天的重点)
策略实盘要注意的一些事项

第一部分:我的量化之路

团队合作

做策略开发的话,其实还有一个比较好的搭档。我的搭档就是安子,应该他的策略在商城上做得比较好的。以前我们是同事,都是做软件开发的,然后我们有共同的爱好,然后我们也是相互信任的。

因为我们之间的代码都是共享的,就是他写什么代码我都能看到,我写什么代码他也知道。我们一旦有什么想法的话,我们就会在一起讨论。然后策略开发的话,我们也是合作开发的,就每个人写一个模块。

这样的话,我们就是会经常会探讨学习、经验交流,然后实盘监督。就是说做实盘的时候,他会监督我一定要按照那个实盘来做。

策略进化

前面这个是我刚开始,我18年的时候所开发的一个策略。然后这个策略的话,当时的话水平比较差,然后做的比较差。

后面这个是我最近开发的策略,因为经过将近两年的学习,所以说方法和思维方式都不一样,做出来的策略质量就会好很多。

第二部分:量化投资的优势

量化投资主要是五个方面的优势:

1. 纪律性

因为策略的话,每天都有交易计划,然后我们只要按照那个交易计划去做就可以了。

如果我们之前炒股的话,就是亏了以后我们就不卖,然后涨了以后我们立马就出了,这样就会导致赚的少、亏的多。所以当我们有了量化投资以后,我们就有纪律性,就是说应该按照那个策略的交易计划来做。

2. 及时性

因为我们策略的话,在训练因子的时候,它会跟踪市场的变化。然后最近市场上有哪些股比较热、热点股它都会进行一个跟踪。

3. 系统性

我们人为选股的话,3000多只股票你看完的话比较难,也比较费时。那么通过量化的话,它就会立马就可以找出来。

4. 准确性

准确客观评价了交易计划,克服主观情绪的偏差,从而盈利。

5. 分散化

我们在做策略投资的时候,我们应该会有很多个策略,我们会把我们的资金分散到每个策略去做。这样的话可以避免一个策略走坏的情况下,整个实盘都变坏的情况。

第三部分:如何开启量化学习

初学困难

刚开始的话,可能大家都在做量化的时候觉得编程是个问题,然后思维也有局限,因为不知道怎么去学习、从哪里下手。因为量化的玩意都是一些新东西,从来都没有接触过。

当时我也遇到这样的问题,然后我学量化的话,就是看社区里面的一些别人的一些模板,然后一个一个去改。

量化的本质

我所理解的量化就是把我们平时选股的方法转换成算法,用代码实现。

比如我们举个很简单的例子,红三兵就是连续三天是收阳线,那么我们用代码去实现怎么做的?就是close0大于close1,close1大于close2,close2大于close3,这样就是实现了红三兵的一个算法。

学习资源

量化是新兴的事物,虽然市面上有很多量化的书籍,但是基本上都是基于国外市场的,不适用于A股。

其实我也买过,刚开始的时候我在网站上也买过一本书,那本书叫《阿布量化》。然后我买回来以后我稍微翻了一下就不看了,因为他们讲的都是国外的,不太适合于国内的平台。

学习方法

多研究别人的策略模板。社区里面有丰富的策略模板,在策略模板基础上开始简单的修改:

第一步:修改持仓天数——由五天改为两天,这是我改的第一个功能
第二步:修改仓位——看不同仓位对策略收益的一些影响
第三步:改训练时间——因为时间的范围决定了样本的数量,样本的话就会决定训练出来模型是好还是坏
第四步:修改模型的算法——像随机森林、排序法等等

第四部分:高质量策略开发(重点)

策略框架理解

要做好策略的开发,首先要了解整个策略的框架是怎么来的。

我们看这个图的话,我们可以分两部分:

第一部分是训练模型
第二部分是用来回测的

训练部分流程:

首先要选择样本
选择好样本以后,还要确定样本的数量
确定样本数量以后,然后就是因子
最后就是训练出来模型

回测部分流程:

模型训练出来以后,然后通过回测部分的样本进行回测,然后得到一个回测结果,看这个结果怎么样。

策略优化实例

这个是我没有修改的,就是通过因子然后训练出来的一个模型。然后这个是修改以后的收益曲线。

从这两幅图来看,收益是增加了将近4到5倍,4倍的样子、三四倍。然后回撤的话也没有差太多。那么这是怎么改的呢?后面我会跟大家讲到。

各模块功能详解

我们先来了解一下每个模块的功能,然后后面就会知道怎么去修改代码:

获取全市场的训练时间数据
样本标注
用到的因子
训练的因子

样本筛选的重要性

如果我们把所有的股票都拿进去进行一个回测或者训练的话,得出来的模型它没有目标性。

举个很简单的例子,假如我们要识别一个杯子,那么我们肯定要拿很多杯子的形状去给机器进行学习。它学习以后,就能很好地识别什么是杯子。

如果我们把书本、杯子、手机各种形状的东西都拿出来去训练,那么训练出来模型的识别度可能就没那么高。

所以说做股票的话,也是一样的道理。我们把股票进行分类,分类以后然后用来训练,这样训练出来模型就有一个针对性。

像我们常见的平时炒股的有:

红三兵
多头排列
均线金叉

那么怎么把这些股筛选出来呢?

风控的重要性

风控的话在这里做风控也很重要,因为像大盘不好的时候你买什么股都是亏的。所以说我们做风控的时候可以很好地降低策略的一个回撤。

样本筛选函数示例

红三兵实现:

红三兵用成交量来做,用交易额。

均线金叉实现:

我们可以用五日均线小于十日均线,然后当天的五日均线大于十日均线,则五日均线跟十日均线形成一个金叉。

红三兵:

就是连续三天上涨。

策略修改技巧

我们在做股票的时候,经常写策略的时候经常是当天买第二天就卖掉了。那么我们可以通过修改,让我们股票拿一天、拿两天或者拿三天,拿任意天数都可以的。

另外还有仓位的一些调整。假如我们买两个股票以后,我们把第一个股票的仓位调大一点,把第二个仓位的股票调小一点,那么它们的整体收益会怎么样呢?回撤会怎么样呢?这个我们都可以试的。

代码实战演示

跳空高开策略

现在这个策略做的是一个跳空高开以后第二天买入。

比如昨天有个股票叫许继电器,000400,这是昨天买入的。前面一天跳空高开,然后这天买入,这天再卖出。

跳空高开我们可以看出它前面一天的最低价要大于前一天的那个最高价形成一个跳空。

代码实现:

代码很简单,三行就可以了:

排除ST的股,ST我们最好还是不要做
当天的最低价大于前面一天的最高价
当天的收盘价大于当天的开盘价,因为不能让它高开低走,那样的也不能做

这样的话我们就会把那个样本给选出来了。

样本数量控制

这里我们最好加一个打印,看样本的数量够不够。因为样本的数量的话,就我的经验而言,样本的数量要控制在2万到4万左右会比较好。

因为样本太小的话,训练出来的模型就会欠拟合。太多的话就会形成过拟合,所以这点是要比较注意的。

训练与回测数据分离

这部分代码就是筛选回测的数据,前面那一份代码是筛选训练的数据。这两部分代码可以做成一样的,也可以做成不一样的。

优化过程演示

初始结果:

第一次回测收益是75.64%

优化1:调整买入数量

现在是每天买两只、卖两只。我们把它改成每天买一只、卖一只,仓位就是各占50%。

(运行结果)

收益高了30%,达到104%了。选两个股票没有选一个股票那么高。

优化2:调整交易频率

我们再改一下,让成今天买明天卖。加一个奇偶交易判断的变量。

(运行结果)

收益提高到188%了。加了这个奇偶判断变量以后,它有个什么特点呢?它不会出现当天买和卖同时出现了。它买就是买,卖就是卖,不会出现同时一天又买又卖。

优化3:过滤不良样本

从这里来看,现在已经提高很多了。那我们还有什么办法能提高它的收益率呢?

看这里,这里它的回撤比较大。我们看一下这个股票它有什么特点,能不能把它过滤掉,从而让它的收益进行一个提高。

这里是2月11号买的一个股票,我们看一下2月12号买的是什么股票。

2月12号香油泵,19块5买的,18块6卖的,跌了将近5个点。所以回撤这里比较大。

我们看一下这个股票它有什么特点。很明显,这里它虽然是跳空高开了,但它高开了多少呢?这个最低价是16.75,最高价是16.74,只差了一分钱。

如果我们把这个跳空高开的幅度把它限制一下,就可以把它过滤掉。

我们把当天的最低价要大于最高价加0.02,看改成这一句,看它的收益会怎么样。

(运行结果)

收益已经达到203%了,回撤也降低了很多,把它进行过滤掉了。所以说这里过滤的话,这个你们还可以改成0.3、0.4都可以改的。

优化4:增加成交量过滤

我们发现有些是冲高回落很多,我们再把它改一下。

添加条件:

获取过去三天的成交量
获取当天的收盘价、最高价
成交量不能太大
最高价也不能比收盘价太多
就是说冲高回落这样的股票不能买
还加了一个条件,成交量之比不能大于一定要大于1

(运行结果)

收益率又提高了。所以说刚刚一个那么差的策略,经过我们几个地方的修改以后,它的回撤没有发生什么变化,但它的收益率已经成倍的增长。所以说明我们这些修改的方法还是有效的。

风控管理

最后讲一下我们风控怎么做的。

风控数据准备:

首先我们读取上证的指数,然后:

当天的涨幅是多少
最近三天涨幅是多少
当天的成交量和前面一天的成交量的比

然后再把这些保存起来。这个是每天都会执行一次的。

风控模块:

首先我们定义标记风控模块等于0,表示没有风控。然后再读取风控数据。

风控条件包括:

大盘放量下跌——当天大盘放量下跌,第二天的话我们肯定要把股票全部卖出
大盘连续下跌——就是说第一天跌了,第二天也跌了,然后也把它卖出
大盘三日下跌超过2%——那么我们也应该把它全部卖出
大盘缩量上涨——那么我们也要把它卖了

当标志等于1的时候,我们就把它所有的给卖掉了。

这个风控的话暂时对这个收益还没有什么影响,只是说风控模块大家可以在这里做。我只是把代码贴出来而已,大家可以自由发挥。

持仓天数调整

还有一个持仓天数的改变,会不会它的收益会增加吗?我们再来试一下。

持仓天数我们现在是当天买今天卖,所以是0。那么我们改成1以后,它的收益会有什么变化?

(运行结果)

看减小了,所以说这样改的话不太好。但我告诉大家的只是一个方法而已,大家可以试着去改。

第五部分:策略实盘注意事项

基本原则

策略开发出来以后,我们肯定要实盘。那实盘我们应该注意哪些事项呢?

1. 策略稳定性

我们回测出来的策略都是经过回测的,是有一定的稳定性的。如果长期跟下去的话几乎不会跑不赢大盘。这是我做了两年策略所总结出来的经验,确实是可以跑赢大盘的。

2. 仓位管理

跟策略的时候,不要满仓跟。先用小资金跟,比如三分之一或者四分之一的仓位跟一个策略。不要满仓去跟一个策略,一个策略的资金不能超过三分之一。

3. 严格执行

必须严格执行策略的交易计划。亏了就不出,赚了还想多赚一点,这都是不对的。因为你不出就没有资金买下一只股票了,这样机会就不均等了。

4. 加仓策略

跟第一次如果亏了也没关系,可以跟第二个,把第二个仓位稍微加大一点。因为第一个亏了以后,第二个赚的概率相对来说会大一点。

如果再回来第三次、第四次,我们都可以再加大一点资金。这样慢慢加上去,只要买对一只,基本上就会把前面亏损的赚回来。

但是一定要注意:买第一只亏了,一定要把它卖掉,千万不能加仓,千万不能加仓。

5. 策略失效判断

如果一个策略走坏了,评判它的标准就是回撤超过前面前期的回撤。像我们一个策略,如果它回撤大于20%的话,我们认为这个策略已经走坏。

6. 人工复核

策略出的股票最好我们自己再分析一下,可不可以买?结合一下大盘,觉得有把握仓位就重一点,反之则小搞或者不搞。

总是一句话:宁愿不断也不能亏。你本金还在的话,机会就还在。

7. 灵活调整

最后也是最重要的一点:严格执行,一定要严格执行。当然了,对那些趋势比较好的股,你有把握的话可以多拿一两天,前提是你还有资金买下一只股票。

常见问题

最近的话,经常有人跟我说,他说我一买就亏,一不买就涨了。有很多,所以说他们跟策略的时候赚不到钱。

这最根本原因就是他没有坚持下去,认为亏了一次以后就不相信策略了,然后就不做了。然后看策略今天涨了,然后又去买,结果又亏了。

所以说,既然你做策略的话,就一定要坚持下去。

组合策略

跟策略的时候,最好不要满仓去跟一个策略。我建议的话,最好是一次可以从平台上选3到5个策略去跟。

这样的话,一个策略跑坏了也没事,两个策略跑坏了也没事,因为你其他策略还是赚钱的。所以说我们要想盈利的话,还是要看整体收益。

实盘案例

这是我上个月测试所做的一个交易记录。上个月的话,收益是31%。基本上都是在收盘的时候买卖,开盘的时候就买了。

因为我在前面一天我就挂涨停价买,所以说肯定是9点25是可以成交的,而且是以开盘价成交。

我们的策略展示

最后再讲一下我们最近开发的一些策略,哪些策略是我们开发的?

策略1:打板策略

我们看年化收益最好的,这个是安子天吉,这就是我的搭档。然后这个策略是我们做的,这是打板的一个策略。

这个我们做的话是一天买一天卖,满仓买、满仓卖。这个策略收益还是可以的,大家可以关注一下。

策略2:均线金叉策略

这个也是我们的,这是安子的头像。你们看这个头像的话,都是安子的账号,我跟他是一个团队的。

这个是我们做的一个均线金叉的策略。这是平均仓位,收益的话不是很高,所以它的回撤也比较低。

其他策略

这个也是安子的。所以我们开发的策略还是蛮多的,所以说大家在订阅策略的时候尽量可以搞组合。因为一个策略的话风险还是比较大,我们只要保持整体收益就OK了。

Q&A环节

Q: 能不能做T+0?

A: 不可能做T+0,肯定是当天买第二天卖的。

Q: 自动交易怎么实现?

A: 住款不是有湘财证券吗?开户以后就可以对接策略。

Q: 能不能一共6只,买两只、卖两只、持有两只?

A: 刚刚我们也看到了,买一只股票的话它的收益是最高的。因为排在前面的它的评分是最高的,所以说它获利的概率是最大的,所以我们就买第一只股票。

Q: 回测和实盘差距比较大怎么办?

A: 这个肯定是存在的,因为回测的话只是代表过去,实盘的话会受到外界的一些影响。

Q: 资金量比较大怎么办?

A: 你可以跟好几个策略。你不可能一个策略就拿300万来搞,那肯定是不行的。

Q: 大盘风控怎么实现?

A: 就要写一个调用函数,不用调用了,你直接在里面就做就可以了。那个risk等于1的话就表示有风控,然后你就把所有的股票卖掉就可以了。

大盘风控的话,其实对于第二天卖的话,大盘风控没什么作用。大盘风控主要用于你买了股票以后,第二天不卖、第三天卖、第四天卖,那么这个时候风控就有用了。我刚刚做的都是第一天买、第二天就卖掉了,所以说风控在这个策略当中是没有什么用的。

Q: 代码会发给我们吗?

A: 代码的话,到时候助教会发给你们,这个不用担心。

Q: 因子怎么调?

A: 因子的话只能是一个一个去调,这个没有什么方法的,就说一个一个去试。

Q: 单因子测试怎么做?

A: 单因子测试的话我没有做过,这个我也不会。

Q: 商城上的代码能买卖吗?

A: 商城上的代码应该是不能买卖的。这个代码你买了以后,人家卖给你以后,人家就没得做了。

Q: 实盘和模拟盘收益是否一致?

A: 因为我做的话,我做的策略比较多,我有十来个策略,然后我会在这十来个策略里面选最好的来做。所以说我也不是说专门只跟一个策略。

Q: 大盘涨跌加速作为因子训练怎么样?

A: 这个我也没有做过,这可以去试一下。应该说不是一种因子,而是一种类型的样本,是叫样本,像均线金叉、跳空高开这些都是样本。

Q: 策略还是要自己写吗?

A: 对,策略还是要自己写,没办法。这个是谁也教不了你的。

Q: 代码有没有未来函数?

A: 这个未来函数你可以自己去看的,这个应该是很容易看出来的。

Q: 开盘价买入怎么实现?

A: 这个很简单,你只要在9点25分之前挂涨停价买入,肯定是开盘价买入。

Q: 代码可以分享吗?

A: 你们代码可以分享,我可以有空的话可以帮你们改一下,但我不知道能不能改到你们想要的效果。

Q: return是什么意思?

A: return的话是当天。假如今天晚上它会说明天的交易计划,所以这个return是表示今天,而不是明天。

Q: 9点15分到9点25之间挂涨停价能买到吗?

A: 可以的,9点15分到9点25之间挂涨停价肯定可以买到的。但如果是一字涨停的话那这个也没办法。

Q: 平台年化收益最高的是多少?

A: 这个你可以看到。

Q: 择时怎么做?

A: 择时的话,因为现在BigQuant只有日数据,没有分时数据,所以说择时目前是没办法做的。

Q: 因子组合怎么选?

A: 这个因子组合是我一个一个调出来的,这没有什么方法。

Q: BigQuant的收盘价收盘时就能立即获取吗?

A: 这个应该获取不到,应该要3点钟收盘以后,应该要到5点钟以后吧。

Q: 平台上策略收益都是模拟实盘的收益吗?

A: 对,平台上策略收益都是模拟实盘的收益,就是以开盘价作为买入,然后收盘价作为卖出的收益。

Q: 因子调试技巧?

A: 首先你就把因子的话,像有技术因子、财务因子,还有一些基本面,像一些什么市盈率这些因子,然后你把每一类的因子都选个两三个,然后组合到一起来看它的收益怎么样,然后再一个一个去调。

如果你看某个因子比较好的话,你再把它改成不同的参数,再一个一个去调。所以调因子的话,没什么技巧的。

Q: 有没有算法能够根据日线的数据走势判断买入或卖出特定的股票?

A: 如果这样说特定的话,那不就是有未来函数了吗?

Q: 半仓买入、半仓卖出怎么样?

A: 最好的收益是今天全仓买入,第二天全仓卖出,第二天不买,第三天又全部买入。所以说你们在跟策略的时候,因为策略有奇偶性。据我一个做私募的朋友说,私募有这样的规定,就是说当天你只要买了一只股票的话,你当天就不能卖。所以这样导致一个奇偶性。

Q: 概念股列表怎么找?

A: 这个你用同花顺也可以找得到。

Q: 你做的策略都是第二天收盘卖出吗?

A: 对,第一天开盘买。就是第一天开盘买,第二天收盘卖,第三天又买,第四天又卖。

Q: 手续费算吗?

A: 这个肯定会算。

**Q:

滑点怎么处理?**

A: 如果滑点的话,你开盘前挂涨停买入,应该开盘价成交,应该不存在滑点。就是卖的时候其实也有技巧的,就是说你在15点57的时候你挂跌停价卖,那么成交价肯定是收盘价。

Q: 一年翻倍吗?

A: 没那么高,哪有那么厉害。

Q: 可视化怎么做?

A: 可视化的话,你可以让大宽给你做,就是说让他们那边给你做。因为我喜欢用写代码,所以说可视化的话我也从来没用过,不怎么熟练,所以不好意思。

Q: 熊市单边下跌的收益怎么样?

A: 熊市的话其实也有跑得比较好的策略,赚钱的也有可能。就看你的策略是适合熊市还是适合牛市。策略的话其实都有它的时效性的,就是说不可能哪一个策略能一直获利。所以说大家一定要搞组合策略,就是说一次跟的话,把所有资金分到三四个策略当中进行跟。

Q: 实盘收益大概能到什么范围?

A: 这个谁也没办法保证的。

Q: 你的平台ID是什么?

A: 你可以看我的PPT上面有我的名字,有VJ2018。

Q: 实盘收益多少?

A: 实盘的话,我刚刚也算了一下,就是说我严格按照策略来做,做了三个月,三个月的收益是30%。是从12月1号开始做的,做到3月1号,它的收益是31%。

Q: 第二天开盘卖、卖好以后马上买可以吗?

A: 我也想这样做,但是平台不支持,我也没办法。我也想过这样,但平台不支持,实现不了。

Q: 个股周线风控怎么做?

A: 这可以试一下。就是说加到筛选栏里面去,如果不满足条件的话就不买。

Q: 你现在还上班吗?

A: 对,我现在没有上班了,我现在全职在做策略开发。

Q: 基本面怎么做?

A: 基本面的话,我没有做过,所以不是很熟悉。

Q: 找因子有什么技巧?

A: 找因子的话,这个就是要有一点耐心。

Q: 可视化怎么学?

A: 可视化的话,最好还是学下Python吧。其实Python也不难,Python我觉得是最好用的语言,比C语言好学多了。

Q: 因子在哪里找?

A: 因子的话,它有因子列表,你看那个学院里面,看文档,大宽的文档,它有介绍因子。

Q: 没有编程基础怎么办?

A: 没有编程基础,那学Python其实也很快。不是有个网站吗?有个菜鸟编程网站,那个网站上面都是有各种编程语言的。

Q: 你的微信号是什么?

A: 这是我的平台ID,微信号的话你去群里面就可以找到。

Q: 打板策略用什么因子?

A: 打板策略的因子的话,也不能说哪个因子好、哪个因子坏。因子的话还是要组合起来用。

Q: 打板策略怎么样?

A: 打板策略的话其实有,怎么说呢?它是高风险高收益。

Q: 能实现财务自由吗?

A: 我也想,大家都想。

Q: 有什么书推荐吗?

A: 书的话我前面给你说了,书的话最好是看社区里面的帖子是最好的。书的话目前市面上没有什么讲量化的书。

Q: 会不会被罚?

A: 都不敢,会被抓的。

Q: 因子一般用多少个?

A: 因子的话,其实我们做的比较好的策略有五六个因子的,也有二十个因子的、三十个因子的也有。但一般的话,我们因子是在10到20个左右吧。

Q: 多少资金做比较好?

A: 我觉得做策略的话应该在10万左右就差不多了。10万的话,你1万5买一只股票的话,你可以买五只股票、六只股票,你可以跟三个策略。

课程总结

好,今天就讲到这里。谢谢大家的收听,有什么不懂的我们后面讨论。

核心要点回顾

量化投资的本质是把选股方法转换成算法,用代码实现
样本筛选至关重要,样本数量控制在2万到4万左右,太少会欠拟合,太多会过拟合
策略优化的方法:
- 调整持仓天数
- 修改仓位配置
- 改变训练时间
- 过滤不良样本
- 增加风控条件
实盘操作原则:
- 不要满仓跟单个策略
- 严格执行交易计划
- 采用组合策略分散风险
- 亏损时可适当加仓后续交易
- 回撤超过20%认为策略走坏
交易技巧:
- 开盘前挂涨停价买入,以开盘价成交
- 收盘前挂跌停价卖出,以收盘价成交
- 奇偶交易避免同天买卖
风控管理:
- 大盘放量下跌要清仓
- 大盘连续下跌要清仓
- 大盘三日跌超2%要清仓
- 大盘缩量上涨要清仓
学习建议:
- 多研究社区策略模板
- 从简单修改开始学习
- 一个一个调试因子
- 保持耐心和纪律性
- 坚持才能看到效果
资金建议:
- 建议10万左右起步
- 单策略资金不超过总资金的1/3
- 同时跟3-5个策略组合
- 先小资金测试,再逐步加仓

好,谢谢,准备下课了,再见!

以太坊联合创始人 Vitalik：如何一年学会中文，回忆 10 年前的中国

一、回忆初访中国并获中国社区支持

肖风： 我要先说一个秘密，2025年正好是我认识Vitalik的十周年。2015年的时候，我们在上海第一次见面。在此刻我们两个人在这里对话，有很多感慨。15年的时候，Vitalik在上海大概生活了差不多有三个月的时间。所以我特别想知道，你对中国、对上海、对中国的以太坊社区，或者说对中国的以太坊开发者，从那个时候开始到今天为止，有什么样的印象？这也是中国的很多开发者非常想了解的。

Vitalik： 我记得我第一次来中国是2014年。我先来北京，然后来了上海、杭州、深圳。我从一开始就感觉到，在那个时候，在中国已经有非常多的公司、团队、开发者，他们都在做各种事情。

我记得我看了OKCoin和火币那些交易所，我发现他们的员工比美国最大的交易所的员工还更多。还有那些比特币的矿工，就是13年到14年，从FPGA转到ASIC的那个时代。我记得有一次去深圳的郊区，有一些特别大的工厂，他们有很多矿机。

在那个时候我已经感觉到，他们的规模非常大，有很多团队都在努力在各个方面推动比特币和区块链这个社区。我发现中国的那些团队很大，项目很大，公司很大，但在国外完全没有人知道，几乎完全不了解。

那个时候大概就只有交易所和矿工。我记得万向和一些其他公司，在2015年的时候就已经开始做一些更有意思的事情。所以从15年开始，我还是很感谢你们那么早就对以太坊有那么大的信心。我还记得你们买了以太坊基金会很多以太币，在那个时候我们很需要这个钱，大概可以说救了基金会。

从那个时间之后，我都感觉到中国的社区变得越来越复杂了，开始做越来越多不同的事情。比如在研究方面，包括协议研究、密码学研究、共识算法研究。可以说15年的时候，除了以色列和旧金山之间，没有什么特别有意思的研究。但到了16年，我记得有RANDAO这样的项目。现在你可以看到有非常多的各种研究，有非常多做ZK的，有非常多做AI的。所以这个社区的质量真的变得非常非常高了。

二、Vitalik如何一年学会中文

肖风： 我前天跟Vitalik说，我们这一场对谈要用中文。15年年初我们在一起的时候，那时候他还完全不会讲中文。但有一天他对我说，我要学习中文。一年以后，大概2016年8月份、9月份，万向区块链在上海有个上海区块链周，他当然是我们的主要嘉宾。8月份我提前找他说，如果你有PPT的话要先给我，我要找人翻成中文，方便与会者更好地了解你讲的内容。结果他告诉我，他会用中文写好，然后用中文来演讲，只用了一年时间而已。

我也想问问你，你是怎么这么快就不仅学会说，而且能够用中文写PPT的？这是更难的事情。

Vitalik： 我学新语言大概有一个已经做过好几次的方式。第一步，有一个可以听的audio program，叫Pimsleur。他们提供很多语言，有90个episode，每个episode是30分钟。他们帮你从开始学起，第一个episode就是”你好”、”我在美国”、”我在中国”，然后逐渐变得更复杂。他们不只是给你说，也让你自己一直在说，一直重复他们说的话，一直回答他们的问题。这是开始。

中文这个语言还有汉字这个概念，所以学习起来更难一点。我一开始用一个flashcards的app，每天给你看20个字，你需要说那个字是什么。做完这些之后，大概唯一的办法就是跟别人说话。

我记得我去一些中国城市的时候，都会看每一条路的名字，因为那些城市路的名字都会有中文和拼音，所以可以在日常生活里多学一点。一年两年之后，唯一的办法就是你需要花很多时间在一个有其他说中文的人的环境里，你就会一直每天了解得越来越多。

肖风： 我还记得16年5月份，我们一起去纽约、旧金山还有伦敦。有一次在纽约的出租车上，Vitalik、我还有分布式资本的沈波三个人在一起，沈波和我用中文讲一个事情，还没讲完，Vitalik就拿出他的手机问我说，你们刚才讲的那个词是不是这个意思。中文就是这样学会的。

我还记得2016年1月份，万向区块链和德勤会计事务所共同在上海举办了第一次以太坊黑客松。当时有100多人从全球各地飞到上海，大部分是从中国、北京或台湾来的。但也有一位意大利裔的高中生从意大利飞到上海参加。他是一个人来的，我们临时组队，结果他们拿了一等奖。

那个时候这位高中生找到万向区块链说，你们能不能让我加入万向区块链，我不打算回意大利了。后来我们说，你至少应该读完高中，并且需要考取大学，证明你有上大学的能力，当然你也可以辍学，然后我们可能才会考虑接受你。一年以后，他在欧洲参加了一个叫Lisk的项目，他成了里面的一个技术骨干。

三、如何看中国开发者对以太坊的贡献

肖风： 中国的开发者社区，从15年、16年、17年开始，对以太坊整个社区建设、技术开发、市场推广都做了非常多的贡献。而且他们确实表现出了对以太坊的那种非常热爱的感情，不仅贡献技术，也非常喜爱。

我记得16年，你上台在万向区块链的论坛上，下面已经把你当成明星了，欢呼程度比今天还要热闹。所以我想代表中国社区、以太坊的中国社区和中国的开发者，不管他现在是否在以太坊上做开发，大家都期待以太坊基金会或者你本人能够表明，从基金会的角度或从你的角度，你期望怎么样让大家在中国更好地建设以太坊社区？这些开发者能够有什么样的途径，在得到以太坊基金会和你本人的支持下，更好地在以太坊上做更多应用开发？

Vitalik： 我觉得一个很重要的是，我们已经解决了很大部分信息边界的问题。有很多事情，包括中国的社区和印度、拉美的社区，之前都不知道，但现在已经改善了很多。比如我这三天见了很多项目，包括账户抽象等等。

还有我们最近做了一个比赛，大家都可以参与，谁提供的AI模型可以回答问题最好就可以收到奖励。我三天前去的一个活动就发现，有一个人现在就在参加。所以这种连接多了，这是一个很大的好处。

现在我们需要什么？第一是我们确实需要更多的应用。但应用这个词，我有时候不太喜欢。为什么？如果你说应用，以太坊可以说应用，但Facebook也会说应用，腾讯也会说应用，所有人都会说应用。所以如果我们只说这个词，我觉得不太能代表这个行业有什么特点，这个行业有什么特别有意思的事情只有我们能做好。

所以我更希望在一些具体领域的应用上，我们有更多专注。比如我不希望我们有100个人都在推动应用，我希望有25个人推动更好的DeFi（包括RWA），25个人推动DeSoc，25个人推动info finance等等。我觉得如果能谈一些具体的以太坊可以做的事情，以太坊有独特机会做的事情，那这个社区就会变得更有意思。

很多团队有机会自己开始做这些事情。现在也有人开始做社区，开始谈一些话题，开始吸引一些开发者做一些应用，这是现在可以做的。基金会有很多支持本地社区的计划，我们已经支持了很多，大家今天和昨天看到了在这里的社区，包括一些直接的支持和间接的支持。有时候我们会支持一个组织，那个组织就会支持其他组织。

因为我们自己的想法是，我们以太坊基金会不想自己控制以太坊这个生态。对我们来说，最好的结果就是我们今天做一些事情，为了明天不再需要做这些事情，这样我们这个生态就可以扩大。

四、Layer 1研发新方向：Beam Chain

Vitalik： 还有一点就是L1这个问题。L1应用有一个优点，就是你自己可以去开始做，你不需要知道现在社区的其他人。

我们最近在努力做的事情，比如Layer 2有一个问题，就是Stage 0、Stage 1、Stage 2，也就是L2是不是足够去中心化的问题。之前有很多L2团队都特别喜欢说”我们是去中心化的”、”我们是以太坊aligned的”、”我们是开放的”、”我们是最好的”，”你看我们跟Vitalik有照片，所以我们就是去中心化的”。

我们不喜欢这种游戏。我们喜欢有一些具体的规则，如果你的项目符合这些安全要求，这是技术方面的technical criteria，如果你能做好，那你的项目自己就可以作为Stage 2的一部分。所以我们希望做一个更公平的、无需许可就可以参与的生态。

在L1的开发上，我们也是这样。现在我们的研究者Justin Drake开始做Beam Chain，可以说是我们的PoS 2.0。因为从15年到现在，我们关于PoS又做了很多很多研究，现在我们知道的比10年前多了很多。所以大概我们现在知道最好的PoS玩法是什么。

在共识算法领域、在抗量子话题上、在经济学和博弈论上，我们都知道得更多了。所以我们现在可以做一个最好的、长期可持续的PoS以太坊核心。

Beam Chain的一个方式，就是故意努力让很多世界的团队都参加Beam Chain的研究。现在有至少七个Beam Chain团队，可能现在更多。我也知道可能在上海交大，可能在一些其他国内的大学，已经有一些人在直接参与这个领域。

所以如果有人感兴趣，开始加入L1的研究和开发，我特别推荐大家看一看，加入一些Beam Chain的工作。因为L1这个事情现在有一个问题，就是如果你在这个圈子里，如果你认识很多圈子里的人，那你参与会比较容易。但如果你谁都不认识，不管你的技术能力好不好，那你参与会更难。

所以我们知道这个问题，我们特别希望解决这个问题。Beam Chain的研发采用比较开放的方式，目标就是这样可以吸引更多新的团队，可以把以太坊的新部分从零开始做起来。

五、区块链如何突破”不可能三角”

肖风： 你刚才的话，我有三个问题要跟你讨论。第一个问题，大家都知道有一个理论叫区块链的”不可能三角”，就是去中心化、安全性和性能，你只能顾两头，不可能三头都顾。不可能三角不仅在区块链上，在很多地方比如汇率等等，这相当于是一个数学问题。

所以区块链如何在保证去中心化和安全性的同时，又能够提升效率、提升可扩展性？因为如果效率和可扩展性、性能不能得到大幅提升，那么它就不可能去支持大规模应用。从成本效率角度，这个不可能三角在平面上可能无法解决。

我个人的看法，到今天为止，只有以太坊的分层架构，才是目前为止解决所谓区块链不可能三角的最好结构。所以刚才Vitalik说到了L1和L2，通过这样一个方法才能够更好地解决它。

我想说的是，我们看互联网，从计算机系统到互联网到区块链，如何解决易用性的问题？把使用这个技术的门槛降到最低，把成本降到最低，把易用性提高到最高，才可能让一个新的高科技技术、服务或产品被更多人、更广泛的人所使用。

我们这个行业里大家都在问，什么时候开始出现区块链的杀手级应用，就是有大规模用户的应用？大规模应用首先必须要提高性能、降低成本、具有很好的扩展性。

从最早的计算机系统，是用命令行来操作的DOS系统。如果计算机系统永远是DOS操作系统，这个世界上会不会有1000万人使用计算机系统呢？很难说。后来因为它太难使用了，不具备可扩展性，不是用户友好，所以后来才有了图形操作系统。图形操作系统显然比DOS命令行操作简化很多，所以使用计算机系统或互联网的用户基础就迅速扩大了十倍甚至几十倍、百倍。

但图形操作系统仍然不能让50亿人都使用互联网。现在全球互联网用户50多亿，是因为移动互联网之后的APP。APP一个手指头就可以上网了。如果用图形操作系统，你还需要坐在电脑前输入网址，通过浏览器，还是很复杂的过程。当APP被发明出来之后，使用互联网、连接互联网的困难程度就大幅下降了。

这让我想到，我们用分层架构L1、L2去解决区块链的不可能三角。但如果我们希望有10亿人、几十亿人去使用以太坊或区块链，我们现在的门槛还是太高。

我想问的问题是，什么时候会出现区块链的APP时刻？比如微信是一个超级APP，微信的运行是一个极其复杂的系统，但这个复杂系统跟用户没有关系。对于一个微信用户来说，只需要一个手指头按一下就打开微信了。什么时候L2能够出现互联网时代的APP时刻？这样的话我们才能知道10亿人、20亿人能够用上以太坊或区块链，那个时候我相信杀手级应用自然就会涌现出来。

Vitalik： 我觉得不会需要很多时间。

六、L2仍有技术瓶颈

Vitalik： 我觉得现在可能最大的问题是还有一些技术问题没有完全解决。比如我今天早上演讲说了一些扩展性的问题。你应该记得，我15年的时候演讲也说过：第一是扩展性，第二是PoS，第三是隐私，第四是安全性。

现在我们在说的话题还是这四个：安全性、隐私、扩展性。零知识证明确实发展了很多，扩展性方面也发展了很多，PoS已经成功了，还有Beam Chain可以提升PoS。

安全方面，可以说协议的安全，也可以说用户账户的安全。因为我一直很多年都很担心一个问题：在一些区块链里，用户有两个选择。第一个选择是自己在电脑上、手机上或一张纸上保管私钥。这个方法特别去中心化，不需要相信任何人，只需要靠自己。但这个方法对几乎所有人来说都太复杂了，其实对我也太复杂，所以很危险。

第二个方法是通过中心化服务做所有事情。中心化服务也有风险，我们看到了Mt. Gox的情况，看到了FTX的情况。

我觉得中心化服务，我们不能完全去掉，他们做的事情是重要的。但只要我们可以找一些更好的办法结合他们，不让他们做他们没有必要做的事情。在钱包里，我们现在有multi-sig、账户抽象、ZK email，有很多很多方法。

所以在我眼里，我们从15年开始的那四个方向，可以说可能70%、50%都完成了。所以我很相信，如果我们把这些技术问题完全解决了，应用就会来。

为什么？我们已经知道，比如Worldcoin现在有1000万个用户，Sony在以太坊上做了自己的L2，还有Kraken，德国银行也做了一个L2。所以有很多机构在参与。

我们刚才谈过，比如在阿根廷、土耳其、东南亚，在很多很多国家有很多独立用户，他们都自己用稳定币、以太币、比特币或一些DeFi。所以这都有。我们只需要给开发者这个信心，如果他们现在开始做一个应用，他们成功之后，在他们下面的基础设施也会准备好。我现在比较乐观，我们都能做到。

七、将”脏活苦活”下沉至L1

肖风： Vitalik刚才讲到像德国银行这些大型机构都在以太坊上做L2，HashKey去年12月份也推出了HashKey Chain，是一个以太坊的L2。但在build这个HashKey Chain的过程中，我一直觉得和APP比较起来还是有很高的成本。

比如说如果你要去建一个L2，你需要至少20个人，可能要一年的时间，因为要做浏览器、钱包，这些都不只是写一个链而已。每年去运行这条链，只是技术运行，差不多一年也要100万美元左右。

当然我相信L2不会像APP那么便宜、那么快速、那么低成本。但如果我们设想其他人，如果你从无到有想要建一个L2，你需要花费很大资源，要找到20个懂这个技术的人。

我现在想异想天开地给你一个建议：能不能把现在L2的这些脏活累活苦活继续下沉到L1，提供更多东西，让L2变得更轻更薄？更多人可以不需要像HashKey建L2这样花这么多人、这么大资源、这么长时间。能不能做到这一点？什么时候能够做到？

Vitalik： 我们已经在做了。可以给一些例子。比如现在L2一个很高的成本就是那些integration。你需要在L2上有一些服务，所有的app开发者需要一些oracle、需要一些稳定币，需要各种其他服务。

我们可以做一个更紧密的L2和L1的连接。这是我昨天早上讲过的一些话题。第一，我们可以降低L1和L2之间沟通的时间，先从一周到一个小时，然后从一个小时到12秒。

第二是L1 SLOAD。通过L1 SLOAD的意思，就是L2上面的EVM可以直接读L1上面的信息。这样的话，你不需要每个L2都有自己的oracle信息，可以直接读L1上的信息。

还有钱包。比如钱包有一个问题，如果我们希望支持一些账户抽象的东西，我们希望让用户能够改自己的密钥、改自己的想法、改自己的一些设置，那我们需要在每一个L2发一个交易。这个问题也可以解决。

这就是我说过的keystore的概念。你可以把钱包的一些核心信息放在L1上，如果需要改，可以在L1上改，那每一个L2的交易就可以直接读L1上面你自己的状态。

所以有很多这种例子。如果我们能够做一个更好的L1和L2之间的连接，那我们对L2需要做的事情会少很多。这是第一。第二，我们会有更多的应用，不只是L1的应用或L2的应用，他们会是L1和L2一起的应用。

肖风： 如果L1能够承担更多的脏活累活苦活，大家所诟病的L2创造了价值最后没有被L1捕获到，这个问题也能解决。如果你提供了更多服务，把更多脏活累活干掉了，让L2变得更轻更薄更易用，那么L2自然应该给更大的价值给到L1，因为要为L1的服务去付费。这也是解决大家目前诟病的L1没有办法捕获到L2上面很多价值的问题。

Vitalik： 对对对。

八、并非所有事都应彻底去中心化

肖风： 这当然是好消息，如果能够很快实现的话，这对于以太坊上的应用绝对是好消息。

另外我想，你刚才也讲到了中心化和去中心化。现在实际上有很多人为了去中心化而去中心化，标榜自己，比如给你照张照片说”我们是以太坊的，我们是去中心化的”。

但现在面临一个问题：走到应用层的时候，基础设施，以太坊的基础设施绝对应该去中心化。但当你走到应用的时候就会出现，可能我们不能做到绝对的去中心化。

比如你刚才讲到的RWA。RWA你怎么能做到绝对去中心化呢？因为任何一个RWA的发行，都可能被认定为一个证券的发行。一个证券发行自然会有发行者、运营者、批准者、监管者，那么就一定会有半中心化或某些中心化的因素在里面。

我们要去跟传统金融结合，用以太坊或区块链来打造一个新的金融基础设施。金融之所以有严格的监管，是因为金融具有非常巨大的负外部性。割韭菜在传统金融里是要被监管的，因为这是一种负外部性，是一种不好的外部性，是一种减少社会福利的外部性，当然要被监管。

随着这两边融合越来越多，我觉得可能会分层：作为基础设施，以太坊的L1必然是去中心化的。其实互联网的基础协议也是去中心化的。IP协议你需要经过谁的审批吗？使用IP协议来构建自己的互联网，你需要谁的许可吗？都是开源开放、无需许可的。

区块链技术也是开源开放、无需许可、去中心化的。但到了应用层，互联网的应用层就必然是中心化的。区块链我们不希望那么中心化。你怎么看待中心化和去中心化，尤其从应用层角度来说？

Vitalik： 在应用层，如果我们想多做一些跟实体经济有关系的事情，那我们不能做完全的去中心化或完全无需许可。为什么？因为实体经济不能靠密码学证明所有事情。

比如我们做电商。我有个手机，我给你卖一个手机，你先给我发0.5个以太币，那我给你发手机。你收到之后，你可能发一个交易确认。但在这个过程中，我有没有真的给你发手机这个事情，没有什么密码学的方法能知道我发了还是没发。

有可能我们可以做一些新时代特别厉害的ZK，我可以说我把手机放在DHL包裹里，我可以给你DHL的确认。但第一还是需要相信DHL，第二还是需要知道我有没有在里面真的放那个手机。

所以我们能减少信任的要求。很多时候减少信任要求是很好的。为什么？如果信任要求很高，那必然意味着只有一些人可以参加，只有大家已经相信的人可以参加，那这个经济、这个市场就会变得不公平，就变得只有一些人可以参与，市场就会变得可能垄断。

如果我们可以减少一些信任要求，那有可能更多人可以参与，更多人可以做手机、买手机。如果我们有更多有意思的经济激励或验证方式，那这会让更多人能够参与，这个事情是好的。

所以那些区块链上的智能合约、资产、代币等等，他们可以代表实体世界里过程的每一步。你可以发一个哈希，你可以说在这里发生了什么，在哪里发生了什么。这有可能会有一些优点。

比如在RWA领域，我可以发一个稳定币。举个例子，我可以发100万个单位。如果我在链上发100万个单位，你可以在网上看到我只发了100万个，我没有发110万个，没有发200万个。同时你可以用ZK-SNARK这些方式，你可以知道我在银行账户里真的有那些100万美元或港币或其他资产。所以你是可以通过这些方式验证的。

或者还有一个例子，如果我是一个政府，我可能会给一些公民数字身份，就是一个数字ID。有可能会有一个问题，比如说有100万个公民，他们会担心我做了100万个假的ID，把假ID又给了一个组织。他们可能会在一些社交媒体上做一些假的事情，做很多这样的假账户。

如果我把那些数字ID放在链上，那就会知道我只发了100万个，我没有发200万个。所以有很多很多这种方式，可以用密码学、用区块链、用很多我们研发的技术，我们可以减少信任要求。

通过减少信任要求，我们就可以做一个效率更高的经济和社会。第二就是一个更公平的经济和社会。为什么更公平？如果信任问题很高，那就意味着只有一些大家已经相信的人可以做事情，其他人大家都不会信他们。所以如果有很严重的信任问题，那必然会导致一个更中心化、更垄断的社会。

所以如果我们有更好的验证方式，我们可以解决更多问题，我们可以让更多人参与，建立一个更公平的环境，互相协作。所以这些是可以做的。

完全去中心化在应用层，有可能在一些领域是可以的。比如如果我有一个数学题，我特别想有人能解决这个数学题，我可以做一个智能合约，在合约的逻辑里，我可以自动验证你有没有真的解决了。如果有，我给你发100个以太币，如果没有，我就不发。但这个只有在一点点领域可以做，在99%以上的世界经济里，这是不可能的。

肖风： 这是一个很重要的问题。我们所有在做Web3应用或区块链应用的时候，我们要明白，不是所有东西都能用去中心化的方法解决。当然能够用是最好的，因为它确实可以免除信任成本。如果去中心化做得好的话，整个经济活动变得更公平，成本会更低，效率会更高，这当然是好的。

可是如果涉及到物理世界、现实世界的很多东西，刚才Vitalik讲到的就是买个手机，你还是得信任DHL，你得相信DHL确实看见他把手机放在包裹里，而且DHL会负责把手机送给你。当然付款过程你可能可以不需要中介。

所以我们不需要拘泥于从底层到应用层都必须百分之百去中心化。去中心化只是为了创造一个更公平、更高效、更低成本的商业环境。能用的应该用，但并不是去中心化能包治百病。

九、中国开发者社区的重要性

肖风： 这是另外我想跟你讨论的问题。我们看到大规模应用，因为最终我觉得区块链，我们以太坊走到分层架构之后，其实就已经进入到了区块链大规模应用的新阶段。

刚才Vitalik也讲到，很多技术的发展，包括L2的继续优化都会很快，技术都在发展得非常快。那么大规模应用，我们从过去从互联网时代开始，互联网、AI到加密区块链，你发现全球前15大互联网平台，除了美国以外就是在中国。

AI也是一样。AI大模型除了美国人有能力开发AI大模型之外，通过DeepSeek我们发现中国人也是有这个能力的。但你反过来看世界上其他国家，日本、印度或者欧盟、英国有大模型的开发能力吗？至少到今天为止没有，他们没有拿出证明说他们也具备这种大模型的开发能力。

到区块链，我认为也是会一样。大部分开发者要么在使用英语，使用英语的人会多一点，但欧洲当然也有。但从规模来说，还是英语地区的人多一点，或者以北美为核心的英语地区多一点。剩下的就是以中国为核心的讲中文的开发者，是另外一个巨大的群体。这两个是全球的两个开发者核心。

如果真的要做大规模应用，那么中国开发者和美国开发者之间，如果有什么不一样的话，中国开发者其实更多在应用层面有很强的开发能力，也有很强的经验，有很强的运营能力。因为从互联网平台开始，中国人就很”卷”，结果是出来了很多产品经理、平台运营者、开发者，非常有经验。

你就说现在全球前十大数字货币交易所，为什么会有超过一半是由中国人或有华人在运营的？因为交易比特币本身，在技术上并不会说不同的交易所交易的比特币是不一样的，其实你交易的还是同样的东西，但是客户体验中国人显然会做得更好。

那么好，现在问题就在于，以太坊如果我们要认为目前进入到一个应用阶段，我们怎么样去发挥好华人或者中国人这些开发者、运营者，不光是开发者，包括运营者，也包括用户？

其实互联网平台最主要的区别，我认为就是一个是英语的用户大概有十几亿，另外一个就是中文的用户也有十几亿，中国本身就有14亿人，然后加上大中华地区，这是两个巨大的客户群体。所以导致从互联网到AI到区块链，现在以太坊基金会，如果你真的要希望有很多应用部署在以太坊上，那么怎么样去发掘这个华人地区的这些开发者、运营者，包括用户？有什么样的策略安排吗？

十、基金会资源有限，望社区自我成长

Vitalik： 我觉得做应用这个层，大部分不是基金会应该直接做的。我们应该做的事情，就是我们可以支持社区去做。

因为我们不希望有一个5年后和10年后，大家都在靠这个基金会，都在问基金会要做什么，完全靠我们会怎么发展以太坊。我们希望是全球的每一个社区自己变得更强大，给大家能力，愿意并能够自己去做更多事情。

我们最近发现，其实在中国、在亚洲一些社区，他们一直在努力。在拉美也是，在非洲最近也是。所以我们跟这些社区的组织有比较多的沟通。

我们为什么说我们不想做一切？有两个原因。第一是如果以太坊这个社区变得过于中心化，那也有很多自己的问题。第二就是基金会的资源是有限制的。其实我们基金会有的以太币，好像比斯坦福大学的还更低。所以我们的资源不是很多，其他人有更多。

还有一点就是在应用这个层，本质上是可以赚钱的。如果你做一个好的应用，你可以找投资人，你可以自己找用户，如果你做的应用是好的，你也可以自己成功。

所以我们一直在思考一个问题：有什么如果我们不做的事情，社区自己不会做到？所以L1就是一个很重要的答案。

还有一些其他的答案，比如我说过的那些ZK email、账户抽象、隐私和其他的ZK应用。这些事情他们可以解决很多应用层和钱包层的一些降低信任要求的问题。但每一个应用对他来说，做这些技术太难了，需要的资源比较多，这也不是他们的专业。所以我们就开始做这些事情。

所以现在我就是做一些重要的事情。第一就是做这些社区，给更多开发者机会，让他们知道我们在以太坊里面做什么，我们在做什么，以太坊为什么存在，应该在以太坊上怎么开始开发一些事情。以太坊和L1、L2、ZK、客户端是怎么结合的，在哪些应用场景是最有意思的。

但是这些我们基金会没有足够的资源和能力在全世界做，所以我们希望跟这里的本地社区有更多合作。其实我们已经开始了，我觉得比两年前我们的一些沟通已经好了很多。所以这样可以开始。

我们希望的就是，如果这些社区有一些问题，有一些他们觉得他们需要的是我们可以做的事情，那我们也可以帮助他们做。这样的话一年两年之后，或者更长时间，不同城市会有更好的社区，有更多的开发者，那以太坊的新一代就已经开始了，可以持续发展。

十一、应在香港设办事处并重启黑客松

肖风： 刚才Vitalik说到，基金会只做应用层的开发者不做的事情，比如ZK、L1这些，这是对的，因为基金会有基金会明确的定位。在应用开发上，他们可能需要得到基金会包括以太坊社区的支持和帮助，怎么样在以太坊上做得更好，那这是帮助。

所以今天一天的会议ETHAction，我们也是把在亚洲不同国家的以太坊社区的人请在一起。我们希望每年都有一个这样的亚洲以太坊社区的聚会，大家来交流，怎么样在亚洲来推广以太坊的应用，或者也推广以太坊的技术。这是一个方面。

所以在这个基础上，我觉得明年我们也希望整个亚洲的以太坊所有社区也能有这么一天聚在一起，来讨论大家关心的问题。

但同时我也有一个建议给以太坊基金会：我希望以太坊基金会能够在香港设一个办事处。大家都非常希望在香港有个办事处，方便亚洲的这些以太坊社区、以太坊上的开发者，哪怕你是做应用来寻求以太坊基金会的帮助，不一定是资金上的帮助，而是辅导、咨询辅导，甚至帮助他们获得更多曝光。

其实我们今天一天的会议，包括昨天我们也是在帮助以太坊的很多开发者、很多项目增加曝光的机会，大家有一个交流展示的机会。这是第一个建议，希望以太坊基金会能够认真考虑。（现场掌声）

第二个建议是，我觉得以太坊基金会，包括尤其是你本人还是应该到中国去，到中国去，不管是去跟以太坊的开发者见面也好。你以前做得非常好，当然后来有疫情，我记得你应该17、18年还去上海，后来因为疫情或者也有些其他原因。

我建议现在是一个很好的时候，恢复以太坊基金会在内地的黑客松也好、workshop也好，包括你本人去。比如说我们今年10月份要在上海举办第11届区块链峰会，你参加了其中的七届，前面连续7年你都参加了。邀请你去。

邀请以太坊的组织者，不一定是基金会的，而是大家有兴趣的话。从万向区块链角度，我们当然也愿意，我们有迫切的这样一个意愿，在内地不同的城市继续恢复以太坊的workshop、以太坊的黑客松。通过workshop、通过黑客松其实是在辅导大家，让大家用以太坊的技术来更好地做各种各样的应用。就这两点建议。

Vitalik： 谢谢你的建议，肖总。还有谢谢你这么多年对以太坊社区、基金会、区块链生态那么好的支持。

肖风： 好，谢谢大家，今天我们就会谈到这里。我可以保证的是，我们在这之前两个人没有任何沟通。谢谢，再次谢谢肖总、Vitalik，让我们再次致以最热烈的掌声，给两位带来今天意义非凡、跨越10年的对谈。

全文完

Tron 创始人孙宇晨专访：谈稳定币、太空旅行、永续合约、新叙事和亚洲的加密地位，为什么投资 DAT 优于 ETF？

一、关于稳定币的竞争与发展

采访者开场： 非常感谢您做这件事，我非常感激。对于这次采访，我准备了一些道具来保持趣味性。让我们看看第一个，这是二十美元的旧绿钞，这代表稳定币。

显然这是今年最大的叙事之一。Scott Bessent认为美国将有两万亿美元计价的稳定币，Arthur Hayes认为是十万亿美元。然后还有新区块链，比如Tempo和谷歌的G Dollar。接下来聚焦稳定币，USDT是最大的稳定币，大部分流量在Tron链上。

问：所以我很好奇，你担心这些竞争对手吗？你在关注它们吗？接下来你们的策略是什么？

孙宇晨： 首先，稳定币结算网络是重要产业。我认为今年随着Circle在美国的IPO，真正将其带入主流视野。之前这个行业规模依然庞大，但公众并未对此给予太多关注，但我认为这是好消息。

越来越多的人开始进入这个行业并开始意识到，USDT比传统方式要好。所以这就是为什么我认为我们乐于贡献并成为其中一部分。

其实我认为大公司，我们已经听到摩根大通和花旗银行也想发行基于区块链的稳定币。我认为越来越多的大企业关注这一点，这是好事。

无论他们最终是否推出产品，我认为首先是要提高公众意识，这对空间中的每个参与者都有利。如果他们推出、发行一个优质的稳定币，在我看来，所有类型的稳定币互相帮助，因为你们共享资金池，共享流动性。

所以最终，例如如果谷歌发行稳定币，该平台的银行渠道将助力其他稳定币发展。这就是我的理论。所以这就是为什么我认为我们拥有的稳定币越多，行业会越强大。

采访者： 这让我想起”涨潮举起所有船”的说法。

孙宇晨： 没错，就像流动性一样。

二、太空旅行经历

采访者： 好的，我们再来看看这里。这是一个更轻便的版本，我有小火箭飞船。所以上个月你乘坐火箭飞船进入太空，你从比我们现在更高的地方看到了地球。关于这一点我的第一个问题是：地球是平的吗？

孙宇晨： 首先，我的第一印象是地球非常渺小。从太空看去，它只是一个非常小的星球。我们所关心的一切，我们所想到的其实都处于一个小小的星球上。

同时，从太空观察会发现，我觉得你会感到地球是脆弱的。太空中发生的任何事都可能影响我们。所以这就是为什么我认为我们需要珍惜在这个星球上生活的机会并尽力而为，我们能做的就是保护它。我认为这也是非常重要的。

第三个，我是第一百一十二号去太空的人员。

采访者： 哦，小团队啊。

孙宇晨： 是的。自从加加林那时候开始，我觉得是1960年代。但我认为那将是地球的未来，越来越多的人将来会进入太空。正如尤里·加加林预测的，我认为人类的未来将是多星球的，将来人们也会去太空，就像我们现在坐飞机一样。

所以这就是我认为的迈出非常重要的下一步。即使对我自己，我会投入更多精力去探索如何帮助、促进和协助推动航天工业发展。

采访者： 听起来太棒了，我希望在我有生之年实现。几个问题，我一直对太空着迷。是否感到幽闭恐惧？比如飞船的大小这类问题？

孙宇晨： 我觉得没问题。因为我觉得今天的宇宙飞船和我们过去见过的完全不同。我觉得二三十年前，尤其是内部设计其实并不好。但今天我认为所有飞船内部设计就像iPhone一样。

所以和酒店没什么不同，我觉得你感觉像离开酒店一样。我认为这是第一点。

然后第二点其实非常用户友好。不会像飞行员那样，面前有上百个按钮，你根本不知道该做什么。对我们来说，只有几个按钮，有非常用户友好的界面，所以你知道该做什么。

当然在去太空前都做过演练，他们反复训练。所以这就是为什么当你进入太空时，你会感到安全且空间更大，并做好准备。

采访者： 关于太空再问几个问题，因为太有趣了。他们让你之前不吃东西吗？你之前被允许吃东西了吗？比如饮料，是不是只喝水？你和机组成员的交流或rapport如何？

孙宇晨： 首先，我不觉得起飞前喝水或吃太多食物是好的做法，所以不要这么做。我自己停止吃东西大概在24小时前，只喝少量水。

但当然大家都不想出问题，所以我们都要穿尿布在起飞前。但在起飞前尽量减少食物和水的摄入，这很重要。

因为对我们来说很幸运，我们有八分钟的发射窗口。但大多数时候，我觉得几小时延误没问题，非常常见。有时甚至听说八小时延误，你就坐在那里。

现在我觉得这几天几小时应该没问题，但如果在以前，二三十年前，听说甚至一天延误都很常见。所以这就是为什么不建议饮水或进食太多，稍微一点应该可以，但不要喝太多、吃太多。

同时，我觉得我们作为团队六个人一起去那里，所以宇航员之间的关系也很重要。我们的团队有一个独特名字叫”Unity-1”，因为每个人都来自不同国家，实际上是不同大洲。

采访者： 真酷。

孙宇晨： 所以这就是为什么我觉得这个名字代表着一切。同时也很重要，我们需要共同努力才能一起探索太空。

所以这就是为什么双方都支持ISS和太空探索，总是倡导、强调团结。在某些案例中，为了共同合作，即使是不同国家今天，即使是俄罗斯和美国，大家团结在一起。但我们需要学会如何合作，这也是非常重要的。

三、永续合约与收益叙事

采访者： 好的，让我们回到现实世界、区块链。我们来看看这里有什么。这是个小存钱罐，这代表了现在加密货币中的另一个重大叙事，那就是收益叙事。我认为最流行的例子比如Hyperliquid或Pump.fun，这确实抓住了加密行业。

首先，你对这个整体收入叙事有什么看法？而Tron正在考虑在这个叙事中做些什么吗？有没有这方面的项目案例？我知道Tron网络收入近期有所增长。

孙宇晨： 对的，完全同意。首先，我们真正相信这一点，所以这就是为什么我们三天前推出了永续合约。我们刚刚推出了一款产品，我相信去中心化期货拥有光明前景。

总的来说，首先，因为期货是自区块链发明以来创造的最重要的东西之一。另一个当然是稳定币。我们行业创造了稳定币，为永续期货交易而发明。因此我认为有巨大应用场景。

同时我也认为去中心化期货有很多优势，因为人们可以自由尝试，他们可以保障隐私，没有对手方风险。同时他们也可以享受流动性，因为永续交易的流动性比现货交易更好，因为现货交易受杠杆限制。

我认为总体来说，在Tron上我们也得到了支持。永续期货非常重要，其中一个原因是这些Tron项目有更多曝光和交易机会。

在那之前，Solana叙事有不同的、规模相当大的平台。所有区块链上都会出现交易机会。因此交易者需要在不同区块链间转移资金最终抓住交易机会。

但通过永续合约，例如在Tron上线，因为永续合约可以交易所有不同的加密货币，他们不需要依赖那条链。例如现在在Tron区块链上已支持35种资产，我们正在扩展到200种资产。

这就是为什么资产支持范围如此广泛，资金无需离开。现在你可以自由接触全球各类资产。所以这就是为什么我认为Tron链上的永续合约非常特殊且重要。

如果我们想留住所有用户、留住所有交易者在区块链上，未来我认为永续合约代表的是区块链交易期货最大的原因之一是资本效率。

在杠杆交易中你可以用十美元换一百美元，但现货交易中只能一比一交易。这就是为什么我认为杠杆更有流动性、效率。这就是为什么我相信永续合约最终今天已占据区块链市场大量流动性，我相信会继续保持。

采访者： 你觉得这种新兴永续合约技术会继续推进吗？

孙宇晨： 是的，我确实相信越来越多的人会开始了解永续合约交易。因为理解永续合约需要一定的基本财务基础知识。

进行永续合约训练，因为小规模训练非常简单，就像大家都在股票市场做的一样——在股价上涨时买入、卖出它，赚钱，容易理解。

但永续合约可能有点困难，但更强大，因为杠杆更高。它更高级，比现货交易高级，但需要理解一些基本概念，花五分钟就可以。但仍然需要花时间学习，因为它涉及到资金费率、仓位、平仓、开仓等概念，需要了解一些时间。

时间很重要，因为与持仓量、开仓历史、清算价格、清算阈值相关。但学习这些是好的，因为它代表更好的资本效率、更好的流动性。所以这就是为什么我认为未来一定是这个方向。

我也听说过例如期货期权，永续期货的基础。我认为这些甚至更复杂且对散户更难入门。这也是为什么你看不到比如像Robinhood五年前的情况，当时没人交易期货期权。而永续合约才是更好的、更适合的产品，我认为对大多数人来说，包括我自己。

四、数字资产国债（DAT）优于ETF

采访者： 好的，我们继续。这里有个小礼物，这是我尝试讨论数字资产国债（DAT）。有人称其为加密资产的wrapper。首先你认为这是不错的描述吗？或者你会用不同的方式描述？

孙宇晨： 首先我觉得这绝对是对整个加密货币行业好的事情。有多个原因值得考虑。

我认为首先，我觉得总体上DAT比ETF更好。因为ETF，大家都知道，我们有黄金ETF、比特币ETF，这不是主动管理策略，基本上是被动的，而且是一一对应。而且很难捕捉到价值。

我认为对于比特币，这有点不同，因为比特币本身差异不大。所以这就是为什么我觉得被动策略有点像保持安静的ETF。但其他方面又有不同，我稍后会解释。

但说到像Tron这样的区块链，像其他区块链，其实我认为DAT公司很重要。首先，你需要了解区块链基础，如果你投资于这些公司，不会像短期内影响那么大。

因为年化收益率有4%或5%，但如果说十年时间，可能是50%。而且以太坊和Tron区块链，你有DeFi，你有去中心化永续合约，大量新机会。

所以总体而言，你可以获得质押年化8%。这类机会可以被DAT公司抓住。当然我们讨论的是那些将要专注在这些链上构建的大型公司。

我知道有些公司转向了广告业务想维持股价，除了这个之外，我认为如果DAT公司专注于构建该协议，长期来看每年差异会显著，差距可能达20-30%。如果说到三年时间，这将是百分之百确定的。

从长远来看，所以这就是为什么首先我认为DAT公司比ETF更好。而且公司在灵活性方面确实更好，因为ETF就是ETF价格，包装币，基本上不会有任何区别。

但DAT公司不同，因为这家公司，尤其是拥有优秀的管理团队，他们可以灵活调整，融入区块链行业以更好地利用资本市场，以最有效地促进区块链生态发展。

所以这就是为什么在我看来，我认为DAT方案同时更好，我认为这个策略比ETF更好。因为还有一些监管规则，有些基金基本上有很多规定，他们不允许购买ETF，因为是被动型的。所以他们可以购买上市公司，但不能购买ETF。

有很多这样的要求。总的来说，我认为这些公司相比ETF更具可及性。但我觉得最终未来所有主流代币最终都会在美国有ETF，而且它们也会有主动管理的DAT类公司。所以两者都服务于不同目的，我认为这将在行业中成为常态。

采访者： 接下来快速回答两个后续问题。听起来你是在说，DAT公司可能更好，如果比较比特币DAT公司与Tron或以太坊，许多DAT类公司，它们更加强大。在非比特币领域，它们对比特币仍然很好，对其他项目更是更加强大。你同意这个观点吗？

孙宇晨： 是的，完全同意。我想让你考虑一些可能发生的情况。因为我们只是正确选择了公司，例如像一些公司实际上可以质押他们的资产用于收益。

所以他们可以获取收益。比如在Tron上质押，此外还能获得5%的质押收益。以太坊也有相同类型的机制。所以我更倾向于分层架构，你也可以在Solana上有类似Jupiter和其他服务。

同时还能将这些整合到收益服务中。当然也能获得相关领域的收益。需要对黑客问题谨慎，但我觉得增加了额外的收益层。

所以如果公司持有大量资金，他们能获得更多相关收益。通过质押协议可获得更多代币。因此最终我认为公司如果管理得当将更灵活。

当然如果管理不当，可能损失资金，这也是问题所在。但从未来视角来看，智能合约DAT公司如果管理得当的话，他们实际上可以为股东争取更多收益。

采访者： 这真是太有趣了。我得好好想想，我从未从这个角度考虑过。

五、亚洲在加密货币中的地位

采访者： 好的，我们还有一个问题。另一个话题，韩国零食，非常美味。我们现在在韩国，在亚洲。从新闻角度，我认为今年的重点在于美国，显而易见的原因。

我很好奇，你是否认为加密行业焦点仍在美国？你对现在美国与亚洲的加密对比怎么看？

孙宇晨： 首先我认为这是今年的开端，大家都在关注美国，因为政策变化，因为美国政府比过去更友好于加密。

但同样，当然我觉得亚洲的加密确实在快速增长。我们在香港达成共识，韩国的KBW，日本的Web应用，今晚就在这里，新加坡，我们看到了迪拜正在增长，泰国，一切都处于增长中。

这就是为什么我坚信不疑，亚洲已成为加密货币的重要枢纽之一。除了美国之外，我认为我们拥有亚洲、美国、欧洲，将成为主要加密市场。

现在非洲是新兴市场，但流量不多。但在交易量和兴趣方面，亚洲和美国是最大的。

采访者： 我注意到，只是四处旅行后，亚洲更多是普通用户实际使用加密货币，而在美国则并非如此。我不说投机，更像是投资。他们并不实际使用加密货币用于实际用途。

孙宇晨： 完全正确。我认为美国在加密使用率方面高低不一，我不会预计大量美国用户。我认为原因之一是过去监管进展缓慢。

采访者： 还有关于韩国的事，你对韩国有什么看法吗？比如韩国在加密货币中的地位？我住在日本，所以我觉得我对日本有一定了解，但我不太了解韩国的加密货币生态，除了韩式溢价，这个大家都知道。你对韩国的地位有什么看法吗？

孙宇晨： 是的，我认为韩国是加密货币领域的领先者之一。原因在于韩国政府一直很友好，就加密货币支持而言。

比如主流加密货币，韩国的交易所实际上可以交易大多数加密货币，但日本的话，差距大得多。

韩国政府税率更低，资本利得税也比日本低。所以我认为韩国一直是整个行业最重要的市场之一。

采访者： 好的，感谢您的时间，先生。我知道您很忙，我知道您明天有演讲，我很期待听到您的观点。

孙宇晨： 谢谢，非常感谢。

全文完

看雪公开课五：《区块链安全从入门到不放弃》

智能合约工程师的赚钱方法

补充：关于推特 API
还有一个事情，就是我最近在做推特相关的东西。因为之前的话，就是那个推特可以买一个 API，那个 API 是永久的，但是那个现在，就是自从它被收购之后就不能用了。后来我发现就是有个平台叫做 RapidAPI，那个上面就是有一些开发者，他基于这个推特现有的 API，他自己去封装了一个服务。那个成本要比官方，就是官方这个 API 的那个成本要低很多。如果你没有做推特的话，可以去看一下那个。

一段话简略总结会议内容，保持简洁正常文本格式。
智能合约工程师分享了通过工作、用钱生钱等方式赚钱的经验，重点探讨了区块链大周期投资、套利与端盘子、远程接单、自媒体变现以及工作附加收益等原始积累途径，并介绍了DeFi质押、全球利率套利、返利卡和货币兑换等被动收入方式，强调通过控制支出实现“不必赚钱”的财务目标。

一、赚钱路径与核心理念

主要赚钱方式

工作赚钱存在时间、做事、技术更新和社交多重成本。
用钱生钱是更可持续的模式，关键在于本金积累、被动收入增长和覆盖支出。

实现“不必赚钱”的条件

需完成本金的原始积累。
被动收入需持续产生并具备增长率。
被动收入最终应能完全覆盖个人支出。

二、原始积累途径

区块链大周期投资

利用比特币四年减半带来的牛熊周期进行低买高卖。
投资需在自身能力范围内投入足够本金，避免All in土狗币。
需保障四年生活资金不受投资干扰，确保策略可持续性。
认为行业共识与个人职业绑定紧密，行业存续直接影响自身价值。

套利与端盘子

套利包括抢跑机器人、三明治攻击、跨链/中心化交易所套利等。
可结合Web2信息（如推特KOL动态）发现链上套利机会。
清算、GameFi打金、分叉空投（如ETHW）也是潜在盈利方向。
执行层面需关注代码漏洞、社会工程攻击（如龙网私钥被盗事件）。

远程接单

WEB3远程工作可获取欧美薪资水平，但需英语能力和渠道。
收入形式多为稳定币支付，避开了传统跨境汇款问题。
接单平台任务有限，自寻客户更灵活但需经验与信任基础。
沟通效率低于线下，项目周期可能拉长，影响交付节奏。

自媒体变现

通过技术分享建立社群，形成知识付费圈子或出售教学内容。
直接收入有限，但能拓展人脉、建立信任、获得合作机会。
文字内容为主，未来计划扩展至视频形式以提升受众。

工作附加收益

除工资外，可获得TOKEN、NFT、销售分成等激励。
内部消息可用于提前布局稀缺资源或市场机会。
可升级合约存在跑路风险，需警惕项目方恶意升级。
市场运营岗位更容易接触合作方信息，技术岗需担任对接角色才能获取。

三、被动收入构建

DeFi质押

稳定币质押（如MakerDAO）年化约5%，底层资产为美债较安全。
单币质押需注意币价波动风险，未对冲可能导致亏损。
双币流动性挖矿收益更高（8%-10%），但面临无常损失和稳定币脱锚风险。

全球利率套利

关注不同地区国债利率差异，如香港、新加坡、美国均高于国内。
可通过香港银行开设美元账户进行定期存款或购买债券。
大额资金更适合此类稳健配置，小额资金建议优先考虑加密资产。

稳定币间套利与资金费率套利

利用BNB生态内稳定币（USDT/USDC/BUSD）汇率微小差异进行无手续费交换获利。
在期货资金费率结算前捕捉短期价格拉升机会，反向收割吃费者。

返利卡与消费返现

币安BNB Visa卡曾提供高达8%返现（上限500欧元），现已停发。
汇丰、汇理等银行借记卡提供0.4%-1%消费返现，适合日常港币消费。
信用卡开卡奖励丰厚，但需建立海外信用记录，操作门槛较高。

货币兑换渠道优化

避免使用CUD等高风险通道，选择加密友好银行（如瑞讯）出入金。
券商渠道换汇费率优于银行，部分按固定费用收取，适合高频操作。
支付机构（如Wise）便捷但安全性不如券商，不建议长期存放资金。
自建银行通道可节省1%-3%的u卡汇率损耗。

四、财务自由关键策略

控制支出的重要性

提升本金和收益率难度较大，而控制支出更具可行性。
花钱决策直接影响被动收入能否覆盖生活成本。
应优先优化支出结构，再追求高收益投资。

时间投入与收益预期

各类方法均需至少一年以上研究与实践才能见效。
被动收入项目需一个月左右学习期，预期年化收益约5%起。
个体差异大，成果从“一顿饭钱”到显著盈余不等。

claude:

我来帮您整理这份转写文稿。这是一场关于智能合约工程师如何赚钱的分享会记录。

智能合约工程师赚钱方法分享

开场介绍

大家好，我是33357。目前是一名智能合约工程师，专门做智能合约方面的研究。今天给大家分享一下，我作为一名智能合约工程师是怎么赚钱的。其实我赚钱呢，这里面有个副标题，就是走向一个不必赚钱的道路。大家可以想一下到底是怎么做的。

为什么要讲赚钱呢？因为我之前也有一个群，像社区一样的东西。我之前在 GitHub 上分享一些技术的东西，然后群里面有人问我，线下做面基交流的时候也有人问我，好多人问我怎么赚钱。但是呢，我那时候没什么准备，一时间我也回答不出来，有点尴尬。就是大家都很关心这个事情。

然后呢，我研究这个怎么作为一个智能合约工程师去赚钱，也研究了很长时间。零零碎碎的，其实我发现有很多零碎的东西。大家呢，我写的东西也可以帮我做一个总结归纳,到时候可以看一下有没有优化的地方。我也挺关心的。最后呢，就是给别人一些帮助。也许可以反过来帮助我赚钱。就是我们大家可以互相分享一下到底怎么赚钱。然后大家有什么问题呢，也可以直接问。到时候我会说的，如果你最后传播的话，可能到时候忘了。我讲到哪你们可以直接问，知道吧？

画饼警告

首先大家看这个，这是一个什么东西，你们可以猜猜看。

这其实是一个饼，你们知道吗？这是我下面讲的东西，都是我给你们画的一个饼。就是我讲的东西讲起来是很容易的，但是你做呢就不一定这么容易。可能没我讲的那么容易。就是你去做的时候，饼这个东西啊，你看起来很好看，但是吃起来不一定好吃。

然后呢，就是我做的这个饼呢，不一定是最适合你们自己的。你们自己如果能做一个饼的话，那才是吃起来会最香的那种。所以呢，最好能找到最适合自己的那个赚钱的方法。你们有什么想法的话可以直接说。

然后就是实际上呢，我做的这个饼也不是特别完善，到时候可能还得跟别人交流一下到底怎么实现。有的东西其实我也是听过的，我并不是，我这边说的东西不是我自己亲身经历的，也有听别人的，看别人的。所以说呢，其实也要依靠别人的经验。

一、工作赚钱的成本

赚钱呢，其实大部分人能够接触到的就是工作赚钱。但是工作呢，其实它是有成本的。

时间成本：你要上班嘛，上班你要早起，然后打卡，然后你要加班。
做事的成本：像我这种做技术的，上班的话，你要去学习新的技术。你把新的技术要学习，你光看不够，你还要去实践，实践去测试，然后去应用。
更新技术的成本：比如说以太坊又升级了，什么什么东西，你还得去更新你的技术。这做事其实挺累的。
社交成本：你去公司里面有领导、同事还有客户，你都要跟他们社交。

这也是一个成本。我感觉的话，就是我目前的话是没有固定工作。但如果我想去固定工作的话，就是我感觉目前来看成本可能有点高，就对我来说。不知道你们自己是怎么想的。

二、用钱赚钱

除了工作赚钱，其实另外一个方法就是用钱赚钱。你们呢，可能应该也接触过。这可以做一个被动收益嘛。

优势：

时间自定，不用打卡上班什么的
没有社交成本
最重要的一点：你在公司里上班做的东西，那个后续收益都不是你的。你只是领工资而已。你离职了，虽然项目还在继续运营，但是那个项目持续运营的收益不是你的。相当于你要一直工作才能一直有钱赚。

但是如果你能找到用钱生钱的办法，就算你最后不去干了，那个收益还是一直会给你。

关键条件：

你想要做到用钱来赚钱呢，首先你要有一个本金的原始积累。就是你要有一个本金。然后呢是一个被动收入，就是你的本金放在里面要有个增长率。最后呢，你要实现那个不必赚钱的目标，你需要用你的被动收入来覆盖支出。就是这三个条件。

三、原始积累的方法

我看了一下，我这个智能合约工程师能把握的一些原始积累：

区块链的大周期
套利端盘子
远程接单
自媒体
工作的附加属性

1. 区块链的大周期

首先我说的那个区块链的大周期是指比特币的那个四年的减半的周期。也是一个牛熊周期。我觉得的话，我只要能把握这个四年的一个牛熊，就是在牛市卖掉，熊市把它接回来，这个意思。其实蛮简单的。然后我就能实现一个本金的增长。

但是呢，你要把握这个周期呢，虽然看起来简单，其实也不简单。

注意事项：

第一，你首先要知道自己的能力和认知的边界。你不能把钱全部拿过去买一些土狗，全浪费掉了。把比特币换成了那些土狗币。

第二，你要在你自己的能力范围内投入足够数量的本金。目前来看的话，比如说比特币的一个四年周期，它是四年。它的收益率，我估计的话就按现在价格，可能下个牛市会到10万。算不算四倍吧，四倍，说多不多，说少也不少。但是你如果想让自己的本金保持增长的话，你也要有一定数量的投入。比如说50%吧，你把50%的钱投进去，然后四倍的话你可以增长两倍你的本金。你还是要有很大比例的一个投入的。

时间周期问题：

然后呢，我遇到的很多情况就是首先他拿不了四年那么长。虽然说做大周期的，也用不着你天天看电脑，去研究那个线啊什么的。但是你得有那个四年的，首先是你要保证自己四年的生活资金。就是你的四年的投资，你的生活用的钱不能被投资的钱干扰。如果说你那个影响到你自己生活的钱，你是绝对不能够用去投资的。这就是确保你四年之内这个策略的一个持续性的保证。

预估逻辑：

我的预估其实很简单，就是类比以前的趋势吧。上个牛市，21年的时候，最高是六万多。然后按照以前的那个，如果下个是牛市的话，至少得破10万吧。因为之前的其实倍数比这个还高。21年比那个17年的，好像最顶峰的话也差了个三倍多。我说实话其实比较保守。

职业绑定：

还有一个特点就是我是一个智能合约工程师，你们知道吧？我其实我的全部知识都是在这个行业内的。如果真的比特币这个归零了，我的知识基本上也就全部没有用了，化作灰飞烟灭了。我整个职业生涯也就结束了。所以说我既然做这个职业，我就得有这个信心。如果真的这个行业没了,我不光是钱没了的问题,我这么多年的能力储备什么的基本上都没了。

我就得重开了，你知道吗？

这成功来讲，就是共识。基于共识来，共识没了，咱们就完了。

对，共识其实一部分是共识，还有一个就是共同利益。共同利益跟共识是要互相增长的。就像我这种就是被整个行业给绑定了。我的社交基本上也是圈子里的人。工作经验也是圈子里的，什么行业都是圈子里的。我是大学一毕业就进了那个做智能合约，就是区块链公司。其他的行业经验我全部没有。我其他的估计，你让我去写别的前端后端，我写不来。也不是写不来吧，反正差别很多。

所以说这个大周期呢，就是我认为比较稳，但是具体的还要看你们个人而定。你们可能还有一些别的顾虑，但是我其实没啥。

我目前的话是比特币、以太坊对半分。

2. 套利端盘子

第二个是一个套利端盘子，其实这两个就差不多。你要是慢点薅，就是一头羊，你要是慢点薅，它就是套利。如果你整个羊都直接开膛破肚了，那就端盘子，就整个羊都吃了。

目前呢，就是你想在那个链上做这个套利的话，就是我目前总结下来就只有你要利用一个市场的一些东西，然后利用规则，然后在规则之下，还有执行层。方方面面你可以去利用去做套利。

（1）抢跑机器人

套利呢，比如一个比较明显的就是抢跑的机器人。这个之前呢，就是在那个 Uniswap 刚出来的时候，那时候大家都去做那个 TOKEN 然后去发池子。然后就有很多抢跑机器人直接，就你刚把那个池子创建出来，那个机器人马上就下笔交易。那个机器人给你买一个 ETH 进去，然后不管你，反正你不管你到时候怎么样，反正他就是第一个买入。第一个买入之后，如果你忽然会发现你那个池子钱变多了。你池子钱变多了，你就不要想把那个钱，反正白来的，直接套出来，我再发一个 token。

但是我当时就遇到这种情况。我去想把这个机器人的钱给套出来，结果发现那个机器人每次交易都比我的那个撤出池子的交易快一步。他的钱先撤出来了，下一笔交易才是我的那个撤池子的交易。相当于我就白忙活了，那个机器人先跑了。

当时我本来想做个什么限定合约的，但是那时候技术有限，而且那个在以太坊上做这个测试太贵了。我也不确定这个机器人它只在以太坊上跑，我不能在其他的测试链上做模拟。我每次那个都是花真金白银去做测试。

其实我最开始想的是用合约去套。但是我发现他那个陷阱合约他会识别出来，那个他就不上当。

节点说实话比不上他那个。我的节点速度没有他那个。我估计他那个机器人用专业节点。我用公共节点,这真是抢不过。

反正后来就放弃了，然后赔了两个以太坊。就是光是 gas 费，你部署合约的 gas 费我就赔了。

（2）Friend.tech

然后那个 Friend.tech 它也是一个新的东西，就是做社交的。它是那个什么 KOL 上去发个币，然后你买这个币就能进那个 KOL 的群。他那个是跟推特连在一起的。如果你能爬那个推特上的那个大 V 的数据，然后等他在 Friend.tech 上开，进驻之后发了币之后，你第一时间去买，其实也可以赚。因为他那个大 V 最后会在那个他的频道里宣传什么东西的。

但是呢，这个就是你要跟 Web2 结合起来，你要去爬那推特消息。

补充讨论：

其实不用，你不用爬推特。因为他会有一个 event，就是创建的时候会有一个 event，然后你可以直接根据那个东西去查他关联的那个推特。

因为这个事情我当时有在做。那个 event 它会暴露出来一个地址，就是因为你玩那个 FT 它会给你创建一个钱包，然后这个钱包呢，实际上是绑定，就是他已经绑定过他的一些推特啊，或者说谷歌邮箱这些东西。他用的那个东西是那个 Privy，我不知道你们有没有用过，就是一个类似于 AA 钱包的一个东西。他用了那个之后，他的那个接口就是我只要有这个人的地址，我就可以查到这个地址所绑定的那个推特。然后呢，我就可以再去查到这个推特上面有多少粉丝这些东西。

我监听到他的房间，我都可以知道他推特上面粉丝的数量，然后再根据这些东西去制定策略，去买入卖出这些。

他那个推特和那个地址，他那个绑定的话是不是有漏洞呢？

对，他就是有漏洞。就是当时还专门有人说过这个事。就是说 FT 的这个用户隐私，他一直迟迟不推出来。因为那个 API 现在我不知道能不能用，现在应该可以用。那就是还可以。就是一旦有新地址创建的话，你就可以查他绑定的推特信息。如果他是个大 V 的话，那你就买了。

当时还有人就是故意去创建一些推特号，然后去刷粉，比如说给自己刷个几万十几万的粉丝，然后去骗机器人。那个十几万粉丝现在很容易的，你发点黄图，然后做成。你发个黄图，发个色情的视频，然后都是几万粉几万粉的增长。然后你再去把这个推特改成你的，装成 Web3 的大佬，然后更吸引人。

那这也属于制造貔貅盘，差不多。

对，其实它有很多套利空间，你在链上查不出来。你要去结合一些其他地方的那个信息，你才能找出来一个套利空间。

补充：关于推特 API

还有一个事情，就是我最近在做推特相关的东西。因为之前的话，就是那个推特可以买一个 API，那个 API 是永久的，但是那个现在，就是自从它被收购之后就不能用了。后来我发现就是有个平台叫做 RapidAPI，那个上面就是有一些开发者，他基于这个推特现有的 API，他自己去封装了一个服务。那个成本要比官方，就是官方这个 API 的那个成本要低很多。如果你没有做推特的话，可以去看一下那个。

（3）三明治攻击

然后我接下来讲那个三明治。三明治这个东西老生常谈了。他就是因为那个 Uniswap 做那个交易的时候有一定延时。为了防止你那个交易波动导致你成交不了，他会给你一定的价格容错空间。然后有的机器人就会钻那个容错空间的空子。就是把你那个本来你那个价差是有一定价差你可以换更多的，但是他把你那个价差给抹平了。然后就套你的那个价格差。

之前那个以太坊基金会卖 ETH 的时候好像也被套了几千个刀，九千五百块钱。

反正现在这个三明治比较卷，它已经转到那个内存池上去了，就交易的那个内存池。你做这个东西的话，你得有那个内存池的那个节点。还要跟别人抢那个 gateway。除非你还有那个 Flashbots，Flashbots 我之前用过，但是现在好像不好用了。

现在比较热度比较大的是那个 MEV，然后还有那个阿信不送。他说话的话就快率，感觉每次代表会发掉吧。

对，他那个以前快率是很高的。现在掉到多少了？因为以前只有他一家做。感觉也对。

反正我就感觉那个太卷了，我不一定抢得过。

但是你做这个东西成本有点高。收入的话会比较高。如果有思路是思路是可以提高很多的。其实真的没有想那么多。你有一个小团队以后，我觉得你可以搞这个。在主流链上确实很卷，但是在一些其他链上，小链的利润真的非常庞大。

还有，你们有没有研究过那个，就现在链上利润有多少被矿工给吃掉了？

做质押的话，一般50%以上都能给。其实给了他之后，之后的利润还是非常高。

你看这一波造型，一天能赚百万人民币。

反正我之前做，我做的不是三明治，是那个 DEX 之间的套利。用 flash loan，用闪电贷做那个套利，DEX 套利。就是搬 DEX 各个 DEX 上面搬。反正我一般都是要交70%给矿工。

你这个做的多吗？

我还挑了那种，就是人比较少玩的那个币。要是主流币，我估计90%。反正现在我觉得，你要一开始，如果自己加节点的话，你矿工你自己做矿工，自己出块，出块不能想节点回来定那个块。只能被矿工吃掉。

反正现在我想做的话，我基本上就找一些那个，首先就是链上的这个数据太透明了。你可以做一些跨链的跨链的交易，这样就不容易看出来。或者是你 DEX 到 CEX 之间交易。还有一些就是你去做一些小币种，或者是小链上的，或者是冷门的一些 swap 里面的。我感觉主流的话，那可能机会没那么大。

（4）清算

然后清算是那个，继 swap 之后另外一个就是比较大的。他那个是做链上质押的那个，做清算的。但这个行业蛮卷的。

清算只有到牛市过了，然后币价大幅下跌的时候，那个时候清算应该很多。那个时候就好做一点。现在不行，没人借钱。

反正之前了解过的几个都挺卷的。

（5）利用规则：Fomo3D 案例

然后主要一方面，上面讲的是那个市场。第二个讲的是一个规则，就是你可以利用一些区块链上的一些规则去做套利。

这个红包锁地不知道你们看到没有？Fomo3D 第一个。这个我记得好像应该是19年的项目。他那个是在以太坊上做了一个盘子，然后最后一个进去的人可以拿走全部收益，就是这么一个盘子。那时候好像有几千万的那个盘子。

他是怎么死的？他是有，好像累积了几千个还不知道几万个以太坊之后，被一个黑客发很多垃圾交易，把以太坊网络给堵死了。

他本来是设计的，你花一个以太坊进去之后，如果接下来一个小时之内没有别人进来，那所有的奖励就归你。

就这个设计。然后奖池累积了几千个还不知道几万个。然后有个黑客，他当最后一个进去的。然后之后的所有交易都被他给堵死了。然后花了好多 gas 费，几百个 ETH 还不知道几千个 ETH，把这个以太坊网全部给堵死，然后堵了一个小时。你可以算一下成本，堵以太坊网络一个小时要多少钱？

怎么做到的？他是拉高 gas 费。他不停发交易，拉 gas 费。你发的比他高，他就再发一个交易，把你的交易给盖住。他那个时候还是 gas price 算法，不然现在现在的话就估计能拉死他了。现在是1559,1559算法要，我估计成本要比那个之前高很多。你要想堵一个小时。

因为你的 base fee 会不断往上涨，然后你要想这么堵的话，可能以前的那个机制上可能有点问题。反正最后就是他利用了以太坊这个堵的，怎么说呢，就是利用以太坊的一个 gas 费规则，把那个网络堵死。本来可能没人想到会有这个问题。就利用这规则漏洞，他赚了很多。我也记不清了，反正很多。

（6）USDC 爆雷套利

然后那个接下来是一个 USDC。USDC 是他之前有过，因为那个硅谷银行爆雷，然后 USDC 就狂跌。跌了十几个点。那个时候链上就是有很多在那个套 USDC 跟其他差价的。一个是套 DAI，因为那个时候 DAI 好像是它跟 USDC 1:1 兑换，但是它那个市场价格没 USDC 下来那么快。然后就有很多人去可以去那个套。

还有一个就是有很多合约，他卖东西，卖东西他是按 U 计价的。他就是一个 USDC 等于一个 USDT 等于一个 BUSD，直接在合约里写死。然后你用 USDT、USDC、BUSD 都可以按同样的价格买他那个东西。然后他那个东西呢，你不光可以买，你还可以赎回。就是你可以用 USDC 买，买了之后，你再用 USDT 赎回。就是跟他那个合约可以这么做。

然后呢，就是平常情况下应该是没问题的。但是你在这个 USDC 爆雷的时候，他就会去挤兑。挤兑就到最后他那个合约里面本来有 USDC、USDT 的，后来全部 USDT 全部换走了，就只留下 USDC。

然后我确实，我之前是找到过这么一个合约，它里面有十几万余额。如果我全部换走的话，起码十个点的话就是一万多余额就能换出来。就是你去市场上再去卖掉就赚一万多元。

但是呢，那个时候就是有个问题，就是你要换一下子换十几万，我就没那么多钱。我想用闪电贷，但是那个链上的闪电贷我还不太清楚，没用过。因为是在 BSC 链上，BSC 链上闪电贷我没碰过。

所以说最后我就是一万一万的换，结果被某个机器人给发现了。他那个机器人钱多，然后他直接一下全换走了。

所以说也挺尴尬的。本来全是我的，后来被那个不知道哪个机器人给发现了。他估计有监控的。他看到你这个交易比较异常，他就来看你怎么交易的，然后直接复制你的交易，直接套一笔全套走了。比较尴尬。

所以说呢，就是你平时如果能多收集一点这种合约的话，估计特殊时候可能会有点用处的。就是那种把那个汇率写死的那种合约。

现在 Base 现在有合约，比如说关键字或者是合约，比如说特殊方法检索吗？可以有的。

（7）GameFi

然后是 GameFi。GameFi 这东西呢就比较复杂，它比像一般的链上的那个东西复杂得多。因为它还有那个，一般游戏呢，一般是那个不光是链上，它链下的逻辑占很大一部分。之前的话比较火的就是光货币在链上，其他的游戏逻辑全在服务器上。

现在呢又有那个全链上的游戏。全链上的游戏呢，就是你可以看到它那个规则。如果有那个套利机会，有的不在链上的，你可以用传统的 Web2 的一些攻击方式。比如说你去服务器攻击他那个服务器，然后把那个币提，提到链上。

这个我之前玩过一个游戏，就是它是可以撸的。就像那个工作室打金一样。你去完成任务，他就给你什么币。后来我做的，他有那个什么脚本，什么按键精灵的什么东西，用那个东西去撸那个游戏。但是我就自己一个人弄，也没找别人来玩。

然后那个后来是过了几个月，他那个币崩盘了。后来官方发公告说是被工作室给撸崩了。具体怎么撸的呢，我估计也不太清楚。好像有什么 bug。按道理来说，产量是确定的，但是后来好像有什么 bug 没有限制住，所以就把那个价格给带崩掉了。

就这东西呢，就是看你们能研究到什么程度吧。

现在好像打金的游戏那个，反正 Big Time 什么东西，你们有没有关注过？那个我还没玩过。说什么要邀请码，然后怎么撸的我也不清

楚。

之前 Decentraland 整一个 MANA 的那个 money，Decentraland 我也玩过一阵。他那个是你完成任务，他直接给你的钱包里发币。那时候还是发50个 MATIC。我一开始觉得那个 MATIC 不怎么值钱，然后就直接卖掉了。后来涨到两刀一个。他那个时候是纯送的。你只要完成你的注册进去，然后完成任务就可以。

（8）ETH 分叉

接下来是 ETH 分叉，就是以太坊分叉吧。它其实算一个技术上的升级，被技术升级带出来的市场需求。现在好像没什么人去那个研究它们的方法。反正就是带出来一个机会。

那个时候是，因为以太坊分叉，所有的官方的那个 DeFi 什么的都支持，都转到那个 PoS 链上。那个 ETHW 上面那些项目就没人维护了。它相当于分叉了一部分数据，但是那个数据呢，你换成 ETHW 还值点钱。但是一开始呢，官方的界面是不支持的，你要自己去调合约。你要自己去用那个 API 去调合约。

但是那个时候浏览器也不大好用。然后我最后是自己写合约用 Remix 去调。然后那时候我本来是存有那个 USDT 的，然后 USDT 我把那个假的 USDT 换成 ETHW，换了几千。

这个呢，其实后面的 Lido 也是一样。就是你要关注那个以太坊的那个升级的话，像这种质押质押项目肯定有机会。也不知道你们之前有没有想过，就不管是分叉还是这个做这个质押，它其实都有机会。

很差了。比方说现在你看链上面有什么攻击的，就去上面，他之前的漏洞再重新攻击一次。

不是重新攻击一次。是 ETHW，因为很多，官方不可能维护那两个链。只要有一个节点就可以复刻，然后攻击，然后换一点钱。不过已经不值钱了。

对，现在已经不值钱了。一开始的时候还值钱。

本来就是那个二宝，有很多单子的 ETHW。

（9）Lido 质押

那这个 Lido 你们关注过吧？就是那个质押 ETH 的。我感觉你如果先知道这个技术路线的话，可以去提前布局这个项目。做质押这个方向。以前没有这个东西，现在有了，而且我感觉需求还很大。如果你在分叉之前就去布局的话，我估计会好很多。但是现在就是已经晚了。

风险就是 ETH 价格跌了，你也跌。但是它的利率的话就是一般，好像风险不怎么大，就除了价格的方面。就是或者说项目跑路，但是这么大的项目应该不会跑路。

被质押，然后再把质押的货币再去借贷，然后就可以放杠杆。放了10倍。

对，你可以做。但是 ETH 最近价格波动有点大，你要是被清算就完了。

基本上是稳定的，因为质押收益也是每天的过滤，基本上是稳定的。这样做借贷，做杠杆，低风险的，基本没有风险。

然后那个 Aave，我之前看过那个，他这个我看见他升级了好多版本，一二三四的那个。因为我一开始不进去用都不知道他用哪个版本。

（10）代码层面的执行

然后这个是一个规则。最后是一个执行层面，执行层面就是一个代码层面。你代码是执行，你员工也是执行，这社会工程就是针对那些员工的。

首先就是一个跨链桥。跨链桥那个东西被盗的太多了。你们应该听过一点吧。

就是因为他有的是什么私钥被盗，有的是什么那个合约有漏洞被盗。

反正记得一个叫 M 的，换了一下，老板直接被云南警方直接抓了。

那个没听说过。他这个就比较 low 了。我之前还给那个 Multichain 投过简历。他说要让我去做那个合约测试。我一想测试没意思，我想做合约开发，然后就没去。所以现在感觉以前之前还蛮遗憾的，现在感觉好像不是。

你去了，你就今天不能演讲了。

反正我也搞不懂里面具体细节是什么。这跨链桥里，用户里面资产全部被拿走了。这算什么呢？按什么算呢？

反正挺尴尬。那时候好像我记得 FTM 这个链，好像他们官方的有，就是有那个跨度的桥。然后他这个被盗之后，官方里面那个钱都提出来了。

就你要去买他那个 U，可能买的是个假 U。那个我之前还遇到过一个野鸡链，野鸡链它里面那个质押的 APY 高达100%多。然后他就做了个桥让你跨过去，然后等你跨过去，他给你发那个跨过去的 U。你弄了个100%的质押，等你想提回来的时候，他那个不支持提回来了。然后，然后那个一群不知道的还以为那边币涨价了，赶紧过去套利呢？结果套利的套不回来。

还有这个 Stars Arena。他这个是一个 FT 的仿盘，在 Avalanche 链上的。然后我看他那个合约没开源，我就没去看。然后后来看那个分析说那个什么，他被重入了，代码被重入了。

其实我很想知道那个没开源的代码，它到底是怎么找那些 bug 的？他要从 opcode 开始，那个逐步分析。

你那个 Etherscan 不是有那个逆向吗？直接看逆向和代码。那个代码也比较难看，差不多都这样。可能也，我目前还不太熟悉这个。就是我不会做这层面，我只用过 Hardhat，用 Hardhat 做。

不用靠，就是你看那个 Etherscan，逆向出来的代码。

可能得练一练，那个看起来不太习惯。

（11）社会工程：龙网案例

最后一个龙网。龙网是之前的一个交易所，他20年倒的。根据他那个官方的说法是，他那个工作人员被某个人发了一个邮件，然后那个邮件里面包含一个安装包。工作人员安装了之后，他那个交易所的私钥就被盗了。这可能属于一个社会工程的方面的一个案例。具体是怎么操作的我也不清楚。

反正就是你从执行人，就不光是代码，就是你执行的工作人员他也会有一些问题。比如说你现在很多公司，其实就我之前做的那个公司，他那个合约的私钥就是直接给我的，然后让我去部署什么东西。虽然说是信任我，但是我感觉这个有漏洞。就是工作人员不应该这么轻易的就可以接触私钥。

就是其实很多公司的话，可能代码方面其实没问题，但就是内部人员被渗透了，还不知道被攻击了。反正就是这就不是完全不是代码上面的问题，就是公司流程还有人员那方面出问题。这也是另外一部分的，就是执行层面的一个漏洞。

目前就是这几个方面。

总结：套利盈利时间

来估算一下这个盈利的时间。投入的时间成本，我这块至少得一年以上吧。你研究这个，时间短的话，不一定能找到机会。就算你找到机会，你也不一定套得出来。然后这个收益呢，就是看人了。你可能是一顿饭的钱到那个几十万上百万的都有。差别很大。就是做这个，人跟人的差别就很大。

对，我之前还混过一个什么科学家社区。他那个是 Telegram 上的群。反正那里面就是有很多人才。天天说自己套多少了套多少，也不知道真的假的。然后现在那个社区好像被卖掉了，被关掉了。反正没人聊了，那个群都被禁言了。

3. 远程接单

接下来讲一个远程接单。远程工作呢，就是目前 Web3 比较流行的这个远程工作。

我之前是因为疫情的时候，在公司远程了一段时间。然后之后就又接着去公司上班。后来的话，我从公司离职了，继续干活。我是先自己做一段时间，自己做不赚钱，后来又去接了个远程工作。

远程工作的类型

其实远程工作的话，按我的想法，最好去找那个老外。老外他给我发那个欧美的工资，能达到美国那种工资，美国那种水平。

但是呢，这个要求比较高。你得会英语，然后工作流程要熟悉。你还得有那个渠道去找。然后你还要去签合同、收款什么的也是问题。

目前一般比较多的话就是有的可以发 U，给你发 U，然后按美元计价还是按人民币计价，给你发 U。发 U 倒是方便，你不用去开户，汇费什么的。

然后呢，有目前有很多的，一部分是在国内的，国内的也是中国人，给你进行对接。还有一部分是香港跟新加坡的，他也算华人吧，可能给你的比较高一点，应该比国内多。然后也让你远程。最高的就是欧美的那种。

大概是多少钱？

不太清楚。但是香港新加坡差不多有五万。

月薪？

五万人民币。那个刀的话，我起码也得是欧美本地那种。

香港和新加坡差不多一个月五万人民币左右。

接任务

然后第二个就是去接任务。接任务它好像有一些任务平台，但是我找到的都是做翻译的，什么东西。然后做代码的话他也是要求英语的比较多。然后那个还有那个写一些，可能外包一些任务都做一些外包的。

总的来说这个做任务你在国内接的话不算多。如果你去找一些国外的平台的话，应该会更高。但你到时候就是渠道，还有一个经验，就是很难的问题。

自己找客户

最后一个就是你要去找那个自己找客户。自己找客户的，我有几个群友来问过我做东西。但我做东西呢，就是其实我也不大好弄。因为一方面说市场价我也不是很清楚。还有一个方面就是合作成本。就是一般的话应该是先付一半，我记得是。你先付一半，然后做完了后续再付一半，类似这种。

就是你自己找客户，你可以跟客户谈，直接相比于找任务的话，那个单谈条件会好一点。但是你得有自己的客户源。

注意事项

你做这个东西呢，最好你得先有经验。你要先有那个工作经验，然后再去找一个远程。因为远程沟通起来的话，不比面对面，就是你沟通那个效率比较低，而且还比较费时。如果你没经验的话，你沟通就是合作起来很难。到时候一个项目做个半年都做不出个样子。

我之前做的远程就是有这个问题。我合约写完了，他那个前端后端，我等了两个月都没做出来。

那人家给你按月给你发工资，你不是很爽吗？

但是我觉得很无聊。

你太实在了。

我把那个合约写完了，然后我就给他写文档，写文档。一个月写完合约，剩下两个月写文档。

人家老外就是这样搞的。你这个在中国卷的，你这太卷了。

反正就是最后比较尴尬，后来也散了。

你太卷了，其他员工说你太卷，你别干了。

收入是蛮舒服的。到时候就是你自己把任务完成就行了，也不怎么管你。

就是我上班的时候，就是一般你如果上班摸鱼，看那个行情什么东西的。你可能会担心领导在背后看你，盯着你。然后你自己远程的话，就是反正感觉轻松很多。反正也没人盯你，你自己干别的也管不着。

反正就是这样，感觉。就是做远程接单，差不多也一年以上吧。就是有机会拿到欧美行业的一个薪水。具体的薪水我也不知道了，可能靠你们自己看。

4. 自媒体

接下来是一个自媒体。自媒体的话我是，怎么说呢？我一开始只是做个分享，做了分享之后发现有很多人来加我好友。然后我就做了个群。做个群之后呢，我就想怎么把这些群友变现呢。

然后我就搞了个圈子。圈子现在怎么说呢？我就是一周发一篇文章。他们有什么提问，我都回一下。

自媒体的价值

做自媒体其实赚钱赚不到多少钱，远不如你自己去打工。你打工赚的都比这个多。但是呢，他这个可以给你扩展你的关系。这个是做别的比不了的。就是你有很多朋友，别人会相信你。

比如说我这次来这边也是因为我做了这个自媒体，然后就是有人看到我了，邀请我进来。之前还是线下，跟他线下约过一次。如果没有，我没有做自媒体，可能我们一辈子都不会认识。就是这钱还是次要的。

收费方式

如果你想做自媒体收费的话，其实也就两种。一个就是你做个圈子，收一次费，把你拉进去。还有一个就是卖教学，你就一篇教学，按次，按一篇一篇收费。

就是做，像我做就做技术，偏技术方向的。我从22年开始，做了一年多了，然后写了点东西。目前群里差不多有一千多个。主要的收益其实是一些渠道方面的，还有一个关系方面的，然后还有一个别人的一个信任的收入。可以降低你们以后合作的成本。

最后就是目前的话，我只是做文字方面的，就写一篇文章。接下来我可能会扩展一下，做个视频什么的。我感觉那个受众可能多一点。

其实有的人就是你在写代码的时候就不聊，就是会听一些东西。我写代码是就是开个视频，然后有一搭没一搭的去看。感觉比纯文本的就是轻松一点，毕竟你不光是看，你还能听。

5. 工作附加属性

最后讲一下那个工作附加。就是你去上班呢，就不能只拿工资。我觉得在 Web3 工作不是为了那点工资，不光是为了那点。

目前的话有一些奖励，可能是 TOKEN 或者 NFT 或者一些项目的销售销售奖金、分成。分成的话一般是合伙人比较大，员工没什么分成比较大。

NFT 奖励

我之前那个公司的时候是发 NFT 的。NFT 它发1万个，然后你作为项目员工可以给你一个两个的。但是一开始那个不值钱。一开始做的 NFT 不大值钱。后来一个值钱的又没给我分。

我就比较尴尬。那时候离职也是因为他那个公司自己做了一个 NFT 项目还比较赚钱，但是就没给我分。然后我就感觉没意思，就不干了。

TOKEN 分成

然后 TOKEN 呢，之前做远程的时候，那个人说以后发 TOKEN 给我分个0.5%什么的。但是后来那个项目，我感觉不太靠谱，然后又拖了很长时间，然后就不做了。我也跑了，然后那个 TOKEN 也没拿到。他 TOKEN 也没上市。

说实话那个，我感觉这个 TOKEN 比那个股票期权什么的都要好一点。因为股票期权你得上市之后，公司上市之后你才能拿到。TOKEN 的话，你只要上线那个 swap 交易所，就能直接变现。一般周期没有那么长，变现比那个股票期权快多了。当然前提是你得找一个比较好的一点公司。

内部消息

然后呢，你做工作，他可能会有一些内部消息。就比如你自己是写代码的，我是写合约的。我写合约的话，它有一些链上的机制。那个时候 NFT 我做的 NFT，它是有一个什么 NFT 融合,1+2融合成3。它会给到我这个配比表。然后配置表，如果那东西值钱的话，我就可以提前囤一些比较稀有的。这种也许是可以的。

那像这种的话，比如说魔兽世界或者传奇，两个装备进行融合，就可以弄得出来了。然后融合之后我还可以把这个 NFT 挂拍卖，然后卖掉。游戏确实可以。

还有一些什么概率的什么东西的，随机的，那东西比较难。不过应该也可以搞操作。还有一个就是做一些更新，比如说你哪个版本更新了，你要改什么机制，你如果知道的话可以想办法搞一些东西。怎么搞？就得看你自己了。

案例

我之前那个公司里面有一个员工,他不是卖,我们公司不是卖那些吗？然后他有个人好像有一个内部渠道，他能自己绕过绕开公司，自己去卖。然后他有个一百万,就卖了。后来被抓到了。

就是你把 NFT 就是一跟二，然后你去把一跟二销毁掉，然后再 mint 出一个三，就这样。

这就是你合约里面本来就有个规则，你就可以。你可以后续更新，反正是可升级合约。说到可升级合约，它这个又是一个问题了。它那个可升级合约，它理论上来说什么都能升级。大多数到时候去，如果说不靠谱的项目，他直接把你合约升级，然后把里面币全提走，他就跑路了。

合作方消息

最后一个合作方的消息。就是如果，但是这方面的话就是市场比较多。市场接触的比较多，就是你是需要做项目对接市场的，你就接触到很多合作方。然后你就可以，我有几个朋友就是之前做运营的、市场的，他就是不知道买了什么东西，然后就发财了。

但是这就是如果你是写像我这样做技术的话，除非你是专门负责跟别人对接的。一般是技术领导了，领导的话会负责跟别人对接，这样的话你才能拿到消息。

然后你要拿这些工作附加，你起码也要一年时间。你得熟悉一下，然后看看怎么搞。然后是有收益，你要看你那公司什么样子。比如说比如说那个币安什么的，那个机会很多。在这种大公司，还有一个什么，我之前记得好像也有过出现过这种事情。反正都是一些那个产品比较成熟的一些，就是有盈利能力的，然后市场流量也大。

这就看公司。你小项目本身就赚不了什么钱，你还去套，被套死了。

四、被动收入

接下来是讲一个被动收入。目前我研究的就一个被动收入，就是一个用钱来生钱。

DeFi 质押
全球利率
返利卡

1. DeFi 质押

DeFi 质押最稳的呢，就是那个稳定币。稳定币你去质押，这个 MakerDAO 这边做的比较大。它好像是年化5%。他那个 DAI，他好像是用那个美国国债去做里面底层资产。然后有个5%的年化收益率，感觉也不错了。

但是主网的话你 gas 费比较高，你资金少了亏是净亏。

如果不到500刀进去一年的话，就亏了。

抵押借贷

但是你抵押进去，你放在那个代币是可以再重新去借贷的。

怎么感觉像房地产？

就降收益率。他其实现在一般的这种收益率，他是阶梯式的。你钱里面钱越多，它收益率越低。一开始好像是8%，后来钱多起来了，就降成5%了。一直跌，那也没办法,它也会降收益。

优势

就是这个这种东西的好处:一个就是你要是去正宗的去投资美债的话，你得可以去开户，你去券商那边开户。然后美国账户，而且美国账户你也，说实话，你要存太多钱，你也感觉不安全。因为你国内身份注册的，有什么分工什么的，你直接过去不一定好使。

但是你在链上做这些的话，你钱，你只要合约是开源的，那你钱就是安全的。你到时候可以拿出来。

质押类型

一般来说呢，首先一个降低的门槛。你不用去开户，不用做 KYC 什么的。还有一个这个收益率就是全球都能来。

质押的话一般就是单币和双币。单币的话就是稳定币就比较推荐。还有一个就是其他类种的币呢，你要做对冲。你不做对冲的话可能亏得很惨的。

之前我压过一个 CAKE。我压了一年，那个跌了80%好像。那个他给我50%的利率好像是，然后跌了80%。然后就是基本上就是纯亏。就是你不做稳定币，做这种，你不做对冲就是纯亏。

但你做对冲呢，你要就要交合约费率。合约费率它要太高的话，你估计也不一定划算。

双币

然后双币的话，双币这个做起来比较难。我一般的话做双币也做稳定币的双币。这个应该比单币增加收益率高一点。

但是呢，双币比稳定币，你也得小心那个 USDC 那个爆雷的那个时候。那那那个时候也比较亏。但是后来 USDC 后来又救回来了，还算比较好的。那没救回来，那你就等着归零吧。

双币大概年化可以做到多少？

年化一般的话,8%~10%。现在现在很低了。之前牛市的时候还要搞十几二十都有，就稳定币。

对，做的比较保险。

他有的就是因为他那个双币稳定，他一般就是他不光是那个流动性 swap 的那个手续费给你，他还有额外的奖励。比如说那个，给你那个项目的 swap 的 TOKEN。他牛市的时候，他这个 swap 的 TOKEN 会涨，涨得很高，然后就带动了你的那个额外收益。

一般来说是一比一吧。感觉就是这价格波动嘛。这价格波动之后，你得小心那个什么无常损失之类的东西。反正对冲的话，对冲的话我记得好像是有期权，得用期权来做对冲，但是没具体研究过。

风险

除非他跑路，不然的话一般不会有风险。或者那个什么假币。

这个呢，你研究一下差不多一个月的时间，然后你可以拿到一个起码一个5%的年化利率吧。但是呢，这东西就是你要真大资金进去，我建议还是分一下。因为区块链风险比较高。这叫分仓。

2. 全球利率

然后接下来是一个全球的利率。那个是我刚查的那个一年期国债利率：

美国：1.4%
香港：4.6%
德国：3.7%
新加坡：3.3%

都比国内高。然后那个如果你想有这个，现在最简单的方法的话是去香港。香港那边有美元存款，还有那个什么国债的话都有。

这个的话我去开户开过，然后也买了点。这也是属于一个被动收入，就是比较稳。我也没做什么基金、股票这些东西。就买一点债券和定期存款。

香港还是比较近的。

关键这么少的钱买那个，那么买那个收益太少。

你资金量太少了，你买的东西还不如买个币，一天翻一两倍的。

开户推荐

中安汇理是电子银行，然后那个汇丰、民生，还有那个招商永隆，它是实体银行。这几个是我开过的，反正也还好用。

汇丰的话，它主要有一个国际转账。到其他的汇丰，其他地方的汇丰一下，它免手续费。但是你要去开别的国家的分支机构也比较难。

稳定币套利补充

还有一些东西，就是这个应该很多人都知道，就是在币安上面稳定币之间会有

价差。虽然利润小，但是还是有。

比如说 USDC、USDT 和这些 BUSD 这些东西，就是它可能会有一个万一到万二的一个收益。因为它这个风险就是，比如说哪个稳定币它崩盘了，但是基本上是不太可能。

前几天我就花了1,000美金，大概1,000的 USDC 换 USDT，他收了我一美元。那个是应该是汇率差。这就是币安上面就是稳定币交换是没有手续费的。

稳定币交易，没有手续费。但是你的 USDT 提出了，它会去收钱的，收10美金吧。USDT 提出，对，你从 Binance 提出,那肯定要收钱的。

我的意思是，比如说我有1万 USDT,然后这时候汇率差我就可以，比如说我可以买到10,001的 USDC。然后我这10,001的 USDC 我又可以，比如说换成10,002的 USDT。他这样安装完成。

资金费率套利

还有一种就是有时候比如说有些特别火的币种，比如说前段时间的 YGG。然后 YGG 的话就是他在某个交易所还有 Binance 上面的这个资金费率的收费时间是不一样的。我们就可以利用这个去吃资金费。

对，还有就是其实现在吃资金费的人还是很多的。所以说呢你就可以去吃吃资金费的那批人的钱。

比如说现在是3:59，然后一个币它的这个费率很负，就是空投很强。那这个时候肯定会要有一批人他想要吃这个资金费，他就会开多开进去。然后你就可以，比如说在3点50左右，或者说更早，在一个合适的位置直接开进去，吃他们那一波拉升的钱。然后赶紧跑。

这种品种其实很多的，就是在比如说八个小时结算一次，到结算点前五分钟或者两分钟。靠资金费率的人会吃进去。就吃他们拉升的比较多。这也偏向于套利了。

这个就直接就是用一个叫做 CCXT 的一个库。那个库，那个我用过，就是那个好多交易所 API。

3. 返利卡

最后还有一个是返利卡。就是我不知道你们有没有用过那个币安卡。就是币安它发的一个 Visa 卡。我反正是申请过一次。它那个返利很香的。你质押到300个 BNB，他给你返8%的消费金额。你花100块钱，他给你返8块钱。

但是呢，他的额度好像是5,000欧元。返利最高是500欧元，我记得是。

然后我用了一段时间之后，他那个合作的银行好像不跟币安合作了，就把我的那个银行卡给它封掉了。一开始我还去问币安客服，币安客服他也是说了一大堆话，也没搞懂。现在币安卡好像不发了。如果发的话，这东西非常香。

还有一个是 Capital.com 的，它也是那个，也是一个返利卡。那个，但是大陆好像注册不了。

借记卡

这个是一个交易所的卡。交易所卡那个币安不能用，现在基本上我也不用。

还有个借记卡，借记卡的话是汇理银行，就 ZA Bank。这个是香港的，香港的还有汇丰。汇丰是你用他那个借记卡的话，就云闪付卡的借记卡，他是消费按你的消费的0.4%给你返。然后汇理的话，它是按港元给你返，就是你得花它的港元，港元是1%返。

信用卡

然后信用卡的话，他说美卡港卡，这个叫美国的信用记录，什么 ITIN 那么个东西。这个我只是加了个群，看到他们有人在聊，但是具体的我还没操作过。我看他们那个开卡奖励都是几百刀几百刀给，还挺香。

时间是至少一个月，然后收益的话，如果光拿那个返现就是你只要你把那个 U 转换成港币，然后直接花港币，也不用换回来。你绑微信、支付宝的话，那个微信的话，这个汇率还好。会收0.5%的手续费。

4. 货币兑换

最后一个是货币兑换。就是一般你出 U 的话,C2C 就怕冻卡。我现在一般走银行渠道，就是银行呢有个问题就是手续费比较高。

你去券商，券商的话一般会给你一个免费额度。有的券商是不是按百分比收费的，他是按固定的收两刀三刀就兑换。就是嘉信跟盈透主要是，盈透就是换汇率，嘉信的话它是可以买美债。

支付机构

最后是一些支付机构，就是 Wise、Payoneer，还有 Neat、Remitly、Anywire。支付机构呢，就是有的可以也可以给你换汇或者换货币。这个机构就不一定安全，没有券商的安全。

券商的话就是他是买那个，他就是一个证券交易商，但是你能在里面出入金。你可以在里面存钱。

U 不行，U 你要先换成美元或者欧元，然后存进去。存进去你去换，它那个汇率比银行好。可能是比银行会收0.5%。但是你有的券商他就是按固定就收你两欧就行了，就不会按百分比收。

券商的话，你要去照顾他生意，你要去买点那个股票、证券什么的，不然他给你关户。看着你天天在这边换汇,我又不是换钱的地方。

然后支付机构呢，就是他就是专门做这个货币兑换的。但是他不一定有这些，有一个老牌机构的安全，可能会跑路。最好不要存钱，你存钱就别存在这个支付机构里，你要换的时候自己换就行。

C2C 冻卡问题

C2C 的话就是你们也没被冻过吗？

我的哥们被冻了，他提八百三十万，冻了三十万。三十万直接不要了。

我是提了几千块钱也被冻了。然后我就再也不走这个 C2C 了，感觉不靠谱。

那钱怎么出来？

等，去申请。他说要报案走流程。那个我几千块钱被冻了，然后去银行找他那个解开，他让我签那个什么防骗协议。我说是的是的，然后就给我解冻。他说要是下次再冻，这卡就用不了了。然后我就再也不走 C2C 了，我就去研究银行。

银行渠道

然后银行的话主要是瑞讯。瑞讯它是它有一些就是它有的银行就是对加密货币比较友好的银行。你可以直接去交易所提，它也有的交易所直接提 U 出来。但传统银行的话就是不支持交易所的转账。你得过一道，中间过一道，再提到传统银行。

反正你你开始研究的话会比较麻烦，你走通就比较成功了。

U 给银行，然后银行给你钱。

不是。你是 U 从交易所换成那个欧元或者美元，然后你交易所汇款到那个对加密货币友好的银行。

很多传统银行它不支持交易所的转账。因为它是公户，就是交易所是公户转的，他一看你那名字不对，什么 Binance 什么的，感觉是黑钱，就不收了。

反正货币兑换呢，你研究差不多起码一个月。然后收益呢，就是你到时候就有更安全的渠道。然后现在有很多 U 卡，做那个 U 卡的，他那个汇率基本上都是起码2%以上吧。但是你如果有自己的研究透了这个银行渠道，你这个这部分钱就可以省下来。然后基本上就是1%~3%吧，我感觉。

五、花钱比赚钱更重要

最后呢，我得讲一个这个：花钱可能比赚钱更重要。

就是因为你要达成这个不必赚钱的目标，你得本金乘以被动收益率，你要大于支出。

然后呢，这个增加本金就比较难，然后你提高被动收益率也很难。但是减少支出就是相对于这前面两个来说还是比较容易的。这都是你可以控制的，其他两个你很难控制。

如果说你花个钱就能提高你的收益，那就更好了。

最后呢，祝大家都能吃到这个饼。

整理完毕。本文档完整保留了原始内容，仅对文字进行了通顺化处理和结构化整理。

了解密码程序库Crypto++发展历史及其重要作用-001

本视频介绍了C++密码学程序库Crypto++的发展历程、功能特性及其在学术与工业领域的广泛应用。主讲人系统讲解了Crypto++支持的加密算法类型，包括对称加密、哈希函数、消息认证码、随机数生成器、公钥密码体制等，并强调库中部分标为“weak”的算法存在安全隐患，不建议在实际项目中使用。同时介绍了该库跨平台兼容性良好，支持多种操作系统和C++标准，适用于商业与非商业项目。视频还列举了其他主流密码学库如OpenSSL、Miracle、SEAL等，对比说明了Crypto++作为通用库的优势。最后，主讲人阐述了学习Crypto++的六大意义：提升C++编程能力、掌握开源库架构、深入理解面向对象与设计模式、实现密码算法理论到实践的转化、加速密码产品开发与原型设计，并预告下期将介绍其在Linux系统中的安装方法。

学习 Crypto++ 的核心价值

编程能力提升

学习 [发言人1] 提出的通过Crypto++巩固C++基础语法、面向对象编程、内存管理、模板技术及STL应用
掌握异常处理机制并在实际编码中加以运用

开源项目理解深化

通过阅读Crypto++源码理解开源库的整体架构与编码规范
参与开源贡献以熟悉协同开发流程与测试构建机制
培养开源思维，了解项目发布与维护的完整生命周期

面向对象与设计模式实践

深入理解继承、封装、多态等核心概念的实际应用场景
学习模板与泛型编程，编写高复用性代码
识别并应用常见设计模式，如工厂模式（AlgorithmFactory）、策略模式（接口与实现分离）、单例模式（RandomPool）、模板方法模式（BlockCipherMode）等

Crypto++ 库的技术特性

支持的算法体系

包含对称密码中的分组密码与流密码
提供多种操作模式，涵盖常规模式与认证加密模式
集成密码学哈希算法与非密码学校验和算法
实现消息认证码、密钥派生函数与基于口令的加密方案
支持公钥密码体系，包括加密、数字签名与密钥协商机制
内置常用代数结构与密码工具，如密钥分享协议

安全与前沿算法管理

标记以“weak”开头的算法为不安全算法，建议避免在生产环境中使用
包含部分低频使用或实验性质的算法，服务于研究目的

跨平台与标准兼容性

完全支持32位与64位架构
适配Android、iOS、BSD、z/OS、Windows等多种操作系统
兼容C++03至C++17等多个语言标准
可在多种编译器与开发环境中编译运行

学习 Crypto++ 的六大意义

第一，强化 C++ 编程技能

将理论知识转化为实际编码能力，全面提升语言掌握水平

第二，打开开源学习突破口

通过真实项目理解大型开源库的设计逻辑与工程实践

第三，深入掌握面向对象思想

在复杂系统中体会抽象、接口设计与模块化开发的重要性

第四，理解高级程序设计技巧

学习并识别工厂模式、策略模式、单例模式、模板方法模式等在密码库中的具体实现

第五，实现理论到实践的过渡

将数学化的密码算法转化为可运行代码，掌握实现细节与优化方法
利用统一接口组合不同算法实现安全通信协议

第六，加速产品开发与科研原型构建

快速搭建密码软件系统，缩短开发周期
帮助研究人员复现论文算法、验证新方案性能并完成原型测试

claude:

Crypto++ 密码学库从入门到精通

课程介绍

各位朋友大家好，欢迎收看三流密码学博士带你学习一流密码学程序库系列视频之 C++ 库从入门到精通。本套视频将带你从 C++ 小白变成 C++ 专家。

在本视频中，我们将一起了解密码学库 Crypto++ 的发展历史以及重要作用。我本人长期从事密码学的学习和研究工作，出版过一本与 Crypto++ 库有关的著作。本套视频也是基于这本著作中的相关内容制作而成。

接下来我们将从如下几个方面了解 Crypto++ 库。

一、Crypto++ 库简介

1.1 名称与起源

Crypto++ 也被称为 CryptoPP、Libcrypto++、Libcryptopp 和 Libcrypto++。它是一个由 David 编写的开源 C++ 类库，包含各种已经公开的加密算法。

其中 PP 表示 plus plus，这就是为什么 CryptoPP 也被称为 Crypto++。

1.2 发展历史与应用

Crypto++ 自1995年发布以来，已广泛用于学术界、学生项目、开源项目、非商业项目以及商业项目。至今，Crypto++ 仍在持续更新，同时不断有新的密码算法加入。

目前最新的 Crypto++ 版本是 8.9。通过右下角这个链接我们可以下载 Crypto++ 的源代码。

二、系统平台与编译器支持

2.1 支持的系统平台

接着我们来看一下 Crypto++ 使用的系统平台以及 Crypto++ 支持的 C++ 版本。

Crypto++ 库完全支持32位和64位架构，适用于许多操作系统平台，包括：

Android（安卓）
Apple（苹果）
BSD
z/OS
Windows
等等

2.2 支持的 C++ 版本

另外一点，Crypto++ 还支持：

C++03
C++11
C++14
C++17

运行时库进行编译，同时兼容多个编译器和开发环境。

三、包含的密码算法

接着我们来看一下 Crypto++ 包含的密码算法。

Crypto++ 包含大量公开的常用的算法，主要有：

3.1 对称密码

对称密码细分的话分为：

分组密码
流密码

3.2 操作模式

操作模式主要是针对分组密码，主要包含两类：

第一类是普通的操作模式
第二类是认证加密模式

3.3 哈希算法

哈希算法也分为两类：

一类是密码学的哈希算法
另外一类是非密码学的校验和算法

3.4 其他算法类别

第四类是消息认证码
第五类是随机数发生器
同时还包含密钥派生和基于口令的密码

3.5 公钥密码

此外还有公钥密码，公钥密码包括：

加密
签名
密钥协商

3.6 其他组件

还有一些常用的代数结构
另外一点的话，还包含一些密码学工具，比如说密钥分享

四、算法详细说明

这个图里边主要给出了 Crypto++ 库包含的密码算法。我们看到每一个蓝色的字体实际上就是一个类，每一个蓝色单词实际上就是一个类，对应一种算法。

4.1 安全性说明

这里边我们要注意的，Weak 开头的单词它表示这个算法存在安全问题。我们建议不要在实际的开发中使用这样的一些算法。

4.2 算法覆盖范围

Crypto++ 库还包含一些不太流行的、使用频率比较低的算法。

第三点的话就是 Crypto++ 库还包含一些处于提议中，或者说处于前沿研究的算法。也就是说这些算法目前处于研究状态，尚未被密码学相关机构和组织批准通过。

五、Crypto++ 库的价值

接下来我们来看一下 Crypto++ 库的价值。

5.1 商业应用

首先我们可以看到基于 Crypto++ 开发的商业产品有许多。

5.2 非商业应用

另外基于 Crypto++ 开发的非商业产品也有很多。

5.3 学术价值

另外一点是我们可以看到这个幻灯片上给出了我在谷歌学术上搜索 Crypto++ 关键字，搜索引擎给出的与 Crypto++ 库有关的学术论文。

六、其他密码学程序库

接下来我们来看一下其他的密码学程序库。在密码学程序库方面，并不是说只有 Crypto++ 一个，还有很多其他编程语言开发出来的密码库。

6.1 其他通用密码学库

第一个是其他通用密码学库。通用的密码学库其实它的功能跟 Crypto++ 一样，都是里边包含了一些已经公开的常用的密码算法。

这里边我们可以看到，其实有很多，那典型的话就是我们这里边说的 OpenSSL。这个是一个非常非常知名的基于 C 语言开发的密码学程序库。如果有时间的话，我们后面的话也出一套视频来讲解 OpenSSL 的使用。

6.2 特殊用途的密码库

第二是关于特殊用途的密码库。这里边我们看到有：

MIRACL：它是针对椭圆曲线的
PBC：它是针对配对密码的
SEAL：这个库是针对同态加密的

七、学习 Crypto++ 库的意义

接下来我们来介绍一下学习 Crypto++ 库的意义。学习 Crypto++ 库有什么意义呢？我们能够收获什么呢？

7.1 第一点：巩固 C++ 编程知识，提升 C++ 编程能力

学习 Crypto++ 库，我们可以巩固 C++ 编程知识，提升 C++ 编程能力。比如说：

我们可以巩固 C++ 的基础语法
加深对面向对象编程和内存管理的理解
了解模板技术和 STL 库的应用
明白如何在实际编程中进行异常处理

7.2 第二点：打开学习开源库的突破口

第二点的话，就是学习 Crypto++ 库能够打开学习开源库的一个突破口。让我们深入理解开源程序库的架构，比如：

我们可以理解开源程序库的架构
通过阅读源代码可以掌握编码规范
通过参与这些开源项目以及贡献代码，我们可以学习开源设计的协同模式
另外一点的话就是我们可以培养开源思维
了解开源项目的构建和测试机制

7.3 第三点：深入理解面向对象编程思想

学习 Crypto++ 库的第三点意义就是我们可以深入理解面向对象程序编程思想。比如说：

我们可以加深对面向对象编程中继承、封装、多态等概念的认识
提升从实际问题中提炼接口和抽象类的能力
另外我们还可以学习模板和泛型编程知识
编写出灵活和可复用的代码

7.4 第四点：了解高级程序设计技巧的应用

学习 Crypto++ 库的第四点意义就是说我们可以了解高级程序设计技巧的应用。

工厂模式

比如 Crypto++ 库，它提供了 AlgorithmFactory 这样的一个类，通过这个类我们可以创建各种加密算法和哈希函数实例。实际上这个类就是一个工厂模式的应用。

策略模式

又比如说 Crypto++ 中的加密算法和哈希函数，通常它通过接口类定义通用的行为，具体算法则在实现类里边实现这些接口，这个实际上就是策略模式。

单例模式

比如说 Crypto++ 中的随机数发生器，AutoSeededRandomPool，它只能创建一个实例，这实际上就是单例模式的体现。

模板方法模式

还有在 Crypto++ 库中有着 BlockCipherMode 类，它定义了加密和解密的基本流程，具体的加密模式则实现了具体的步骤，这实际上就是模板方法模式的一个应用。

实际上在 Crypto++ 库中使用设计模式的地方还有很多。

7.5 第五点：了解密码算法的实现方法，完成理论学习到实践的过渡

接下来我们来看一下学习 Crypto++ 库的第五点意义，也就是了解密码算法的实现方法，完成理论学习到实践的过渡。

Crypto++ 库将复杂的数学理论转化成了具体的代码
Crypto++ 库也提供了许多的代码实现细节，这些细节我们在理论的学习中可能会被忽略
另外一点就是 Crypto++ 库它提供了多种密码学协议的实现，我们可以将这些协议通过不同组合、不同的方式组合在一起，实现安全通信或重要数据的保护
另外一点，Crypto++ 库也提供了一致性很好的接口。我们可以在现有库的基础上添加新的算法或改进现有的算法，实现对现有算法的扩展和定制

7.6 第六点：加快密码产品开发和实现密码算法原型

接下来我们来看一下学习 Crypto++ 库的第六点，第六个意义就是加快密码产品开发和实现密码算法原型。

产品开发

就是说基于这个 Crypto++ 库，我们可以快速完成密码软件产品的开发。

科研应用

另外，Crypto++ 库也可以帮助研究人员：

快速复现论文中的算法
或者完成自研算法的原型开发
以及性能评估

这个是我们针对研究人员来说，有这样的一个优势。

课程总结

这就是我们本次视频的全部内容。在下一个视频中，我们将介绍 Crypto++ 库在 Linux 系统的安装方法。

感谢大家关注我的 B 站账号，更感谢大家的一键三连转发，更更感谢大家的投币和充电。如果想与我进行深入交流，可以扫码添加我的微信。

整理完毕。本文档完整保留了原始内容，仅对文字进行了通顺化处理和结构化整理。

原文链接: https://dashen.tech/2018/09/08/Web3视频转文字汇总/

版权声明: 转载请注明出处.