3.2 设置编译流程

riyad

0 D) r- B8 t6 R% J1 G& v

本课的目的是建立一个能够编译智能合约示例的本地项目。我们现在还不打算编写任何 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
  
  

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

建立项目。

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

1. mkdir my_first_contract && cd my_first_contract
   

复制代码

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

1. yarn init
   & l% P9 i. h* e  o1 L

复制代码

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

1. {
   ; |0 f6 K0 ?" g. q; S* e$ K& i0 Z
2. 
   % s( |. ?; I8 n( O
3.   "name": "my_first_contract",
   + W; `: `  |2 Y/ ]$ \" v" k% D
4. 
   4 c9 a( ]' E- L& m5 I' A4 A* |
5.   "version": "1.0.0",
   
6. 
   . a4 o( \; R7 _: D6 l% D
7.   "main": "index.js", //we don't really need this line, feel free to remove it
   2 y( h6 c* F! S# o, _8 o, K" ~' s! F
8. 
   , E9 e" }' X' c* a, z
9.   "license": "MIT"
   ) y" C' q( r5 i! {' j1 F
10. 
    8 K* R1 {+ r: ^
11. }

复制代码

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

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

1. yarn add typescript ts-node @types/node @swc/core --dev
   # J! n& |; z9 s) X1 K( M

复制代码

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

1. {
   - W9 O6 W# Z3 ]4 V( N2 \3 B
2. 
   0 J- |9 z. t) v. A. ~
3.   "compilerOptions": {
   $ Q# a$ ~  d0 N- u7 R
4. 
   6 d3 e' h0 F; e% {
5.     "target": "es2020",
   
6. 
   : [9 A+ ]  p; c! w" Y( ^
7.     "module": "commonjs",
   " S% y7 l2 n& j) Q0 W
8. 
   0 \1 g6 M3 q! w# L/ G) {6 S; W
9.     "esModuleInterop": true,
   
10. 
    7 J" @2 J1 K$ }) I. M# ~# v5 J
11.     "forceConsistentCasingInFileNames": true,
    9 y. w# i' u. G; L& y7 n, v
12. 
    
13.     "strict": true,
    
14. 
    
15.     "skipLibCheck": true,
    + j3 B- y" I, L4 d! w3 k  _) K7 O
16. 
    
17.     "resolveJsonModule": true
    9 s' [5 x/ R. W! K8 J
18. 
    
19.   },
    
20. 
    
21.   "ts-node": {
    
22. 
    7 o* ]$ Y& e2 `  {
23.     "transpileOnly": true,
    
24. 
    
25.     "transpiler": "ts-node/transpilers/swc"
    3 c+ L* Z7 h" M/ Y. M7 U: L
26. 
    
27.   }
    - r( L5 y9 m% t' O- H8 o9 B% \
28. 
    
29. }

复制代码

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

• ton-core - 实现 TON 区块链底层基元的核心库。
• ton-crypto - 用于为 TON 区块链构建应用程序的加密基元。
• @ton-community/func-js - TON FunC 编译器
  
  7 N) A4 E, _* n8 d6 Q+ W

4 B! ]6 z& j/ H9 o  [. r

1. yarn add @ton/core ton-crypto @ton-community/func-js --dev
   % a" y, J. B) }

复制代码

FunC 代码示例

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

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

1. mkdir contracts && cd contracts && touch main.fc
   

复制代码

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

1. () recv_internal(int msg_value, cell in_msg, slice in_msg_body) impure {
   ) N* ]+ T8 d7 _  e$ `
2. 
   - h. }& x9 C5 x
3. }

复制代码

您已经知道 TON 智能合约可以接收两种信息，如果您不清楚这些信息是什么，请参阅第 1 章。这些简单的代码就足够我们编写一个编译器脚本了。我们开始吧！
! v0 E4 r* O) q6 c: h9 k' b% n6 ^
编写编译脚本

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

1. mkdir scripts && cd scripts && touch compile.ts
   : A; Z9 k- f4 m. O

复制代码

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

1. {
   
2.    //...your previous package.json contents
   6 n3 i2 c, D8 v2 [( [4 ^( n8 A
3.    "scripts": {
   & m3 ^% a. X/ v' C
4. "compile": "ts-node ./scripts/compile.ts"
   
5.    }
   5 W* N+ d& N! h, }8 B
6. }

复制代码

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

首先，我们要导入：

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

1. import * as fs from "fs";
   : ]5 g8 ^2 p7 j  _( V
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   & P  n4 r% m' F6 t
4. import { compileFunc } from "@ton-community/func-js";

复制代码

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

, P* u( {. x; a( A# i

1. import * as fs from "fs";
   
2. import process from "process";
   9 E' [& f" R# U5 T% x" P2 X0 }$ O
3. import { Cell } from "@ton/core";
   0 {8 |: y# l9 M: r1 }% n
4. import { compileFunc } from "@ton-community/func-js";
   
5. 
   . A* {$ E5 Z" }2 ]  w3 f9 B
6. async function compileScript() {
   ) R3 @' f9 s; d
7. 
   
8. }
   2 c% r9 u- d7 O9 f0 p& d
9. 
   
10. compileScript();

复制代码

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

1. import * as fs from "fs";
   
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   ! Z. L- Z1 k8 ?6 i' y6 ^8 r/ l% P
4. import { compileFunc } from "@ton-community/func-js";
   2 [* b0 X* g% t2 ^& B- J
5. 
   
6. async function compileScript() {
   
7. 
   2 d$ @: X4 i9 Z1 `
8.   const compileResult = await compileFunc({
   
9.     targets: ["./contracts/main.fc"],
   $ j% j! o* M  ^: L3 K
10.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    9 Z8 H7 A0 H, I
11.   });
    + H- `  g2 K( x/ I  G1 E$ v
12. 
    ! U3 P! E, T- u& q' j% Q; C. L
13.   if (compileResult.status === "error") {
    
14.     process.exit(1);
    
15.   }
    3 ]$ c, _) r1 v9 Y1 x) u+ X5 r
16. }
    8 {/ U3 h; t6 G2 }  r3 f
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")
   

复制代码

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

1. import * as fs from "fs";
   $ H( U) V6 h6 d, ~
2. import process from "process";
   ' F2 ]5 B# L( m( S2 H% x& \* T4 {
3. import { Cell } from "@ton/core";
   " k% _0 j' |. \6 W6 [0 z9 U, H. S
4. import { compileFunc } from "@ton-community/func-js";
   
5. 
   $ R; _7 a- c' p5 L2 J, ^, G
6. async function compileScript() {
   
7. 
   
8.   const compileResult = await compileFunc({
   & A; M2 N: F8 r) r1 o
9.     targets: ["./contracts/main.fc"],
   : n& j$ h" ~- f# ?
10.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    
11.   });
    3 N3 ?! N3 Z9 B
12. 
    
13.   if (compileResult.status === "error") {
    4 Q1 Z. e. r7 g- q) _+ @+ n" ]; T
14.     process.exit(1);
    
15.   }
    
16. 
    
17.   const hexArtifact = `build/main.compiled.json`;
    
18. 
    
19.   fs.writeFileSync(
    / S. v  X4 x0 j% {4 q2 b/ O: g
20.     hexArtifact,
    
21.     JSON.stringify({
    
22.       hex: Cell.fromBoc(Buffer.from(compileResult.codeBoc, "base64"))[0]
    
23.         .toBoc()
    
24.         .toString("hex"),
    - q$ @* A, A% P4 T
25.     })
    
26.   );
    
27. }
    
28. compileScript();

复制代码

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

# x5 R1 z& n! l; Y! A  U( Z以下是最终代码

1. import * as fs from "fs";
   
2. import process from "process";
   
3. import { Cell } from "@ton/core";
   ' O. P( e& i5 C1 s+ N
4. import { compileFunc } from "@ton-community/func-js";
   
5. 
   % `; B/ M/ i! L6 w
6. async function compileScript() {
   4 n, L3 g' o! R; w" k
7.   console.log(
   
8.     "================================================================="
   ( O6 s1 {8 ?0 H: C6 C0 d
9.   );
   9 n* W' V# P- j6 ^
10.   console.log(
    
11.     "Compile script is running, let's find some FunC code to compile..."
    
12.   );
    
13. 
    # v, p/ P! O2 J- j( F. F
14.   const compileResult = await compileFunc({
    
15.     targets: ["./contracts/main.fc"],
    
16.     sources: (x) => fs.readFileSync(x).toString("utf8"),
    , {/ k6 [8 \6 x* m* F
17.   });
    
18. 
    . m/ G+ F& f3 J) n
19.   if (compileResult.status === "error") {
    ! G; f' J. H- |+ h6 ~1 N
20.     console.log(" - OH NO! Compilation Errors! The compiler output was:");
    + ^( P# a; u1 Q8 D. ~+ }
21.     console.log(`\n${compileResult.message}`);
    / y1 Z% \4 V0 f& Z7 t' E/ h' p
22.     process.exit(1);
    
23.   }
    9 @1 P7 _" b! C' }* ?/ z
24. 
    
25.   console.log(" - Compilation successful!");
    1 h8 f& e. K! n7 j
26. 
    
27.   const hexArtifact = `build/main.compiled.json`;
    
28. 
    
29.   fs.writeFileSync(
    
30.     hexArtifact,
    $ L) C% F5 y" n6 X6 r6 x  p
31.     JSON.stringify({
    
32.       hex: Cell.fromBoc(Buffer.from(compileResult.codeBoc, "base64"))[0]
    
33.         .toBoc()
    4 r4 e% J& h+ Z* |" M4 v8 }8 y
34.         .toString("hex"),
    
35.     })
    - t* C# v4 O0 y/ C' o) Y
36.   );
    " e5 ?# U! k! f/ @' o5 b5 q8 o
37. 
    
38.   console.log(" - Compiled code saved to " + hexArtifact);
    $ q  A1 r+ E6 C& T- s+ R9 Z8 e  y
39. }
    
40. compileScript();

复制代码

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

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

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

我们在那里看到了什么:

1. {"hex":"b5ee9c72410102010012000114ff00f4a413f4bcf2c80b010006d35f03fbffbf07"}
   ! k# Q; ?, l( c8 p0 o/ s" m  X/ h

复制代码

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

到时见！

* K2 |! O3 ~* }
. x$ v/ I8 h# `: q$ V