3.2 设置编译流程

riyad

" d0 \! w3 J" z+ p8 q3 Y/ p

本课的目的是建立一个能够编译智能合约示例的本地项目。我们现在还不打算编写任何 FunC。我们只是在准备搭建我们的本地环境。这部分内容以后可以在所有项目中重复使用。

首先，请确保您拥有三样东西：

• Node.js (16.15.0 或更高版本） 安装说明 here ( https://nodejs.org/)  运行命令 node -v 在终端中验证您的安装
• 软件包管理器 - 它可能已经与 Node.js 安装在一起，但请确保您已经安装了 Node.js。在本课中，我们将使用 Yarn，但您也可以自行选择使用 Yarn, 但您也可以选择使用 (ex. npm)
• 带有 FunC 和 TypeScript 的集成开发环境 支持 我们建议使用 Visual   Studio Code 与 FunC plugin 已安装。如果您使用的是 IntelliJ，以下是相应的链接 FunC plugin
  
  ! q" u. y, s! B- b3 z

满足上述要求后，我们就可以开始了！

. Q  q$ Q/ e6 W; P建立项目。

首先为我们的项目创建一个文件夹

1. mkdir my_first_contract && cd my_first_contract
   , k/ w' c2 m  e9 X: j1 m. z6 [

复制代码

让我们启动 package.json 文件. 我要用 yarn, 但如果你觉得使用 npm 更好，你可以自由选择。

1. yarn init
     G% g) A; O! o- W6 h; X

复制代码

系统会提示你输入一些参数，但你只需在每个提示符下点击 Enter 按钮即可。完成后，项目目录下的 package.json 文件将包含以下默认内容：

1. {
   # S& k8 N" u2 m& R
2. 
   6 w+ {. y4 y8 C' d* \1 X$ _
3.   "name": "my_first_contract",
   ) Q# ]! V7 e* L. x$ f; h9 s
4. 
   
5.   "version": "1.0.0",
   5 P7 l' Y' l5 F8 ^/ |9 d
6. 
   
7.   "main": "index.js", //we don't really need this line, feel free to remove it
   
8. 
   3 G$ `( Q0 F" O8 }2 m
9.   "license": "MIT"
   
10. 
    9 q- {9 x' a5 f" h3 C3 _  Y; u2 U" V
11. }

复制代码

现在，让我们安装以下 4 个库：

这些都是与 TypeScript 相关的库。在本课程中，我们不会深入探讨 TypeScript 本身的工作原理。

1. yarn add typescript ts-node @types/node @swc/core --dev
   

复制代码

我们创建一个 tsconfig.json 文件，并在其中添加以下配置：

1. {
   
2. 
   4 _$ i! `' M% J, V1 Z2 v0 _
3.   "compilerOptions": {
   - P2 R% }( y) o6 _. d) P, \, {
4. 
   
5.     "target": "es2020",
   
6. 
   ! o: \& ^: H( m$ A
7.     "module": "commonjs",
   
8. 
   1 ~3 R, Y) _/ o- i& y3 e
9.     "esModuleInterop": true,
   
10. 
      {& M" X8 p$ j9 \8 G$ v2 A
11.     "forceConsistentCasingInFileNames": true,
    ! B# \, j: Y3 a- i# @$ D, l
12. 
    - t9 R: [3 j: ]. S4 g) G
13.     "strict": true,
    
14. 
    , y1 y% j! q. x% D
15.     "skipLibCheck": true,
    6 I! |; Y& k: i9 x$ I  T
16. 
    " K! p9 s% U1 U; Q; u6 q
17.     "resolveJsonModule": true
    
18. 
    # ]% F: d  i% L7 C
19.   },
    
20. 
    ! h1 T5 }* j% X3 T
21.   "ts-node": {
    
22. 
    
23.     "transpileOnly": true,
    
24. 
    ' I8 H- m( z! ^6 y+ I( P+ m
25.     "transpiler": "ts-node/transpilers/swc"
    5 h/ y2 Q. C* N6 I0 W2 ]; t
26. 
    
27.   }
    
28. 
    
29. }

复制代码

实际上，我们还需要三个与 TON 有关的 lib，它们是:

• ton-core - 实现 TON 区块链底层基元的核心库。
• ton-crypto - 用于为 TON 区块链构建应用程序的加密基元。
• @ton-community/func-js - TON FunC 编译器
  
  

9 j4 G( U8 j& p% E

1. yarn add @ton/core ton-crypto @ton-community/func-js --dev
   

复制代码

FunC 代码示例

现在，我们将创建一个包含最小 FunC 代码示例的文件，然后编写一个可以编译它的脚本。

我们创建一个 contracts 文件夹，并在其中创建一个 FunC 文件（main.fc）：

1. mkdir contracts && cd contracts && touch main.fc
   * B% k! C2 O7 z3 S2 W$ M

复制代码

打开 main.fc 文件进行编辑，并插入以下示例 FunC 代码：

1. () recv_internal(int msg_value, cell in_msg, slice in_msg_body) impure {
   
2. 
   
3. }

复制代码

您已经知道 TON 智能合约可以接收两种信息，如果您不清楚这些信息是什么，请参阅第 1 章。这些简单的代码就足够我们编写一个编译器脚本了。我们开始吧！

编写编译脚本

在项目根目录下创建 scripts 文件夹，并在 scripts 文件夹下新建文件 compile.ts：

1. mkdir scripts && cd scripts && touch compile.ts
   9 `7 L2 j( \0 T. {' E* ^

复制代码

我们已经有了一个 compile.ts 文件，但还是让它在我们完成代码后方便运行吧。让我们在 package.json 文件中创建一个脚本快捷方式。只需添加以下脚本键即可：

1. {
   ) _# I  [5 ?( T+ ~
2.    //...your previous package.json contents
   
3.    "scripts": {
   5 Y4 h" S1 M+ U* v2 A% I
4. "compile": "ts-node ./scripts/compile.ts"
   
5.    }
   
6. }

复制代码

现在在编辑器中打开 scripts/compile.ts 文件，开始编写编译脚本。我们将一步一步地添加代码，并附带说明，因此在本节结束时，你将拥有编译脚本的完整代码。

首先，我们要导入：

• fs 用于处理文件
• process 来控制脚本的执行过程
• Cell 构造函数（我们合约的字节码将存储为 Cell）
• compileFunc - 实际编译功能
  
  9 v( H& v8 b  x

: d) `2 D; j) P0 R, y/ P. H8 ]

1. import * as fs from "fs";
   
2. import process from "process";
   $ y1 K4 w7 l  l) C
3. import { Cell } from "@ton/core";
   * P4 |( |9 l: A
4. import { compileFunc } from "@ton-community/func-js";

复制代码

我们将有一些异步代码，因此让我们创建一个异步函数，在内部运行这些代码：

1. import * as fs from "fs";
   
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   
4. import { compileFunc } from "@ton-community/func-js";
   . ^7 ]6 M9 i: H" X" l8 {
5. 
   ; |6 G7 ~) A% z0 O% X9 P2 q0 k
6. async function compileScript() {
   * G5 v2 V3 [8 g% p- [$ G
7. 
   . y. S, b  r  a+ C: L- N
8. }
   
9. 
   
10. compileScript();

复制代码

现在，我们将样本合约的文件名传入 compileFunc 函数，如果结果状态为错误，则退出脚本：

1. import * as fs from "fs";
   - X+ q; i' b* P% I) V" B
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   0 U1 ?: Y$ S5 [0 A0 R4 x* F( s
4. import { compileFunc } from "@ton-community/func-js";
   
5. 
   
6. async function compileScript() {
   
7. 
   
8.   const compileResult = await compileFunc({
   $ T' E, K1 v" g) O
9.     targets: ["./contracts/main.fc"],
   # X- ~( j) T7 [
10.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    3 W; F% H5 ^8 H6 C: \% ]
11.   });
    6 n. d/ Y4 C. c
12. 
    - b  @( J) L2 _5 m9 r- r
13.   if (compileResult.status === "error") {
    
14.     process.exit(1);
    ; k% Q& ]6 S' D% Z
15.   }
    * s5 J+ I$ l. Q
16. }
    " [# t0 Y$ Y+ A
17. compileScript();

复制代码

太棒了！从技术上讲，你已经可以进入我们项目的根目录，运行  yarn compile 指挥部. 但如果这样做，就无法看到编译结果。让我们将编译结果保存到文件夹 build 在我们项目的根目录下（确保先创建了它)。

编译结果将是一个 BOC（Body of Cell）base64 字符串，但如果我们想在本地进一步使用这个编译后的合约（在编写测试时），就需要构建一个包含该 BOC 的 Cell，并将其存储起来以备日后使用。

Cell 构造函数有一个 .fromBoc 方法，该方法希望接收一个缓冲区，因此我们将向其提供一个 BOC base64 字符串缓冲区。一旦我们从 BOC 构建了一个cell，我们就要为这个cell创建一个十六进制表示法，并将其存储到一个 JSON 文件中。这就是cell构建和转换命令的样子：

1. Cell.fromBoc(Buffer.from(compileResult.codeBoc, "base64"))[0].toBoc() .toString("hex")
   0 K1 q* W  D) u; ?; y+ o* n/ S$ g

复制代码

现在，我们将其放入脚本，并使用 fs.writeFileSync 将结果保存到 JSON 文件中：

1. import * as fs from "fs";
   " m: A$ W" b) C1 c
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   : [$ r+ e7 a5 x
4. import { compileFunc } from "@ton-community/func-js";
   4 ~% W: I. h3 W" ~, f9 `2 m" |
5. 
   , \4 l! V7 H( S2 p# a
6. async function compileScript() {
   " U3 ?6 X$ D* F  n" y4 y1 Z
7. 
   0 r, s4 b3 Y. I& V
8.   const compileResult = await compileFunc({
   
9.     targets: ["./contracts/main.fc"],
   
10.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    ( C, q7 A5 W# ]6 A, S# M2 D
11.   });
    
12. 
    
13.   if (compileResult.status === "error") {
    3 c" d" v) o2 S6 q* s
14.     process.exit(1);
    * N4 e& X  Z; }  U
15.   }
    7 a, Q6 N% }4 i9 v3 j
16. 
    % {: |+ C* g" Q; U4 j
17.   const hexArtifact = `build/main.compiled.json`;
    ) o6 A: w( f* ?3 Y) J. I: B4 c( Q
18. 
    
19.   fs.writeFileSync(
    
20.     hexArtifact,
    * t4 U7 P- z: f3 p6 S4 d- m: X
21.     JSON.stringify({
    ! \% i. w. `( D& [3 N# w& N
22.       hex: Cell.fromBoc(Buffer.from(compileResult.codeBoc, "base64"))[0]
    7 a$ Q: F8 A) ^/ n* R
23.         .toBoc()
    # N$ f) A1 |$ t$ W+ u: p
24.         .toString("hex"),
    
25.     })
    ( \& o7 D5 B2 K0 q
26.   );
    8 r+ K* T: j5 i' U0 u1 O
27. }
    0 p3 R* }+ c0 i( Y9 j* C
28. compileScript();

复制代码

这段代码已经可以运行了，但让我们做一些最后的编辑，使我们的脚本在运行时能提供更多信息。我们将为每一步添加漂亮的控制台日志。

9 o' \. t3 S& b+ d, m以下是最终代码

1. import * as fs from "fs";
   
2. import process from "process";
   $ X& D7 O! F( C; F4 p& e
3. import { Cell } from "@ton/core";
   
4. import { compileFunc } from "@ton-community/func-js";
   
5. 
   " W5 H5 f; Z' K( z! X+ }+ Y5 g9 \5 M
6. async function compileScript() {
   * e7 K1 _* J3 d4 v7 V3 W4 J
7.   console.log(
   , c  \3 ]3 o# V% M) {
8.     "================================================================="
   8 M( D5 d% D( E3 k& k# H
9.   );
   - r0 J: i) X& ^# }. `7 h% S
10.   console.log(
    " {5 [' ~4 I3 D/ b
11.     "Compile script is running, let's find some FunC code to compile..."
    
12.   );
    
13. 
    0 n" ?! |3 F* E' V9 Y7 A4 `
14.   const compileResult = await compileFunc({
    
15.     targets: ["./contracts/main.fc"],
    
16.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    . E% }: s7 K% c* ~$ U
17.   });
    
18. 
    7 R" F3 r5 \. {! z$ D9 z4 ]5 F! X5 C
19.   if (compileResult.status === "error") {
    ( O; J) ?" N- F/ X5 j) {. }) _4 @
20.     console.log(" - OH NO! Compilation Errors! The compiler output was:");
    " {6 h; m* W2 ?* A% O
21.     console.log(`\n${compileResult.message}`);
    
22.     process.exit(1);
    * F# R4 O) H9 a# L0 Y( m* d
23.   }
    1 f* m+ g0 T4 R; k' @& W" y5 K
24. 
    
25.   console.log(" - Compilation successful!");
    
26. 
    " g7 N6 k* }0 Y; q: r' l- \6 D5 e
27.   const hexArtifact = `build/main.compiled.json`;
    
28. 
    / w) `6 f2 B2 |  L& U/ Q) g# z  G; Q
29.   fs.writeFileSync(
    
30.     hexArtifact,
    & B; b- L6 a1 Y& c1 W) t' p
31.     JSON.stringify({
    
32.       hex: Cell.fromBoc(Buffer.from(compileResult.codeBoc, "base64"))[0]
    " @: Z# [9 D% T; V3 B2 z9 u
33.         .toBoc()
    ) K: X0 ]. x& b6 z, `* Q3 i
34.         .toString("hex"),
    5 A% w( T5 V1 O$ N, R2 f) s. s
35.     })
    
36.   );
    
37. 
      c* U# Y8 G; T9 y( l5 P! v
38.   console.log(" - Compiled code saved to " + hexArtifact);
    
39. }
    . l' y/ B; r9 @+ B4 ?, ]
40. compileScript();

复制代码

这是我们的编译脚本，每次修改代码时都要运行它。稍后，一旦我们有了一些可测试的 FunC 逻辑和部署脚本，我们就可以在任何测试或部署之前自动运行该脚本。

我们的 "卫星装配 "实验室设备越来越齐全！

不过，让我们再运行一次 yarn 编译，看看编译的结果如何。为此，让我们打开 main.compiled.fc 文件。

我们在那里看到了什么:

1. {"hex":"b5ee9c72410102010012000114ff00f4a413f4bcf2c80b010006d35f03fbffbf07"}
   

复制代码

听起来很疯狂，但这就是我们的合约。在下一课中，我们将编写第一个 FunC 逻辑，并将其与我们刚刚编写的脚本进行编译。

到时见！

( R! W/ q+ ~2 i! m& u
+ f6 q+ U& L5 I7 N1 K% h! z. g: s4 E