跳到主要内容

TL-B 类型

高级模式

此信息属于非常底层的内容，对新手来说可能难以理解。 因此，您可以稍后再阅读。

在本节中，我们将分析复杂和非传统的类型化语言二进制（TL-B）结构。开始之前，我们建议先阅读此文档，以更熟悉该主题。

tlb structure

以上任一情况​

left$0 {X:Type} {Y:Type} value:X = Either X Y;
right$1 {X:Type} {Y:Type} value:Y = Either X Y;

Either类型用于可能出现两种结果类型之一的情况。在这种情况下，类型选择取决于所示的前缀位。如果前缀位是0，则序列化左类型，而如果使用1前缀位，则序列化右类型。

例如，在序列化消息时使用它，当消息体要么是主cell的一部分，要么链接到另一个cell。

Maybe​

nothing$0 {X:Type} = Maybe X;
just$1 {X:Type} value:X = Maybe X;

Maybe类型与可选值一起使用。在这些情况下，如果第一位是0，则不会序列化该值（实际上被跳过），而如果值是1，则会被序列化。

Both​

pair$_ {X:Type} {Y:Type} first:X second:Y = Both X Y;

Both类型变体仅与普通对一起使用，两种类型依次序列化，没有条件。

Unary​

Unary函数类型通常用于动态大小的结构，例如hml_short。

Unary提供两个主要选项：

unary_zero$0 = Unary ~0;
unary_succ$1 {n:#} x:(Unary ~n) = Unary ~(n + 1);

Unary序列化​

通常，使用unary_zero变体相当简单：如果第一位是0，则Unary反序列化的结果为0。

然而，unary_succ变体更复杂，因为它是递归加载的，具有~(n + 1)的值。这意味着它会顺序调用自身，直到达到unary_zero。换句话说，所需的值将等于一连串单位的数量。

例如，让我们分析位串110的序列化。

调用链如下：

unary_succ$1 -> unary_succ$1 -> unary_zero$0

一旦到达unary_zero，值就会返回到序列化位串的末尾，类似于递归函数调用。

现在，为了更清楚地理解结果，让我们检索返回值路径，显示如下：

0 -> ~(0 + 1) -> ~(1 + 1) -> 2，这意味着我们将110序列化为Unary 2。

Unary反序列化​

假设我们有Foo类型：

foo$_  u:(Unary 2) = Foo;

根据上述内容，Foo将被反序列化为：



foo u:(unary_succ x:(unary_succ x:(unnary_zero)))

Hashmap​

Hashmap复杂类型用于存储FunC智能合约代码中的字典（dict）。

以下TL-B结构用于序列化具有固定键长度的Hashmap：

hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
          {n = (~m) + l} node:(HashmapNode m X) = Hashmap n X;

hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;
hmn_fork#_ {n:#} {X:Type} left:^(Hashmap n X)
           right:^(Hashmap n X) = HashmapNode (n + 1) X;

hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= m} s:(n * Bit) = HmLabel ~n m;
hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;
hml_same$11 {m:#} v:Bit n:(#<= m) = HmLabel ~n m;

unary_zero$0 = Unary ~0;
unary_succ$1 {n:#} x:(Unary ~n) = Unary ~(n + 1);

hme_empty$0 {n:#} {X:Type} = HashmapE n X;
hme_root$1 {n:#} {X:Type} root:^(Hashmap n X) = HashmapE n X;

这意味着根结构使用HashmapE及其两种状态之一：包括hme_empty或hme_root。

Hashmap解析示例​

例如，考虑以下以二进制形式给出的Cell。

1[1] -> {
  2[00] -> {
    7[1001000] -> {
      25[1010000010000001100001001],
      25[1010000010000000001101111]
    },
    28[1011100000000000001100001001]
  }
}

此Cell使用了HashmapE结构类型，并具有8位键大小，其值使用uint16数字框架（HashmapE 8 uint16）。HashmapE使用3种不同的键类型：

1 = 777
17 = 111
128 = 777

为了解析此Hashmap，我们需要预先知道使用哪种结构类型，hme_empty还是hme_root。这是通过识别正确前缀来确定的。hme empty变体使用一个位0（hme_empty$0），而hme root使用一个位1（hme_root$1）。读取第一位后，确定它等于一（1[1]），意味着它是hme_root变体。

现在，让我们用已知值填充结构变量，初始结果为： hme_root$1 {n:#} {X:Type} root:^(Hashmap 8 uint16) = HashmapE 8 uint16;

这里已经读取了一位前缀，而{}中的条件不需要读取。条件{n:#}表示n是任何uint32数字，而{X:Type}表示X可以使用任何类型。

接下来需要读取的部分是root:^(Hashmap 8 uint16)，而^符号表示必须加载的链接。

2[00] -> {
    7[1001000] -> {
      25[1010000010000001100001001],
      25[1010000010000000001101111]
    },
    28[1011100000000000001100001001]
  }

初始化分支解析​

根据我们的架构，这是正确的Hashmap 8 uint16结构。接下来，我们用已知的值填充它，并得到如下结果：

hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l 8)
          {8 = (~m) + l} node:(HashmapNode m uint16) = Hashmap 8 uint16;

如上所示，现在出现了条件变量{l:#}和{m:#}，但我们不知道这两个变量的值。此外，在读取相应的label之后，很明显n涉及等式{n = (~m) + l}，在这种情况下我们计算l和m，符号~告诉我们结果值。

为了确定l的值，我们必须加载label:(HmLabel ~l uint16)序列。如下所示，HmLabel有三种基本结构选项：

hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= m} s:(n * Bit) = HmLabel ~n m;
hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;
hml_same$11 {m:#} v:Bit n:(#<= m) = HmLabel ~n m;

每个选项都由相应的前缀确定。目前，我们的根cell由两个零位组成，显示为：(2[00])。因此，唯一合理的选项是以0开头的前缀hml_short$0。

用已知值填充hml_short：

hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= 8} s:(n * Bit) = HmLabel ~n 8

在这种情况下，我们不知道n的值，但由于它有一个~字符，可以计算它。为此，我们加载len:(Unary ~n)，关于Unary的更多信息。

在这种情况下，我们从2[00]开始，但在定义了HmLabel类型之后，两个位中只剩下一个。

因此，我们加载它并看到它的值是0，这意味着它显然使用了unary_zero$0变体。这意味着使用HmLabel变体的n值为零。

接下来，需要使用计算出的n值完成hml_short变体序列：

hml_short$0 {m:#} {n:#} len:0 {n <= 8} s:(0 * Bit) = HmLabel 0 8

结果我们得到一个空的HmLabel，表示为s = 0，因此没有什么可以下载的。

接下来，我们用计算出的l值补充我们的结构，如下所示：

hm_edge#_ {n:#} {X:Type} {l:0} {m:#} label:(HmLabel 0 8)
          {8 = (~m) + 0} node:(HashmapNode m uint16) = Hashmap 8 uint16;

现在我们已经计算出l的值，我们可以使用等式n = (~m) + 0来计算m，即m = n - 0，m = n = 8。

确定所有未知值后，现在可以加载node:(HashmapNode 8 uint16)。

至于HashmapNode，我们有以下选项：

hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;
hmn_fork#_ {n:#} {X:Type} left:^(Hashmap n X)
           right:^(Hashmap n X) = HashmapNode (n + 1) X;

在这种情况下，我们不

hmn_fork#_ {n:#} {X:uint16} left:^(Hashmap n uint16)
           right:^(Hashmap n uint16) = HashmapNode (n + 1) uint16;

输入已知值后，我们必须计算 HashmapNode (n + 1) uint16。这意味着得出的 n 值必须等于我们的参数，即 8。 要计算 n 的本地值，我们需要使用以下公式：n = (n_local + 1) -> n_local = (n - 1) -> n_local = (8 - 1) -> n_local = 7。

hmn_fork#_ {n:#} {X:uint16} left:^(Hashmap 7 uint16)
           right:^(Hashmap 7 uint16) = HashmapNode (7 + 1) uint16;

既然我们知道需要上述公式，那么获得最终结果就很简单了。 接下来，我们加载左分支和右分支，并对随后的每个分支重复该过程 。

分析加载的 Hashmap 值​

继续前面的例子，我们来看看加载分支的过程是如何进行的（对于 dict 值）。

继续前面的例子，让我们来看看加载分支的过程是如何工作的（对于dict值），即28[1011100000000000001100001001]

hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l 7)
          {7 = (~m) + l} node:(HashmapNode m uint16) = Hashmap 7 uint16;

接下来，因为前缀是 10，所以使用 HmLabel 变体加载 HmLabel 响应。

hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;

现在，让我们来填写序列：

hml_long$10 {m:#} n:(#<= 7) s:(n * Bit) = HmLabel ~n 7;

新的结构--"n:(#<= 7)"，显然表示与数字 7 相对应的大小值，它实际上是数字 + 1 的 log2。但为了简单起见，我们可以计算写数字 7 所需的比特数。 与此相关，二进制形式的数字 7 是 111 ；因此需要 3 位，即 n = 3 的值。

hml_long$10 {m:#} n:(## 3) s:(n * Bit) = HmLabel ~n 7;

接下来，我们将 n 加载到序列中，最终结果为 111 ，正如我们上面所提到的 = 7，巧合的是，这就是 7。接下来，我们将 s 加载到序列中，7 位 - 000000。记住，s是密钥的一部分。

接下来我们将n加载到序列中，最终结果为111，如上所述，这与7相符。接下来，我们将s加载到序列中，7位 - 0000000。记住，s是键的一部分。

hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel 7 7)
          {7 = (~m) + 7} node:(HashmapNode m uint16) = Hashmap 7 uint16;

然后我们计算 m 的值，m = 7 - 7，因此 m 的值 = 0。 由于 m = 0 的值，该结构非常适合与 HashmapNode 一起使用：

hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;

接下来，我们代入 uint16 类型并加载数值。十进制形式的 0000001100001001 的剩余 16 位是 777，因此就是我们的值。

接下来我们替换我们的uint16类型并加载值。剩余的16位0000001100001001以十进制形式为777，因此这就是我们的值。

现在让我们恢复键，我们必须将之前计算的所有键部分的有序列表组合起来。两个相关的键部分根据使用的分支类型合并为一位。对于右分支，添加‘1’位，对于左分支添加‘0’位。如果上面有完整的HmLabel，则将其位添加到键中。

其他哈希表类型​

既然我们已经讨论了 Hashmap 以及如何加载标准 Hashmap 类型，下面就让我们来解释一下其他 Hashmap 类型是如何工作的。

HashmapAugE​

ahm_edge#_ {n:#} {X:Type} {Y:Type} {l:#} {m:#}
  label:(HmLabel ~l n) {n = (~m) + l}
  node:(HashmapAugNode m X Y) = HashmapAug n X Y;

ahmn_leaf#_ {X:Type} {Y:Type} extra:Y value:X = HashmapAugNode 0 X Y;

ahmn_fork#_ {n:#} {X:Type} {Y:Type} left:^(HashmapAug n X Y)
  right:^(HashmapAug n X Y) extra:Y = HashmapAugNode (n + 1) X Y;

ahme_empty$0 {n:#} {X:Type} {Y:Type} extra:Y
          = HashmapAugE n X Y;

ahme_root$1 {n:#} {X:Type} {Y:Type} root:^(HashmapAug n X Y)
  extra:Y = HashmapAugE n X Y;

HashmapAugE 与普通 Hashmap 的主要区别在于每个节点中都有一个 extra:Y 字段（而不仅仅是有值的叶子）。

PfxHashmap​

phm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
           {n = (~m) + l} node:(PfxHashmapNode m X)
           = PfxHashmap n X;

phmn_leaf$0 {n:#} {X:Type} value:X = PfxHashmapNode n X;
phmn_fork$1 {n:#} {X:Type} left:^(PfxHashmap n X)
            right:^(PfxHashmap n X) = PfxHashmapNode (n + 1) X;

phme_empty$0 {n:#} {X:Type} = PfxHashmapE n X;
phme_root$1 {n:#} {X:Type} root:^(PfxHashmap n X)
            = PfxHashmapE n X;

PfxHashmap 与普通 Hashmap 的主要区别在于，由于存在 phmn_leaf$0 和 phmn_fork$1 节点，它可以存储不同长度的密钥。

VarHashmap​

vhm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
           {n = (~m) + l} node:(VarHashmapNode m X)
           = VarHashmap n X;
vhmn_leaf$00 {n:#} {X:Type} value:X = VarHashmapNode n X;
vhmn_fork$01 {n:#} {X:Type} left:^(VarHashmap n X)
             right:^(VarHashmap n X) value:(Maybe X)
             = VarHashmapNode (n + 1) X;
vhmn_cont$1 {n:#} {X:Type} branch:Bit child:^(VarHashmap n X)
            value:X = VarHashmapNode (n + 1) X;

// nothing$0 {X:Type} = Maybe X;
// just$1 {X:Type} value:X = Maybe X;

vhme_empty$0 {n:#} {X:Type} = VarHashmapE n X;
vhme_root$1 {n:#} {X:Type} root:^(VarHashmap n X)
            = VarHashmapE n X;

VarHashmap 与普通 Hashmap 的主要区别在于，由于存在 vhmn_leaf$00 和 vhmn_fork$01 节点，它可以存储不同长度的密钥。此外，"VarHashmap "还能形成一个公共值前缀（子映射），而不需要 "vhmn_cont$1"。

BinTree​

bta_leaf$0 {X:Type} {Y:Type} extra:Y leaf:X = BinTreeAug X Y;
bta_fork$1 {X:Type} {Y:Type} left:^(BinTreeAug X Y)
           right:^(BinTreeAug X Y) extra:Y = BinTreeAug X Y;

二叉树密钥生成机制的工作方式与标准化 Hashmap 框架类似，但不使用标签，只包含分支前缀。

Addresses​

TON 地址是通过使用 TL-B StateInit 结构的 sha256 散列机制形成的。这意味着可以在部署网络合约之前计算出地址。

序列化​

标准地址（如 EQBL2_3lMiyywU17g-or8N7v9hDmPCpttzBPE2isF2GTzpK4）使用 base64 uri 进行字节编码。 通常，它们的长度为 36 个字节，其中最后 2 个字节是使用 XMODEM 表计算的 crc16 校验和，第一个字节代表标志，第二个字节代表工作链。 中间的 32 个字节是地址本身的数据（也称为 AccountID），通常用 int256 等模式表示。

标准地址，例如EQBL2_3lMiyywU17g-or8N7v9hDmPCpttzBPE2isF2GTzpK4，使用base64 uri对字节进行编码。通常它们长度为36字节，其中最后两个字节是使用XMODEM表计算的crc16校验和，而第一个字节表示标志，第二个表示工作链。中间的32字节是地址本身的数据（也称为AccountID），通常在诸如int256之类的架构中表示。

参考资料​

Here a link to the original article by Oleg Baranov.