7.2 Jetton 总承包合同

riyad

我们将从 Jetton 标准。Jetton 也被称为 "同质化代表标准"，编号74。 在 this repository  的所有标准中，有关于 Jetton 合约必须如何运作的全部描述。您可以在这里看到两个合约，一个主合约（或矿工合约）和一个钱包合约。

我们来看看钱包智能合约的规范.  钱包智能合约必须处理某些信息。例如，传输和解释所发生的一切以及传输的原因。它必须处理烧毁信息。然后，它还必须使用 get_wallet_data 方法来返回有关自身的数据。这就是实现钱包合约的主要方法。

这里是主合约. 在这里，我们不放代码，我们放的是应该以某种方式实现的功能，因此其他合约可以与您的 Jetton 合约进行交互。它们会清楚地知道如何与你的合约互动，因为你有主合约。矿工实际上是在铸造所有这些jettons。您还会为每个Jetton用户和外部服务制定钱包合约，这些合约有时会与用户的钱包合约互动。有时，它们也会与你的主合约、矿工合约发生交互。为了让你不需要每次都搞清楚它是如何运作的，它们只是同意了它们必须如何运作的标准。例如，钱包希望显示余额，而不希望处理每种 Jetton 类型。

$ j# ?6 N4 W# x6 b) ]

我们假定，如果某些功能不符合此处解释的 Jetton 标准，则不能被视为 Jetton - 无论是钱包、浏览器还是其他服务。您必须遵守这些规则，才能被视为 Jetton。正如我之前提到的，这只是一套合约。

到目前为止，我们已经学到了合约编程的基础知识，但这里还有更复杂的逻辑。阅读 Jetton、Master、Wallet 合约对你理解和实际了解其工作原理非常有帮助。通过这种方式，你可以了解Cell是如何组成的，你可以在自定义合约中实现哪些复杂的逻辑，即使这些合约与 Jetton 无关。Jetton 和 NFT 合约是让你了解可以做什么、如何使用语法以及如何实现一些复杂功能的绝佳途径。

让我们深入研究一下 Jetton 合约的代码。正如我所说，有两种合约。我们已经有了实现它们的最佳实践。你不必使用这些代码，可以自己实现，但必须符合标准。

在 this repository (https://github.com/ton-blockchain/token-contract), 我们继续 ft 文件夹（同质化代币，或 Jetton). 在这里，我们可以看到多份合约。Jetton minter (https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-minter.fc) 和 Jetton wallet (https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-wallet.fc) 这些合约是我们要研究的最多的合约。还有其他合约，如 Jetton Minter ICO ( https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-minter-ICO.fc) — 这只是首次代币发行功能的实现。我们不打算深入探讨，但我真的鼓励你研究一下这段代码，看看其中的逻辑有多复杂。这会让你学到很多东西。

$ E2 L; y1 @, F# g

我们还将使用一些文件，如 Jetton utils (https://github.com/ton-blockchain/token-contract/blob/main/ft/jetton-utils.fc) 因为 Jetton 工具有一定的逻辑，可以帮助 Jetton 矿工的主文件。此外，我们还有 op-codes (https://github.com/ton-blockchain/token-contract/blob/main/ft/op-codes.fc) 我们有 params (https://github.com/ton-blockchain/token-contract/blob/main/ft/params.fc) — 这些只是辅助实用程序文件，我们只是在这里封装了一些逻辑，以便重复使用。

我们继续。我将克隆代币通证合约标准实现的存储库：

1. git clone https://github.com/ton-blockchain/token-contract.git
   

复制代码

我们从 Jetton 矿工开始，因为它是初始化其他一切的核心合约。一开始我们看到的是存储方案。

1. ;; storage scheme
   
2. ;; storage#_ total_supply:Coins admin_address:MsgAddress content:^Cell jetton_wallet_code:^Cell = Storage;
   / I+ N) B8 C9 b2 \; L/ U
3. 
   $ l+ b9 E% j4 b- O
4. (int, slice, cell, cell) load_data() inline {
   
5.   slice ds = get_data().begin_parse();
   
6.   return (
   3 X9 H( y/ U' M' Q( j
7.       ds~load_coins(), ;; total_supply
   
8.       ds~load_msg_addr(), ;; admin_address
   
9.       ds~load_ref(), ;; content
   # G% {1 w5 ~/ M
10.       ds~load_ref()  ;; jetton_wallet_code
    
11.   );
    
12. }
    
13. 
    * s& o; \7 K; W1 P
14. () save_data(int total_supply, slice admin_address, cell content, cell jetton_wallet_code) impure inline {
    
15.   set_data(begin_cell()
    
16.             .store_coins(total_supply)
    : X, o/ M# n6 P% R/ O! c
17.             .store_slice(admin_address)
    
18.             .store_ref(content)
    
19.             .store_ref(jetton_wallet_code)
    6 |  G5 o9 e0 d# j2 E5 n
20.            .end_cell()
    , S1 O& E3 J6 g  A; t! m1 P) ^& K
21.           );
    
22. }

复制代码

我们已经知道这个逻辑封装了读取和保存存储中的数据。我们可以在代码的任何地方使用这个函数，以简化读取数据的过程。首先，我们有 total_supply. 我们保持 admin_address — 它是整个合约的管理者，有些信息只能从管理者那里接受. 我们看到 content — 基本上就是描述通证中独有内容的数据。在这里，我们还可以了解一下数据标准--这些数据应该有一个标准，包括标题、描述和其他一些东西，这样浏览器和其他服务就可以使用你的合约元数据向用户展示他们正在使用的 Jetton。

最后是 jetton_wallet_code. 从第一课中，你可能已经知道合约是有比例的。我们有一个主合约--这就是矿工。它在挖矿时会部署钱包合约。然后，钱包合约也可以部署其他钱包。因此，如果我要给一个还没有钱包的人汇款，我就会用代码发送。因此，我们的钱包合约也会保留钱包代码，我们马上就会看到。

现在，让我们进入标准资源库，看看 standard regarding the data. 这里我们有一些指南，例如，创建 NFT Collection 元数据、NFT item 元数据、Jetton 元数据示例--究竟会在那里存储什么内容，我们只是看到了它。

需要注意的是，对于链外内容布局，应将第一个字节存储为 0x01，这将向任何人显示此 URI 指向 JSON。因此，你基本上可以对读取这些数据的任何人说 "嘿，我有链外数据。看看这个链接，下载 JSON，你会在那里找到一切"。

但如果是在链上存储，就必须把 0x00. 这样你就可以看到键值字典存储在内存的其他部分。这基本上就是一个如何优化的技巧。你可以自行决定，但重要的是，你要知道我们所说的内容Cell内存储的是什么。

从存储器读取数据并将数据保存到存储器后，我们将 mint_tokens. 这是一个实现铸造功能的函数，我们只需在这里定义它。

1. ​​() mint_tokens(slice to_address, cell jetton_wallet_code, int amount, cell master_msg) impure {
   
2.   cell state_init = calculate_jetton_wallet_state_init(to_address, my_address(), jetton_wallet_code);
   , ]2 M$ U% H! ^, Z3 b5 b3 z4 }3 u
3.   slice to_wallet_address = calculate_jetton_wallet_address(state_init);
   % @1 _; ?  c  h/ |  U) h: [' z
4.   var msg = begin_cell()
   3 G# ~  C7 i# H
5.     .store_uint(0x18, 6)
   8 B; F8 I5 }7 S: b6 O
6.     .store_slice(to_wallet_address)
   
7.     .store_coins(amount)
   
8.     .store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1)
   
9.     .store_ref(state_init)
   
10.     .store_ref(master_msg);
    # v( R# R& A) O4 ~5 D  \3 l
11.   send_raw_message(msg.end_cell(), 1); ;; pay transfer fees separately, revert on errors
    ' K0 r/ t9 ?# x- q& S2 D  V1 Y
12. }

复制代码

我们的下一个东西则是 recv_internal, 这是任何智能合约的核心功能。在这里，你实际上读到了信息的第一个参数。我们很快就会解释。

1. () recv_internal(int msg_value, cell in_msg_full, slice in_msg_body) impure {
   8 M. f" w8 k; ^2 u5 ]. q
2.     if (in_msg_body.slice_empty?()) { ;; ignore empty messages
   
3.         return ();
   
4.     }
   
5.     slice cs = in_msg_full.begin_parse();
   
6.     int flags = cs~load_uint(4);
   
7. 
   
8.     if (flags & 1) { ;; ignore all bounced messages
   
9.         return ();
   ' N5 O  a2 m7 f1 t
10.     }
    
11.     slice sender_address = cs~load_msg_addr();
    3 @4 N: v1 m. ^- p+ u4 P; z$ ]
12. 
    0 `2 P: g8 V0 g; J
13.     int op = in_msg_body~load_uint(32);
    , j5 O+ ]8 |. A2 ^5 C
14.     int query_id = in_msg_body~load_uint(64);
    6 Q5 {: ^: u3 D3 S, @, V: t
15. 
    % B8 q3 P5 ^3 i! h0 B% ~5 u4 N6 ^8 x5 R
16.     (int total_supply, slice admin_address, cell content, cell jetton_wallet_code) = load_data();

复制代码

然后，根据操作代码并接收更多扩展功能：

0 ~. \1 @9 A$ h/ n

1. if (op == op::mint()) {
   
2.         throw_unless(73, equal_slices(sender_address, admin_address));
   ; u; j/ O1 A2 n9 @) l  `
3.         slice to_address = in_msg_body~load_msg_addr();
   
4.         int amount = in_msg_body~load_coins();
   9 c* @+ p- f, A# d6 c4 a( ]
5.         cell master_msg = in_msg_body~load_ref();
   
6.         slice master_msg_cs = master_msg.begin_parse();
   1 O# R$ w. k5 m5 u
7.         master_msg_cs~skip_bits(32 + 64); ;; op + query_id
   5 B: Q* j: K3 M$ O5 }
8.         int jetton_amount = master_msg_cs~load_coins();
   8 W( r0 D% j6 u
9.         mint_tokens(to_address, jetton_wallet_code, amount, master_msg);
   
10.         save_data(total_supply + jetton_amount, admin_address, content, jetton_wallet_code);
    
11.         return ();
    
12.     }
    
13. 
    
14.     if (op == op::burn_notification()) {
    
15.         int jetton_amount = in_msg_body~load_coins();
    4 }4 I2 h$ y# p, x' O' c
16.         slice from_address = in_msg_body~load_msg_addr();
    + y6 C; p: q5 g# d9 _; b
17.         throw_unless(74,
    
18.             equal_slices(calculate_user_jetton_wallet_address(from_address, my_address(), jetton_wallet_code), sender_address)
    
19.         );
    
20.         save_data(total_supply - jetton_amount, admin_address, content, jetton_wallet_code);
    
21.         slice response_address = in_msg_body~load_msg_addr();
    
22.         if (response_address.preload_uint(2) != 0) {
    9 B6 O$ b4 W& e4 o, e( ]
23.           var msg = begin_cell()
    1 T5 F* ~1 U0 f, ^
24.             .store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    - b  W& U5 T8 k9 a- R$ ~6 z3 R
25.             .store_slice(response_address)
      h. h; n2 Q% d" ^& q; t# ]
26.             .store_coins(0)
    
27.             .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
    0 u% l0 h- Y. L2 n) w& M1 v# }
28.             .store_uint(op::excesses(), 32)
    
29.             .store_uint(query_id, 64);
    
30.           send_raw_message(msg.end_cell(), 2 + 64);
    
31.         }
      V! s: ]# k  h1 R
32.         return ();
    - A2 A4 y! {8 I1 l  M8 G4 M
33.     }
    ) A! ?5 d0 w  @/ p/ Y) E( J, i7 v
34. 
    7 A: e: g7 L3 @0 m, W
35.     if (op == 3) { ;; change admin
    & x' f5 D9 [7 k* a2 G" y
36.         throw_unless(73, equal_slices(sender_address, admin_address));
    
37.         slice new_admin_address = in_msg_body~load_msg_addr();
    
38.         save_data(total_supply, new_admin_address, content, jetton_wallet_code);
    
39.         return ();
    
40.     }
    0 \/ b9 @8 o# ?& T+ H/ Z5 J3 V* V4 H8 ~
41. 
    
42.     if (op == 4) { ;; change content, delete this for immutable tokens
    % H" n, c, a1 o2 A9 Q; n0 x" g
43.         throw_unless(73, equal_slices(sender_address, admin_address));
    
44.         save_data(total_supply, admin_address, in_msg_body~load_ref(), jetton_wallet_code);
    
45.         return ();
    ( G( C; _' g3 r- e
46.     }
    5 g' T$ I( E+ E4 v, a) T. p
47. 
    
48.     throw(0xffff);
    + x% }' Q# o0 e+ r5 q* m' o# J
49. }

复制代码

例如，我们在这个函数中保留了铸造的功能。我们准备了一些数据，读出了一些重要的信息--我们也将讨论这个问题。然后我们运行这个 mint_tokens 功能。我们不会把所有代码都放在这里。例如 burn_notification, 逻辑非常简单，因此我们没有将其封装到另一个函数中。下面是核心结构。

让我们来概述一下一切。我们有 load_data, save_data — 这很简单，我们已经知道了。我们有一些处理任何信息的基本逻辑。然后，我们还有准备运行 mint_tokens 功能。我们还有 burn_notification 逻辑--这是当一些代币本应被烧毁时发出的信息。我们还有一些管理逻辑。例如，上面我们有 (op == 3), 表示更换管理员。在这里，您只需读取当前的管理员，进行比较，然后保存新的管理员。

这很简单，我们已经可以很容易地理解。你可以更改内容，也可以关闭删除这个逻辑的选项。如果你不使用可编辑的内容，或者你想让它成为可编辑的内容，其实你可以把它保留在这里。在这里，管理员可以保存带有不同元数据的数据，如你所见。这是一些基本的东西，只需要你稍加练习，就能理解它有时会有多复杂，以及你可以在这里使用从我们编写合约时学到的东西。

当然，我们还有 getter 方法，这里很简单。你只需返回从这里读取的内容，并将其提供给外部。所以你可以获得 total_supply, admin_address, content, jetton_wallet_code, 和获取钱包地址可以帮助找出某个地址的钱包地址。例如，我有一个钱包，我想获得一些jettons。但我想知道一旦我得到了 Jettons，我的钱包地址会是什么，因为 Jettons 不会进入我的钱包合约，而是进入一个已部署的钱包，即 Jetton 钱包合约。到那时，我需要找出我的地址。这个功能可以帮我做到这一点。

好了，我们再花点时间来了解一下里面的内容。这个逻辑非常简单。我们不想处理空的信息正文，所以我们返回并执行：

1. () recv_internal(int msg_value, cell in_msg_full, slice in_msg_body) impure {
   6 E( Y1 l% k. o! D8 [3 g1 x6 x
2.     if (in_msg_body.slice_empty?()) { ;; ignore empty messages
   
3.         return ();

复制代码

然后，我们要找出标记，这样就可以忽略所有退回的信息。我们还将在此处停止执行:

1. if (flags & 1) { ;; ignore all bounced messages
   
2.     return ();
   
3. }

复制代码

然后，我们找出谁是发件人。此时，我们从 in_msg_full — 这对我们如何进一步发展非常重要。

1. slice sender_address = cs~load_msg_addr();
   

复制代码

你还记得我们是如何部署合约的吧？我们实际上是在计算 state_init，这正是这里要做的，因为这个函数要部署一个新钱包、新合约。因此，我们使用的这个函数在 Jetton utils. 是的，我们在这里定义了这个函数，并将一个Cell与 state_init.

大家还记得，我们在 TypeScript 中做了类似的工作。现在你可以在 FunC 中看到类似的内容。下面是 jetton_wallet_code, 接下来你必须打包数据。一旦有了合约，数据就是初始数据。我们将在下一课概述钱包代码时了解更多。在这里，你可以使用这个函数来打包 Jetton 钱包的数据。在存储方案中，我们将看到 balance, owner_address, jetton_master_address, jetton_wallet_code. 此时，我们将在Cell格中输入代码，形成 state_init, 初始状态数据。这是我们将要使用的函数之一。

让我们回到矿工身上。我们正在计算 state_init 因为我们需要将其附加到信息中。然后我们有 to_address, 因此，我们需要知道该把信息发送到哪里。那么合约的地址是什么呢？就像我们在 TypeScript 中做的那样，但在 FunC 中它也会做同样的事情。因此，这对你来说是一个很好的练习。这个 to_wallet 地址将是我们实际发送信息的目的地 state_init, master_msg, 和 amount.

1. slice calculate_jetton_wallet_address(cell state_init) inline {
   ' h. j, Y5 R3 i8 A. d
2.   return begin_cell().store_uint(4, 3)
   $ M2 i3 d* p5 R7 p, r3 H# j$ R& ?5 b
3.                      .store_int(workchain(), 8)
   ( P' o3 Q1 {  p* b3 I9 }9 N$ g! b* G
4.                      .store_uint(cell_hash(state_init), 256)
   
5.                      .end_cell()
   % y8 N: n$ E# j% w# f
6.                      .begin_parse();

复制代码

现在我们将使用 calculate_jetton_wallet_address 函数来计算钱包地址。在这里，我们正在做类似的事情。因此，正如你所理解的，如果 state_init 变化。但我们可以看到 state_init Cell格哈希值并不是全部，也不是整个地址。有一些标志，有一个 workchain 在这里我们也使用参数中的数字。默认情况下，我们使用零工作链。

在这里，您还可以了解地址是如何形成的。TypeScript 将我们从这种复杂性中解救出来，但你需要了解这一点，因为有时你需要编译相同数量的Cell，在部署合约时将Cell与实际发送的地址编译在一起。因此，查看地址是一个非常好的做法。我们在 TypeScript 中做了同样的事情，但这里是在 FunC 中进行的，所以你在这里可以学到更多。

因此，我们正在撰写地址。您可以在这里阅读有关每个位（bit）及其含义的文档. 但这是 workchain, 这是Cell哈希值，表示如果 state_init 变化。而 state_init 如果代码或数据发生变化，它们也会发生变化。这就像多米诺骨牌。这是一个Cell，如果你想读出它，就可以开始解析。这就是返回片段的方法。记住，在 FunC 中，地址总是一个片段。

1. () mint_tokens(slice to_address, cell jetton_wallet_code, int amount, cell master_msg) impure {
   * g7 p; {! a0 Q# l9 h. F/ Z
2.   cell state_init = calculate_jetton_wallet_state_init(to_address, my_address(), jetton_wallet_code);
   
3.   slice to_wallet_address = calculate_jetton_wallet_address(state_init);
   $ ^' Y; L6 j8 t8 h* f2 B) ?
4.   var msg = begin_cell()
   4 L) u7 V+ m7 n7 Z$ G
5.     .store_uint(0x18, 6)
   
6.     .store_slice(to_wallet_address)
   3 \% K. L* `9 e8 i. y  P
7.     .store_coins(amount)
   1 P& y0 A$ I% f4 O$ u. {$ h
8.     .store_uint(4 + 2 + 1, 1 + 4 + 4 + 64 + 32 + 1 + 1 + 1)
   2 `8 w& [; T' j) P+ t+ q6 ?
9.     .store_ref(state_init)
   
10.     .store_ref(master_msg);
    % Z: Q' ^5 K+ }9 y) G9 ^9 O
11.   send_raw_message(msg.end_cell(), 1); ;; pay transfer fees separately, revert on errors
    ; y0 _9 i+ t: n0 w* d3 B
12. }

复制代码

好了，我们回到矿工的话题。基本上，我们计算了 state_init, 并计算出钱包地址。 我们把要转发和发送的Ton数放在这里。我们还把 master_msg, 就是我们的内部转账信息。信息到达后，将由钱包合约处理。我们稍后再讨论这个问题。

1. if (op == op::burn_notification()) {
   ' @3 X, ]6 g1 @# P& w
2.     int jetton_amount = in_msg_body~load_coins();
   
3.     slice from_address = in_msg_body~load_msg_addr();
   $ p* f! p1 n$ V8 X0 X
4.     throw_unless(74,
   + d, w; ^+ W" z+ D
5.         equal_slices(calculate_user_jetton_wallet_address(from_address, my_address(), jetton_wallet_code), sender_address)
   ' N% x5 c6 D, {2 d: j: z
6.     );
   5 a/ r" d0 |& M, g
7.     save_data(total_supply - jetton_amount, admin_address, content, jetton_wallet_code);
   , y# I  F' |, L8 m3 ?5 f, q1 @
8.     slice response_address = in_msg_body~load_msg_addr();
   
9.     if (response_address.preload_uint(2) != 0) {
   
10.       var msg = begin_cell()
    
11.         .store_uint(0x10, 6) ;; nobounce - int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    
12.         .store_slice(response_address)
    
13.         .store_coins(0)
    0 y. w  K, G! G8 q: E9 p& W
14.         .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
    ; l' g9 x) \! C& F5 `6 f
15.         .store_uint(op::excesses(), 32)
    7 I, z5 G5 |4 W/ T# g% f: y
16.         .store_uint(query_id, 64);
    
17.       send_raw_message(msg.end_cell(), 2 + 64);
    
18.     }
    
19.     return ();
    
20. }

复制代码

我们要快速浏览的最后一部分是 burn_notification。基本上，这是当我们收到要刻录的 Jetton 数量时。我们要找出发送地址--为此我们使用 calculate_user_jetton_wallet_address 功能。


7 n, _5 y$ y9 T4 m$ r( ^5 a+ ?我们看看它能做什么。因此，有人在发送信息时使用了 burn_notification. 我们计算出应该烧掉多少Jettons。然后，我们要检查烧毁通知来自谁。让我们查看 utils:

1. slice calculate_jetton_wallet_address(cell state_init) inline {
   
2.   return begin_cell().store_uint(4, 3)
   4 _$ Y2 o2 c/ z6 ?/ t2 |
3.                      .store_int(workchain(), 8)
   5 V7 R% `, d" r0 W4 ?$ e3 Y) q
4.                      .store_uint(cell_hash(state_init), 256)
   
5.                      .end_cell()
   4 f- S3 I1 o5 I5 ?! V0 ~
6.                      .begin_parse();
   $ j% w7 _2 i& T# E1 Z
7. }
   
8. 
   
9. slice calculate_user_jetton_wallet_address(slice owner_address, slice jetton_master_address, cell jetton_wallet_code) inline {
   
10. return calculate_jetton_wallet_address(calculate_jetton_wallet_state_init(owner_address, jetton_master_address, jetton_wallet_code));
    
11. }

复制代码

我们在这里计算所有者地址的 state_init 。让我们回到矿工的话题： from_address 将是所有者地址, my_address 是这份合约的地址，暨我们的矿工。然后我们有 jetton_wallet_code. 因此，我们要检查 calculate_user_jetton_wallet_address 函数的结果与 sender_address 相同。 无论是谁发送了这条信息， from_address, 我们都应该烧掉这些Jettons。因此，我们将计算该用户的钱包地址。我们要确保它与  sender_address相同. 然后我们打开这个函数，看看它能做什么。

它基本上使用了我们已经知道的另外两个函数。它正在计算地址并从我们在这里传递的owner_address、jetton_master_address (本合约地址）和 jetton_wallet_code获取 state_init. 从 state_init,中，我们计算 jetton_master_address, 这样就能确保发送这条信息的人，就是我们要烧掉Jettons的合约的所有者。

这样，我们就能从总供应量中扣除Jettons的数量，并保存这些数据。现在，我们可以在存储中看到供应的Jettons数量减少了。然后我们读取响应地址。根据计划，正文中必须包含响应地址--我们应该将剩余的Jetton交付给谁，并附上 op::excesses.

我们从这里开始组成正文。我们正在撰写无法被退回的信息，因此快捷方式改为 0x10. 基本上，我们使用 2 + 64 原始代码。因此，我们会向响应地址发送该信息附带的所有资金，以及 op::excesses.

基本上就是这样。我们已经像处理程序一样发送了两条合约信息，我们发现这些只是合约而已。Jettons钱包里没有魔法，它只是一个具有特定逻辑的合约，只要读懂合约的工作原理，就能给我们带来很多好处。下一课，我们将学习Jetton钱包，你将从另一个角度了解它，看看钱包是如何与它互动的。此外，我们还将回到 minter 有时要看一些逻辑，尤其是在部署时。我祝愿你在学习软件仓库的这一逻辑时好运。下一课再见，Jetton 钱包合约代码回顾！

5 g$ \9 L7 l+ k/ w# C3 l" g- \( c. v% Q0 c/ Y