L03a 智能合约:一台装在每个节点上的自动售货机
从零讲智能合约的四句话定义、和传统合约的六行对照、源码怎么变成每个节点都执行的字节码,再逐行读懂课件里的 Namespace 合约。
一句话版
智能合约是一段部署在区块链上的程序。它把多方之间的约定写成代码,到了条件就自己执行,部署之后谁也改不了。
读之前最好先懂上一讲的账户、交易和 gas:合约也是一种账户,调用合约就是发一笔交易。这一页从零讲合约是什么、代码怎么跑到链上,最后逐行读懂课件里的第一份合约。
先认识这几个词
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| 智能合约 | smart contract | 部署在链上、按代码自动执行的程序 |
| Solidity | 读「搜利迪提」 | 写以太坊合约最常用的编程语言 |
| 字节码 | bytecode | 源代码编译后给虚拟机执行的机器指令 |
| EVM | Ethereum Virtual Machine,以太坊虚拟机 | 每个节点里执行合约字节码的那台「虚拟电脑」 |
| wei | ETH 的最小计价单位 | 10¹⁸ wei = 1 ETH,合约里的金额默认按 wei 记 |
| mapping | 映射 | 合约里的一张「键 → 值」查找表 |
| require | 读「瑞快尔」 | 合约里的检查语句,条件不满足就整笔交易回滚 |
一个类比:一台不能退货的自动售货机
售货机的规则在出厂时就写死了:投够钱、按对按钮,货就出来。投币口有一道卡尺,硬币不对就退回去。机器旁边没有店员,你没法跟它讲道理。
合约也一样。require(msg.value == REGISTRATION_COST) 就是那道卡尺:付的钱必须正好等于报名费,差一点、多一点都不行,整笔交易被撤销。
这台售货机还有个特别的地方:它同时摆在成千上万个节点上,每台都按同一份程序跑一遍。大家跑出来的结果必须一样,否则就说不清到底卖出去了没有。
类比在哪里失效:
- 真售货机老板能开门补货、手动退款。合约部署后连作者都改不了,忘了写取款函数,收进来的钱就永远锁在里面。
- 售货机的货架是不透明的。合约的存储是玻璃做的,任何人都能读里面存了什么,下一页的猜拳游戏会栽在这一点上。
- 售货机出了错可以找厂家理赔。合约代码写错了也照样执行,没有「合理解释」的余地。
从零讲起
1. 智能合约是什么
它解决什么问题
两个人签一份合同,谁来保证对方照做?传统做法是找中间人:银行托管付款,律师楼保管文件,出了争议找法官。中间人要收费,也可能出错或偏袒。
智能合约想把「保证照做」这件事交给代码。规则写成程序放到链上,到了条件程序自己执行,谁都拦不住,也就不需要信任对方。
从哪来(补充)
「智能合约」这个词比以太坊早得多。计算机科学家 Nick Szabo 在 1996 年前后就用它来指「由物理财产强制执行的合约」,他举的例子正是自动售货机:投币、出货,整个交易不需要人参与。
二十年后以太坊让任何人都能把这类程序部署到公链上,这个词才真正流行起来。
直觉
课件用四句话定义它,每句都是考点:
- 合同,非正式地说,就是多方之间的书面协议。
- 把这份协议翻译成代码、部署到区块链上,就得到数字合约。
- 合约自己能强制执行协议,所以叫 smart。
- 合约一旦部署就不能修改。
第 3 句的 smart 指「自动执行、不需要外部强制」,和聪明没有关系。第 4 句是后面很多设计的根源:代码改不了,bug 也就修不了;想升级只能靠另外设计的代理合约。
一步一步看
目标:按六个维度逐行对照传统合约和智能合约,看付款和托管为什么能内置进代码。
把传统合约和智能合约按六个维度逐行对照,就是课件那张表。一行一行读:
-
怎么写下来:传统合约用自然语言,智能合约用代码。
-
怎么证明是你同意的:传统合约手写签名,智能合约用数字签名。
-
吵起来找谁:传统合约找法官、仲裁员,智能合约由去中心化平台按代码执行。
-
能不能撤销:传统合约由法官裁定,智能合约这一栏是 N/A。
-
钱怎么付:传统合约另行付款,智能合约把付款内置在代码里。
-
钱先放哪:传统合约找可信第三方托管,智能合约自己就能托管。
维度 传统合约 智能合约 Specification 自然语言 代码 Identity & Consent 手写签名 数字签名 Dispute Resolution 法官、仲裁员 去中心化平台 Cancel 法官 N/A Payment 另行进行 内置 Escrow 可信第三方 内置
最后两行能「内置」,是因为合约本身就是一个账户,有自己的余额。钱可以直接锁在合约里,按代码写的条件放出去。
怎么判断
拿到一段描述,判断它说的是不是智能合约,问四个问题:规则是不是写成了代码?代码是不是部署在链上?到了条件是不是自己执行?部署以后能不能随手改?
前三个答「是」、第四个答「不能」,就符合课件的定义。
还要多问一句:这份合约里有没有预先写好的升级或暂停开关?有的话,字节码虽然没变,系统的行为却可能变。所以「代码不能改」和「行为永远不变」要分开看。
常见误解
以为智能合约就是有法律效力的电子合同
两者没有必然关系。智能合约不需要任何一方「签字」,它只是一段到条件就执行的程序。代码自动执行了,并不代表这件事在法律上就成立;法律效力要另外看所在地的规定。
以为「部署后不能修改」就是系统行为永远不变
已经部署的那份字节码确实不能直接改写。但开发者可以事先设计代理合约,把调用转发到一份新的逻辑合约上;也可以预留管理员暂停权限。读一份合约时,要去查它有没有这类开关。
试一下
六行对照里,为什么 Cancel 那一栏写 N/A?
因为合约部署后不能修改,也没有任何一方有权叫停它。这是四句话定义第 4 句的直接后果。传统合约那一栏填的是由法官裁定。
有人说:「合约没有店员,所以付款和托管都得另找银行。」错在哪?
说反了。合约本身是能持币的账户,钱可以直接锁在合约里,按代码条件放出,所以 Payment 和 Escrow 两行都是「内置」,不需要银行或律师楼当中间人。
2. 代码怎么跑到链上:编译在链下,执行在每个节点
它解决什么问题
开发者写的 Solidity 源码是给人读的。节点要执行它,就得先变成机器能跑的指令。问题是:这一步在哪里做,谁来做?每个节点又是怎么保证跑出同样结果的?
直觉
想想 Java:程序员写 Java 源码,编译器把它编译成 JVM 字节码,再交给 Java 虚拟机去跑。虚拟机保证同一份字节码在任何电脑上结果都一样。
以太坊照搬了这个分工。开发者在自己电脑上用编译器 solc 把 Solidity 编译成 EVM 字节码,把字节码放进一笔部署交易发出去。每个节点收到后,用自己的 EVM 执行这份字节码。节点从头到尾都没见过 Solidity 源码。
一步一步看
目标:跟着一份合约从本机源码走到每个节点执行,看编译发生在链下,执行却在每个全节点上各跑一遍。
-
开发者在本机写 Solidity 源码。这一步只有开发者自己参与,人能读懂。
-
开发者在本机运行编译器 solc,得到 EVM 字节码。编译在链下完成。
-
字节码装进一笔部署交易的 data 字段,广播出去。交易上链后,合约就有了自己的地址。
-
以后每次有人调用这个合约,每个全节点都用自己的 EVM 把字节码跑一遍,各自更新自己那份合约存储。
课件的另一张图画了五个节点围成一圈,每个节点里都有同样的三层:合约存储、EVM、节点本身。配文是「每个节点跑同一份字节码」。
怎么判断
遇到「谁编译、谁执行」的题,按这条线判断:凡是发生在开发者电脑上的,是链下;凡是每个节点都要做一遍的,是链上。编译只做一次,在链下;执行每个节点都做,在链上。
再判断一段合约逻辑能不能写:它在每个节点上跑出来的结果会不会不一样?会不一样,就不能写进合约。随机数、系统时间、网络请求都属于这一类,因为每个节点拿到的值可能不同,共识就会分叉。
常见误解
以为链上存的是 Solidity 源码,节点读源码执行
链上存的是字节码。编译在链下由 solc 完成,部署交易里装的已经是 EVM 字节码,节点只负责执行。课件说 EVM 负责「把高级语言编译成字节码」,这句不准确,答题时按「节点执行字节码」写。
以为只有一个节点执行合约,其他节点抄结果
每个全节点都处理每一笔交易、存全部状态,同一份合约在每个节点上各执行一遍。这就是上一讲「世界计算机」在执行层的含义,也是以太坊又慢又贵的原因。
试一下
一个合约函数想用「当前网页上的天气」决定付不付款,能直接写进合约吗?为什么?
不能直接写。每个节点各跑一遍,各自去查网页,拿到的结果可能不一样,结果对不上,共识就会分叉。合约必须是确定性的,不能发网络请求。
同一份字节码,在五个节点上各执行一次,执行了几次?编译了几次?
执行了五次,编译了零次。编译在部署之前由开发者在链下做了一次,节点只拿到编译好的字节码。
3. 读懂课件的第一份合约:Namespace
它解决什么问题
域名系统(DNS)里有一张「名字 → IP」的表,比如课件里 www.turnonvpn.org 对应 198.61.190.243。这张表由一个中心化机构管理,可以被改,也可能被劫持。
Namespace 合约把这张表搬到链上:谁拥有一个名字、名字指向什么值,由合约规则决定,没有哪个机构能私下改。
直觉
合约里只有一张表 data。表的每一行有三格:
- key:名字的 keccak256 哈希,32 字节定长。
- owner:这个名字归谁。
- value:这个名字指向什么值。
三个函数就是对这张表的三种操作:nameNew 注册,nameUpdate 更新,nameLookup 查询。合约开头定了两个常量:注册费 REGISTRATION_COST = 100,更新费 UPDATE_COST = 10。这两个数没有单位后缀,所以是 100 wei 和 10 wei,几乎等于免费,这是教学示例的数字。
一步一步看
目标:跟着 Alice 注册、更新并转让一个名字,看 Namespace 合约每一步查哪些条件、表里哪一格变了。
跟着 Alice 走一遍,看表和合约余额怎么变。青绿框是这一步被改动的格子。
-
合约刚部署,表里一行都没写过。mapping 里没写过的 key 读出来全是默认值,owner 是零地址
address(0)。 -
Alice 先在自己电脑上算出
keccak256("alice"),调用nameNew(这个哈希),同时付正好 100 wei。第一道require查付款是否等于 100,通过;第二道查这一行的 owner 是不是零地址,也通过。于是 owner 写成 Alice。 -
Alice 调用
nameUpdate("alice", v, Bob),付 10 wei。合约先把原始名字哈希一遍,找到这一行;查付款是 10,查调用者是 owner;然后把 value 写成 v,再把 owner 转给 Bob。 -
之后任何人调用
nameLookup("alice"),合约同样先哈希再查表,返回 owner 和 value。它是view函数,只读不改,不花 gas。
怎么算
合约里的余额只有一条来路:每次成功的调用付进来的钱。所以:
合约余额 = 100 × 成功注册次数 + 10 × 成功更新次数
意思是:只数成功的交易。被 require 拒掉的交易整笔回滚,付的钱原路退回,不进合约余额。这份合约没有任何往外付钱的函数,所以余额只增不减。
再看每道检查用的是什么比较:
msg.value == REGISTRATION_COST:严格相等。意思是付 99 不行,付 101 也不行。data[hash].owner == address(0):意思是这个名字还没人注册过。data[hash].owner == msg.sender:意思是只有当前 owner 能改这一行。
常见误解
以为 nameNew 收哈希是为了让名字绝对安全
注册时只交哈希,链上的人暂时看不出你注册的是什么名字,等你第一次 nameUpdate 时名字才暴露。这算是最简单的「承诺」。但别人在 mempool 里看到你的哈希,可以直接复制去抢先注册,所以它演示的是数据结构,算不上安全设计。以太坊上真实的域名服务 ENS 用的是「承诺、等待、揭示」三步,下一页讲这套办法。
以为合约收了手续费,作者以后总能取出来
取钱要靠合约里写好的取款函数。这份合约没有写,部署后也加不上去,手续费就永远锁在合约里。这是「不可修改」第一次让人付出具体代价。
试一下
Alice 注册时手一抖付了 101 wei,会发生什么?合约余额变成多少?
第一道 require 用的是严格相等,101 不等于 100,交易回滚,那 101 wei 退回给 Alice。合约余额不变,还是 0。
Alice 已经注册了 alice,Bob 也算出同一个哈希来调用 nameNew 并付 100 wei,结果如何?
付款检查通过,但第二道检查发现这一行的 owner 已经是 Alice,不是零地址,于是报 “Name already registered” 回滚,Bob 的 100 wei 退回。
把它们串起来
这一页讲了合约的两面。第一面是它的定义:协议写成代码,部署上链,自动执行,部署后不能改。和传统合约逐行对照,最大的差别在 Cancel 一栏是 N/A,而付款和托管都能内置。
第二面是它怎么跑:开发者在链下编译,部署交易里装的是字节码,每个节点各执行一遍。正因为人人都执行、人人都能读,合约必须是确定性的,存储也是公开的。
Namespace 合约把这两面落到了一张表上:两道 require 是售货机的卡尺,没有取款函数是「不能改」的代价,只交哈希是一种最粗糙的保密。存储公开带来的麻烦,下一页用猜拳游戏放大来看。
课件里的坑
- [课件有误] p.6 写 EVM “compiles code from high-level language to bytecode” 不准确。编译在链下由 solc 完成,节点从来不见 Solidity 源码,收到的部署交易里已经是字节码,EVM 只负责执行。
- [口径差异] p.2 第四句说合约部署后不能修改。字节码确实不能直接改写,但代理升级或预设的暂停权限仍可能改变系统行为,答题时可以补一句「除非预先设计了升级机制」。
- [读代码提醒] p.4 的
REGISTRATION_COST = 100没有单位后缀,是 100 wei,不是 100 ether。mapping(...) public data的public已经自动生成了 getter,nameLookup存在的意义是让调用方传名字而不是传哈希。
课后 10 分钟:考点复习
这 10 分钟怎么用:合上页面,先默写四句话定义和六行对照表;再在纸上画 Namespace 那张三列表,跟着 Alice 注册、更新走一遍;最后回查两个最容易错的地方:链上存的是字节码,多付一个 wei 也会回滚。
必背
- 智能合约四句话:协议写成代码、部署上链、自己强制执行、部署后不能修改;smart 指自动执行,不指聪明
- 六行对照里 Cancel 一栏是 N/A;Payment 和 Escrow 能内置,因为合约本身是能持币的账户
- 智能合约把规则写成链上程序;代码不可直接改写不等于系统行为永远不变,代理升级或管理员权限须另查;自动执行不自动赋予法律效力
- 源码用 Solidity 写、在链下编译成 EVM bytecode 再部署;节点不编译只执行,每个全节点处理每一笔交易、存全部状态
- 每个节点各跑一遍同一份字节码、结果必须一致,所以合约必须是确定性的:不能有随机数、不能读系统时间、不能发网络请求
- Namespace 合约:nameNew 付正好 100 wei 且名字没人占才登记;nameUpdate 付 10 wei 且调用者必须是 owner;合约没有取款函数,手续费永远锁在里面
课件例题
例 1(课件 p.4):读 Namespace 合约
题面:合约用 mapping(bytes32 => NameEntry) public data 存「名字哈希 → (owner, value)」,REGISTRATION_COST = 100、UPDATE_COST = 10。nameNew(hash) 要求 msg.value == REGISTRATION_COST 且名字没人占;nameUpdate(name, newValue, newOwner) 要求付 UPDATE_COST 且调用者是 owner。问:(1) 付 101 去注册会怎样?(2) nameNew 为什么收哈希而不收名字?(3) 收进来的手续费去了哪里?
提示
(1) 看 require 用的是哪种比较。(2) 想想链上谁能看到交易参数。(3) 在合约里找一找有没有往外付钱的函数。
解答
- (1)
require用的是严格相等,多付一个 wei 也被拒绝,整笔交易回滚。100 没有单位后缀,是 100 wei。 - (2) 注册时只交哈希,链上观察者看不到你注册的是什么名字,第一次
nameUpdate时名字才暴露。这是最简单的承诺;但别人可以直接复制你的哈希抢先注册,它演示的是数据结构,算不上安全设计。 - (3) 合约没有取款函数,手续费永远锁在合约里。部署后想补一个取款函数也加不了,这是不可修改的代价。
例 2(课件 p.5–7):编译和执行分别在哪里发生
题面:课件 p.5 说合约用高级语言写、编译成 EVM 字节码后部署;p.6 说每个节点跑一个 EVM,每个全节点处理每一笔交易、存全部状态;p.7 的图里每个节点都跑同一份字节码。问:(1) 编译由谁在哪里完成?(2) 为什么合约不能读系统时间、不能发网络请求?
提示
(1) 节点收到的部署交易里装的是什么?(2) 想想五个节点各跑一遍时,各自拿到的时间和网页内容是否一样。
解答
- (1) 编译由开发者在本机用 solc 完成,属于链下。部署交易的 data 字段里已经是字节码,节点只负责执行。p.6 把编译写成 EVM 的工作,这一点不准确。
- (2) 同一份合约在每个节点上各执行一遍,结果必须一致,否则共识会分叉。系统时间和网络请求在不同节点上的结果可能不同,所以合约必须是确定性的。
完整例题
题面(改编自课件 p.4):Namespace 合约刚部署,余额 0。依次发生下面五笔交易,写出每笔是成功还是回滚、data 表里 alice 这一行怎么变、合约余额多少。
(a) Alice 调 nameNew(keccak256("alice")),付 100 wei。
(b) Bob 调 nameNew(keccak256("alice")),付 100 wei。
(c) Bob 调 nameUpdate("alice", v1, address(0)),付 10 wei。
(d) Alice 调 nameUpdate("alice", v1, Bob),付 10 wei。
(e) Alice 调 nameUpdate("alice", v2, address(0)),付 10 wei。
约定:被 require 拒掉的交易整笔回滚,付的钱退回,表不变。
解法:
- (a) 付款 100 等于注册费,这一行 owner 是零地址,两道检查都过。owner 写成 Alice。余额 100 wei。
- (b) 付款检查过了,但 owner 已经是 Alice,第二道检查失败,回滚。表不变,余额还是 100 wei。
- (c) 付款 10 正确,但调用者 Bob 不是 owner,报 “Not owner” 回滚。余额还是 100 wei。
- (d) 付款正确,调用者 Alice 是 owner。value 写成 v1;newOwner 是 Bob,不是零地址,于是 owner 改成 Bob。余额 110 wei。
- (e) 付款正确,但现在 owner 是 Bob,Alice 已经不是 owner,回滚。余额还是 110 wei。
- 最后 alice 这一行:owner = Bob,value = v1。合约余额 = 100 × 1 + 10 × 1 = 110 wei,这些钱永远取不出来。
要点:只有成功的交易改表、进余额。newOwner 传零地址表示「不转让」,这是 if (newOwner != address(0)) 那一行的作用。
答题格式:画一张表「交易 / 成功或回滚 / 原因 / owner / value / 余额」,每笔一行;最后单独写余额公式。
变式题(先自己做)
(1) 改编自课件 p.4:Alice 注册 alice 时付了 99 wei,结果如何?她接着付 100 wei 再注册一次呢? (2) 改编自课件 p.4:Alice 注册了 alice 之后,连续更新三次 value,每次都不转让,合约余额是多少? (3) 自编情境:有人说「Namespace 合约部署后发现手续费太贵,作者改一下常量就行」。这句话错在哪?
提示
(1) 回滚的交易对表和余额有没有影响?(2) 用余额公式,只数成功的交易。(3) 回到四句话定义的第 4 句。
判分点与答案(非官方评分标准)
判分点:① (1) 要写出两笔交易各自的结果,并说明第一笔不影响第二笔;② (2) 要列式;③ (3) 要点名「部署后不能修改」,并说出唯一的出路是事先设计升级机制或重新部署。
(1) 99 不等于 100,回滚,钱退回,这一行 owner 仍是零地址。第二次付 100,两道检查都过,注册成功,余额 100 wei。
(2) 余额 = 100 × 1 + 10 × 3 = 130 wei。
(3) 常量编译进了字节码,部署后的字节码不能直接改写。这份合约也没有预留升级入口,想改手续费只能重新部署一份新合约,旧合约里已收的钱仍然取不出来。
闪卡自测
1. 六行对照表里 Cancel 一栏为什么是 N/A?
因为合约部署后不可修改,也没有任何一方有权叫停。这是定义第四条的直接后果。传统合约那一栏填的是「由法官裁定」(p.2、p.8)。
2. Payment 和 Escrow 为什么能「内置」?
因为合约本身就是一个能持币的账户,有 balance 字段。钱可以直接锁在合约里、按代码写的条件放出,不需要银行或律师楼当托管中间人(p.8)。
3. Dispute Resolution 一栏写「去中心化平台」是什么意思?好处和坏处各是什么?
意思是代码怎么写就怎么执行,没有「合理解释」的空间。好处是不需要信任对方,坏处是代码写错了也照样执行(p.8)。
4. 链上存的是 Solidity 源码还是字节码?编译在哪里做?
字节码。开发者在链下用编译器 solc 编译,部署交易里装的就是字节码,节点只执行(p.5、p.6)。
5. 为什么合约必须是确定性的?
每个全节点都执行同一份字节码、存一份状态副本,结果必须一致,否则共识就会分叉。所以合约里不能有随机数、不能读系统时间、不能发网络请求(p.6、p.7)。
6. Namespace 合约的 data 表,key 为什么用名字的 keccak256 哈希?
mapping 的 key 要用定长类型,keccak256 输出固定 32 字节。另外注册时只交哈希,名字在第一次更新前不会暴露(p.4)。
7. Namespace 合约里 nameLookup 和 public data 的 getter 有什么区别?
功能上重复。public 自动生成的 getter 要传哈希,nameLookup 让调用方直接传名字,在函数里再哈希。它是 view 函数,只读不改状态(p.4)。
下一讲
下一页 L03a-2 承诺-揭示 用一个刻意写坏的猜拳合约,把「合约存储是公开的」这个性质放大来看:后出拳的人能看到你出了什么。然后用哈希承诺把它修好。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。