@layerzerolabs/layerzero-v2-ton 3.0.12-ton.0

package/src/funC++/classlib.fc

@@ -0,0 +1,819 @@
+#include "utils.fc";
+#include "constants.fc";
+#include "stdlib.fc";
+#include "stringlib.fc";
+
+;; Types for storage abstraction
+const int cl::t::bool = 0;
+const int cl::t::uint8 = 3;
+const int cl::t::uint16 = 4;
+const int cl::t::uint32 = 5;
+const int cl::t::uint64 = 6;
+const int cl::t::coins = 7; ;; fixed-width uint128, because we are civilized people
+const int cl::t::uint256 = 8;
+const int cl::t::address = cl::t::uint256;
+const int cl::t::cellRef = 9;
+const int cl::t::dict256 = cl::t::cellRef;
+const int cl::t::objRef = cl::t::cellRef;
+const int INVALID_TYPE = 13;
+
+const int DICT256_KEYLEN = 256;
+
+const int cl::NULL_CLASS_NAME = "NULL"u;
+
+const int cl::ERROR::INVALID_CLASS = "cl::ERROR::INVALID_CLASS"c & ERRORCODE_MASK;
+
+const int DEBUG = 0;
+
+const int MAX_NAME_LEN = 10; ;; each name can be up to 10 characters long
+const int _NAME_WIDTH = 8 * MAX_NAME_LEN; ;; convert to bits
+const int _BASIC_HEADER_WIDTH = _NAME_WIDTH;
+const int MAX_NAME_INTLEN = (1 << (8 * MAX_NAME_LEN)) - 1;
+
+const int _FIELD_TYPE_WIDTH+_CELL_ID_WIDTH = 6; ;; support up to 16 types
+
+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
+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 _HEADER_WIDTH = _BASIC_HEADER_WIDTH + _MAX_CLASS_FIELDS * _FIELD_INFO_WIDTH;
+
+;; declarations require a tuple of the form [[ name, type, val ], ...]
+const int FIELD_TYPE_IDX = 0;
+const int FIELD_VAL_IDX = 1;
+
+;;; ====================== Address functions ======================
+int basechainAddressStdToHashpart(slice full_address) inline {
+    (int wc, int hp) = parseStdAddress(full_address);
+    if (DEBUG) {
+        throw_unless(0, wc == BASECHAIN);
+    }
+    return hp;
+}
+
+slice hashpartToBasechainAddressStd(int hashpart) inline {
+    return begin_cell()
+        .store_uint(4, 3) ;; 0b100
+        .store_int(BASECHAIN, 8)
+        .store_uint(hashpart, 256)
+        .as_slice();
+}
+
+int getContractAddress() impure inline {
+    return my_address().preload_bits_offset(11, 256).preload_uint(256);
+}
+
+slice cl::objToSlice(cell $obj) inline method_id {
+    return $obj.begin_parse();
+}
+
+;;; ====================== Class functions ======================
+;; returns type width in bits
+int _getTypeWidth(int clType) inline {
+    if (clType <= cl::t::uint256) {
+        return 1 << clType; ;; type names are set up so this is true
+    }
+    ;; all other types are ref types with 0 data bits
+    return 0;
+}
+
+int cl::hash(cell $obj) impure inline {
+    return $obj.cell_hash();
+}
+
+int cl::isNull(cell $obj) impure inline {
+    return $obj.cell_is_empty();
+}
+
+;; checks if a class lib object is flat, and contains no 'refs'
+;; null is considered 'flat'
+int cl::noRefFields(cell $obj) {
+    slice headerSlice = $obj.begin_parse();
+    int numRefs = headerSlice.slice_refs();
+
+    if (numRefs == 0) {
+        return true;
+    } elseif (numRefs <= 2) {
+        ;; if there are refs, the struct is not flat
+        return false;
+    }
+
+    if (numRefs >= 3) {
+        if (
+            (headerSlice.preload_ref_at(0).cell_is_empty() == false)
+            | (headerSlice.preload_ref_at(1).cell_is_empty() == false)
+            | (headerSlice.preload_ref_at(2).begin_parse().slice_refs() != 0)
+        ) {
+            ;; if there is 1 structural node, that structural node must have 0 refs
+            return false;
+        }
+    }
+
+    if (numRefs >= 4) {
+        if (headerSlice.preload_ref_at(3).begin_parse().slice_refs() != 0) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+int cl::equalObjTypeShallow(cell $a, cell $b) {
+    slice aSlice = $a.begin_parse();
+    slice bSlice = $b.begin_parse();
+    int aRefs = aSlice.slice_refs();
+
+    if (
+        (aRefs != bSlice.slice_refs())
+        | (aSlice.slice_bits() != bSlice.slice_bits())
+    ) {
+        return false;
+    }
+
+    int refIndex = 2;
+    while (refIndex < aRefs) {
+        if (
+            (aSlice.preload_ref_at(refIndex).begin_parse().slice_refs() != bSlice.preload_ref_at(refIndex).begin_parse().slice_refs())
+            | (aSlice.preload_ref_at(refIndex).begin_parse().slice_bits() != bSlice.preload_ref_at(refIndex).begin_parse().slice_bits())
+        ) {
+            return false;
+        }
+        refIndex += 1;
+    }
+
+    return true;
+}
+
+() setContractStorage(cell $obj) impure inline {
+    set_data($obj);
+}
+
+cell getContractStorage() impure inline method_id {
+    return get_data();
+}
+
+int computeContractAddress(cell $storage, cell code) impure inline {
+    return begin_cell()
+        .store_uint(6, 5)
+        .store_ref(code)
+        .store_ref($storage)
+        .end_cell()
+        .cell_hash();
+}
+
+int cl::typeof(cell $obj) inline method_id {
+    if (cl::isNull($obj)) {
+        return cl::NULL_CLASS_NAME;
+    }
+    return $obj.begin_parse().preload_uint(_NAME_WIDTH);
+}
+
+cell cl::declare(int name, tuple fields) inline method_id {
+    tuple classBuilder = unsafeTuple([null(), begin_cell()]);
+
+    if (DEBUG) {
+        if (name > MAX_NAME_INTLEN) {
+            ~strdump("Class name too long! ".str::concat(str::asciiUint256ToStr(name)));
+        }
+    }
+
+    int num_fields = fields.tlen();
+    builder headerBuilder = begin_cell().store_uint(name, _NAME_WIDTH);
+
+    ;; Loop indices
+    int curDataCell = 1;
+    int curRefCell = 1;
+    ;; allow one direct ref in the root cell
+    int curCellMaxRefs = 2;
+    int curDataOffset = _HEADER_WIDTH;
+    int curRefOffset = 0;
+
+    int curField = 0;
+    while (curField < num_fields) {
+        ;; ======================
+        ;; loop management
+        tuple field = fields.tuple_at(curField);
+        int fieldType = field.int_at(FIELD_TYPE_IDX);
+        ;; ===================================
+        int fieldBits = _getTypeWidth(fieldType);
+        if ((curDataOffset + fieldBits) > MAX_CELL_BITS) {
+            ;; move to the next cell
+            curDataCell += 1;
+            curDataOffset = 0;
+            if (curDataCell >= classBuilder.tlen()) {
+                classBuilder = classBuilder.tpush(begin_cell());
+            }
+        }
+        if ((curRefOffset + 1) > curCellMaxRefs) {
+            ;; move to the next cell
+            curRefCell += 1;
+            curRefOffset = 0;
+            curCellMaxRefs = MAX_CELL_REFS;
+            if (curRefCell >= classBuilder.tlen()) {
+                classBuilder = classBuilder.tpush(begin_cell());
+            }
+        }
+
+        if (fieldType <= cl::t::address) {
+            classBuilder = classBuilder.tset(
+                curDataCell,
+                cast_to_builder(classBuilder.at(curDataCell))
+                    .store_uint(abs(field.int_at(FIELD_VAL_IDX)), fieldBits)
+            );
+        } elseif (fieldType == cl::t::objRef) {
+            classBuilder = classBuilder.tset(
+                curRefCell,
+                cast_to_builder(classBuilder.at(curRefCell))
+                    .store_ref(field.cell_at(FIELD_VAL_IDX))
+            );
+        } else {
+            cell field_val = field.cell_at(FIELD_VAL_IDX);
+            classBuilder = classBuilder.tset(curRefCell,
+                cast_to_builder(classBuilder.at(curRefCell))
+                    .store_ref(field_val)
+            );
+        }
+
+        headerBuilder = headerBuilder
+            .store_uint(fieldType, _FIELD_TYPE_WIDTH);
+        if (fieldBits > 0) {
+            headerBuilder = headerBuilder
+                .store_uint(curDataCell == 1 ? 0 : curDataCell, _CELL_ID_WIDTH)
+                .store_uint(curDataOffset, _DATA_OFFSET_WIDTH)
+                .store_uint(3, _REF_OFFSET_WIDTH);
+            curDataOffset += fieldBits;
+        } else {
+            headerBuilder = headerBuilder
+                .store_uint(curRefCell == 1 ? 0 : curRefCell, _CELL_ID_WIDTH)
+                .store_uint(MAX_CELL_BITS, _DATA_OFFSET_WIDTH)
+                .store_uint(curRefOffset, _REF_OFFSET_WIDTH);
+            curRefOffset += 1;
+        }
+        curField += 1;
+    }
+
+
+    builder rootBuilder = classBuilder.at(1);
+    int numCells = classBuilder.tlen() - 1;
+    if (DEBUG) {
+        throw_if(cl::ERROR::INVALID_CLASS, numCells > 3);
+    }
+    if (numCells > 1) {
+        if (rootBuilder.builder_refs() == 0) {
+            rootBuilder = rootBuilder
+                .store_ref(empty_cell())
+                .store_ref(empty_cell());
+        } elseif (rootBuilder.builder_refs() == 1) {
+            rootBuilder = rootBuilder
+                .store_ref(empty_cell());
+        }
+    }
+
+    headerBuilder = headerBuilder
+        .store_ones(_HEADER_WIDTH - headerBuilder.builder_bits())
+        .store_builder(rootBuilder);
+
+    if (numCells == 1) {
+        return headerBuilder.end_cell();
+    }
+    if (numCells == 2) {
+        return headerBuilder
+            .store_ref(classBuilder.at(2).end_cell())
+            .end_cell();
+    }
+    return headerBuilder
+        .store_ref(classBuilder.at(2).end_cell())
+        .store_ref(classBuilder.at(3).end_cell())
+        .end_cell();
+}
+
+cell cl::nullObject() inline method_id {
+    return empty_cell();
+}
+
+;;; ====================== Class Setter ======================
+int cl::getFieldType::asm(slice self, int fieldInfoOffset ) asm """
+// STACK [fieldInfoOffset, headerSlice]
+4 PUSHINT      // STACK [_FIELD_TYPE_WIDTH, fieldInfoOffset, headerSlice]
+SDSUBSTR       // STACK [substring]
+4 PLDU         // STACK [2BitUnsignInt]
+""";
+
+int cl::getFieldCellIndex::asm(slice self, int fieldInfoOffset ) asm """
+4 ADDCONST     // STACK [fieldInfoOffset + _FIELD_TYPE_WIDTH, headerSlice]
+2 PUSHINT      // STACK [_CELL_ID_WIDTH, fieldInfoOffset + _FIELD_TYPE_WIDTH, headerSlice]
+SDSUBSTR       // STACK [substring]
+2 PLDU         // STACK [2BitUnsignInt]
+""";
+
+int cl::getFieldOffset::asm(slice self, int fieldInfoOffset ) asm """
+6 ADDCONST     // STACK [fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH, headerSlice]
+10 PUSHINT      // STACK [_DATA_OFFSET_WIDTH, fieldInfoOffset +_FIELD_TYPE_WIDTH + _CELL_ID_WIDTH, headerSlice]
+SDSUBSTR       // STACK [substring]
+10 PLDU         // STACK [10BitUnsignInt]
+""";
+
+int cl::getFieldCellOffset::asm(slice self, int fieldInfoOffset ) asm """
+16 ADDCONST     // STACK [fieldInfoOffset  + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH, headerSlice]
+2 PUSHINT      // STACK [_REF_OFFSET_WIDTH, fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH headerSlice]
+SDSUBSTR       // STACK [substring]
+2 PLDU         // STACK [10BitUnsignInt]
+""";
+
+int cl::preload_bits_offset_3::asm(int width1, slice self, int fieldOffset, int width2 ) asm """
+SDSUBSTR       // STACK [substring]
+s1 XCHG0
+PLDUX          // STACK [10BitUnsignInt] (CC +1 )
+""";
+
+forall X -> cell cl::set(cell $self, int fieldName, X val) 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 fieldType = headerSlice.cl::getFieldType::asm(fieldInfoOffset);
+    int fieldOffset = headerSlice.cl::getFieldOffset::asm(fieldInfoOffset);
+    int fieldRefsOffset = headerSlice.cl::getFieldCellOffset::asm(fieldInfoOffset );
+
+    if (DEBUG) {
+        throwErrorUnless(fieldType < INVALID_TYPE, "Type does not exist");
+    }
+
+    int fieldWidth = _getTypeWidth(fieldType);
+    slice victim = fieldCellIndex == 0
+        ? headerSlice
+        : headerSlice.preload_ref_at(fieldCellIndex).begin_parse();
+    if (fieldWidth != 0) {
+        fieldRefsOffset = MAX_CELL_REFS;
+    }
+
+    builder replacement = begin_cell()
+        .store_slice(
+            victim.scutfirst(
+                min(victim.slice_bits(), fieldOffset),
+                min(fieldRefsOffset, victim.slice_refs())
+            )
+        );
+
+    if (fieldType == cl::t::cellRef) {
+        replacement = replacement
+            .store_ref(val.cast_to_cell())
+            .store_slice(victim.scutlast(0, victim.slice_refs() - fieldRefsOffset - 1));
+    } elseif (fieldType == cl::t::objRef) {
+        replacement = replacement
+            .store_ref(val.cast_to_cell())
+            .store_slice(victim.scutlast(0, victim.slice_refs() - fieldRefsOffset - 1));
+    } else { ;; numeric type
+        replacement = replacement
+            .store_uint(abs(val.cast_to_int()), fieldWidth)
+            .store_slice(victim.sskipfirst(fieldOffset + fieldWidth, victim.slice_refs()));
+    }
+
+    if (fieldCellIndex > 0) {
+        ;; link the replacement into the root cell
+        return begin_cell()
+            .store_slice(headerSlice.scutfirst(headerSlice.slice_bits(), fieldCellIndex))
+            .store_ref(replacement.end_cell())
+            .store_slice(headerSlice.scutlast(0, headerSlice.slice_refs() - fieldCellIndex - 1))
+            .end_cell();
+    }
+    return replacement.end_cell();
+}
+;;; ====================== Class Getters ======================
+
+const int _NAME_WIDTH = 8 * MAX_NAME_LEN; ;; convert to bits
+const int _BASIC_HEADER_WIDTH = _NAME_WIDTH;
+const int MAX_NAME_INTLEN = (1 << (8 * MAX_NAME_LEN)) - 1;
+
+const int _FIELD_TYPE_WIDTH+_CELL_ID_WIDTH = 6; ;; support up to 16 types
+
+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();
+
+    int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
+    int fieldCellIndex = headerSlice.cl::getFieldCellIndex::asm(fieldInfoOffset);
+    int fieldOffset = headerSlice.cl::getFieldOffset::asm(fieldInfoOffset);
+
+    if (DEBUG) {
+        int fieldType = headerSlice
+            .preload_bits_offset(
+                fieldInfoOffset,
+                _FIELD_TYPE_WIDTH
+            )
+            .preload_uint(_FIELD_TYPE_WIDTH);
+        int expected_field_width = _getTypeWidth(fieldType);
+        throw_unless(0, expected_field_width == width);
+    }
+
+    if (fieldCellIndex == 0) {
+        return cl::preload_bits_offset_3::asm(width, headerSlice, fieldOffset, width);
+    }
+    else {
+        return cl::preload_bits_offset_3::asm( width, headerSlice.preload_ref_at(fieldCellIndex).begin_parse(), fieldOffset,  width);
+    }
+}
+
+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);
+
+    if (DEBUG) {
+        int fieldType = headerSlice
+            .preload_bits_offset(
+                fieldInfoOffset,
+                _FIELD_TYPE_WIDTH
+            )
+            .preload_uint(_FIELD_TYPE_WIDTH);
+        int expected_field_width = _getTypeWidth(fieldType);
+        throw_unless(0, expected_field_width == 0);
+    }
+
+    return fieldCellIndex == 0
+    ? headerSlice.preload_ref_at(fieldRefIdx)
+    : (headerSlice
+        .preload_ref_at(fieldCellIndex)
+        .begin_parse()
+        .preload_ref_at(fieldRefIdx)
+    );
+}
+
+cell cl::getWithCell<cellRef>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<cellRef>(fieldName);
+}
+
+cell cl::get<objRef>(cell $self, int fieldName) inline method_id {
+    return cl::get<cellRef>($self, fieldName);
+}
+
+int cl::get<uint8>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 8);
+}
+
+int cl::get<uint16>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 16);
+}
+
+int cl::get<uint32>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 32);
+}
+
+int cl::get<uint64>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 64);
+}
+
+int cl::get<coins>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 128);
+}
+
+int cl::get<uint256>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 256);
+}
+
+slice cl::get<std_address>(cell $self, int fieldName) inline method_id {
+    return hashpartToBasechainAddressStd(
+        $self.cl::get<uint>(fieldName, 256)
+    );
+}
+
+int cl::get<bool>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 1) != 0;
+}
+
+cell cl::get<dict256>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<cellRef>(fieldName);
+}
+
+int cl::get<address>(cell $self, int fieldName) inline method_id {
+    return $self.cl::get<uint>(fieldName, 256);
+}
+
+;;; =============== DEBUG / CONVENIENCE FUNCTIONS =================
+int typeofField(cell $self, int fieldName) inline {
+    slice headerSlice = $self.begin_parse();
+    int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
+    return headerSlice
+        .preload_bits_offset(
+            fieldInfoOffset,
+            _FIELD_TYPE_WIDTH
+        )
+        .preload_uint(_FIELD_TYPE_WIDTH);
+}
+
+;; returns -1 (true) if equal, otherwise the index of the first field that differs
+int compareObjectFields(cell $lhs, cell $rhs) impure inline {
+    int malformed = cl::typeof($lhs) != cl::typeof($rhs);
+    if (malformed) {
+        return INVALID_CLASS_MEMBER;
+    }
+    if (cl::typeof($lhs) == cl::NULL_CLASS_NAME) {
+        return -1;
+    }
+    int fieldIndex = 0;
+    while (fieldIndex < INVALID_CLASS_MEMBER) {
+        int curFieldType = $lhs.typeofField(fieldIndex);
+        if (curFieldType == cl::t::cellRef) {
+            malformed = $lhs.cl::get<objRef>(fieldIndex).cl::hash() != $rhs.cl::get<objRef>(fieldIndex).cl::hash();
+            if (malformed) {
+                ~dump($lhs.cl::get<objRef>(fieldIndex).cell_hash());
+                ~dump($rhs.cl::get<objRef>(fieldIndex).cell_hash());
+            }
+        } elseif (curFieldType <= cl::t::uint256) {
+            int cur_field_width = _getTypeWidth(curFieldType);
+            malformed = $lhs.cl::get<uint>(fieldIndex, cur_field_width) != $rhs.cl::get<uint>(fieldIndex, cur_field_width);
+            if (malformed) {
+                str::console::log<int>("lhs: ", $lhs.cl::get<uint>(fieldIndex, cur_field_width));
+                str::console::log<int>("rhs: ", $rhs.cl::get<uint>(fieldIndex, cur_field_width));
+            }
+        } else {
+            fieldIndex = INVALID_CLASS_MEMBER;
+        }
+        if (malformed) {
+            str::console::log<int>("Malformed field: ", fieldIndex);
+            return fieldIndex;
+        }
+        fieldIndex += 1;
+    }
+    return -1;
+}
+
+int objectsAreEqual(cell $lhs, cell $rhs) impure inline {
+    return compareObjectFields($lhs, $rhs) == -1;
+}
+
+slice _typeToStr(int fieldType) {
+    if     (fieldType == cl::t::uint8)   { return "uint8";   }
+    elseif (fieldType == cl::t::uint16)  { return "uint16";  }
+    elseif (fieldType == cl::t::uint32)  { return "uint32";  }
+    elseif (fieldType == cl::t::uint64)  { return "uint64";  }
+    elseif (fieldType == cl::t::uint256) { return "uint256"; }
+    elseif (fieldType == cl::t::coins)   { return "coins";   }
+    elseif (fieldType == cl::t::address) { return "address"; }
+    elseif (fieldType == cl::t::dict256) { return "dict256"; }
+    elseif (fieldType == cl::t::objRef)  { return "objRef";  }
+    elseif (fieldType == cl::t::cellRef) { return "cellRef"; }
+    elseif (fieldType == cl::t::bool)    { return "bool";    }
+    else                                 { return "unknown"; }
+}
+
+() printField(cell $obj, int fieldName) impure inline {
+    slice headerSlice = $obj.begin_parse();
+    int fieldType = typeofField($obj, fieldName);
+    int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
+    int fieldCellIndex = headerSlice
+        .preload_bits_offset(
+            fieldInfoOffset + _FIELD_TYPE_WIDTH,
+            _CELL_ID_WIDTH
+        )
+        .preload_uint(_CELL_ID_WIDTH);
+    int fieldRefIdx = headerSlice
+        .preload_bits_offset(
+            fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH,
+            _REF_OFFSET_WIDTH
+        )
+        .preload_uint(_REF_OFFSET_WIDTH);
+
+    int fieldBits = _getTypeWidth(fieldType);
+    int fieldOffset = headerSlice
+        .preload_bits_offset(
+            fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH,
+            _DATA_OFFSET_WIDTH
+        )
+        .preload_uint(_DATA_OFFSET_WIDTH);
+
+    slice toPrint = _typeToStr(fieldType)
+        .str::concat(" ")
+        .str::concatInt(fieldName)
+        .str::concat(" at c")
+        .str::concatInt(fieldCellIndex);
+    if (fieldBits > 0) {
+        toPrint = toPrint.str::concat(".b").str::concatInt(fieldOffset);
+    } else {
+        toPrint = toPrint.str::concat(".r").str::concatInt(fieldRefIdx);
+    }
+    if (fieldType <= cl::t::uint256) {
+        ~strdump(
+            toPrint
+                .str::concat(" = ")
+                .str::concatInt($obj.cl::get<uint>(fieldName, fieldBits))
+        );
+    } elseif (fieldType == cl::t::objRef) {
+        ~strdump(toPrint
+            .str::concat(" hash = ")
+            .str::concatInt($obj.cl::get<objRef>(fieldName).cl::hash())
+        );
+    } else {
+        ~strdump(toPrint
+            .str::concat(" hash = ")
+            .str::concatInt($obj.cl::get<cellRef>(fieldName).cell_hash())
+        );
+    }
+}
+
+;;; ====================== Dictionary functions ======================
+
+slice uint256ToSlice(int val) inline method_id {
+    return begin_cell().store_uint256(val).as_slice();
+}
+
+int sliceToUint256(slice s) inline method_id {
+    return s.preload_uint(256);
+}
+
+;; override the insane behavior of TON to optimize out empty dictionaries
+;; into a single bit
+cell cl::dict256::New() inline method_id {
+    return empty_cell();
+}
+
+(slice, int) cl::dict256::get(cell dict, int key) inline method_id {
+    if (dict.cell_is_empty()) {
+        return new_dict().udict_get?(DICT256_KEYLEN, key);
+    }
+    return dict.udict_get?(DICT256_KEYLEN, key);
+}
+
+(int, int) cl::dict256::get<uint256>(cell dict, int key) inline method_id {
+    (slice val, int exists) = cl::dict256::get(dict, key);
+    if (exists) {
+        return (sliceToUint256(val), true);
+    }
+    return (0, false);
+}
+
+(cell, int) cl::dict256::get<cellRef>(cell dict, int key) inline method_id {
+    if (dict.cell_is_empty()) {
+        return (empty_cell(), false);
+    }
+    return dict.udict_get_ref?(DICT256_KEYLEN, key);
+}
+
+cell cl::dict256::setRef(cell dict, int key, cell val) inline method_id {
+    if (dict.cell_is_empty()) {
+        return new_dict().udict_set_ref(
+            DICT256_KEYLEN,
+            key,
+            val.cast_to_cell()
+        );
+    }
+    return dict.udict_set_ref(DICT256_KEYLEN, key, val.cast_to_cell());
+}
+forall X -> cell cl::dict256::set(cell dict, int key, X val) inline {
+    slice _val = val.is_slice() ? val.cast_to_slice() : uint256ToSlice(val.cast_to_int());
+    if (dict.cell_is_empty()) {
+        return new_dict().udict_set(DICT256_KEYLEN, key, _val);
+    }
+    return dict.udict_set(DICT256_KEYLEN, key, _val);
+}
+
+cell cl::dict256::delete(cell dict, int key) {
+    if (dict.cell_is_empty()) {
+        return dict;
+    }
+    (cell modified_dict, _) = dict.udict_delete?(DICT256_KEYLEN, key);
+    return modified_dict.is_cell() ? modified_dict : cl::dict256::New();
+}
+
+;;; ====================== Dictionary Iterators ======================
+;; returns key, val, and key == -1 if there is no next (or min) element
+;; if the val exists, it is returned
+;; if a val does not exist, null() is returned
+
+(int, slice) cl::dict256::getMin<slice>(cell dict256) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, slice val, int exists) = dict256.udict_get_min?(DICT256_KEYLEN);
+    if (exists) {
+        return (key, val);
+    }
+    return (-1, null());
+}
+
+(int, int) cl::dict256::getMin<uint256>(cell dict256) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, slice val, int exists) = dict256.udict_get_min?(DICT256_KEYLEN);
+    if (exists) {
+        return (key, val.preload_uint(256));
+    }
+    return (-1, null());
+}
+
+(int, cell) cl::dict256::getMin<cellRef>(cell dict256) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, cell val, int exists) = dict256.udict_get_min_ref?(DICT256_KEYLEN);
+    if (exists) {
+        return (key, val);
+    }
+    return (-1, null());
+}
+
+(int, slice) cl::dict256::getNext<slice>(cell dict256, int pivot) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, slice val, int exists) = dict256.udict_get_next?(DICT256_KEYLEN, pivot);
+    if (exists) {
+        return (key, val);
+    }
+    return (-1, null());
+}
+
+(int, int) cl::dict256::getNext<uint256>(cell dict256, int pivot) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, slice val, int exists) = dict256.udict_get_next?(DICT256_KEYLEN, pivot);
+    if (exists) {
+        return (key, val.preload_uint(256));
+    }
+    return (-1, null());
+}
+
+(int, cell) cl::dict256::getNext<cellRef>(cell dict256, int pivot) {
+    if (dict256.cell_is_empty()) {
+        return (-1, null());
+    }
+    (int key, slice val, int exists) = dict256.udict_get_next?(DICT256_KEYLEN, pivot);
+    if (exists) {
+        return (key, val.preload_first_ref());
+    }
+    return (-1, null());
+}
+
+int cl::dict256::size(cell dict) inline {
+    int count = 0;
+    (int pivot, _) = dict.cl::dict256::getMin<slice>();
+    while (pivot >= 0) {
+        (pivot, _) = dict.cl::dict256::getNext<slice>(pivot);
+        count = count + 1;
+    }
+    return count;
+}
+
+;;; ====================== Nested Dict Helpers ======================
+
+forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) inline method_id {
+    return $self.cl::set(
+        fieldName,
+        $self
+            .cl::get<dict256>(fieldName)
+            .cl::dict256::set(key, val)
+    );
+}
+
+cell cl::nestedDict256::setRef(cell $self, int fieldName, int key, cell val) inline method_id {
+    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 method_id {
+    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 method_id {
+    return $self.cl::get<dict256>(fieldName).cl::dict256::get<uint256>(key);
+}
+
+(slice, int) cl::nestedDict256::get<slice>(cell $self, int fieldName, int key) inline method_id {
+    return $self.cl::get<dict256>(fieldName).cl::dict256::get(key);
+}
+
+(cell, int) cl::nestedDict256::get<cellRef>(cell $self, int fieldName, int key) inline method_id {
+    (slice s, int exists) = $self.cl::get<dict256>(fieldName).cl::dict256::get(key);
+    if (exists) {
+        return (s.preload_first_ref(), exists);
+    }
+    return (empty_cell(), exists);
+}