7.3 Jetton 钱包合同

riyad

在本课中，我们将回顾钱包智能合约. 正如你所记得的，一旦我们铸造了Jettons，钱包智能合约就会被矿工智能合约部署。或者，当我们进行转账时，钱包智能合约会被另一个钱包智能合约部署。所以，我们还是要做一定的准备：

1. int min_tons_for_storage() asm "10000000 PUSHINT"; ;; 0.01 TON
   7 H4 J4 ^0 \/ M- m6 G$ n. P
2. ;; Note that 2 * gas_consumptions is expected to be able to cover fees on both wallets (sender and receiver)
   9 V/ v) i6 \7 q8 f4 H5 A
3. ;; and also constant fees on inter-wallet interaction, in particular fwd fee on state_init transfer
   : \8 s: P6 A  K
4. ;; that means that you need to reconsider this fee when:
   
5. ;; a) jetton logic become more gas-heavy
   # [$ n5 M, D3 ~3 v
6. ;; b) jetton-wallet code (sent with inter-wallet message) become larger or smaller
   
7. ;; c) global fee changes / different workchain
   
8. int gas_consumption() asm "15000000 PUSHINT"; ;; 0.015 TON

复制代码

您可以在代码中看到，我们当然需要一定数量的Ton。我们需要从每笔交易中扣除TON，以确保存储支付有最低可用量。我们还对 gas_consumption 做了一些常数— 这只是一个近似值。

1. {-
   
2.   Storage
   " R' G+ U& F8 q$ `. I0 w& u( `
3.   storage#_ balance:Coins owner_address:MsgAddressInt jetton_master_address:MsgAddressInt jetton_wallet_code:^Cell = Storage;
   * `8 ^+ e0 @4 \# L4 b2 h5 O, i
4. -}
   ) n8 \# K% q4 g! s1 x
5. 
   / a" Z8 M- @: J! R9 M6 [. I# j% N. D
6. (int, slice, slice, cell) load_data() inline {
   # A5 z* [5 \& _+ b- f" j6 ]) k
7.   slice ds = get_data().begin_parse();
   2 a1 m3 L) a$ m* k  K8 i# x
8.   return (ds~load_coins(), ds~load_msg_addr(), ds~load_msg_addr(), ds~load_ref());
   7 E1 {' z2 [! k" V/ o3 Z' X
9. }
   
10. 
    / G! C0 d( X+ }0 h. `/ S8 N$ I
11. () save_data (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) impure inline {
    
12.   set_data(pack_jetton_wallet_data(balance, owner_address, jetton_master_address, jetton_wallet_code));
    % y" J' }1 Y& @/ }, g5 [, n: m& D) b
13. }

复制代码

当然，我们还可以这样做 load_data, save_data 就像我们一开始封装读取存储的逻辑一样。让我们来看看我们实际部署合约的矿工。在这里，我们将 Jetton 钱包数据从 utils: 输入余额、所有者地址、主地址和 jetton_wallet_code。我们可以在这里看到代币、地址、地址和Cell：

1. return (ds~load_coins(), ds~load_msg_addr(), ds~load_msg_addr(), ds~load_ref());
   / v5 D9 ^. S5 q

复制代码

因此，代码被存储为一个Cell，我们把它放在这里。基本上，这就是这个钱包合约首次执行后的初始数据示例。这里有哪些功能？我们有 send_tokens 功能, receive_tokens 功能, burn_tokens功能, on_bounce, 而这一切都是由我们来定义的。这不符合标准。recv_internal 是核心部分，在这里我们可以看到一个标准的东西。

因此，一旦信息中的操作代码与传输操作代码、内部传输或刻录相匹配，我们就会运行刚才讨论过的函数：

1. int op = in_msg_body~load_uint(32);
   
2. 
   
3. if (op == op::transfer()) { ;; outgoing transfer
   2 P5 U9 s% P: _
4.   send_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
   : o* m2 J$ l- a1 o4 \2 x
5.   return ();
   
6. }
   * M# A3 v# s; l( N4 s) z
7. 
   * [) e- T% K6 W; y5 w
8. if (op == op::internal_transfer()) { ;; incoming transfer
   0 y' U8 O9 e* P  w
9.   receive_tokens(in_msg_body, sender_address, my_balance, fwd_fee, msg_value);
   % H; r6 s; r7 D6 v' R5 J
10.   return ();
    ( h( r# G/ W6 r  ]
11. }
    ' g; l* K4 B3 n+ _0 a
12. 
    # J0 C9 k7 m9 g2 g7 U: r' _) S  q
13. if (op == op::burn()) { ;; burn
    ( ?2 Y$ A( A9 p" R- w8 J4 X
14.   burn_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
    / \* l5 O% V# c5 t
15.   return ();
    ) _! @# l4 a4 _, ], J5 c
16. }

复制代码

在这里，我们必须回顾五件核心事情。一是这里的准备工作：当我们第一次刚刚看到 in_msg_full 并开始读取它时会发生什么？因此，我们要弄清楚如何处理它。然后，根据操作代码，我们对转账进行检查，即 send_tokens 函数。然后，我们将回顾 receive_tokens 功能，也可在此处获取，以及 burn_tokens. 我们需要做的最后一件事是 getter 方法，但这是最简单的方法。因此，我们从逻辑开始 here:

+ {4 o) c. B5 ~* i3 m% j

1. () recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
   
2.   if (in_msg_body.slice_empty?()) { ;; ignore empty messages
   ) M  C6 b# D. }2 K; P6 I/ N& t
3.     return ();
   
4.   }
   $ t( o" a' r( ~. s% k0 n2 T
5. 
   
6.   slice cs = in_msg_full.begin_parse();
   ! [* P; d. }! w5 Y6 X$ j
7.   int flags = cs~load_uint(4);
   , _3 r$ r; f' q. ~8 L  L) [
8.   if (flags & 1) {
   
9.     on_bounce(in_msg_body);
   + i/ b% S( @  Q6 V4 X
10.     return ();
      h1 k8 V( I# r0 T. q
11.   }
    % ~8 [8 G/ W9 I' r4 S5 V7 }
12.   slice sender_address = cs~load_msg_addr();
    9 [8 r& R6 A8 c) c. n% U3 `/ b
13.   cs~load_msg_addr(); ;; skip dst
      Y) c9 l! y; [; X* P
14.   cs~load_coins(); ;; skip value
    7 m/ J# y/ M" g# X
15.   cs~skip_bits(1); ;; skip extracurrency collection
    
16.   cs~load_coins(); ;; skip ihr_fee
    ' a9 y: a7 K9 a) [' G* P' N
17.   int fwd_fee = muldiv(cs~load_coins(), 3, 2); ;; we use message fwd_fee for estimation of forward_payload costs

复制代码

同样，我们不想处理空正文的信息。因此，我们开始读取 in_msg_full 来查看标记。我们将再次检测标记是否显示这是一条被退回的信息。现在我们要处理它，稍后我们将查看它。然后我们找出 sender_address 是什么。然后我们跳过一些信息，因为我们要把 in_msg_body 传递到相应的函数中。因此，在这里我们并不关心这个问题。

但接下来，我们要关心的是 fwd_fee. 在这里，我们估算出上一笔交易支付了多少钱，现在我们想知道这个金额，以便在合约中实际保留一定的金额。因此，我们要估算下一笔交易的费用。这是一个有趣的逻辑，你必须学会。

你已经知道如何撰写信息了，因为我们在前面的章节中已经做了介绍，包括 send_draw_message. 你已经知道 send_draw_message 接受一个包含所有这些参数的Cell。这就是为什么我们可以在这里读出它的原因，因为这些参数是以比特形式存在于这个信息Cell中的。

1. int op = in_msg_body~load_uint(32);
   
2. 
   8 O) T; w; \- U
3.   if (op == op::transfer()) { ;; outgoing transfer
   0 L4 m9 t0 O, i) N- i* ~
4.     send_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
   
5.     return ();
   
6.   }
   * W% u/ x) O4 `# ^) P" V; _+ p
7. 
   ! \6 j9 E# {- s+ ]. V0 o/ ?0 C
8.   if (op == op::internal_transfer()) { ;; incoming transfer
   
9.     receive_tokens(in_msg_body, sender_address, my_balance, fwd_fee, msg_value);
   $ B5 S  Q$ D0 u9 o
10.     return ();
    " y2 C0 s5 P2 N7 r1 ]8 A0 P9 }4 ~4 s
11.   }
    ' p% S; O. w- G6 j4 V) w0 D( \
12. 
    3 H+ k  j5 ]: y3 H
13.   if (op == op::burn()) { ;; burn
    
14.     burn_tokens(in_msg_body, sender_address, msg_value, fwd_fee);
    6 ~8 a+ |' T. Q4 _+ q) t+ v& P
15.     return ();
      \8 g0 V6 b: c1 V
16.   }

复制代码

好了，接下来我们来看看操作代码. 此时此刻，我们已经算出了界限，算出了下一次交易成本应该保留多少。现在我们来看看操作代码。我们可以看到这些 send_tokens 并传递 in_msg_body. 我们传递正文中的所有内容--发件人地址和信息值。你还记得吗 msg_value 就是这条信息带来了多少钱。而 fwd_fee 是估算值，基本上是这条信息之前转发所花费的确切金额，我们将其传递给 send_tokens 中。

转让代币

我们一起来看看：

1. () send_tokens (slice in_msg_body, slice sender_address, int msg_value, int fwd_fee) impure {
   ) x* Q, q6 o+ {. K1 E$ B* {0 _* A! R
2.   int query_id = in_msg_body~load_uint(64);
   
3.   int jetton_amount = in_msg_body~load_coins();
   
4.   slice to_owner_address = in_msg_body~load_msg_addr();
   ( m6 {+ D# A/ I/ k. F( v) u8 \
5.   force_chain(to_owner_address);
   
6.   (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
   
7.   balance -= jetton_amount;

复制代码

发送代币就在这里。所以我们读取 query_id 因为我们已经读出了操作码。我们得到 jetton_amount 然后读取地址。所以我们要执行 force_chain, 然后确保我们在正确的链上。然后，我们从存储器中读取所有数据。我们将余额减少一位数，现在我们要做一些检查。

1. throw_unless(705, equal_slices(owner_address, sender_address));
   
2. throw_unless(706, balance >= 0);

复制代码

因此，我们要确保 sender_address 是所有者。所有者是一些真实的钱包合约，是拥有这个 Jetton 钱包合约的真实钱包合约。它保存在存储器中。我们要确保向我们发送信息的发件人的地址与这个钱包的所有者地址相同。如果不是这样，我们就会出错。然后，我们要检查在减少 Jetton 金额后，余额是否仍大于或等于 0。

1. cell state_init = calculate_jetton_wallet_state_init(to_owner_address, jetton_master_address, jetton_wallet_code);
   
2. slice to_wallet_address = calculate_jetton_wallet_address(state_init);
   
3. slice response_address = in_msg_body~load_msg_addr();
   # G" G( A" V; K# g
4. cell custom_payload = in_msg_body~load_dict();
   ( D0 l  ?4 o* H) J# `; Z/ T$ |
5. int forward_ton_amount = in_msg_body~load_coins();
   ' r' J! X: q" M5 u
6. throw_unless(708, slice_bits(in_msg_body) >= 1);
   
7. slice either_forward_payload = in_msg_body;
   . z+ w& P/ ?* Y6 z4 f# ~! v
8. var msg = begin_cell()
   
9.   .store_uint(0x18, 6)
   ' L- Z" F8 [! q0 U
10.   .store_slice(to_wallet_address)
    0 A3 g' d# j- t9 U/ ~1 P8 \
11.   .store_coins(0)
    
12.   .store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1)
    
13.   .store_ref(state_init);
    
14. var msg_body = begin_cell()
    
15.   .store_uint(op::internal_transfer(), 32)
    
16.   .store_uint(query_id, 64)
    
17.   .store_coins(jetton_amount)
    & g' O6 V  ~3 E2 ^) Q3 ?: z, l+ {
18.   .store_slice(owner_address)
    
19.   .store_slice(response_address)
    8 G9 _2 c6 t, U  v
20.   .store_coins(forward_ton_amount)
    0 P. m7 W" j% o2 d5 Z3 Y& F% p
21.   .store_slice(either_forward_payload)
    0 ^3 @1 }! l, X2 q8 a
22.   .end_cell();

复制代码

现在，我们开始准备发送用于部署此钱包合约的消息。我们使用 Jetton utils 文件夹。我们不会在这里深入讨论，因为你已经了解了它的工作原理。因此，我们计算 state_init, 找出我们要发送信息的钱包地址。然后我们读取 response_address. 那么 in_msg_body 将包含谁获得了访问权，以及在这一系列交易完成后，谁应该获得其余数据的通知。然后，我们就可以将 custom_payload 和 forward_ton_amount, 这样我们就知道应该在该交易中放入多少Ton。

于是，我们开始编写发送Jetton的信息。我们要发送Jetton的对象可能没有Jetton钱包合约。这就是为什么我们需要附加 state_init 到这条信息：如果没有，我们将部署合约。

因此，我们一开始就在标志上设置了相同的快捷方式。接下来是目的地。我们现在不放任何硬币，因为我们会在发送时再放。接下来，我们将组合所有这些功能--有些功能还无法使用，有些功能将由验证器重写。接下来，我们在信息核心之后编写信息正文。

这里有一些有趣的东西是你之前没有遇到过的。我们实际上可以继续这段代码，因为我们没有在 var msg 中结束Cell。我们可以继续把某些东西放到这个Cell中。

所以我们稍后会在信息正文组成后将 store_ref 放入该信息正文中。再次强调，这是内部转账。我们把 query_id,  jetton_amount, owner_address, response_address, 要转发多少Ton数，以及可能保留在 in_msg_body 中的转发有效载荷放在其中.

1. msg = msg.store_ref(msg_body);
   
2.   int fwd_count = forward_ton_amount ? 2 : 1;
   
3.   throw_unless(709, msg_value >
   
4.                      forward_ton_amount +
   0 B0 g1 ]1 h) s0 E1 W4 u
5.                      ;; 3 messages: wal1->wal2,  wal2->owner, wal2->response
   + V7 n, J7 W: i7 ?) E2 }
6.                      ;; but last one is optional (it is ok if it fails)
   
7.                      fwd_count * fwd_fee +
   & Y8 o# g3 U" @5 \; r% U7 q
8.                      (2 * gas_consumption() + min_tons_for_storage()));
   , Y$ V% ~$ n. d& s- p
9.                      ;; universal message send fee calculation may be activated here
   : N+ i$ G# v. _" ?& F) V6 `  C
10.                      ;; by using this instead of fwd_fee
    4 _' {; M" J' t( r: M2 Y+ P
11.                      ;; msg_fwd_fee(to_wallet, msg_body, state_init, 15)
    
12. 
    
13.   send_raw_message(msg.end_cell(), 64); ;; revert on errors
    7 t' k6 m8 o/ R8 ~. P" ~4 [
14.   save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
    : e+ X7 V. `' e" N9 |! d; I
15. }

复制代码

好吧，我们去 fwd_count. 我们在这里检查执行这笔交易后，我们的合约是否还有足够的资金存活。只有在这个时候，我们才会结束信息Cell并发送这条Cell。通过 64，我们将继续传递该消息中的资金。您应该在文档中了解更多关于这种模式和标志的信息，我们已经讨论过这个问题。当然，在完成所有这些操作后，您还可以保存新数据和新余额。

很好，这就是转账函数。主钱包将调用这个函数。例如，你有一个普通的钱包，比如 Tonhub 或 Tonkeeper。这个钱包合约将触发 send_tokens. 或者还有其他逻辑。但你必须是这个 Jetton 钱包合约的所有者，才能触发 send_tokens 操作。

接收代币

下一个是接收代币：

1. () receive_tokens (slice in_msg_body, slice sender_address, int my_ton_balance, int fwd_fee, int msg_value) impure {
   
2.   ;; NOTE we can not allow fails in action phase since in that case there will be
   8 ^3 s9 c& ~. U0 ~# a8 W
3.   ;; no bounce. Thus check and throw in computation phase.
   
4.   (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
   - P: H8 V( X5 z2 e. E5 P
5.   int query_id = in_msg_body~load_uint(64);
   0 H: i  [- [, n% t9 V
6.   int jetton_amount = in_msg_body~load_coins();
   
7.   balance += jetton_amount;
   
8.   slice from_address = in_msg_body~load_msg_addr();
   
9.   slice response_address = in_msg_body~load_msg_addr();
   
10.   throw_unless(707,
    
11.       equal_slices(jetton_master_address, sender_address)
    2 ?% @, g. l9 q$ ^- u& W! p9 x
12.       |
    * I1 @$ @" M5 \. J  T
13.       equal_slices(calculate_user_jetton_wallet_address(from_address, jetton_master_address, jetton_wallet_code), sender_address)
    
14.   );
    3 v3 V8 a# X9 f/ d6 `
15.   int forward_ton_amount = in_msg_body~load_coins();
    1 ~/ A/ r$ c6 X2 j; g/ [
16. 
    
17.   int ton_balance_before_msg = my_ton_balance - msg_value;
    
18.   int storage_fee = min_tons_for_storage() - min(ton_balance_before_msg, min_tons_for_storage());
    . F( D7 D" p1 n% D& Z* A
19.   msg_value -= (storage_fee + gas_consumption());
    
20.   if(forward_ton_amount) {
    
21.     msg_value -= (forward_ton_amount + fwd_fee);
    5 F7 u; Y$ T2 p; k
22.     slice either_forward_payload = in_msg_body;
    $ l3 @9 Z3 C0 H8 l3 O2 v! Q
23. 
    3 Z& U& _# G3 R5 w5 R' o6 p6 Y
24.     var msg_body = begin_cell()
    9 `- y* X) E( l- w3 [3 u. z1 d+ ?; R! M( h
25.         .store_uint(op::transfer_notification(), 32)
    3 q6 j, r5 e# t" c
26.         .store_uint(query_id, 64)
    " d' K  C; [# ^  G. |/ ^; U' L
27.         .store_coins(jetton_amount)
    + [  D" r/ w9 ^6 y2 n8 \8 ~$ @
28.         .store_slice(from_address)
    
29.         .store_slice(either_forward_payload)
    0 o/ _0 Y. y; V
30.         .end_cell();
    
31. 
    
32.     var msg = begin_cell()
    
33.       .store_uint(0x10, 6) ;; we should not bounce here cause receiver can have uninitialized contract
    - @3 R1 S7 t( F
34.       .store_slice(owner_address)
    
35.       .store_coins(forward_ton_amount)
    
36.       .store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
    4 K9 y: c9 V9 z
37.       .store_ref(msg_body);
      n0 I/ e+ z4 ~. B, o
38. 
    ; f6 w) t0 Y. ~* r$ v% l8 ?8 b
39.     send_raw_message(msg.end_cell(), 1);
    
40.   }
      B7 P# u' h2 k, r* `
41. 
    
42.   if ((response_address.preload_uint(2) != 0) & (msg_value > 0)) {
    
43.     var msg = begin_cell()
    
44.       .store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 010000
    
45.       .store_slice(response_address)
    ) A  U! L/ g9 m4 h( p
46.       .store_coins(msg_value)
    
47.       .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
    
48.       .store_uint(op::excesses(), 32)
    " C: `# Q1 B, ]' n
49.       .store_uint(query_id, 64);
    1 I5 ^# O! a/ [0 t: x
50.     send_raw_message(msg.end_cell(), 2);
    
51.   }
    , B' M. ^! R9 w5 p: K
52. 
    2 R8 \0 q* _+ j( D9 U# @8 x
53.   save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
    
54. }

复制代码

以下是接收代币的方法。同样，你要从存储器中读取所有数据。我们增加余额。我们要检查给我们发送 Jettons、发送增加余额信息的是主合约还是 Jetton 钱包的其他合约。然后我们读取 forward_ton_amount，以确保我们有足够的资金继续执行合约。如果有 forward_ton_amount, 我们用 forward_ton_amount 和 forward_payload, 如果那里确实有的话。当然，如果存在访问权限，我们也需要将其发送出去。因此，如果指定了响应地址，我们就要编写一条信息，将该交易链上的所有访问权限发送到响应地址。然后，我们将新数据保存在这里。无论发生什么变化，都只会改变余额。好极了。这就是我们处理接收代币的方法。

燃烧代币

还剩下两个问题：我们如何实际燃烧它们以及如何执行 on_bouce。你看，我们不会深入研究我们编写的每一行和每一个逻辑Cell，因为这将花费我们几个小时的时间来概述。我希望你能从更高层次理解逻辑。我们可以为每一个合约编写一个章节，来说明这里可以处理的每一个逻辑案例。但我希望你能理解高层次的逻辑，因为你不会自己创建这些合约。你只需要了解它们是如何工作的，这样你就会真正使用这些函数，因为大多数 Jetton 合约都在使用它们。你将知道如何在你的案例中使用它们。

1. () burn_tokens (slice in_msg_body, slice sender_address, int msg_value, int fwd_fee) impure {
   
2.   ;; NOTE we can not allow fails in action phase since in that case there will be
   8 Q. ]6 X5 g5 d: D9 l* t4 L
3.   ;; no bounce. Thus check and throw in computation phase.
   3 H- ^- j4 [  W: ~# O6 I
4.   (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
   % m% ^! ~/ |4 M2 K! H! o
5.   int query_id = in_msg_body~load_uint(64);
   & V* ^# |4 X; H4 ^# l
6.   int jetton_amount = in_msg_body~load_coins();
   
7.   slice response_address = in_msg_body~load_msg_addr();
   9 b, B5 q% {) b: F
8.   ;; ignore custom payload
   * ~/ {; r$ q4 U& W7 Z
9.   ;; slice custom_payload = in_msg_body~load_dict();
   
10.   balance -= jetton_amount;
    0 D' u6 {$ \4 z( h
11.   throw_unless(705, equal_slices(owner_address, sender_address));
    . C4 T) L2 M6 `( F* N) M
12.   throw_unless(706, balance >= 0);
    # A% W& p$ y1 w: a& _! c
13.   throw_unless(707, msg_value > fwd_fee + 2 * gas_consumption());
    
14. 
    - S' ]& |1 {. s, X2 O) j
15.   var msg_body = begin_cell()
    
16.       .store_uint(op::burn_notification(), 32)
    
17.       .store_uint(query_id, 64)
    
18.       .store_coins(jetton_amount)
    
19.       .store_slice(owner_address)
    
20.       .store_slice(response_address)
      D  Z0 @! E9 q
21.       .end_cell();
    7 G& J8 y. o( T/ X! }
22. 
    ) H2 A6 [7 c: q1 ?  I
23.   var msg = begin_cell()
    $ T8 [" D: J! Z; J
24.     .store_uint(0x18, 6)
    3 S! |, C1 y# W
25.     .store_slice(jetton_master_address)
    
26.     .store_coins(0)
    & P- O0 c$ K5 z* H4 [# f
27.     .store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
    
28.     .store_ref(msg_body);
    
29. 
    
30.   send_raw_message(msg.end_cell(), 64);
    
31. 
      v6 ^+ k) g0 Z
32.   save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
    + `9 v8 D6 |+ ^  ~
33. }

复制代码

基本上是这样、burn_tokens 就是为了减少。我们读取数据，得到 query_id, 然后我们检查发送者是否是所有者，如果余额仍然大于 0。因此，我们要检查发送者是否是所有者，余额是否仍大于 0。我们要确保附带的金额足够，在我们发送这笔交易后，合约本身将继续存活，并能够支付租金。然后，我们再撰写烧毁通知，就像我们检查它一样。

因此，我们有 burn_notification. 我们将发送 burn_notification 作为主合约的信息主体。我们写上了金额、所有者和回复。你还记得，作为响应，我们还实现了向谁发送响应，对吗？实际上，我们组成了信息Cell。我们将信息主体放在这里，然后发送包含这些信息和信息主体的原始信息。然后我们发送 save_data 因为余额发生了变化。

反弹

本课最后要复习的内容是 on_bounce:

1. () on_bounce (slice in_msg_body) impure {
   6 j0 m7 J; w* H0 b9 z% @0 _
2.   in_msg_body~skip_bits(32); ;; 0xFFFFFFFF
   
3.   (int balance, slice owner_address, slice jetton_master_address, cell jetton_wallet_code) = load_data();
   4 l& O: N) r4 V* J6 p, e5 l
4.   int op = in_msg_body~load_uint(32);
   
5.   throw_unless(709, (op == op::internal_transfer()) | (op == op::burn_notification()));
   ! [3 |& H4 P* y5 h
6.   int query_id = in_msg_body~load_uint(64);
   
7.   int jetton_amount = in_msg_body~load_coins();
   
8.   balance += jetton_amount;
   2 u/ W  @5 E1 l
9.   save_data(balance, owner_address, jetton_master_address, jetton_wallet_code);
   6 u2 `, O0 @. s* V
10. }

复制代码

当邮件被退回时，我们该怎么办？跳转时会有一定的错误，因此我们要读取余额，检查操作代码是否为 internal_transfer 或 burn_notification 反弹消息。如果是这样，我们就必须把另一份合约没有接受的Jetton数量重新纳入我们的合约。

结论

这就是 Jetton 钱包合约的核心逻辑。我希望它不会让你感到困惑。这是一个很好的例子，让你真正读懂代码，看看它有多复杂。如果你花一些时间阅读这些合约，会对你有很大帮助。如果你不明白某些东西，比如Cell中的行或位，你可以很容易地分组阅读或阅读文档。本课的目的是让你更深入地了解 Jettons 的工作原理，这样你就能理解不同合约与标准交互的逻辑。

在下一课中，我们将仔细研究一种不同类型的代币，即非同质化代币（NFT）。这对你来说会很有趣，因为我们有collections合约和item合约。你们已经通过了这个非常困难的部分，现在你们明白了可以有多个合约。Jetton 不是一个单一的合约，而是一个合约系统。对于 NFT，你们也将非常感兴趣地看到它们是如何根据标准在底层工作的。我们很快就会再见面！