Merge pull request #1559 from ton-blockchain/tolk-v0.10

Tolk v0.10: preparing for serialization; types `intN`, `bytesN`, `coins`

Author: EmelyanenkoK

crypto/smartcont/tolk-stdlib/common.tolk

@@ -1,7 +1,7 @@
 // Standard library for Tolk (LGPL licence).
 // It contains common functions that are available out of the box, the user doesn't have to import anything.
 // More specific functions are required to be imported explicitly, like "@stdlib/tvm-dicts".
-tolk 0.9
+tolk 0.10
 
 /**
   Tuple manipulation primitives.
@@ -54,6 +54,13 @@ fun tupleLast<T>(self: tuple): T
     Mathematical primitives.
  */
 
+/// Converts a constant floating-point string to nanotoncoins.
+/// Example: `ton("0.05")` is equal to 50000000.
+/// Note, that `ton()` requires a constant string; `ton(some_var)` is an error
+@pure
+fun ton(floatString: slice): coins
+    builtin;
+
 /// Computes the minimum of two integers.
 @pure
 fun min(x: int, y: int): int
@@ -187,6 +194,42 @@ fun commitContractDataAndActions(): void
   Signature checks, hashing, cryptography.
  */
 
+/// Compile-time function that calculates crc32 of a constant string.
+/// Example: `const op = stringCrc32("some_str")` = 4013618352 = 0xEF3AF4B0
+/// Note: stringCrc32(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringCrc32(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates crc16 (XMODEM) of a constant string.
+/// Example: `const op = stringCrc16("some_str")` = 53407 = 0xD09F
+/// Note: stringCrc16(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringCrc16(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates sha256 of a constant string and returns 256-bit integer.
+/// Example: `const hash = stringSha256("some_crypto_key")`
+/// Note: it's a compile-time function, `stringSha256(slice_var)` does not work.
+/// Use `sliceBitsHash` or `sliceHash` (declared below) to hash a slice without/with its refs at runtime.
+@pure
+fun stringSha256(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates sha256 of a constant string and takes the first 32 bits.
+/// Example: `const minihash = stringSha256_32("some_crypto_key")`
+/// Note: stringSha256_32(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringSha256_32(constString: slice): int
+    builtin;
+
+/// Compile-time function that takes N-chars ascii string and interprets it as a number in base 256.
+/// Example: `const value = stringToBase256("AB")` = 16706 (65*256 + 66)
+/// Note: stringToBase256(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringToBase256(constString: slice): int
+    builtin;
+
 /// Computes the representation hash of a `cell` [c] and returns it as a 256-bit unsigned integer `x`.
 /// Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.
 @pure
@@ -203,7 +246,7 @@ fun sliceHash(s: slice): int
 /// Computes sha256 of the data bits of `slice` [s]. If the bit length of `s` is not divisible by eight,
 /// throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.
 @pure
-fun stringHash(s: slice): int
+fun sliceBitsHash(s: slice): int
     asm "SHA256U";
 
 /// Checks the Ed25519-`signature` of a `hash` (a 256-bit unsigned integer, usually computed as the hash of some data)
@@ -333,6 +376,22 @@ fun debugDumpStack(): void
   When you _preload_ some data, you just get the result without mutating the slice.
  */
 
+/// Compile-time function that converts a constant string to TL-encoded MsgAddressInt (TVM slice).
+/// Example: stringAddressToSlice("EQCRDM9h4k3UJdOePPuyX40mCgA4vxge5Dc5vjBR8djbEKC5")
+/// Example: stringAddressToSlice("0:527964d55cfa6eb731f4bfc07e9d025098097ef8505519e853986279bd8400d8")
+/// Note: it's a compile-time function, `stringAddressToSlice(slice_var)` does not work.
+/// Use `parseStandardAddress` to decode a slice at runtime into workchain and hash.
+@pure
+fun stringAddressToSlice(constStringAddress: slice): slice
+    builtin;
+
+/// Compile-time function that converts a constant hex-encoded string to N/2 bytes.
+/// Example: `const v = stringHexToSlice("abcdef")` = slice with 3 bytes `[ 0xAB, 0xCD, 0xEF ]`
+/// Note: stringHexToSlice(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringHexToSlice(constStringBytesHex: slice): slice
+    builtin;
+
 /// Converts a `cell` [c] into a `slice`. Notice that [c] must be either an ordinary cell,
 /// or an exotic cell (see [TVM.pdf](https://ton-blockchain.github.io/docs/tvm.pdf), 3.1.2)
 /// which is automatically loaded to yield an ordinary cell `c'`, converted into a `slice` afterwards.
@@ -386,7 +445,7 @@ fun preloadBits(self: slice, len: int): slice
 
 /// Loads serialized amount of Toncoins (any unsigned integer up to `2^120 - 1`).
 @pure
-fun loadCoins(mutate self: slice): int
+fun loadCoins(mutate self: slice): coins
     asm( -> 1 0) "LDGRAMS";
 
 /// Loads bool (-1 or 0) from a slice
@@ -485,7 +544,7 @@ fun storeSlice(mutate self: builder, s: slice): self
 
 /// Stores amount of Toncoins into a builder.
 @pure
-fun storeCoins(mutate self: builder, x: int): self
+fun storeCoins(mutate self: builder, x: coins): self
     asm "STGRAMS";
 
 /// Stores bool (-1 or 0) into a builder.

crypto/smartcont/tolk-stdlib/gas-payments.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 0.9
+tolk 0.10
 
 /**
   Gas and payment related primitives.

crypto/smartcont/tolk-stdlib/lisp-lists.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 0.9
+tolk 0.10
 
 /**
     Lisp-style lists are nested 2-elements tuples: `(1, (2, (3, null)))` represents list `[1, 2, 3]`.

crypto/smartcont/tolk-stdlib/tvm-dicts.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 0.9
+tolk 0.10
 
 /**
     Dictionaries are represented as `cell` data type (cells can store anything, dicts in particular).

crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 0.9
+tolk 0.10
 
 /// Usually `c3` has a continuation initialized by the whole code of the contract. It is used for function calls.
 /// The primitive returns the current value of `c3`.

tolk-tester/tests/a6.tolk renamed to tolk-tester/tests/a-tests.tolk

@@ -4,7 +4,7 @@ fun f(a: int, b: int, c: int, d: int, e: int, f: int): (int, int) {
   __expect_type(D, "int");
   __expect_type(D*D, "int");
   __expect_type(calc_phi, "() -> int");
-  return (Dx/D,Dy/D);
+  return (Dx/D,Dy/D,);
 };;;;
 
 fun calc_phi(): int {
@@ -16,7 +16,7 @@ fun calc_phi(): int {
   do {
     (p,q)=(q,p+q);
   } while (q <= n); //;;
-  return mulDivRound(p, n, q);
+  return mulDivRound(p, n, q,);
 }
 
 fun calc_sqrt2(): int {
@@ -31,10 +31,10 @@ fun calc_sqrt2(): int {
   return mulDivRound(p, n, q);
 }
 
-fun calc_root(m: int) {
+fun calc_root(m: int,) {
   var base: int=1;
   repeat(70) { base *= 10; }
-  var (a, b, c) = (1,0,-m);
+  var (a, b, c) = (1,0,-m,);
   var (p1, q1, p2, q2) = (1, 0, 0, 1);
   do {
     var k: int=-1;
@@ -76,7 +76,7 @@ fun main(): int {
 }
 
 /**
-    method_id | in | out
+    method_id  | in | out
 @testcase | 0  |    | 31415926535897932384626433832795028841971693993751058209749445923078164
 
 @code_hash 84337043972311674339187056298873613816389434478842780265748859098303774481976

tolk-tester/tests/a6_1.tolk

@@ -47,7 +47,7 @@ fun test_call_1(x: int): (int, int, int, int, int, int, int) {
     return foo1(x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
 }
 
-fun foo2(x1: int, x2: int, x3456: (int, int, int, int), x7: int): (int, int, int, int, int, int, int) {
+fun foo2(x1: int, x2: int, x3456: (int, int, int, int), x7: int, ): (int, int, int, int, int, int, int) {
     var (x3: int, x4: int, x5: int, x6: int) = x3456;
     return (x1, x2, x3, x4, x5, x6, x7);
 }

tolk-tester/tests/a6_5.tolk

@@ -5,7 +5,7 @@ fun extractFromTypedTuple(params: [int]) {
 
 @method_id(101)
 fun test101(x: int) {
-    var params = [x];
+    var params = [x, ];
     return extractFromTypedTuple(params);
 }
 
@@ -38,7 +38,7 @@ fun getTensor_1X(x: int) {
 }
 fun getTuple_12() {
     callOrder.tuplePush(110);
-    return [1, 2];
+    return [1, 2, ];
 }
 fun getTuple_1X(x: int) {
     callOrder.tuplePush(111);
@@ -133,7 +133,7 @@ fun test108() {
 fun test109() {
     callOrder = createEmptyTuple();
     var x = 0;
-    [getTuple_12().0, getTuple_1X(x = getIntValue5()).1, getTuple_1X(x += 10).0] = [getIntValue5(), getIntValue5(), getIntValueX(x)];
+    [getTuple_12().0, getTuple_1X(x = getIntValue5()).1, getTuple_1X(x += 10).0] = [getIntValue5(), getIntValue5(), getIntValueX(x), ];
     return (callOrder, x);
 }
 
@@ -203,9 +203,18 @@ fun test116() {
     return (a, b, c, d, rhs2);
 }
 
+@method_id(117)
+fun test117() {
+    var c = [((1, ), ), ];
+    __expect_type(c, "[int]");
+    c.0 = 10;
+    c.0 = (20, );
+    return c;
+}
+
 
 
-fun main(value: int) {
+fun main(value: int, ) {
     var (x: int?, y) = (autoInferIntNull(value), autoInferIntNull(value * 2));
     if (x == null && y == null) { return null; }
     return x == null || y == null ? -1 : x! + y!;
@@ -231,6 +240,7 @@ fun main(value: int) {
 @testcase | 114 |        | 13 [ 1 14 ] 1 3
 @testcase | 115 |        | [ 101 111 ] 9 9
 @testcase | 116 |        | 1 2 3 4 [ 1 2 3 4 ]
+@testcase | 117 |        | [ 20 ]
 
 
 @fif_codegen

tolk-tester/tests/a7.tolk

@@ -0,0 +1,48 @@
+fun takeAnySlice(slice: slice) {}
+fun getSomeSlice() { return beginCell().endCell().beginParse(); }
+fun getNullableBytes16(): bytes16? { return getSomeSlice() as bytes16; }
+
+const someBytes = "asdf" as bytes16;
+const anotherBytes: bytes16 = "asdf" as bytes16;
+
+fun autoInferBytes16() {
+    if (random()) { return someBytes; }
+    else if (random()) { return true ? "" as bytes16 : anotherBytes; }
+    else { return someBytes!; }
+}
+
+@method_id(101)
+fun test1() {
+    var ss = beginCell().storeInt(1, 32).storeInt(2, 32).endCell().beginParse() as bits32;
+    __expect_type(ss, "bits32");
+    __expect_type(ss as slice, "slice");
+    __expect_type(ss as slice?, "slice?");
+    __expect_type(ss as bytes128, "bytes128");
+    __expect_type(someBytes, "bytes16");
+    __expect_type(10>3 ? (null, ss as bits1) : (ss as bytes1, null), "(bytes1?, bits1?)");
+    return (getRemainingBitsCount(ss as slice), loadInt(mutate ss as slice, 32), (ss as slice).loadInt(32));
+}
+
+fun test2(a: bytes8, b: bits64) {
+    a = b as bytes8;
+    b = a as bits64;
+    (a as slice).loadRef();
+    (b as slice?)!.loadRef();
+}
+
+@method_id(103)
+fun test3() {
+    var slice = beginCell().storeInt(1, 32).storeInt(2, 32).endCell().beginParse();
+    var bq = slice as bits16?;
+    if (bq != null) {
+        return (bq as slice).loadInt(32 as uint8) + (slice = bq as slice).getRemainingBitsCount();
+    }
+    return -1;
+}
+
+fun main() {}
+
+/**
+@testcase | 101 |    | 64 1 2
+@testcase | 103 |    | 33
+ */