每当大型中心化交易所崩溃时，一个常被提及的问题是：我们是否可以利用加密技术来解决这个问题。交易所可以通过创建密码学证明的方式证明其链上持有的资金足以偿付用户，而不仅仅依靠政府牌照、审计员、调查公司治理以及交易所法人背调等「法币」方案。1 n) }" G* Y2 V
* [; }8 Z. f: J5 h
更有野心的是，交易所可以建立一个未经储户同意无法提取储户资金的系统。我们可以尝试探索「不作恶」有职业素养的 CEX 与「无法作恶」却泄漏隐私的低效链上 DEX 之间的界限。这篇文章将深入探讨让 CEX 更加去信任的历史尝试，与其采用技术的局限性，以及一些依赖 ZK-SNARKs 等先进技术的有力手段。
3 d/ [7 ^# ~+ O; h8 }9 |# u, s4 A! l3 ]- o
余额表和 Merkle 树：传统的可偿付证明交易所试图用密码学来证明自己没有欺骗用户的最早尝试可以追溯到很久以前。2011 年，当时最大的比特币交易所 MtGox 通过发送一笔移动 424,242 个 BTC 到预先公布地址的交易来证明他们拥有该笔资金。2013 年，大家开始讨论如何解决该问题的另一面：证明用户存款的总规模。如果你证明用户的存款等于 X （负债证明 proof of liabilities），并证明拥有 X 个代币的私钥（资产证明 proof of assets），那么就提供了可偿付证明（proof of solvency）：你证明了交易所有足够的资金偿还给储户。
0 _+ J! k! n6 Y" y/ K) r% m/ c" D$ u& M6 n; j# B" @. |
提供存款证明的最简单方法是公布一个列表。每个用户都可以检查他们在列表中的余额，而且任何人都可以检查完整的列表：（i）每项余额都是非负的；（ii）总额是宣称的金额。+ b; `! U/ L3 f  e

: a* m0 N8 M) f: d; t3 J当然，这会破坏隐私，所以我们可以稍微改变一下该方案：发布一个  列表，并私下给用户发送 salt 值。但即使这样也会泄漏余额与其分布。为了保护隐私，我们采用了后续技术：Merkle 树技术。
; h0 d+ _. ^, b% H$ V0 U% y( V, G& c& @

* F; @: ~5 {9 G/ z4 h0 E
9 u2 H% E! W" g" i: r绿色：Charlie 的节点。蓝色：Charlie 收到用于证明的节点。黄色：根节点，向所有人公布$ t* S4 b: A. `
$ B7 m9 L/ e% i* G% j5 o; ?
Merkle 树技术会将用户余额表放进 Merkle 总和树。在 Merkle 总和树中，每个节点都是对。底层叶子节点表示各个用户的余额以及用户名的加盐哈希。在每个更高层的节点中，余额是下面两个节点余额的总和，而哈希是下面两个节点的哈希。Merkle 总和证明和 Merkle 证明一样，是一个由叶子节点到根节点路径上所有姐妹节点组成的「分支」。" W7 p% N% z( E! g5 V1 h# b
1 e4 [! y. \# d2 G& _# {- l
首先，交易所会向每个用户发送一份其余额的 Merkle 总和证明。然后，用户能够确定其余额作为总额的一部分而被正确地包含。可以在这里找到简单的示例代码。
2 T4 d( b! T2 ^' v4 f( e4 `/ m/ p  e1 C

1. # The function for computing a parent node given two child nodes
     |6 U( d! m. d. s
2. 5 |5 f) d( H: y% z
   
3. def combine_tree_nodes(L, R):
   ( p0 D3 q; ]/ N$ u
4. 
   3 `9 y+ J. H$ x# Y: h6 k
5. L_hash, L_balance = L7 x- G: V' z) E
   
6. & R! m* z8 U9 b' c  D3 t$ w/ H
   
7. R_hash, R_balance = R# I0 {% A) q4 b: d
   
8. 
   * E3 F4 Q  `, z' T5 X' [
9. assert L_balance >= 0 and R_balance >= 02 p2 w) Y$ Z" a; J/ F
   
10. % ~" K; s8 j1 h; ~: \0 f, _
    
11. new_node_hash = hash(; ~3 Y3 W: B& A8 F: [* N% q% \) j
    
12. 
    , W" W( `: E& C5 N/ w& \5 |. \
13. L_hash + L_balance.to_bytes(32, 'big') +7 J& Y3 x$ @, n3 T/ ^8 z; S
    
14. 
    9 n* x+ M; s; T/ M( Z, l5 q
15. R_hash + R_balance.to_bytes(32, 'big')
    1 \7 s) e% h+ A  v; @  `
16. 
    0 i/ P: t+ V1 i6 O  |% A
17. )
    2 R5 g5 o* J- G. A5 B4 x7 V
18. & q1 i2 M' T7 N
    
19. return (new_node_hash, L_balance + R_balance)
    % d  k9 W- ^7 I2 y
20. ' D% u5 Z' b% \, P9 ~
    
21. # Builds a full Merkle tree. Stored in flattened form where* h2 P) W- b5 [' l
    
22. 5 h: o/ {8 T; T# z
    
23. # node i is the parent of nodes 2i and 2i+1% b0 j+ E1 p6 t% L* H" ~
    
24. 
    + g" m: v3 ?3 j8 j, P
25. def build_merkle_sum_tree(user_table: "List[(username, salt, balance)]"):
    $ p+ R9 M. c: b  ^( a- {) }1 D
26. 
    + s; e& [# ]; F8 D( r
27. tree_size = get_next_power_of_2(len(user_table))
    ; N1 d5 z, Y6 D" D& a- j
28.   F1 [! t& V5 t. q, |/ D4 k$ s
    
29. tree = (
    + ?* `, q5 k# S% J0 Q
30. 4 [$ F% C( ~  P
    
31. [None] * tree_size +
    0 f0 X- S, @9 D. D
32. 5 g' B) D' x% w8 x- M5 X; p
    
33. [userdata_to_leaf(*user) for user in user_table] +
    . L9 O! W) k3 D, l  P4 y
34. 
    8 R8 e; e/ ~( |( Q! r2 p2 a
35. [EMPTY_LEAF for _ in range(tree_size - len(user_table))]8 d# n0 I: `; J; H
    
36. 
    ! w( y" J: p  E; m
37. )
    9 W& M, ]5 n' j9 }  z& O* i& @9 f" d
38. 
    - l7 A/ ~- B. N, c! ~4 @6 J
39. for i in range(tree_size - 1, 0, -1):- V' r- Y9 I2 z' u( J
    
40. 
    / r$ `( p/ `: n8 i
41. tree = combine_tree_nodes(tree[i*2], tree[i*2+1]): t8 V! T9 i8 J$ X' `6 c; d
    
42. 
    1 u: E- V9 P- I* m0 b6 d8 S9 C
43. return tree( J, c% n# r8 X6 v% a7 R
    
44. 
    5 A0 ]- d8 A1 ]4 D  H
45. # Root of a tree is stored at index 1 in the flattened form
      p! M' Z7 M( y9 Y
46. 
    2 K& G2 G1 V9 }0 Q4 j" _! }  N
47. def get_root(tree):9 t6 a! f% ?" A  p7 P5 K' o* j
    
48. 
    % {8 t' J7 H2 P8 u6 c# r
49. return tree[1]
    ! x2 O" t' N( R& j- ~
50. ; X( _* V0 N  t; e" N$ m
    
51. # Gets a proof for a node at a particular index
    : [9 v$ M+ O! `  ?  z0 F
52.   W, |$ }+ `7 _: G- z0 x& k
    
53. def get_proof(tree, index):
    + k4 D3 I1 q! O  s2 s; U7 [1 }$ l' `
54. 
    3 {: w8 [/ D1 [6 s
55. branch_length = log2(len(tree)) - 1) d0 _8 M0 M! y: W
    
56. 
    # W* R( X- n% ~1 O4 S
57. # ^ = bitwise xor, x ^ 1 = sister node of x
    6 l- V/ U0 M  Y7 }6 V
58. 
    8 w) q' v4 \/ {4 B1 ^  h
59. index_in_tree = index + len(tree) // 2
    , E4 e8 c# z6 F0 p) x( `
60. . E. V, q% C/ c
    
61. return [tree[(index_in_tree // 2**i) ^ 1] for i in range(branch_length)]$ E) ]2 D2 c: N
    
62. 
    ; [( b, F8 g- e% b. v" q& z0 H
63. # Verifies a proof (duh)
    ' C; @+ x. w1 o' f! h
64. + x3 u5 g$ X5 Y# u
    
65. def verify_proof(username, salt, balance, index, user_table_size, root, proof):: u5 T5 l  M4 Z; O9 Z! D
    
66. 
    3 T- G2 \4 q1 N7 [7 a, U' }/ N
67. leaf = userdata_to_leaf(username, salt, balance)/ K# ?* Y$ I& ^% [  |6 n
    
68. 
    ! ^# [# I" ^' p. T3 a" a8 o. d
69. branch_length = log2(get_next_power_of_2(user_table_size)) - 1
    1 [+ ?& Q( ]4 _
70. 
    $ w6 z) l0 C5 F( L& [) Y" G4 K- \
71. for i in range(branch_length):
    $ X4 s0 R/ `7 w# g4 G
72. 
    - O) k/ N. {- `. G- O/ w
73. if index & (2**i):
    & A8 t; o* I$ C- |% M; d) P) S! B4 f( v0 T
74. 9 b! o- f! t" x7 h# u( p5 v
    
75. leaf = combine_tree_nodes(proof, leaf)
    8 g' t/ E/ b! ]/ A+ X
76. ( G* K5 q- d- @( E
    
77. else:
      G6 r% |$ a* Z# O
78. 5 K- t; d- m) i  L+ c" L3 T
    
79. leaf = combine_tree_nodes(leaf, proof)
    7 }) g3 \9 x3 I9 g
80. 9 i* k' f% I# U3 ^! G
    
81. return leaf == root

复制代码

! w2 X7 Z) J' {