8.4 存储管理

riyad

• 在以太坊虚拟机合约中，您可以单独访问和修改每个存储元素。
• 而在 TON 中，存储空间是通过 get_data()/set_data() 访问的（c4 存储器持有Cell袋的引用）。
• 这就要求开发人员手动 "管理 "存储空间
  
  7 M5 @' P- k/ K$ d( @& V( F

' I- k% V* L$ |6 D$ v典型的信息处理程序

TON 中典型的信息处理程序就是采用这种方法：

1. () handle_something(...) impure {
   3 G* x7 w, u8 J* a7 O. j! c
2.     (int total_supply, <a lot of vars>) = load_data();
   
3. 
   1 C% F% H2 v4 P: X
4.     ... ;; do something, change data
   9 R' Z+ K  j) ~2 z6 X- [4 w
5. 
   1 J9 r/ A8 N( a& Y6 n& v1 M9 N
6.     save_data(total_supply, <a lot of vars>);
   
7. }

复制代码

不幸的是，我们注意到了一种趋势： <a lot of vars> 是对所有合约数据字段的真正枚举。例如

1. (int total_supply, int swap_fee, int min_amount, int is_stopped, int user_count, int max_user_count,
   2 d. K  i9 n% G9 N
2. slice admin_address, slice router_address, slice jettonA_address, slice jettonA_wallet_address,
   
3. int jettonA_balance, int jettonA_pending_balance, slice jettonB_address, slice jettonB_wallet_address,
   ! F' E% |  N7 s& O' ?
4. int jettonB_balance, int jettonB_pending_balance, int mining_amount, int datetime_amount, int minable_time,
   
5. int half_life, int last_index, int last_mined, cell mining_rate_cell, cell user_info_dict, cell operation_gas,
   * w9 D( l7 h0 O( I  P5 ~, a
6. cell content, cell lp_wallet_code) = load_data();

复制代码

这种方法有许多缺点。

问题 1：难以更新存储结构

• 增加一个字段就需要更新整个合约。
  
  

首先，如果您决定添加另一个字段，例如 is_paused，那么您就需要更新整个合约中的 load_data()/save_data() 语句。这不仅耗费大量人力，还会导致难以捕捉的错误。

在最近的一次 CertiK 审核中，我们注意到开发人员在某些地方混淆了两个参数，并写道：

1. save_data(total_supply, min_amount, swap_fee, ...
   , u& S0 ?; M8 s- {% ~
2. instead of
   
3.     save_data(total_supply, swap_fee, min_amount, ...

复制代码

在没有专家团队进行外部审计的情况下，很难发现这样的漏洞。出现错误的函数很少被使用，两个混淆的参数值通常都为零。要发现这样的错误，你必须知道自己在寻找什么。
问题 2：命名空间污染

• 读取当前命名空间的所有存储字段会污染命名空间。
  
  + `( W/ Z6 Q0 y

其次是 "命名空间污染"。让我们用审计中的另一个例子来解释问题所在。在函数的中间部分，输入参数为

1. (int total_supply, int swap_fee, int min_amount, <a lot of vars>) = load_data();
   $ j  ]: l# C) b
2. ...
   8 f) z' }5 @0 R  \# U9 W) U. {
3. int min_amount = in_msg_body~load_coins();
   ' Y5 F+ Z6 Q8 O( c
4. ...
   
5. save_data(total_supply, swap_fee, min_amount, <a lot of vars>);

复制代码

也就是说，局部变量对存储字段进行了阴影处理，在函数结束时，这个被替换的值被存储在存储空间中。攻击者有机会覆盖合约的状态。

• FunC 允许重新声明变量。
  
  

问题 3：GAS成本增加

最后

• 解析整个存储空间并在每次调用每个函数时将其打包回去，会增加GAS成本。
  
  ! H4 {% f+ H# z% Y

解决方案 1： 使用全局变量

在原型设计阶段，由于合约中存储的内容并不完全明确，因此可以使用全局变量。

1. global int var1;
   * G9 k8 I" Z, F+ Y" @2 v. M( l1 U
2. global cell var2;
   1 C, Q3 l* h( P: E6 f. _
3. global slice var3;
   8 g1 W1 j* D  w" ]/ i* \
4. 
   
5. () load_data() impure {
   
6.     var cs = get_data().begin_parse();
   
7.     var1 = cs~load_coins();
   0 l+ J% K3 |! ^& Z3 Y1 s+ }3 j
8.     var2 = cs~load_ref();
   ! V8 G* k. ~( B  m6 Z8 u2 M  g
9.     var3 = cs~load_bits(512);
   + h. N2 D( E  l& T
10. }
    ' k) ~2 V* X6 B8 E
11. 
    
12. () save_data() impure {
    
13.     set_data(
    . z+ P1 b! Q3 K! t  ^
14.         begin_cell()
    
15.             .store_coins(var1)
      k# e# w: z: C$ W! }4 E) q& ^# t" W
16.             .store_ref(var2)
    ' L+ f* l- {1 ~2 b
17.             .store_bits(var3)
    
18.             .end_cell()
    
19.         );
    0 q2 m/ W( q" Q2 P9 E" |  a
20. }

复制代码

这样，如果发现需要另一个变量，只需添加一个新的全局变量并修改 load_data() 和 save_data()。整个合约无需任何改动。但是

• 全局变量不能超过 31 个。
• 全局变量比在堆栈中存储更昂贵。
  
  

解决方案 2：使用 "嵌套 "存储

原型设计完成后，我们建议采用这种存储组织方法：

1. () handle_something(...) impure {
   " z6 {8 B1 y7 G  c3 ]- g5 a( n0 E, j
2.     (slice swap_data, cell liquidity_data, cell mining_data, cell discovery_data) = load_data();
   
3.     (int total_supply, int swap_fee, int min_amount, int is_stopped) = swap_data.parse_swap_data();
   / n% I6 w5 [: `* ?( H
4.     …
   % ?7 @  L- Q6 A2 O
5.     swap_data = pack_swap_data(total_supply + lp_amount, swap_fee, min_amount, is_stopped);
   & C1 y6 ~; m8 ?
6.     save_data(swap_data, liquidity_data, mining_data, discovery_data);
   
7. }

复制代码

• 如果变量经常使用（如 is_paused），则由 load_data() 立即提供。
• 如果只在一种情况下需要使用参数组，就不要拆包。
  
  

存储空间由相关数据块组成。如果每个函数都使用一个参数，例如 is_paused，那么  load_data() 会立即提供该参数。如果一个参数组只在一种情况下需要使用，那么它就不需要解压缩，也不需要打包，更不会污染命名空间。

• 如果添加了新变量，需要更新的代码片段就会减少。
  
  7 ?1 c+ B+ b1 E8 O. M' U0 h

如果存储结构需要更改（通常是添加一个新字段），那么需要进行的编辑就会大大减少。

• 嵌套变量可以再嵌套。
  
  

此外，这种方法还可以重复使用。如果我们的合约中有 30 个存储字段，那么一开始你可以得到四组，然后从第一组中得到几个变量和另一个子组。最主要的是不要做得太过分。

• Cell最多可存储 1023 个比特和 4 个参考点。无论如何，你都会分片。
  
  , C$ \* u2 i% |+ a- `% c

请注意，由于一个Cell最多可存储 1023 位数据和 4 个引用，因此无论如何都必须将数据拆分到不同的Cell中。

分层数据是 TON 的主要功能之一，让我们将其用于预期目的。

使用 end_parse()

• 从存储器和信息有效载荷读取数据时，尽可能使用 end_parse()。
  
  5 H5 B- T1 F/ g0 m2 f" |

由于 TON 使用的是可变数据格式的位（bit）流，因此确保读取的数据量与写入的数据量相等是很有帮助的。这样可以节省一个小时的调试时间。

使用辅助函数，避免幻数

这段代码来自一个真实的项目。由于有大量幻数，即使是经验丰富的开发人员也会被吓到

1. var msg = begin_cell()
   
2.     .store_uint(0xc4ff, 17)         ;; 0 11000100 0xff
   
3.     .store_uint(config_addr, 256)
   ; s2 h" ^* B6 x0 w& W) c" B
4.     .store_grams(1 << 30)           ;; ~1 gram of value
   
5.     .store_uint(0, 107)
   
6.     .store_uint(0x4e565354, 32)
   3 E# f1 G9 w2 D4 p! L
7.     .store_uint(query_id, 64)
   
8.     .store_ref(vset);
   5 P9 R5 A& U5 M  b
9.    
   8 I' `/ E; X0 R0 Q0 `. c1 G! V: r
10. send_raw_message(msg.end_cell(), 1

复制代码

根据需要引入尽可能多的常量和封装器，以实现代码的表现力

9 r$ j; e5 T/ _$ `1 I0 G: W7 V

1.     var msg = begin_cell()
   
2.         .store_msg_flags(BOUNCEABLE)
   
3.         .store_slice(to_wallet_address)
   4 r/ Y/ c8 I9 C0 ]( }: A. }
4.         .store_coins(amount)
   . F/ s) k8 v& S$ _) Q$ w6 y$ W
5.         .store_msgbody_prefix_stateinit()
   
6.         .store_ref(state_init)
   
7.         .store_ref(master_msg);
   6 }$ `: P, B4 ^! k: M0 n
8. 
   
9.     send_raw_message(msg.end_cell(), SEND_MODE_PAY_FEES_SEPARETELY);

复制代码

错误示例

不要忘记所有与 TON 无关的传统陷阱和潜在错误。下面是一个实际项目中的例子。

1. () handle_transfer(...) impure {
   
2.   ...
   + j1 A: i. f6 E. b+ r- c& T7 V  X# c
3.   (slice from_user_info, int from_flag) = user_info_dict.udict_get?(256, from_addr_hash);
   * ?0 v- i1 R6 y4 ?* e
4.   int from_balance = from_user_info~load_coins();
   ( @" {. w& @( K2 S0 G9 i7 m
5.   ...
   3 u- I3 C. v  B2 X9 u9 h$ z
6.   (slice to_user_info, int to_flag) = user_info_dict.udict_get?(256, to_addr_hash);
   ! N8 F, ^6 I- |" r0 R: r, h/ H; I
7.   int to_balance = to_user_info~load_coins();
   
8.   ...
   3 y* P! K1 \1 D2 I
9.   ;; save decreased from_balance to user_info_dict
   
10.   ;; save increased to_balance to user_info_dict
    
11. }

复制代码

由于 to_balance 会覆盖已清零的 from_balance，因此向同一地址转账实际上会使余额翻倍。

/ B9 u& R) j3 m摘要

• 使用 "嵌套 "存储组织和全局变量，保持存储操作的稳健性。
• 编写封装程序并声明常量，以保持代码的表达能力。
• 测试你的代码。
• 进行彻底审核，避免损失。
  
  ; B/ P6 ^* _6 O

8 J8 ?; B6 G7 K9 I2 l6 v
# Q, L. x! c+ @9 N