← COMP5565 全部讲次
L05b · 第 6 周

L05b 存储布局:给合约的数据编门牌号

从一个 32 字节的槽讲起,算清整数、负数、地址、打包、短字符串、动态数组和 mapping 各落在哪个槽。

一句话版

合约的每个状态变量都住在一个编号的格子里,固定大小的按顺序挤着住,大小不定的只留门牌、真身搬到哈希算出来的远处。

先认识这几个词

词 全称 / 读法 一句人话
storage 合约存储 合约长期保存数据的地方,交易结束后还在
slot 存储槽 storage 里的一个格子,每格 32 字节,从 0 开始编号
字节 byte 8 个二进制位,写成十六进制正好两个字符
补码 two’s complement 计算机表示负数的标准方式
packing 打包 几个小变量挤进同一个槽,省空间
keccak256 以太坊用的哈希函数 把任意输入压成 32 字节的「指纹」,用来算远处的槽号
mapping 键值表 按 key 查 value 的表,像字典

一个类比:给合约的数据编门牌号

把 storage 想成一条极长的街,门牌号从 0 排起,每户房子正好 32 个房间。合约按变量声明的先后,从 0 号门牌开始一户一户分房子。

一个 uint256 正好住满一户。两个 bool 各只要 1 个房间,就和一个 20 个房间的地址合住同一户,从最右边的房间开始排。

动态数组和 mapping 住多少人事先不知道。它们在顺序里只领一户当「登记处」,真正的住户被安排到一个用哈希算出来的远处门牌,那里离 0 号门太远,不会和别人撞上。

类比在哪里失效:

  1. 现实的门牌号能看出远近。keccak256 算出的门牌号像随机数,两户算出来的数挨不挨着,完全看不出规律。
  2. 现实里空房子就是空的。没写过的槽读出来一律是 0,所以「读到 0」和「从没写过」在链上没法区分。

从零讲起

1. 十六进制、字节与补码(补充)

它解决什么问题

课件里的槽内容全是 0x…2a、…ffd6 这样的十六进制串。不会读十六进制和补码,后面每一道槽位题都卡在第一步。

从哪来(补充)

补码的想法很早:冯·诺依曼在 1945 年那份 EDVAC 报告草稿里就建议用它表示负数,1949 年的 EDSAC 已经采用(Wikipedia: Two’s complement)。它的好处是加法电路不用区分正负,今天几乎所有计算机都这么存负数。

直觉

十六进制每一位表示 0 到 15,用 0-9 和 a-f 写。一个字节是 8 个二进制位,正好写成两个十六进制字符。一个槽 32 字节,就是 64 个十六进制字符。

补码可以想成里程表倒转。从 0 往回走 1 步,表上显示的是全 f;往回走 42 步,就停在「全 f 减 41」的位置。

一步一步看

目标:手算 42 的十六进制和 -42 的补码,看出它们放进 32 字节的槽里为什么分别读作 0x00…002a 和 0xff…ffd6。

  1. 把 42 写成十六进制:42 = 2×16 + 10,十位是 2,个位 10 写作 a,得到 2a。

  2. 补满 32 字节:左边补 62 个 0,读作 0x00…002a。

  3. 求 -42 的补码,先写 42 的最低字节二进制:0010 1010。

  4. 每一位取反:1101 0101,十六进制是 d5。更高的字节全是 0,取反后全变成 ff。

  5. 加 1:d5 + 1 = d6,没有进位,高位全 ff 不变。

    步骤 最低字节 其余 31 个字节
    42 2a 全 00
    取反 d5 全 ff
    加 1,得 -42 d6 全 ff
  6. 所以 -42 在槽里读作 0xff…ffd6。

怎么算

补码的公式是:负数 -n 在 256 位里存成 2²⁵⁶ - n。

意思是:从「刚好溢出回 0」的那个数里减掉 n。-42 就是 2²⁵⁶ - 42,写成十六进制正是全 f 开头、末字节 d6。

手算只看最低字节时,用 256 - n:256 - 42 = 214,214 的十六进制就是 d6。

常见误解

以为负数前面加一个负号位就行,-42 就是「符号位 + 2a」

那是「原码」的思路,以太坊不用。-42 存的是 2²⁵⁶ - 42,几乎所有位都是 1,末字节是 d6,不是 2a。

以为十六进制串越长数越大,ff…ffd6 是个巨大的数

看类型。同一串字节按 uint256 读是一个巨大的正数,按 int256 读就是 -42。槽里只存字节,怎么解读由变量类型决定。

试一下

int256 x = -1; 在槽里长什么样?-16 的末字节是多少?

-1 是 2²⁵⁶ - 1,64 个字符全是 f。-16:256 - 16 = 240 = f0,末字节是 f0,其余全 ff。

2. 槽:按声明顺序一格一格放

它解决什么问题

读写合约数据,或者判断升级会不会写坏数据,都要先知道「第几个变量在第几号槽」。这一节先讲每个变量都占满一槽的最简单情况。

直觉

每个合约有自己的 storage,一共 2²⁵⁶ 个槽,每槽 32 字节。合约只能读写自己的槽,没写过的槽读出来是 0。

变量按声明的先后,从 slot 0 开始一个接一个放。uint256、int256 正好 32 字节,一个变量占满一槽。address 只有 20 字节,在槽里靠右放,左边补零。

一步一步看

目标:按声明顺序把四个变量放进槽,看出每个变量落在哪号槽,第二个地址为什么挤不进 slot 2。

  1. 合约依次声明 uint256 positiveNumber = 42;、int256 negativeNumber = -42;、address addr1、address addr2,两个地址相同。

  2. positiveNumber 是第一个,进 slot 0:0x00…002a。

  3. negativeNumber 进 slot 1:按上一节的补码,0xff…ffd6。

  4. addr1 进 slot 2。地址 20 字节靠右,左边补 12 个字节的零,地址字母按小写显示。

  5. addr2 也是 20 字节。slot 2 只剩 12 字节,放不下,换到 slot 3。

    三个槽的字节格:slot 0 末字节 2a(青绿高亮)左边全是 00,slot 1 末字节 d6 左边全是 ff,slot 2 右侧 20 字节是地址 f39f…2266、左侧 12 字节补零

怎么判断

判断一个变量落在哪一槽,按顺序问:

  1. 它多大?uint256 和 int256 是 32 字节,address 是 20 字节,bool 是 1 字节。
  2. 当前槽还剩多少?能放下就放进去,放不下就开新槽。

意思是:槽号由「前面所有变量占了多少」决定,和变量叫什么名字无关。这也是上一页说升级时不能改旧变量顺序的原因。

常见误解

以为地址在槽里靠左放

地址和整数一样靠右(右对齐),高位补零。读 slot 2 时,最右边 40 个十六进制字符是地址,左边 24 个是 0。

试一下

依次声明 address owner; uint256 total; address admin;。三个变量各在第几槽?

owner 在 slot 0(占右边 20 字节)。total 要 32 字节,slot 0 只剩 12 字节放不下,进 slot 1。admin 进 slot 2。

3. packing:小变量挤进同一槽

它解决什么问题

存储很贵,每多用一个槽都要多付 gas。几个小变量能挤进同一槽,就少占槽。读槽的人也要会把一个槽拆回几个变量。

直觉

一个槽 32 字节,两个 bool 加一个地址只要 22 字节,剩下的空着太浪费。编译器从槽的最右边开始,按声明顺序把它们一个挨一个往左排。

一步一步看

目标:插入两个 bool 后重新排 slot 2,看出小变量怎样从最低字节往左挤进同一槽,整槽又该怎么读。

  1. 在 negativeNumber 后面插入 bool test = true; 和 bool test2 = false;,再声明 addr1,去掉 addr2。

  2. slot 0 和 slot 1 不变,还是 42 和 -42。

  3. test 是 slot 2 里的第一个,放在最低字节:01。

  4. test2 紧挨着往左:00。

  5. addr1 20 字节,槽里还剩 30 字节,放得下,接着往左排。最左边剩下的 10 字节补零。

    slot 2 的三帧打包过程:第一帧只放 test 的 01 在最右,第二帧加上 test2 的 00,第三帧再加 20 字节地址 f39f…2266,最左 10 字节为零

  6. 整槽读作 0x00000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660001。

怎么算

packing 有五条规则:

  1. 从槽的最低位(最右边)开始放。
  2. 只占真实字节数。
  3. 剩下的空间放不下就换新槽。
  4. 结构体(struct)和数组(array)新开一个槽,内部再紧凑排。
  5. 它们后面的变量也新开槽。

意思是:拆槽时从右往左读,先声明的变量在最右。上面那个槽,最右两个字符 01 是 test,再往左 00 是 test2,再往左 40 个字符是地址。

常见误解

以为先声明的变量放在槽的左边

反过来。先声明的放在最低位,也就是最右边。按阅读习惯从左往右看,会把顺序读反。

以为 bool 至少要占一整个槽

bool 只占 1 字节。前后有能挤进来的小变量,就和它们共用一槽。

试一下

依次声明 uint8 a = 1; uint16 b = 2; address c;。三个都在 slot 0 吗?末尾 6 个十六进制字符是什么?

都在 slot 0:1 + 2 + 20 = 23 字节,不超过 32。最低字节是 a 的 01,往左两个字节是 b 的 0002,所以末尾 6 个字符是 000201。

4. 定长数组、结构体与短字符串

它解决什么问题

数组和结构体是「一组变量」,它们怎么排?字符串长度不定,短的时候又怎么塞进一个槽?这一节把这几种复合类型讲清楚。

直觉

定长数组和结构体都按规则 4 新开一槽,内部成员再按普通规则排。它们结束后,后面的变量也新开槽,不和成员挤在一起。

短字符串(不超过 31 字节)整串塞进一个槽:字符按 ASCII 码(字母对应的数字编码)从左往右放,最右边那个字节记长度。

一步一步看

目标:把定长数组和结构体逐个放进槽,看出它们各自新开槽,短字符串 Alice 和它的长度怎样塞进同一个槽。

  1. 依次声明 uint256 positiveNumber = 42;、uint256[3] fixedNumbers = [1, 2, 3];、结构体 Person { string name; uint256 age; } 的实例 person = Person("Alice", 30)。

  2. positiveNumber 进 slot 0。

  3. fixedNumbers 新开槽,三个 uint256 各占一槽:slot 1、2、3 依次是 1、2、3。

  4. 结构体新开槽。name 是短字符串,进 slot 4。

  5. Alice 五个字母的 ASCII 是 41 6c 69 63 65,从左往右放;最低字节存长度 5 乘 2,即 0a。

  6. age 进 slot 5,30 的十六进制是 1e。

    slot 0 到 slot 5 竖排:0 是 42,1 到 3 是定长数组的 1、2、3,slot 4 是 Alice 的 ASCII 字节靠左、最右字节 0a(青绿高亮),slot 5 是 age 的 1e

怎么算

短字符串的最低字节等于 length×2。

意思是:长度乘 2 一定是偶数,读到偶数就知道这是短串,字符就在本槽里;长串用别的格式存,那个字节是奇数。Alice 长 5,5×2 = 10,写成十六进制就是 0a。

字符的 ASCII:A 是 41,小写 l i c e 依次是 6c 69 63 65。

常见误解

以为短字符串和整数一样靠右放

字符串的字符靠左放,从槽的最高位开始;最右边那个字节留给长度标记。整数和地址才靠右。

以为 0a 是字母 a

0a 是数字 10,也就是 5×2 的长度标记。小写字母 a 的 ASCII 是 61。

试一下

string s = "Hi"; 单独占一个槽。最左两个字节和最右一个字节各是什么?(H 是 48,i 是 69)

最左两个字节是 48 69。长度 2,2×2 = 4,最右一个字节是 04,中间全是 0。

5. 动态数组与 mapping

它解决什么问题

动态数组可以一直 push,mapping 的 key 可以有无数个。如果它们的数据在声明顺序里挨着放,一变长就会撞上后面的变量。它们必须有另一套放法。

直觉

两者都在声明顺序里只占一个「主槽」。动态数组的主槽记长度,元素从 keccak256(主槽号) 开始连续放。mapping 的主槽留空、恒为 0,每个 key 的值单独放在 keccak256(key, 主槽号) 那一格。

哈希出来的数在 0 到 2²⁵⁶ 之间近似随机,离 slot 0 附近的普通变量极远,撞上的可能性可以忽略。

一步一步看

目标:给动态数组 push 两个数、给 mapping 写一个余额,看出数据落到 keccak256 算出的远处槽,主槽只留长度或空位。

  1. 合约依次声明 positiveNumber = 42(slot 0)、uint256[] numbersArray(slot 1)、string name = "Alice"(slot 2)、mapping(address => uint256) balanceOf(slot 3)、uint256 count = 1(slot 4)。

  2. numbersArray push 了 123 和 456。slot 1 存长度 2。

  3. 元素基址是 keccak256(uint256(1)),即 0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6。基址 + 0 存 123 = 0x7b,基址 + 1 存 456 = 0x1c8。

  4. balanceOf[msg.sender] = 1000。slot 3 保持 0。

  5. 值的槽号是 keccak256(abi.encode(msg.sender, uint256(3))),算出来是 0xc651ee22…c137,里面存 1000 = 0x3e8。

    左边是 slot 0 到 4 的主槽,slot 1 写长度 2、slot 3 写 0;右边远处是 keccak256(1)+0 和 +1 两格存 123 与 456,以及 keccak256(key,3) 那一格存 1000,箭头从主槽指过去

  6. count 照常落在 slot 4。数组和 mapping 再怎么长,也不会挤到它。

怎么算

两条公式:

  1. 动态数组 arr 在主槽 p,arr[i] 在 keccak256(p) + i。
  2. mapping m 在主槽 p,m[key] 在 keccak256(abi.encode(key, p))。

意思是:数组只算一次哈希,之后元素按下标往后挨着放;mapping 每个 key 都单独算一次哈希,key 之间互不相邻。两条公式里的 p 都是主槽号,不是元素下标。

常见误解

以为 mapping 主槽存着「有多少个 key」

记长度是动态数组的事。mapping 主槽留空,恒为 0;值全在哈希算出来的槽里,合约本身也不知道一共有多少个 key。

以为动态数组的元素紧跟在主槽后面

主槽后面一格是下一个变量。元素在 keccak256(主槽号) 起的远处,所以数组变长不会影响后面的变量。

试一下

上面那个合约再 push 一次 789,slot 1 变成多少?789 放在哪一格?slot 4 的 count 会变吗?

slot 1 变成 3。789 放在 keccak256(uint256(1)) + 2。count 还在 slot 4,值不变。

把它们串起来

每个变量都按声明顺序领槽号。读槽内容要先会十六进制和补码:42 是 2a,-42 是全 f 加末尾 d6。

固定大小的变量从槽的最右边往左挤,放不下就换槽。结构体和数组另起一槽,后面的变量也另起。短字符串字符靠左、最右一字节记 length×2。

大小不定的动态数组和 mapping 只在顺序里留一个主槽,数据挪到 keccak256 算出来的远处。所以它们怎么长都不会撑开后面的变量。

这一页的计算是上一页 Proxy 升级的前提:新实现合约读的还是同一片存储,只要有一个变量的槽号算错,升级后就会把别的数据读错或写坏。

课件里的坑

  • [读图提醒] p.12 的 Slot[2] 按常规左高右低写成 …660001,读的时候要从右往左拆:01 是 test,00 是 test2,66 是地址的最低字节;先声明的变量在更低位,按阅读习惯从左往右看会把顺序读反(p.12)
  • [记号提醒] 课件写 mapping 取值在 keccak256(key . slot),p.15 的代码写法是 keccak256(abi.encode(key, uint256(3)));中间的点表示把 key 和主槽号拼在一起再哈希,不是乘法(p.14–15)
  • [理解提醒] p.14 说 mapping 和动态数组不能插在前后变量中间把它们撑开,原因是槽位布局必须在编译期确定;它们在声明顺序里只占一个主槽,长度变化只发生在哈希算出的远处(p.14)

课后 10 分钟:考点复习

这 10 分钟怎么用:合上页面,先手算一遍 42 和 -42 的槽内容;再把例 2 的 Slot[2] 从右往左拆成三个变量;最后默写动态数组和 mapping 的两条公式,说清主槽里各存什么。

必背

  1. 合约 storage 共 2²⁵⁶ 个槽、每槽 32 字节;除动态数组与 mapping 外按声明顺序紧凑排布;packing 五条:低位对齐、只占真实大小、塞不下换槽、struct/array 及其后变量都新开槽。
  2. 短 string 最低字节存 length×2(偶数表示短串),「Alice」五字节 ASCII 左对齐、末字节 0x0a;动态数组主槽存 length、元素从 keccak256(主槽号) 起;mapping 主槽恒为 0、取值在 keccak256(abi.encode(key, 主槽号))。
  3. 整数按十六进制存,-42 用 256 位补码存、末字节为 d6;address 占 20 字节,在槽里右对齐、高位补零。
  4. 动态数组和 mapping 在声明顺序里各只占一个主槽,数据放在 keccak256 算出的远处,所以不会把后面的变量撑开。
  5. 读打包过的槽要从右往左拆:先声明的变量在最低位。

课件例题

例 1(课件 p.10):四个变量各占一槽

题面:合约依次声明 uint256 positiveNumber = 42;、int256 negativeNumber = -42;、address addr1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;、address addr2 取同一地址。写出 Slot[0] 到 Slot[3] 的内容。

提示

整数按十六进制补满 32 字节;负数用补码;地址 20 字节靠右,一个槽塞不下两个地址。

解答
  1. Slot[0]:42 的十六进制是 2a,左边补零到 32 字节,末尾读作 …002a。
  2. Slot[1]:-42 用 256 位补码存,前面全是 f,末字节是 d6,读作 0xff…ffd6。
  3. Slot[2]:地址 20 字节,靠右放,左边补 12 个字节的零,地址字母一律按小写显示:0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266。
  4. Slot[3]:与 Slot[2] 相同。每个变量都占满或放不下第二个地址,所以各占一槽。

例 2(课件 p.12):插入两个 bool 之后

题面:在 negativeNumber 后面插入 bool test = true; 和 bool test2 = false;,再声明 addr1(同上地址),去掉 addr2。Slot[2] 现在是什么?

提示

先加总三个变量的字节数,看能不能塞进一槽;再按低位对齐从右往左排。

解答
  1. 两个 bool 各 1 字节,地址 20 字节,合计 22 字节,能塞进一个 32 字节的槽。
  2. 从最低位开始放:最低字节是 test 的 01,次低是 test2 的 00,再往左 20 字节是地址,最左边 10 字节补零。
  3. 整槽为 0x00000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660001。读槽从右往左拆:01 是 test,00 是 test2,再往左 40 个十六进制字符是地址。

例 3(课件 p.13):定长数组和结构体

题面:依次声明 uint256 positiveNumber = 42;、uint256[3] fixedNumbers = [1, 2, 3];、结构体 Person { string name; uint256 age; } 的实例 person = Person("Alice", 30)。写出 Slot[0] 到 Slot[5]。

提示

数组和结构体都新开槽;name 是短字符串,字符靠左、最低字节记 length×2。

解答
  1. Slot[0] 是 42,…2a。
  2. 定长数组新开槽,三个 uint256 各占一槽:Slot[1]、Slot[2]、Slot[3] 依次是 1、2、3。
  3. 结构体也新开槽。name 是短字符串,放 Slot[4]:Alice 五个字母的 ASCII 是 41 6c 69 63 65,从左往右放;最低字节存长度 5 乘 2,即 0a。整槽为 0x416c696365 后接零、末尾 0a。
  4. age 放 Slot[5],30 的十六进制是 1e,读作 …001e。

例 4(课件 p.15):动态数组与 mapping 的槽位:见下方完整例题。

完整例题

题面(课件 p.15):合约按顺序声明:

uint256 positiveNumber = 42;           // slot 0
uint256[] numbersArray;                // slot 1,随后 push 123, 456
string name = "Alice";                 // slot 2
mapping(address => uint256) balanceOf; // slot 3,随后 balanceOf[msg.sender] = 1000
uint256 count = 1;                     // slot 4

问:(1) slot 0、1、2、3、4 主槽各存什么?(2) numbersArray[0]、[1] 的存放地址怎么算、值是多少?(3) "Alice" 为什么以 0a 结尾?(4) balanceOf[msg.sender] 的值存在哪个槽?

解法:

  1. 主槽按声明顺序排:动态数组和 mapping 在声明顺序里各只占一个 32 字节槽,后面的变量照常往下排,所以 count 落在 slot 4。
  2. slot 0 = 42 = 0x…2a;slot 1 存数组长度,push 了两次,所以是 2;slot 2 是短串 Alice;slot 3 是 mapping 主槽,恒为 0;slot 4 = 1。
  3. 数组元素基址:主槽号是 1,基址 = keccak256(uint256(1))=0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6。
  4. 元素值:基址 + 0 存 123=0x…007b,基址 + 1(末尾变成 0cf7)存 456=0x…01c8。课件还列了基址 + 2,没有 push 过,读出来是 0。
  5. Alice 的结尾:长 5,最低字节存 5×2=10=0x0a(短串规则:末字节 = length×2)。
  6. mapping 取值:槽号 = keccak256(abi.encode(key, uint256(3))),key 是 msg.sender 地址,3 是主槽号。算出来是 0xc651ee22…c137,里面存 1000=0x…03e8。

要点:固定大小的变量按顺序挤,大小不定的数组和 mapping 只在顺序里留一个门牌,数据挪到哈希算出来的远处,所以它们不会把后面的变量撑开。

答题格式:先列主槽表(槽号、变量、内容),再分别写数组和 mapping 的公式代入过程,最后给出十六进制值和十进制对照。

变式题

改编自课件 p.12–15:合约依次声明 uint8 a = 1;、uint16 b = 2;、uint256 c = 3;、bool d = true;、uint256[] list;。(1) 一共用了几个主槽?slot 0 的末尾几个字节读出来是什么?(2) list 的元素从哪里开始放?

提示

第一问按 packing 五条一个个往槽里放:uint8 占 1 字节、uint16 占 2 字节,uint256 一个人就占满一槽。第二问先数 list 的主槽号,再套动态数组的公式。

判分点与答案(非官方评分标准)

判分点:① a 和 b 能挤进同一槽,c 放不下必须换槽;② d 排在 c 后面,c 占满了 slot 1,所以 d 进 slot 2;③ 动态数组的公式里用的是主槽号,不是元素下标。

(1) slot 0:最低字节 a = 01,往左两个字节 b = 0002,末尾读作 …000201。slot 1:c = 3。slot 2:d 的 01。slot 3:list 的长度,还没 push,为 0。一共 4 个主槽 ✓。

(2) list 主槽号是 3,元素从 keccak256(uint256(3)) 开始,list[i] 在基址 + i ✓。

闪卡自测

1. packing 五条规则是什么?

低位对齐;只占真实大小;塞不下换槽;struct/array 新开槽;它们之后的变量也新开槽(p.11)。

2. 短字符串「Alice」的槽为何以 0a 结尾?

最低字节存 length×2;5×2=10=0x0a,偶数表示短串(p.13)。

3. True or False: A mapping's base slot holds the number of keys.
中文:mapping 主槽存着 key 的个数。

False. The base slot is left zero; values sit at keccak256(key . slot). 长度是动态数组主槽的事(p.14–15)。

4. -42 在 int256 槽里的末字节是多少?为什么?

d6。补码存 2²⁵⁶ - 42,最低字节等于 256 - 42 = 214 = 0xd6(p.10)。

5. 动态数组 arr 在 slot 1,arr[1] 在哪?

keccak256(uint256(1)) + 1(p.15)。

下一讲

L05c DAO 与访问控制:合约可以升级以后,谁有权改实现地址?下一页讲 DAO 的提案和投票,再讲两个因为「谁能调这个函数」没管好而出事的代币合约。

下一讲 →
L05c L05c DAO 与访问控制:谁有权按下那个按钮

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。