1.1 节点发现协议 Discovery Protocol#

这完全不同于 HTTP。它使用的是基于 Kademlia 算法的 DHT分布式哈希表

• Enode ID: 每个节点的身份证

  • 格式：enode://<128 位公钥 >@<IP 地址 >:< 端口 >
  • 当你启动一个 Geth 客户端，它会生成这个唯一的 URL

• 引导节点 (Bootnodes):

  • 这是代码里写死的种子节点列表
  • 新节点上线时，先去，质询 Bootnodes 在线节点
  • Bootnodes 返回一堆它知道的 IP。你的节点再去连这些 IP，像病毒扩散一样Gossip找到整个网络

1.2 通信协议 RLPx#

一旦找到了对方，怎么发数据？不可能是 http 以太坊使用的是 RLPx (Recursive Length Prefix Transport Protocol)

• 握手 (Handshake):

  1. A 发送 Auth 消息（用对方公钥加密的 ECDH 密钥交换）
  2. B 返回 Ack
  3. 建立加密通道（TCP 长连接）

• 多路复用 (Multiplexing):

  • 在这个 TCP 连接里，同时跑着不同的子协议：
  • eth/66: 交换区块头、交易数据
  • snap/1: 快速同步快照数据

2.1 什么是树#

这是一种结合了哈希树Merkle Tree和前缀树Radix Trie的变态结构

• Key: 账户地址的哈希（Keccak256(Address)）
• Value: 账户内容的 RLP 编码（[Nonce, Balance, StorageRoot, CodeHash]）

2.2 节点的四种形态#

在数据库底层，MPT 树由四种节点拼凑而成：

1. Leaf Node ( 叶子节点 ): [Key, Value]。这是真正存数据的地方（比如你的余额）

2. Extension Node ( 扩展节点 ): [Shared Key, Next Node Hash]

   • 如果一堆地址都是 0xabc... 开头，我们不需要存一万次 0xabc，只存一次，下面挂一个指针。这叫路径压缩

3. Branch Node ( 分支节点 ): 一个长度为 17 的数组

   • 前 16 个对应十六进制的 0-f
   • 决定了路径是往 0 走还是往 f 走

4. Null Node: 空节点

2.3 状态更新#

当你修改余额时：

1. 我们不复制整棵树。
2. 我们只修改受影响的叶子节点
3. 然后重新计算这条路径上所有父节点的 Hash，直到根节点
4. 旧的节点依然存在（这就实现了历史回溯），但生成了一个新的 Root Hash
5. 这个新的 Root Hash 被放进了新的区块头里

3.1 内存模型详解#

EVM 运行时有三块区域，性质完全不同：

1. Stack ( 堆栈 ):

   • 结构: LIFO ( 后进先出 )，最大深度 1024
   • 作用: 所有的计算（加减乘除）都在这里发生
   • 指令: ADD 从栈顶拿两个数，相加，结果推回栈顶
   • 特性: 几乎免费（Gas 极低），但随着函数结束消失

2. Memory ( 内存 ):

   • 结构: 线性字节数组
   • 作用: 临时存放字符串、数组、返回值
   • 成本: 它是按平方计费的，你申请的内存越大，Gas 呈指数级上涨（防止你把节点的 RAM 撑爆）
   • 特性: 交易结束后数据清零

3. Storage ( 存储 ):

   • 结构: 键值对映射 (Key-Value Map)
   • 作用: 永久写入区块链状态（MPT 树）
   • 指令: SSTORE ( 写 ), SLOAD ( 读 )
   • 成本: 天价。写一个非零值会需要 20000 Gas
   • 特性: 永久保存，全网同步

3.2 具体指令的执行流#

假设代码是 a = b + c。在 EVM 字节码里是这样的：

1. PUSH1 0x05 ( 把数值 5 推入栈 ) -> Stack: [5]
2. PUSH1 0x03 ( 把数值 3 推入栈 ) -> Stack: [3, 5]
3. ADD ( 加法操作 )
   • CPU 弹出 3 和 5。
   • 计算 3+5=8。
   • 把 8 推入栈。
   • Stack: [8]
4. PUSH1 0x00 ( 准备存到 Slot 0) -> Stack: [0, 8]
5. SSTORE ( 存储指令 )
   • CPU 弹出 0 (Key) 和 8 (Value)。
   • 物理动作: 在 LevelDB 里写入 MPT_Update(Key=0, Value=8)。
   • 扣费: 扣除用户 20000 点 Gas

4.1 Recursive Length Prefix)#

这是以太坊发明的一种极简序列化格式。
如果是一个字节，直接存。如果是一串字节，前面加一个前缀表示长度，这极致压缩了空间

4.2 交易结构#

一笔 Raw Transaction 包含以下字段（按顺序 RLP 编码）：

1. nonce: 计数器（防重放）
2. gasPrice: 你愿意为每单位 Gas 出多少钱
3. gasLimit: 你最多愿意花多少 Gas
4. to: 目标地址（如果是空，表示创建新合约）
5. value: 转账金额（Wei）
6. data: 这就是智能合约的函数调用数据（比如 0xa9059cbb...）
7. v, r, s: ECDSA 数字签名

4.3 签名原理#

当你点击 发送交易 时，你的钱包在做什么？

1. 哈希: 计算 h = Keccak256(RLP(nonce, gasPrice, ... data))
2. 签名: 使用你的私钥 dAd_A 和随机数 kk，根据椭圆曲线公式计算出 (r,s)(r, s)
3. 打包: 把 v, r, s 附在交易末尾

节点端验证: 节点收到交易，不需要知道你的私钥。它通过 v, r, s 和 h，利用椭圆曲线逆运算，可以算出一个公钥 QQ 如果 Address(Q) == From_Address，则签名有效，交易合法

5.1 验证者工作流#

现在可不再是挖矿算 Hash，而是在场证明Attestation

1. 质押 Staking: 你必须把 32 ETH 锁进存款合约。这笔钱是你的人质
2. 随机抽签 Randao: 系统每 12 秒随机选出一个 提议者 Proposer 又称矿工
3. 提议: 被选中的人打包交易，广播新区块
4. 见证 Attestation: 其他几千个验证者组成委员会，对这个区块进行签名投票，同意这个块合法

1. 预言机 Oracle#

• 区块链是封闭的，它不知道现在 ETH 的美元价格是多少，也不知道今天气温多少
• 这就产生了一个把现实世界数据（价格、天气）写入区块链的桥梁服务
• 在杠杆中，它是裁判。它说降价了，合约会就执行清算

2. Gas#

• 为什么我在链上点一下就要花几十块钱？
• 因为执行智能合约需要消耗全网节点的算力。Gas 就是你付给矿工的计算服务费
• 代码越复杂（循环越多、存数据越多），Gas 越贵

3. DApp 去中心化应用#

• 定义：Frontend ( 网页 /APP) + Smart Contract ( 后端 )
• 你看到的漂亮网页（比如 Uniswap 的界面）只是一个壳，它负责把你的点击转化为交易指令发送给区块链

4. DAO 去中心化自治组织#

• Aave 借贷协议里的 利息 是谁定的？
• 是持有治理代币Token的人投票决定的，这就像公司的股东大会，但是投票权是根据你手里币的多少来由代码自动统计的

6.1 定义#

这玩意既不智能，也不合约

在计算机科学中，智能合约的准确定义是：

存储在区块链上的、地址唯一的、不可篡改的、确定性执行的字节码

• 它没有 AI，不会思考。它只是一个死板的 If-This-Then-That的脚本
• 它没有法律效力（目前大多数国家），它更像是一个自动贩卖机的机械装置，算不上合约

6.2 贩卖机模型#

这是理解智能合约最经典的教科书模型（由尼克·萨博提出）：

1. 传统交易（Web2/ 柜台）：你把钱给售货员 →\to 售货员确认金额 →\to 售货员拿可乐给你 →\to 找零。
   • 风险：售货员可能拿钱跑路，可能算错账，可能不想卖给你
2. 智能合约（Web3/ 贩卖机）：你把钱投入机器槽口 →\to 齿轮转动 →\to 此时如果金额足够，可乐必须掉下来
   • 没有中间人。一旦你投币，结果是物理 / 数学上确定的

6.3 代码解析#

我们用最通用的语言 Solidity（以太坊的编程语言，长得像 JavaScript/C++）写一个最简单的存钱罐合约

// 1. 声明版本
pragma solidity ^0.8.0;
// 2. 定义合约（就像定义一个 Class 类）
contract PiggyBank {
    // --- 状态变量 ( 写在区块链硬盘上的数据 ) ---
    address public owner;  // 存钱罐的主人是谁？
    uint256 public balance; // 里面有多少钱？(uint256 是正整数 )
    // --- 构造函数 ( 部署时只运行一次 ) ---
    constructor() {
        owner = msg.sender; // 谁把这个合约部署上链，谁就是主人
        balance = 0;
    }
    // --- 函数：存钱 ---
    // payable 关键字表示这个函数能接收真金白银 (ETH)
    function deposit() public payable {
        balance += msg.value; // 余额增加
    }
    // --- 函数：取钱 ---
    function withdraw(uint256 amount) public {
        // A. 身份验证
        require(msg.sender == owner, "你是所有者吗你就整，滚出去");
        // B. 余额检查
        require(amount <= balance, "bro 没钱了");
        // C. 转账操作
        balance -= amount;
        payable(msg.sender).transfer(amount);
    }
}

1. 部署： 当你把这段代码通过钱包发送到区块链时，它会被编译成字节码 (Bytecode)（一堆机器才看得懂的 60806040...），并分配到一个以 0x 开头的合约地址

   • 从此，这段代码无法修改，无法删除

2. 调用： 当你在这个合约上点击 存钱 按钮时，其实是向这个合约地址发送了一笔交易

   • EVM 会被唤醒
   • 它加载这个合约的代码
   • 它执行 deposit 函数
   • 它修改 balance 变量的状态
   • 全网所有节点同步更新这个变量

3. 不可篡改： 注意 withdraw 函数里的 require(msg.sender == owner)

   • 在现实银行，如果有人拿着枪指着柜员，柜员可以把你的钱转走
   • 在智能合约里，如果私钥签名不对，莱斯特来了也转不走这笔钱。代码逻辑是绝对的铁律

7.1 Web3 杠杆#

• 传统金融（信用贷）： 你想借 100 万炒股。券商 / 银行看你的工资流水、房产证、信用分。如果觉得你靠谱，就借给你

  • 这基于人的信用

• Web3 金融（抵押贷）： 区块链不知道你是谁，也没法法院起诉你。它怎么敢借钱给你？ 答案是：超额抵押 噔 噔 咚

7.3 清 算#

既然是借钱，合约必须保证借款人的本金不亏损。 合约里写死了一行代码：清算阈值

假设 ETH 价格暴跌 你的 1.8 ETH 贬值了，价值快要低于你借出来的 USDC 总额了 一旦触碰设定的数学红线：

1. 预言机 告诉合约：现在 ETH 跌到 $2000 了
2. 合约触发 Liquidate 函数
3. 合约自动拍卖你抵押的 ETH，用来偿还你借的 USDC
4. 如果还有渣子会退给你

在这个过程中，没有催收电话，没有宽限期，只有代码被执行，你的本金可能会一瞬间蒸发

7.4 超额抵押#

这里我们深入讲解传统借贷和 web3

• 传统银行：

  • 你什么都不用押，凭工资条借了 10 万块
  • 你跑路了： 银行亏 10 万。银行报警，法院查封你财产，上征信黑名单
  • 你要知道的是，银行在害怕你跑路

• Web3 协议：

  • 你要借 80 块钱（USDC），你必须先往智能合约里存入价值 100 块钱的比特币（BTC）
  • 你拿着 80 块钱跑路了
  • 结果协议手里扣着你价值 100 块的比特币。协议把你的比特币卖了，扣除借给你的 80 块，甚至还赚了
  • 协议压根不在乎你跑不跑路，他们甚至希望你跑路

在去中心化世界，没有警察和法院，代码只相信扣在手里的资产

7.5 谁来清算？#

• 假设你抵押了 100 块的 BTC，借了 80 块出来。突然 BTC 暴跌，跌到 81 块了，马上就要资不抵债了（跌破 80），谁来卖掉你的债？

并没有人坐在电脑前盯着你的账户 执行清算的是一群机器人，我们称之为 清算人

流程如下：

1. 触发： 智能合约里写死了一条规则：如果（抵押物价值 < 借款金额 * 1.05），允许任何人调用 liquidate() 函数

2. 巡逻： 全世界有成千上万个 24 小时运行的脚本，它们时刻监听着链上的每一个借贷账户

3. 发现： 当你的 BTC 价值跌到红线那一瞬间，这几千个机器人会像鲨鱼闻到血腥味一样，争先恐后地向智能合约发送交易，试图触发 liquidate 函数

4. 处决：

   • 机器人帮你是还一部分欠款（比如还 40 块）
   • 作为回报，合约会把你的 BTC 以打折价（比如 5% - 10% 的折扣）卖给这个机器人

5. 结局：

   • 协议收回了欠款
   • 机器人赚到了差价（比如它花 40 块帮你还债，拿走了价值 44 块的 BTC）
   • 你的 BTC 被低价强制卖掉了，你亏大了

清算你的没有官方，而是为了赚取那 5% 罚金的第三方套利机器人。这是一种基于贪婪的自我维护系统

8.1 恒定乘积公式 CPMM#

这是一个极其优雅的数学模型，它不需要任何做市商挂单，只要有资金池就能交易

• 模型: 一个池子里有两种资产，A ( 数量 xx) 和 B ( 数量 yy)
• 铁律: 在交易前后，两个池子的数量乘积 kk 必须保持不变（忽略手续费） xold×yold=k=xnew×ynewx_{\text{old}} \times y_{\text{old}} = k = x_{\text{new}} \times y_{\text{new}}

8.2 交互推导#

假设池子里有：

• ETH (xx): 10 个
• USDC (yy): 30,000 个
• 当前价格: 3000 USDC/ETH
• k=10×30,000=300,000k = 10 \times 30,000 = 300,000

你想用 USDC 买 1 个 ETH

1. 你给合约发了若干 USDC（设为 Δy\Delta y）
2. 你想拿走 1 个 ETH (Δx=1\Delta x = 1)
3. 计算:
   • 池子剩下的 ETH 必须是: xnew=10−1=9x_{\text{new}} = 10 - 1 = 9
   • 为了维持 k=300,000k=300,000，池子里的 USDC 必须变成: ynew=300,0009=33,333.33y_{\text{new}} = \frac{300,000}{9} = 33,333.33
   • 所以，你必须投入的 USDC (Δy\Delta y) 是: Δy=ynew−yold=33,333.33−30,000=3,333.33\Delta y = y_{\text{new}} - y_{\text{old}} = 33,333.33 - 30,000 = 3,333.33

• 虽然初始价格是 3000，但你买这 1 个 ETH 实际上花了 3333.33
• 滑点 Slippage: 这一单把价格从 3000 推高到了 3333。买得越多，单价越贵。这就是供需曲线的自动调节

8.3 无常损失 Impermanent Loss#

这是作为流动性提供者 LP 必须懂的数学陷阱

• 当你把 ETH/USDC 存入池子做市，如果 ETH 暴涨，你的 ETH 会被套利者买走（因为池子里便宜），你会满手全是贬值的 USDC
• 自动卖出上涨资产，买入下跌资产。这是一种做空波动率的策略

9.1 架构设计#

1. 链上部分: 一个简单的存储合约

   PRTCL // SOLIDITY

   contract PriceFeed {
       int256 public price;
       function updatePrice(int256 _price) public { ... }
   }

2. 链下部分 Oracle Nodes: 几百个独立运行的服务器，监听交易所 API

9.2 数据上链流程#

1. 聚合 Aggregation: 21 个节点分别从币安、Coinbase 获取 ETH 价格
   • 节点 A: 3001
   • 节点 B: 3002
   • 节点 C: 2999
   • …
2. 共识: 它们在链下（Off-chain P2P 网络）对数据进行签名，取中位数。中位数能过滤掉个别恶意报价
3. 写入: 一个指定的节点把这一包带有 21 个签名的最终数据，发送给链上合约
4. 验证: 链上合约验证签名数量是否达标，然后更新 price 变量

这就是为什么 DeFi 借贷协议依赖 Chainlink。如果 Chainlink 被黑，所有借贷协议都会因为价格错误而发生连环清算

10.1 乐观汇总#

代表：Arbitrum, Optimism。

• 工作原理:
  1. L2 节点在链下飞快地跑交易
  2. 每隔几分钟，把几千笔交易压缩，计算出一个新的 State Root
  3. 把这个 Root 发布到以太坊 L1
  4. 乐观假设: L1 默认认为这个 Root 是对的，直接接受
• 欺诈证明 (Fraud Proof):
  • 如果在 7 天挑战期 内，有人发现这个 Root 是错的（比如 L2 节点私自改了余额）
  • 挑战者提交一段数学证据给 L1
  • L1 重新执行那一笔交易。如果发现确实错了，L2 节点被罚没押金，回滚状态
• 代价: 提现需要等待 7 天，也就是挑战时间，可以理解为冷静期

10.2 零知识汇总#

代表有：zkSync, Starknet

• 工作原理:
  1. L2 节点打包交易
  2. 数学魔法: 生成一个 零知识证明 (SNARK/STARK)。这个证明用密码学保证了：我刚刚执行的这 1000 笔交易，其状态变化确实导致了新的 Root，绝无作假
  3. 把 Root + 证明 提交给 L1
  4. L1 的验证合约校验这个证明。如果通过，立即确认状态
• 优势: 它是数学真理，不需要等待 7 天
• 劣势: 生成证明极其消耗 CPU 算力

11.1 重入攻击 Reentrancy Attack#

这是 The DAO 事件（导致以太坊分叉）的罪魁祸首

漏洞代码示例:

function withdraw() public {
    uint bal = balances[msg.sender];
    require(bal > 0);
    // 1. 转账
    (bool success, ) = msg.sender.call{value: bal}("");
    // 2. 扣余额
    balances[msg.sender] = 0;
}

攻击原理:

1. 黑客写了一个恶意合约
2. 黑客调用 withdraw()
3. 目标合约执行到 msg.sender.call（转账）时，会触发恶意合约的 fallback 函数
4. 恶意合约的 fallback 函数里写了一行代码：再次调用目标合约的 withdraw()
5. 此时，目标合约的第 2 步（余额归零）还没执行，所以 bal > 0 依然成立
6. 结果: 像递归一样，黑客把钱提了一次又一次，直到把池子提空，最后才执行余额归零

如何防御？: checks-effects-interactions 模式（先扣款，再转账）

11.2 抢跑与三明治攻击 MEV#

内存池 是完全公开的。矿工 / 验证者就像拥有上帝视角

你发了一笔交易：用 1000 USDC 买 ETH。这笔大单会把 ETH 价格推高 1%

攻击者 (Searcher Bot) 监测到了这笔交易：

1. 抢跑 (Front-run): 机器人发一笔交易买入 ETH，并将 Gas 费设得比你高。矿工会先打包它的交易。
   • 结果机器人把你买入前的价格抬高了
2. 你的交易执行: 你以更高的价格买入了 ETH（你亏了）。价格进一步拉高
3. 夹尾 (Back-run): 机器人紧跟着你的交易卖出 ETH
   • 结果机器人低买高卖，吃掉了你的滑点

这就是 Maximal Extractable Value。这是区块链这种公开透明账本的必然副作用

12.1 核心原理#

想象一下，你花钱买了一颗星星的命名权

• 你得到星星了吗？ 没有，星星还在天上，谁都能看，谁都能拍照
• 那你买到了什么？ 你买到了一张纸，上面写着：坐标 ~ 的这颗星星，现在归 Chongxi
• 谁承认这张纸？ 假如有一本全人类公认的、绝对无法涂改的天文学大账本（区块链），全世界只有这一本账本

NFT 就是这本大账本上的一行字：

编号 #8888 的东西，属于 #你的钱包地址

至于这个 #8888 是一张图片、一首歌，还是一把游戏里的屠龙刀，区块链其实根本不在乎。它只在乎确权

12.2 为什么比特币不是 NFT？#

• 比特币（同质化）= 钞票 你手里的一百块钱，和我手里的一百块钱，是一模一样的。咱俩换一下，毫无影响。这就叫同质化

• NFT（非同质化）= 房产证 你手里的是 1 排 1 座 的票，我手里是 最后一排厕所门口 的票 虽然都是票，但价值完全不一样，不能随便换。这就叫非同质化

所以在区块链上，比特币只记录 你有几个币
而 NFT 必须记录 你拥有的是哪一个编号

12.3. 最大的谎言#

NFT 最荒诞、也最技术性的地方

因为区块链简直是寸土寸金。要在以太坊链上存一张普通的 1MB 高清大图，光存进去的手续费可能就要几万甚至几十万人民币，哪怕是土豪项目方也存不起

那怎么办？存链接

你的 NFT 上，其实只写了一行像网址一样的东西：

TokenURI：https://…/oiiaoii.jpg

残酷的是：

• 你花了 100 万买的 NFT，在区块链上只是一行代码，这行代码指向了某台服务器上的一张图
• 如果项目方没钱续费服务器了，或者项目方跑路把服务器关了，你的 NFT 还在链上，但那个网址打不开了
• 结果你花 100 万买的房产证，变成了一张白纸

解决办法 现在的良心项目，会把图片存在 IPFS（一种去中心化硬盘） IPFS 的特点是：只要世界上还有一台电脑存着这张图，链接就永远有效。这就相当于把 房产证 指向了一个永远不会倒闭的图书馆

12.4 何为拥有#

很多人最不服气的地方便是：这图片我也能下载，我也能设成头像，凭什么要花 100 万？

• 你去卢浮宫，可以对着《蒙娜丽莎》拍照，可以把照片洗出来挂家里，甚至画得比真迹还清楚
• 但是，当你拿着照片去苏富比拍卖行，没人会理你
• 只有那个持有真品证书的人，才能把画卖出天价

在 Web3 的世界里，所有人的钱包都是透明的 你有没有这个 NFT，大家在链上一查就知道

• 你下载图片设头像 大家查你的钱包，发现里面是空的，纯装
• 你买了 NFT 设头像 大家查你的钱包，发现真的有记录，我去碰到老资历了

NFT 的价值，不在于 看 ，而在于 被全网验证的炫耀权

12.5 授权机制#

你在交易平台卖 NFT 时，你会发现你不需要把 NFT 转给平台 那平台怎么能在你睡觉的时候，自动把你的 NFT 卖给别人呢？

这里用到了一个类似 房屋中介 的机制：

1. 授权： 你第一次上架时，钱包会弹窗让你点确认。 这一步其实是在链上签了一份委托书：

   我授权 Opensea 这个中介，可以随时动用我钱包里的这张名为 #8888 的房产证

2. 签名： 你填个价格：10 ETH 这一步其实是你写了一张条子：

   谁给我 10 ETH，中介就把房产证给他 这张条子没上链，只是贴在了 Opensea 的服务器上（为了省手续费）

3. 成交： 买家来了，看中了。买家把 10 ETH 给 Opensea 的智能合约 合约拿着你的委托书，直接把 NFT 从你的钱包里抓出来，塞给买家，同时把钱给你

为什么很多人点个链接 NFT 就没了？ 因为骗子做的钓鱼网站，伪装成抽奖页面，弹出的那个确认框，其实是最高权限委托书 你一旦点了确认，骗子就有权搬空你所有的 NFT，根本不需要知道你的密码

14.1. 支付革命#

这是目前 Web3 唯一真正的大规模应用

• 在阿根廷、土耳其、尼日利亚等通胀严重的国家，普通人把积蓄换成 USDT/USDC 存在手机里
• 这并不是为了炒币，而是为了生存。它让一个没有美国银行账户的非洲人，拥有了持有美元资产的权利。这在人类历史上是第一次
• 现在汇款要几天，收几高手续费；用链上转账，几秒钟，几分钱，全天候。银行的 SWIFT 体系注定会被淘汰

14.2 资产代币化#

别再炒你那破图片了，未来炒的是现实世界，把美债、房地产、股票映射到链上

*   你可以在周日凌晨 3 点，把你的 100 块钱美债卖掉，换成一杯咖啡
*   你可以买 0.0001 份纽约的一栋大楼的收租权。

• 逻辑： 并不是为了去中心化，而是为了流动性和全球化。黑石（BlackRock）等巨头正在入场，这才是万亿级的市场

14.3 数据主权与数字身份#

这是对抗 AI 时代唯一的武器

• 在 AI 时代，怎么证明 我是人？怎么证明 这个作品是我画的，不是 AI 生成的？
• Web3 的解法： 你的私钥签名是无法伪造的数字指纹
• 你的社交关系、你的医疗数据、你的创作内容，不再存在腾讯或 Google 的服务器里，而是加密存在 IPFS 上，钥匙在你手里。任何 App 想用数据，必须经你授权（甚至要付费！）

14.4 无摩擦的全球协作#

• 虽然现在的 DAO 很乱，但代码级公司的形态是先进的
• 没有财务部门（链上自动记账），没有跨国转账障碍，根据贡献（代码提交量 / 投票）自动发工资。这对于开源社区和全球化组织是降维打击