@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/src/funC++/actions/utils.fc

@@ -16,8 +16,8 @@ tuple emptyActions() inline {
         .store_slice(hashpartToBasechainAddressStd(toAddress))
         .store_coins(0);
     b = stateInit.is_null()
-    ? b.store_uint(1, 107)
-    : b.store_uint(7, 108).store_ref(stateInit);
+        ? b.store_uint(1, 107)
+        : b.store_uint(7, 108).store_ref(stateInit);
     send_raw_message(b.store_ref(messageBody).end_cell(), CARRY_ALL_BALANCE | extraFlags);
 }
 

package/src/funC++/classlib.fc

@@ -36,10 +36,10 @@ const int _DATA_OFFSET_WIDTH = 10; ;; 1023 bits per cell = 2**10 - 1
 const int _REF_OFFSET_WIDTH = 2; ;; each cell can have up to 4 refs
 const int _FIELD_INFO_WIDTH = _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH + _REF_OFFSET_WIDTH;
 const int _MAX_CLASS_FIELDS = 15; ;; reserve 0xff for the "invalid" object field name
-const int INVALID_CLASS_MEMBER = 16;
+const int INVALID_CLASS_MEMBER = 15;
 const int _HEADER_WIDTH = _BASIC_HEADER_WIDTH + _MAX_CLASS_FIELDS * _FIELD_INFO_WIDTH;
 
-;; declarations require a tuple of the form [[ name, type, val ], ...]
+;; declarations require a tuple of the form [[ type, val ], ...]
 const int FIELD_TYPE_IDX = 0;
 const int FIELD_VAL_IDX = 1;
 
@@ -127,7 +127,7 @@ int cl::typeof(cell $obj) inline method_id {
     return $obj.begin_parse().preload_uint(_NAME_WIDTH);
 }
 
-cell cl::declare(int name, tuple fields) inline {
+cell cl::declare(int name, tuple fields) impure inline {
     ;; Initialize a tuple with [null, empty_builder] to store cell builders
     tuple classBuilder = unsafeTuple([null(), begin_cell()]);
 
@@ -139,7 +139,7 @@ cell cl::declare(int name, tuple fields) inline {
     ;; Initialize tracking variables
     int curDataCell = 1;                ;; Current cell for storing data fields
     int curRefCell = 1;                 ;; Current cell for storing reference fields
-    ;; root node is special as it only allows two refs (1 for header, 1 for rest of obj)
+    ;; root node is special as it only allows two ref fields
     int curCellMaxRefs = 2;             ;; Max references allowed in current cell 
     int curDataOffset = _HEADER_WIDTH;  ;; Current bit offset in data cell
     int curRefOffset = 0;               ;; Current reference offset in ref cell
@@ -309,9 +309,10 @@ forall X -> cell cl::set(cell $self, int fieldName, X val) inline method_id {
     int fieldCellIndex = headerSlice.cl::getFieldCellIndex::asm(fieldInfoOffset);
     int fieldType = headerSlice.cl::getFieldType::asm(fieldInfoOffset);
     int fieldOffset = headerSlice.cl::getFieldOffset::asm(fieldInfoOffset);
-    int fieldRefsOffset = headerSlice.cl::getFieldCellOffset::asm(fieldInfoOffset );
+    int fieldRefsOffset = headerSlice.cl::getFieldCellOffset::asm(fieldInfoOffset);
 
     int fieldWidth = _getTypeWidth(fieldType);
+
     slice victim = fieldCellIndex == 0
         ? headerSlice
         : headerSlice.preload_ref_at(fieldCellIndex).begin_parse();
@@ -331,7 +332,8 @@ forall X -> cell cl::set(cell $self, int fieldName, X val) inline method_id {
         replacement = replacement
             .store_ref(val.cast_to_cell())
             .store_slice(victim.scutlast(0, victim.slice_refs() - fieldRefsOffset - 1));
-    } else { ;; numeric type
+    } else {
+        ;; numeric type
         replacement = replacement
             .store_uint(abs(val.cast_to_int()), fieldWidth)
             .store_slice(victim.sskipfirst(fieldOffset + fieldWidth, victim.slice_refs()));
@@ -357,17 +359,6 @@ const int _FIELD_TYPE_WIDTH = 4; ;; support up to 16 types
 const int _CELL_ID_WIDTH = 2; ;; the classlib backend supports up to 4 inner cells including root
 const int _DATA_OFFSET_WIDTH = 10; ;; 1023 bits per cell = 2**10 - 1
 
-;; int cl::get<uint>::asm_t( int width, int fieldName, tuple self) asm """
-;; // DUMPSTK      // STACK [s, fieldName, width]
-;; 0 INDEX         // cell cell_at(tuple t, int index) => STACK [cellResult, fieldName, width]
-;; CTOS            // slice begin_parse(cell c) => STACK [sliceResult, fieldName, width]
-;; s1 XCHG0        // STACK [fieldName, sliceResult, width]
-;; 18 MULCONST     // STACK [_FIELD_INFO_WIDTH*fieldName, sliceResult, width]
-;; 84 ADDCONST     // STACK [_BASIC_HEADER_WIDTH + _FIELD_TYPE_WIDTH + (_FIELD_INFO_WIDTH*fieldName) = fieldInfoOffset, mulRes, sliceResult, width]
-;; s1 s1 s1 XCHG3  // STACK [width, fieldInfoOffset,  sliceResult]
-;; SDSUBSTR        // STACK [preloadBitsOffsetResult]
-;; 10 PLDU         // STACK [fieldCellIndex]
-;; """;
 
 int cl::get<uint>(cell $self, int fieldName, int width) inline method_id {
     slice headerSlice = $self.begin_parse();
@@ -386,19 +377,18 @@ int cl::get<uint>(cell $self, int fieldName, int width) inline method_id {
 cell cl::get<cellRef>(cell $self, int fieldName) inline method_id {
     slice headerSlice = $self.begin_parse();
     int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
-    int fieldCellIndex = headerSlice.cl::getFieldCellIndex::asm(
-        fieldInfoOffset);
-    int fieldRefIdx = headerSlice
-        .cl::getFieldCellOffset::asm(
-            fieldInfoOffset);
-
-    return fieldCellIndex == 0
-        ? headerSlice.preload_ref_at(fieldRefIdx)
-        : (headerSlice
-            .preload_ref_at(fieldCellIndex)
-            .begin_parse()
-            .preload_ref_at(fieldRefIdx)
-        );
+    int fieldCellIndex = headerSlice.cl::getFieldCellIndex::asm(fieldInfoOffset);
+    int fieldRefIdx = headerSlice.cl::getFieldCellOffset::asm(fieldInfoOffset);
+
+    if (fieldCellIndex == 0) {
+        return headerSlice.preload_ref_at(fieldRefIdx);
+    }
+
+    return headerSlice
+        .preload_ref_at(fieldCellIndex)
+        .begin_parse()
+        .preload_ref_at(fieldRefIdx)
+    ;
 }
 
 cell cl::get<objRef>(cell $self, int fieldName) inline method_id {
@@ -645,7 +635,7 @@ cell cl::dict256::delete(cell dict, int key) {
 ;; if the val exists, it is returned
 ;; if a val does not exist, null() is returned
 
-(int, slice) cl::dict256::getMin<slice>(cell dict256) {
+(int, slice) cl::dict256::getMin<slice>(cell dict256) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -656,7 +646,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-(int, int) cl::dict256::getMin<uint256>(cell dict256) {
+(int, int) cl::dict256::getMin<uint256>(cell dict256) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -667,7 +657,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-(int, cell) cl::dict256::getMin<cellRef>(cell dict256) {
+(int, cell) cl::dict256::getMin<cellRef>(cell dict256) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -678,7 +668,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-(int, slice) cl::dict256::getNext<slice>(cell dict256, int pivot) {
+(int, slice) cl::dict256::getNext<slice>(cell dict256, int pivot) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -689,7 +679,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-(int, int) cl::dict256::getNext<uint256>(cell dict256, int pivot) {
+(int, int) cl::dict256::getNext<uint256>(cell dict256, int pivot) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -700,7 +690,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-(int, cell) cl::dict256::getNext<cellRef>(cell dict256, int pivot) {
+(int, cell) cl::dict256::getNext<cellRef>(cell dict256, int pivot) impure inline {
     if (dict256.cell_is_empty()) {
         return (-1, null());
     }
@@ -711,7 +701,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-int cl::dict256::size(cell dict) inline method_id {
+int cl::dict256::size(cell dict) impure inline method_id {
     int count = 0;
     (int pivot, _) = dict.cl::dict256::getMin<slice>();
     while (pivot >= 0) {
@@ -723,7 +713,7 @@ int cl::dict256::size(cell dict) inline method_id {
 
 ;;; ====================== Nested Dict Helpers ======================
 
-forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) inline {
+forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) impure inline {
     return $self.cl::set(
         fieldName,
         $self
@@ -732,29 +722,29 @@ forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X va
     );
 }
 
-cell cl::nestedDict256::setRef(cell $self, int fieldName, int key, cell val) inline {
+cell cl::nestedDict256::setRef(cell $self, int fieldName, int key, cell val) impure inline {
     return $self.cl::set(
         fieldName,
         $self.cl::get<dict256>(fieldName).cl::dict256::setRef(key, val)
     );
 }
 
-cell cl::nestedDict256::delete(cell $self, int fieldName, int key) inline {
+cell cl::nestedDict256::delete(cell $self, int fieldName, int key) impure inline {
     return $self.cl::set(
         fieldName,
         $self.cl::get<dict256>(fieldName).cl::dict256::delete(key)
     );
 }
 
-(int, int) cl::nestedDict256::get<uint256>(cell $self, int fieldName, int key) inline {
+(int, int) cl::nestedDict256::get<uint256>(cell $self, int fieldName, int key) impure inline {
     return $self.cl::get<dict256>(fieldName).cl::dict256::get<uint256>(key);
 }
 
-(slice, int) cl::nestedDict256::get<slice>(cell $self, int fieldName, int key) inline {
+(slice, int) cl::nestedDict256::get<slice>(cell $self, int fieldName, int key) impure inline {
     return $self.cl::get<dict256>(fieldName).cl::dict256::get(key);
 }
 
-(cell, int) cl::nestedDict256::get<cellRef>(cell $self, int fieldName, int key) inline {
+(cell, int) cl::nestedDict256::get<cellRef>(cell $self, int fieldName, int key) impure inline {
     (slice s, int exists) = $self.cl::get<dict256>(fieldName).cl::dict256::get(key);
     if (exists) {
         return (s.preload_first_ref(), true);

package/src/funC++/constants.fc

@@ -10,10 +10,10 @@ const int MAX_U128  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 const int MAX_U256  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 const int MAX_COINS = 1329227995784915872903807060280344575; ;; 2^120 - 1
 
-const ADDR_TYPE_NONE = 0;
-const ADDR_TYPE_EXTERN = 1;
-const ADDR_TYPE_STD = 2;
-const ADDR_TYPE_VAR = 3;
+const int ADDR_TYPE_NONE = 0;
+const int ADDR_TYPE_EXTERN = 1;
+const int ADDR_TYPE_STD = 2;
+const int ADDR_TYPE_VAR = 3;
 
 const int TRUE = -1;
 const int FALSE = 0;
@@ -26,39 +26,39 @@ const int SEND_MSG_BOUNCEABLE = 0x18;
 const int SEND_MSG_NON_BOUNCEABLE = 0x10;
 
 ;; MODIFIER
-const NORMAL = 0;
-const PAID_EXTERNALLY = 1;
-const IGNORE_ERRORS = 2;
+const int NORMAL = 0;
+const int PAID_EXTERNALLY = 1;
+const int IGNORE_ERRORS = 2;
 
 ;; SEND MODES
-const BOUNCE_IF_FAIL = 16;
-const DESTROY_IF_ZERO = 32;
-const CARRY_REMAINING_GAS = 64;
-const CARRY_ALL_BALANCE = 128;
+const int BOUNCE_IF_FAIL = 16;
+const int DESTROY_IF_ZERO = 32;
+const int CARRY_REMAINING_GAS = 64;
+const int CARRY_ALL_BALANCE = 128;
 
 ;; SENDMSG modes
-const SUB_BALANCE_MSG = 64;
-const SUB_BALANCE_CONTRACT = 128;
-const ONLY_ESTIMATE_FEES = 1024;
+const int SUB_BALANCE_MSG = 64;
+const int SUB_BALANCE_CONTRACT = 128;
+const int ONLY_ESTIMATE_FEES = 1024;
 
 ;; SEND MODES QUIETED
-const QDESTROY_IF_ZERO = 34;
-const QCARRY_REMAINING_GAS = 66;
-const QCARRY_ALL_BALANCE = 130;
+const int QDESTROY_IF_ZERO = 34;
+const int QCARRY_REMAINING_GAS = 66;
+const int QCARRY_ALL_BALANCE = 130;
 
-const RESERVE_EXACTLY    = 0;
-const RESERVE_ALL_EXCEPT = 1;
-const RESERVE_AT_MOST    = 2;
-const EXTRN_DO_NOT_FAIL  = 2;
-const BALANCE_INCREASED  = 4;
-const BALANCE_DECREASED  = 8;
+const int RESERVE_EXACTLY    = 0;
+const int RESERVE_ALL_EXCEPT = 1;
+const int RESERVE_AT_MOST    = 2;
+const int EXTRN_DO_NOT_FAIL  = 2;
+const int BALANCE_INCREASED  = 4;
+const int BALANCE_DECREASED  = 8;
 const int RESERVE_BOUNCE_ON_ACTION_FAIL = 16;
 
 ;; a lot of different constants, because arithmetic manipulation of constants is not optimized
-const MAX_CELL_BITS = 1023;
-const MAX_CELL_BYTES = 127;
-const MAX_CELL_WHOLE_BYTE_BITS = MAX_CELL_BYTES * 8;
-const MAX_CELL_BIT_INDEX = 1022;
-const MAX_CELL_REFS = 4;
+const int MAX_CELL_BITS = 1023;
+const int MAX_CELL_BYTES = 127;
+const int MAX_CELL_WHOLE_BYTE_BITS = MAX_CELL_BYTES * 8;
+const int MAX_CELL_BIT_INDEX = 1022;
+const int MAX_CELL_REFS = 4;
 
 const int NULLADDRESS = 0;

package/src/funC++/dataStructures/PipelinedOutOfOrder.fc

@@ -11,6 +11,62 @@ const int POOO::bitmap = 1;
 
 const int POOO::ERROR::negativeIndex = 1153;
 
+cell POOO::New() impure inline method_id {
+    return cl::declare(
+        POOO::NAME,
+        unsafeTuple([
+            [cl::t::uint64, 1], ;; nextEmpty
+            [cl::t::cellRef, begin_cell().store_zeroes(MAX_CELL_BITS).end_cell()] ;; bitmap
+        ])
+    );
+}
+
+const int POOO::_headerInfoBits = _BASIC_HEADER_WIDTH + (_FIELD_INFO_WIDTH * 2);
+const int POOO::_headerFillerBits = _HEADER_WIDTH - POOO::_headerInfoBits;
+const int POOO::_headerInfo = 92590899976783941628;
+
+cell POOO::buildFull(int nextEmpty, cell bitmap) impure inline {
+    return begin_cell()
+        .store_uint(POOO::_headerInfo, POOO::_headerInfoBits)       ;; header info
+        .store_ones(POOO::_headerFillerBits)                        ;; header filler
+        .store_uint64(nextEmpty)                                    ;; nextEmpty
+        .store_ref(bitmap)                                          ;; bitmap
+        .end_cell();
+}
+
+;; ========================== Object Getters ==========================
+
+const int POOO::_nextEmptyOffset = _HEADER_WIDTH;
+
+int POOO::getNextEmpty(cell $self) impure inline {
+    return $self.cellPreloadUint64At(POOO::_nextEmptyOffset);
+}
+
+int POOO::maxSettableBit(cell $self) impure inline {
+    return $self.POOO::getNextEmpty() + MAX_CELL_BIT_INDEX;
+}
+
+;; ========================== Object Multi-Getters ==========================
+
+;; returns (nextEmpty, bitmap.slice)
+(int, slice) POOO::deserialize(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadUint64At(POOO::_nextEmptyOffset),
+        selfSlice.preloadRefSliceAt(0)
+    );
+}
+
+;; ========================== Object Utils ==========================
+
+int POOO::isBitSet(cell $self, int absoluteIdx) impure inline {
+    (int nextEmpty, slice bitmap) = POOO::deserialize($self);
+    int relativeIdx = absoluteIdx - nextEmpty;
+    return bitmap.preloadBoolAt(relativeIdx);
+}
+
+;; ========================== Object Setters ==========================
+
 ;; Algorithm:
 ;; 1. Extract the first `index` bits from the original bitmap.
 ;; 2. Append a '1' bit to the extracted bits.
@@ -28,11 +84,11 @@ const int POOO::ERROR::negativeIndex = 1153;
 cell POOO::set(cell $self, int absoluteIndex) impure inline method_id {
     throw_if(POOO::ERROR::negativeIndex, absoluteIndex < 0);
 
-    slice bitmapSlice = $self.cl::get<cellRef>(POOO::bitmap).begin_parse();
-    int nextEmpty = $self.cl::get<uint64>(POOO::nextEmpty);
+    (int nextEmpty, slice bitmapSlice) = POOO::deserialize($self);
     if (absoluteIndex < nextEmpty) {
         return $self;
     }
+
     int index = absoluteIndex - nextEmpty;
 
     (int leadingOnes, slice remainingBitmap) = ldones(
@@ -42,20 +98,19 @@ cell POOO::set(cell $self, int absoluteIndex) impure inline method_id {
             .store_slice(scutlast(bitmapSlice, MAX_CELL_BITS - index - 1, 0))
             .as_slice()
     );
-    return $self
-        .cl::set(
-            POOO::bitmap,
-            begin_cell()
-                .store_slice(remainingBitmap)
-                .store_zeroes(leadingOnes)
-                .end_cell()
-        )
-        .cl::set(POOO::nextEmpty, nextEmpty + leadingOnes);
+    
+    return POOO::buildFull(
+        nextEmpty + leadingOnes,
+        begin_cell()
+            .store_slice(remainingBitmap)
+            .store_zeroes(leadingOnes)
+        .end_cell()
+    );
 }
 
 cell POOO::unsafeSetBits(cell $self, int start, int end) impure inline method_id {
-    slice bitmapSlice = $self.cl::get<cellRef>(POOO::bitmap).begin_parse();
-    int nextEmpty = $self.cl::get<uint64>(POOO::nextEmpty);
+    (int nextEmpty, slice bitmapSlice) = POOO::deserialize($self);
+
     int startIndex = start - nextEmpty;
     int endIndex = end - nextEmpty;
 
@@ -66,51 +121,12 @@ cell POOO::unsafeSetBits(cell $self, int start, int end) impure inline method_id
             .store_slice(scutlast(bitmapSlice, MAX_CELL_BITS - endIndex, 0))
             .as_slice()
     );
-    return $self
-        .cl::set(
-            POOO::bitmap,
-            begin_cell()
-                .store_slice(remainingBitmap)
-                .store_zeroes(leadingOnes)
-                .end_cell()
-        )
-        .cl::set(POOO::nextEmpty, nextEmpty + leadingOnes);
-}
-
-cell POOO::New() inline method_id {
-    return cl::declare(
-        POOO::NAME,
-        unsafeTuple([
-            [cl::t::uint64, 1], ;; nextEmpty
-            [cl::t::cellRef, begin_cell().store_zeroes(MAX_CELL_BITS).end_cell()] ;; bitmap
-        ])
-    );
-}
-
-cell POOO::NewWithBitsSets(int startingBit, int endingBit) method_id {
-    return cl::declare(
-        POOO::NAME,
-        unsafeTuple([
-            [cl::t::uint64, 1],
-            [cl::t::cellRef, begin_cell()
-                .store_zeroes(1)
-                .store_ones(endingBit - startingBit)
-                .store_zeroes(MAX_CELL_BITS - endingBit)
-                .end_cell()
-            ]
-        ])
+    
+    return POOO::buildFull(
+        nextEmpty + leadingOnes,
+        begin_cell()
+            .store_slice(remainingBitmap)
+            .store_zeroes(leadingOnes)
+        .end_cell()
     );
-}
-
-int POOO::isBitSet(cell $self, int absoluteIdx) inline method_id {
-    int relativeIdx = absoluteIdx - $self.cl::get<uint64>(POOO::nextEmpty);
-    return $self
-        .cl::get<cellRef>(POOO::bitmap)
-        .begin_parse()
-        .preload_bits_offset(relativeIdx, 1)
-        .preload_uint(1) == 1;
-}
-
-int POOO::maxSettableBit(cell $self) inline method_id {
-    return $self.cl::get<uint64>(POOO::nextEmpty) + MAX_CELL_BIT_INDEX;
 }

package/src/funC++/stdlib.fc

@@ -1,6 +1,21 @@
 ;; Standard library for funC
 ;;
 
+{-
+    This file is part of TON FunC Standard Library.
+
+    FunC Standard Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    FunC Standard Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+-}
+
 {-
   # Tuple manipulation primitives
   The names and the types are mostly self-explaining.
@@ -108,7 +123,7 @@ forall X -> (X, ()) ~impure_touch(X x) impure asm "NOP";
 int now() asm "NOW";
 
 ;;; Returns the internal address of the current smart contract as a Slice with a `MsgAddressInt`.
-;;; If necessary, it can be parsed further using primitives such as [parseStdAddress].
+;;; If necessary, it can be parsed further using primitives such as [parse_std_addr].
 slice my_address() asm "MYADDR";
 
 ;;; Returns the balance of the smart contract as a tuple consisting of an int
@@ -229,7 +244,7 @@ cont bless(slice s) impure asm "BLESS";
 ;;; In other words, the current smart contract agrees to buy some gas to finish the current transaction.
 ;;; This action is required to process external messages, which bring no value (hence no gas) with themselves.
 ;;;
-;;; For more details check [accept_message effects](https://ton.org/docs/#/smart-contracts/accept).
+;;; For more details check [accept_message effects](https://docs.ton.org/develop/smart-contracts/guidelines/accept).
 () accept_message() impure asm "ACCEPT";
 
 ;;; Sets current gas limit `gl` to the minimum of limit and `gm`, and resets the gas credit `gc` to zero.
@@ -267,10 +282,10 @@ int abs(int x) asm "ABS";
 
   It is said that a primitive _loads_ some data,
   if it returns the data and the remainder of the slice
-  (so it can also be used as [modifying method](https://ton.org/docs/#/func/statements?id=modifying-methods)).
+  (so it can also be used as [modifying method](https://docs.ton.org/develop/func/statements#modifying-methods)).
 
   It is said that a primitive _preloads_ some data, if it returns only the data
-  (it can be used as [non-modifying method](https://ton.org/docs/#/func/statements?id=non-modifying-methods)).
+  (it can be used as [non-modifying method](https://docs.ton.org/develop/func/statements#non-modifying-methods)).
 
   Unless otherwise stated, loading and preloading primitives read the data from a prefix of the slice.
 -}
@@ -290,13 +305,13 @@ slice begin_parse(cell c) asm "CTOS";
 ;;; Preloads the first reference from the slice.
 cell preload_ref(slice s) asm "PLDREF";
 
-  {- Functions below are commented because are implemented on compilator level for optimisation -}
+{- Functions below are commented because are implemented on compilator level for optimisation -}
 
 ;;; Loads a signed [len]-bit integer from a slice [s].
 ;; (slice, int) ~load_int(slice s, int len) asm(s len -> 1 0) "LDIX";
 
 ;;; Loads an unsigned [len]-bit integer from a slice [s].
-(slice, int) ~load_uint(slice s, int len) asm( -> 1 0) "LDUX";
+;; (slice, int) ~load_uint(slice s, int len) asm( -> 1 0) "LDUX";
 
 ;;; Preloads a signed [len]-bit integer from a slice [s].
 ;; int preload_int(slice s, int len) asm "PLDIX";
@@ -310,7 +325,7 @@ cell preload_ref(slice s) asm "PLDREF";
 ;;; Preloads the first `0 ≤ len ≤ 1023` bits from slice [s] into a separate `slice s''`.
 ;; slice preload_bits(slice s, int len) asm "PLDSLICEX";
 
-;;; Loads serialized amount of TonCoins (any unsigned integer up to `2^128 - 1`).
+;;; Loads serialized amount of TonCoins (any unsigned integer up to `2^120 - 1`).
 (slice, int) load_grams(slice s) asm( -> 1 0) "LDGRAMS";
 (slice, int) load_coins(slice s) asm( -> 1 0) "LDGRAMS";
 
@@ -337,6 +352,7 @@ cell preload_dict(slice s) asm "PLDDICT";
 
 ;;; Loads a dictionary as [load_dict], but returns only the remainder of the slice.
 slice skip_dict(slice s) asm "SKIPDICT";
+(slice, ()) ~skip_dict(slice s) asm "SKIPDICT";
 
 ;;; Loads (Maybe ^Cell) from `slice` [s].
 ;;; In other words loads 1 bit and if it is true
@@ -401,7 +417,7 @@ int builder_depth(builder b) asm "BDEPTH";
   # Builder primitives
   It is said that a primitive _stores_ a value `x` into a builder `b`
   if it returns a modified version of the builder `b'` with the value `x` stored at the end of it.
-  It can be used as [non-modifying method](https://ton.org/docs/#/func/statements?id=non-modifying-methods).
+  It can be used as [non-modifying method](https://docs.ton.org/develop/func/statements#non-modifying-methods).
 
   All the primitives below first check whether there is enough space in the `builder`,
   and only then check the range of the value being serialized.
@@ -426,7 +442,7 @@ builder store_ref(builder b, cell c) asm(c b) "STREF";
 ;;; Stores `slice` [s] into `builder` [b]
 builder store_slice(builder b, slice s) asm "STSLICER";
 
-;;; Stores (serializes) an integer [x] in the range `0..2^128 − 1` into `builder` [b].
+;;; Stores (serializes) an integer [x] in the range `0..2^120 − 1` into `builder` [b].
 ;;; The serialization of [x] consists of a 4-bit unsigned big-endian integer `l`,
 ;;; which is the smallest integer `l ≥ 0`, such that `x < 2^8l`,
 ;;; followed by an `8l`-bit unsigned big-endian representation of [x].
@@ -611,7 +627,7 @@ int rand(int range) impure asm "RAND";
 ;;; Returns the current random seed as an unsigned 256-bit Integer.
 int get_seed() impure asm "RANDSEED";
 ;;; Sets the random seed to unsigned 256-bit seed.
-() set_seed(int x) impure asm "SETRAND";
+() set_seed(int) impure asm "SETRAND";
 ;;; Mixes unsigned 256-bit integer x into the random seed r by setting the random seed to sha256 of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed r, and the second with the big-endian representation of x.
 () randomize(int x) impure asm "ADDRAND";
 ;;; Equivalent to randomize(cur_lt());.
@@ -619,7 +635,6 @@ int get_seed() impure asm "RANDSEED";
 
 ;;; Checks whether the data parts of two slices coinside
 int equal_slice_bits(slice a, slice b) asm "SDEQ";
-int equal_slices(slice a, slice b) asm "SDEQ";
 
 ;;; Concatenates two builders
 builder store_builder(builder to, builder from) asm "STBR";

package/src/funC++/testutils.fc

@@ -61,11 +61,11 @@ cell _garbigify(cell $input, cell garbage) impure {
     ;; Should never happen as the above checks and returns from all cases
     ;; The compiler needs you to return from all possible control flows
     ;; and it isn't smart enough to know that this will never be reached.
-    ~strdump("garbigify: this print should never happen");
+    throw("garbigify: this print should never happen"c);
     return empty_cell();
 }
 
-() profile_gas(var func, tuple args) {
+() profile_gas(var func, tuple args) impure {
     int gas_consumed = get_gas_consumed();
     int gas_consumed_consumed = get_gas_consumed();
     int gas_consumed_of_gas_consumed = gas_consumed_consumed - gas_consumed;

package/src/funC++/txnContext.fc

@@ -2,19 +2,19 @@
 
 global tuple txnContext;
 
-const _IS_BOUNCED = 0;
-const _CALLER = 1;
-const _FWD_FEE = 2;
-const _OPCODE = 3;
-const _QUERY_ID = 4;
-const _BALANCE = 5;
-const _MSG_VALUE = 6;
-const _BODY = 7;
-const _RAW_MSG = 8;
-const _ORIGIN = 9;
-const _DONATION_NANOS = 10;
-const _MD = 11;
-const _VALUE_OUTFLOW = 12;
+const int _IS_BOUNCED = 0;
+const int _CALLER = 1;
+const int _FWD_FEE = 2;
+const int _OPCODE = 3;
+const int _QUERY_ID = 4;
+const int _BALANCE = 5;
+const int _MSG_VALUE = 6;
+const int _BODY = 7;
+const int _RAW_MSG = 8;
+const int _ORIGIN = 9;
+const int _DONATION_NANOS = 10;
+const int _MD = 11;
+const int _VALUE_OUTFLOW = 12;
 
 int getMsgValue() inline {
     return txnContext.int_at(_MSG_VALUE);
@@ -84,7 +84,7 @@ cell getMsgData() inline {
     slice _sender_address = cs~load_msg_addr();
     cs~load_msg_addr();
     cs~load_coins();
-    cs~skip_bits(1);
+    cs~skip_dict();
     cs~load_coins();
     int senderAddress = basechainAddressStdToHashpart(_sender_address);