Tact 语言基础 | 合约

riyad

Tact 中的合约类似于流行的面向对象语言中的类，只是它们的实例部署在区块链上，不能像 结构和信息 那样被传递。

7 e1 Y* V' }$ \, K, r# i自引用
合约和trait有一个内置的标识符 self，用于引用它们的字段（持久状态变量和常量）和方法（内部函数）：

1. contract Example {
   
2.     // persistent state variables
   
3.     foo: Int;
   
4. 
   
5.     init() {
   * K/ O2 b& b. ^4 k) r0 C
6.         self.foo = 42; // <- referencing variable foo through self.
   , Z5 t: b( K4 j5 A( y' \8 {
7.     }
   
8. }

复制代码

结构
每份合约可包括:
& ~7 {% A6 B' ^

• 可继承trait
• 支持的接口
• 持久状态变量
• 构造函数 init()
• 合约常量
• Getter 函数
• Receiver 功能
• 内部功能
  . H6 Y: `' h9 V9 N; x3 i

) ~% g9 Q5 V- P/ O% l
3 i! }1 F! L3 T/ G# y* {9 B# o继承trait， with

合约可以继承traits的所有声明和定义，并覆盖它们的某些默认行为。 除此之外，每个合约和trait都隐式继承了特殊的BaseTrait trait。

要继承trait，请在合约声明中的关键字with后指定其名称。 要同时继承多个性状，请在逗号分隔的列表中指定它们的名称，并在后面加上逗号。

) E( e, ]) B$ B3 k' j

1. trait InheritMe {}
   
2. trait InheritMeToo {}
   % c8 F9 F8 r5 v0 u, A8 U" {. `
3. 
   
4. // A contract inheriting a single trait
   
5. contract Single with InheritMe {}
   9 A. l" Q9 j' _4 r$ W" s
6. 
   / ^. d  S- A0 ^8 Q; y3 K" g6 \
7. // A contract inheriting multiple traits
   
8. contract Plural with
   # a/ [) V. H  w' s+ B8 Q
9.     InheritMe,
   ; I& X$ W' j0 m% V
10.     InheritMeToo, // trailing comma is allowed
    : O4 V! L9 ^) |7 ^6 H3 ~6 {4 z
11. {}

复制代码

1 l$ Q( ~7 T1 B0 W由于traits不允许有init()函数，因此继承了声明了任何持久状态变量的trait的合约必须通过提供自己的init()函数来初始化这些变量。
5 z- r9 u- _* o2 {

1. trait Supe { omelander: Bool }
   
2. 
   
3. contract Vot with Supe {
   . u( d5 z5 e0 o( N; U2 V4 ?
4.     init() {
   
5.         self.omelander = true;
   5 e; X/ O: B6 {; `/ ^  V
6.     }
   5 i5 P& p" V. ^% L: Y* E1 L+ |$ O
7. }

复制代码

如果在trait中声明或定义了内部函数和常量，则可将其标记为虚拟或抽象，并在从trait继承的合约中重写。
9 ^# Q( |. H$ P- T% I

支持的接口，@interface(…)
如果不查看源代码，就很难弄清一个合约是做什么的，有哪些receiver和getter。 有时，无法获得或无法访问源代码，剩下的办法就是尝试拆解合约，并以这种方式对其进行回推，这是一种非常混乱且容易出错的方法，其收益会递减，而且没有真正的可重复性。

为了解决这个问题，创建了 OTP-001：支持的接口。 据此，Tact 合约可以报告 支持的接口列表，作为特殊的 supported_interfaces getter 的返回值。 该getter可以通过任何TON区块链浏览器在链下访问——只需指定supported_interfaces作为执行的方法，返回一个十六进制值的列表。

& t  o0 Q1 R  u" q% u
8 x) B3 v& R: z* m0 M. }; D要声明支持某个接口，可在 contract 和trait声明之前添加一个或多个@interface("…")属性：
  \$ z$ U  \: `; T' Z

1. @interface("His name is")
   
2. @interface("John")
   
3. contract SeeNah with Misc {
   
4.     // ...
   3 G9 {+ I, I4 {6 t% J9 I2 h/ u: `
5. }
   
6. 
   
7. @interface("name_of_your_org - miscellaneous")
   
8. trait Misc {
   
9.     // ...
   
10. }

复制代码

% B* ~6 W0 B/ ?/ v% w, Z, q& Q2 B

7 d9 f2 Y/ o2 S6 K% S
7 m7 l& e. |( q. m) r( e2 ]* i标准库中的一些traits也定义了它们的接口：

2 ^5 K9 ?9 s, Y1 k

• Ownable trait 指定"org.ton.ownable"
• OwnableTransferable trait 指定"org.ton.ownable.transferable.v2"
• Stoppable trait 指定"org.ton.stoppable"
• Resumable trait 指定"org.ton.resumable"
  

5 k) w; D  A' h* I要启用 supported_interfaces getter 生成并在 Tact 合约中使用 @interface() 属性，请修改项目根目录下的 tact.config.json 文件（如果该文件不存在，则创建该文件），并 将 interfacesGetter 属性设置为 true。
& q3 \. I% K  V7 G) J8 b
如果您的项目基于 Blueprint，您可以在合约的编译配置中启用supported_interfaces，这些配置位于名为wrappers/的目录中：

$ B. H  x) p# s
8 q$ z" h- a& Y2 R' N

1. import { CompilerConfig } from '@ton/blueprint';
   
2. 
   . A$ D( K* i: j+ m) A" J- g1 [
3. export const compile: CompilerConfig = {
   
4.   lang: 'tact',
   
5.   target: 'contracts/your_contract_name.tact',
   
6.   options: {
   
7.     interfacesGetter: true, // ← that's the stuff!
   9 F2 L8 h1 ^" t0 D, s' {
8.   }
   & x! h: A6 r) I5 R
9. };

复制代码

除此之外，tact.config.json 仍然可以用于 Blueprint 项目。 除此之外，Blueprint 项目中仍可使用 tact.config.json。 在这种情况下，除非在 wrappers/ 中进行修改，否则 tact.config.json中指定的值将作为默认值。
! h2 Y# v" k4 g% [
6 u! s0 E' F) F
& C4 r9 m0 q/ x1 `6 r注意
- d' w8 z$ X8 y6 o% C# v3 w
2 i/ _, Z6 u+ E; l  e8 R如果你有 separateCompilables 选项设置为 true 在 blueprint.config.ts，然后.compile.ts文件将位于compilables/目录中，不位于wrapper/。

$ d7 ~6 [, J. F3 s- X& E# _4 B警告
1 B! C7 h5 `: _
2 _! D! o" Y( z9 m. n请注意，添加接口并不能保证合约实际实现任何特定功能，也不能保证以任何特定方式实现这些功能。 这只是一种可验证的链外承诺，即合约中可能包含某些特定代码。 您应该相信但要核实这些说法。
7 b) }% U# b, g2 J" U& ?
此外，不同接口之间也不能保证不会发生名称冲突，尽管这种情况不太可能发生，因为即使是 SHA-256 的前 128 位也能提供足够的抗碰撞性。

6 b" w! i9 K* e7 Y

持久状态变量
合约可以定义在合约调用之间持续存在的状态变量。 合约可以定义在合约调用之间持续存在的状态变量。 TON 中的合约支付租金 与它们消耗的持久空间成正比，因此鼓励通过序列化进行紧凑表示。
- s; e( D6 R7 v# a$ o

, e" b2 B; |/ c2 I7 f, `

1. contract Example {
   & W6 l& K5 D4 T, Z
2.     // persistent state variables
   % C" z. e6 V" v' Y+ ?
3.     val: Int;              // Int
   / ]" v5 u1 f2 e- q& S
4.     val32: Int as uint32;  // Int serialized to an 32-bit unsigned
   
5.     mapVal: map<Int, Int>; // Int keys to Int values
   
6.     optVal: Int?;          // Int or null
   
7. }

复制代码

状态变量必须有默认值或在 init() 函数中初始化，该函数在部署合约时运行。 唯一的例外是 map<K, V> 类型的持久状态变量，因为它们默认初始化为空。
5 ~) I1 M7 x& A6 ]. C8 ?3 G) F
( F9 y* L/ x1 ~* X
' o. |. l, a7 d注意
$ S  B3 C$ S% [
& _; T, T2 R- L' C+ O- H/ `# X6 V请注意，Tact 也支持非持续状态的局部变量，请参阅：变量声明。


  h4 z4 H- S! s8 {) Q2 O7 {