#include "utils.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 cl::t::addressList = cl::t::cellRef; const int DICT256_KEYLEN = 256; const int cl::NULL_CLASS_NAME = "NULL"u; const int cl::ERROR::INVALID_CLASS = 1057; const int cl::ERROR::MALFORMED_OBJECT = 1058; 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 = 15; const int _HEADER_WIDTH = _BASIC_HEADER_WIDTH + _MAX_CLASS_FIELDS * _FIELD_INFO_WIDTH; ;; declarations require a tuple of the form [[ type, val ], ...] const int FIELD_TYPE_IDX = 0; const int FIELD_VAL_IDX = 1; ;;; ====================== Class functions ====================== ;; returns type width in bits int _getTypeWidth(int clType) impure 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::isNullObject(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) impure { 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) impure { 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; } int cl::typeof(cell $obj) impure inline method_id { if (cl::isNullObject($obj)) { return cl::NULL_CLASS_NAME; } return $obj.begin_parse().preload_uint(_NAME_WIDTH); } 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()]); ;; Get number of fields of the object we want to create int num_fields = fields.tlen(); ;; Start building header with class name builder headerBuilder = begin_cell().store_uint(name, _NAME_WIDTH); ;; 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 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 ;; Iterate through all fields int curField = 0; while (curField < num_fields) { ;; Get current field and its type from tuple tuple field = fields.tuple_at(curField); int fieldType = field.int_at(FIELD_TYPE_IDX); ;; Get number of bits needed for this field type ;; (2^{bitLength} for uints, 0 for Refs) int fieldBits = _getTypeWidth(fieldType); if (fieldBits > 0) { ;; If adding this integer field would exceed cell bit limit if ((curDataOffset + fieldBits) > MAX_CELL_BITS) { curDataCell += 1; ;; Move to next cell curDataOffset = 0; ;; Reset bit offset ;; Add new cell builder if needed if (curDataCell >= classBuilder.tlen()) { classBuilder = classBuilder.tpush(begin_cell()); } } } else { ;; For reference types (fieldBits == 0) ;; If adding this ref would exceed cell ref limit if ((curRefOffset + 1) > curCellMaxRefs) { curRefCell += 1; ;; Move to next cell curRefOffset = 0; ;; Reset ref offset curCellMaxRefs = MAX_CELL_REFS; ;; Use max refs for non-root cells ;; Add new cell builder if needed if (curRefCell >= classBuilder.tlen()) { classBuilder = classBuilder.tpush(begin_cell()); } } } ;; Store field value based on type if (fieldType <= cl::t::address) { ;; For numeric types, store as uint 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) { ;; For object references, store as ref classBuilder = classBuilder.tset( curRefCell, cast_to_builder(classBuilder.at(curRefCell)) .store_ref(field.cell_at(FIELD_VAL_IDX)) ); } else { throw(CLASSLIB::ERROR::INVALID_FIELD_TYPE); } ;; Build field metadata in header headerBuilder = headerBuilder .store_uint(fieldType, _FIELD_TYPE_WIDTH); if (fieldBits > 0) { ;; For data fields, store cell index, bit offset, and ref offset 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 { ;; For ref fields, store cell index and ref offset 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; } ;; Get root cell builder and count total cells builder rootBuilder = classBuilder.at(1); int numCells = classBuilder.tlen() - 1; ;; For multi-cell objects, ensure root has exactly 2 refs 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()); } } ;; Finalize header and combine with root cell headerBuilder = headerBuilder .store_ones(_HEADER_WIDTH - headerBuilder.builder_bits()) .store_builder(rootBuilder); ;; Return final cell based on number of cells used 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() impure inline method_id { return empty_cell(); } ;;; ====================== Class Setter ====================== int cl::getFieldType::asm(slice self, int fieldInfoOffset) asm """ // STACK: left -> right: bottom -> top // // Setup // STACK [ headerSlice, fieldInfoOffset ] 4 PUSHINT // STACK [ headerSlice, fieldInfoOffset, _FIELD_TYPE_WIDTH ] SDSUBSTR // STACK [ substring ] 4 PLDU // STACK [ 2BitUnsignInt ] """; int cl::getFieldCellIndex::asm(slice self, int fieldInfoOffset) asm """ // STACK: left -> right: bottom -> top // // Setup // STACK [ headerSlice, fieldInfoOffset ] 4 ADDCONST // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH ] 2 PUSHINT // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH, _CELL_ID_WIDTH ] SDSUBSTR // STACK [ substring ] 2 PLDU // STACK [ 2BitUnsignInt ] """; int cl::getFieldOffset::asm(slice self, int fieldInfoOffset) asm """ // STACK: left -> right: bottom -> top // // Setup // STACK [ headerSlice, fieldInfoOffset ] 6 ADDCONST // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH ] 10 PUSHINT // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH, _DATA_OFFSET_WIDTH ] SDSUBSTR // STACK [ substring ] 10 PLDU // STACK [ 10BitUnsignInt ] """; int cl::getFieldCellOffset::asm(slice self, int fieldInfoOffset) asm """ // STACK: left -> right: bottom -> top // // Setup // STACK [ headerSlice, fieldInfoOffset ] 16 ADDCONST // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH ] 2 PUSHINT // STACK [ headerSlice, fieldInfoOffset + _FIELD_TYPE_WIDTH + _CELL_ID_WIDTH + _DATA_OFFSET_WIDTH, _REF_OFFSET_WIDTH ] SDSUBSTR // STACK [ substring ] 2 PLDU // STACK [ 10BitUnsignInt ] """; int cl::preload_bits_offset_3::asm(int width1, slice self, int fieldOffset, int width2) asm """ // STACK: left -> right: bottom -> top // // Setup // STACK [ width1, headerSlice, fieldOffset, width2 ] SDSUBSTR // STACK [ width1, substring ] s1 XCHG0 // STACK [ substring, width1 ] PLDUX // STACK [ 10BitUnsignInt ] ( CC + 1 ) """; forall X -> cell cl::set(cell $self, int fieldName, X val) impure 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); 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)); } 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 = 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(cell $self, int fieldName, int width) impure 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 (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(cell $self, int fieldName) impure 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 (fieldCellIndex == 0) { return headerSlice.preload_ref_at(fieldRefIdx); } return headerSlice .preload_ref_at(fieldCellIndex) .begin_parse() .preload_ref_at(fieldRefIdx) ; } cell cl::get(cell $self, int fieldName) impure inline method_id { return cl::get($self, fieldName); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 8); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 16); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 32); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 64); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 128); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 256); } slice cl::get(cell $self, int fieldName) impure inline method_id { return hashpartToBasechainAddressStd( $self.cl::get(fieldName, 256) ); } int cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 1) != 0; } cell cl::get(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName); } int cl::get

(cell $self, int fieldName) impure inline method_id { return $self.cl::get(fieldName, 256); } ;;; =============== DEBUG / CONVENIENCE FUNCTIONS ================= int typeofField(cell $self, int fieldName) impure 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 ;; returns 16 if the types of the objects are not equal 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(fieldIndex).cl::hash() != $rhs.cl::get(fieldIndex).cl::hash(); if (malformed) { ~dump($lhs.cl::get(fieldIndex).cell_hash()); ~dump($rhs.cl::get(fieldIndex).cell_hash()); } } elseif (curFieldType <= cl::t::uint256) { int cur_field_width = _getTypeWidth(curFieldType); malformed = $lhs.cl::get(fieldIndex, cur_field_width) != $rhs.cl::get(fieldIndex, cur_field_width); if (malformed) { str::console::log("lhs: ", $lhs.cl::get(fieldIndex, cur_field_width)); str::console::log("rhs: ", $rhs.cl::get(fieldIndex, cur_field_width)); } } else { ;; Finished iteration return -1; } if (malformed) { ~strdump("Malformed field"); ~dump(fieldIndex); return fieldIndex; } fieldIndex += 1; } return -1; } int objectsAreEqual(cell $lhs, cell $rhs) impure inline { return compareObjectFields($lhs, $rhs) == -1; } slice _typeToStr(int fieldType) impure { 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(fieldName, fieldBits)) ); } elseif (fieldType == cl::t::objRef) { ~strdump(toPrint .str::concat(" hash = ") .str::concatInt($obj.cl::get(fieldName).cl::hash()) ); } else { ~strdump(toPrint .str::concat(" hash = ") .str::concatInt($obj.cl::get(fieldName).cell_hash()) ); } } ;; doesn't actually return a tuple, just pushes something to the stack casted to a tuple tuple getObjectField(cell $storage, int field) impure { int fieldType = typeofField($storage, field); int fieldBits = _getTypeWidth(fieldType); if (fieldType == cl::t::bool) { return unsafeTuple($storage.cl::get(field)); } elseif (fieldType <= cl::t::uint256) { return unsafeTuple($storage.cl::get(field, fieldBits)); } return unsafeTuple($storage.cl::get(field)); } ;; doesn't actually return a tuple, just pushes something to the stack casted to a tuple tuple getContractStorageField(int field) impure method_id { return getObjectField(getContractStorage(), field); } ;; doesn't actually return a tuple, just pushes something to the stack casted to a tuple tuple getContractStorageNestedField(int field, int nestedField) impure method_id { return getObjectField(cast_to_cell(getContractStorageField(field)), nestedField); } ;;; ====================== Dictionary functions ====================== slice uint256ToSlice(int val) impure inline { return begin_cell().store_uint256(val).as_slice(); } int sliceToUint256(slice s) impure inline { return s.preload_uint(256); } ;; override the insane behavior of TON to optimize out empty dictionaries ;; into a single bit cell cl::dict256::New() impure inline { return empty_cell(); } (slice, int) cl::dict256::get(cell dict, int key) impure inline method_id { if (dict.cell_is_empty()) { return (null(), false); } return dict.udict_get?(DICT256_KEYLEN, key); } (int, int) cl::dict256::get(cell dict, int key) impure 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(cell dict, int key) impure inline method_id { if (dict.cell_is_empty()) { return (null(), false); } (cell ret, int exists) = dict.udict_get_ref?(DICT256_KEYLEN, key); ifnot (exists) { return (null(), false); } return (ret, true); } cell cl::dict256::setRef(cell dict, int key, cell val) impure 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) impure 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) impure { 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(cell dict256) impure inline { 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(cell dict256) impure inline { 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(cell dict256) impure inline { 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(cell dict256, int pivot) impure inline { 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(cell dict256, int pivot) impure inline { 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(cell dict256, int pivot) impure inline { 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) impure inline method_id { int count = 0; (int pivot, _) = dict.cl::dict256::getMin(); while (pivot >= 0) { (pivot, _) = dict.cl::dict256::getNext(pivot); count = count + 1; } return count; } ;;; ====================== Nested Dict Helpers ====================== forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) impure inline { return $self.cl::set( fieldName, $self .cl::get(fieldName) .cl::dict256::set(key, val) ); } cell cl::nestedDict256::setRef(cell $self, int fieldName, int key, cell val) impure inline { return $self.cl::set( fieldName, $self.cl::get(fieldName).cl::dict256::setRef(key, val) ); } cell cl::nestedDict256::delete(cell $self, int fieldName, int key) impure inline { return $self.cl::set( fieldName, $self.cl::get(fieldName).cl::dict256::delete(key) ); } (int, int) cl::nestedDict256::get(cell $self, int fieldName, int key) impure inline { return $self.cl::get(fieldName).cl::dict256::get(key); } (slice, int) cl::nestedDict256::get(cell $self, int fieldName, int key) impure inline { return $self.cl::get(fieldName).cl::dict256::get(key); } (cell, int) cl::nestedDict256::get(cell $self, int fieldName, int key) impure inline { (slice s, int exists) = $self.cl::get(fieldName).cl::dict256::get(key); if (exists) { return (s.preload_first_ref(), true); } return (null(), false); } ;; ========================= Storage View Functions ========================= ;; -- Level 0: returns storage.fieldName int getStorageFieldL0(int fieldName) impure method_id { cell $storage = getContractStorage(); int fieldType = typeofField($storage, fieldName); int typeWidth = _getTypeWidth(fieldType); return cl::get($storage, fieldName, typeWidth); } cell getStorageFieldL0(int fieldName) impure method_id { return cl::get( getContractStorage(), fieldName ); } cell getStorageFieldL0(int fieldName) impure method_id { return cl::get( getContractStorage(), fieldName ); } ;; -- Level 1: returns storage.fieldName.nestedFieldName int getStorageFieldL1(int fieldName, int nestedFieldName) impure method_id { cell field = getStorageFieldL0(fieldName); int nestedFieldType = typeofField(field, nestedFieldName); int nestedFieldWidth = _getTypeWidth(nestedFieldType); return cl::get(field, nestedFieldName, nestedFieldWidth); } cell getStorageFieldL1(int fieldName, int nestedFieldName) impure method_id { return cl::get( getStorageFieldL0(fieldName), nestedFieldName ); } cell getStorageFieldL1(int fieldName, int nestedFieldName) impure method_id { return cl::get( getStorageFieldL0(fieldName), nestedFieldName ); } ;; returns storage.fieldName[key] cell getStorageFieldL1(int fieldName, int key) impure method_id { (cell field, int exists) = cl::dict256::get( getStorageFieldL0(fieldName), key ); if (exists) { return field; } return cl::nullObject(); } int getStorageFieldL1(int fieldName, int key) impure method_id { (int field, int exists) = cl::dict256::get( getStorageFieldL0(fieldName), key ); if (exists) { return field; } return -1; } ;; Level 2: returns storage.fieldName[outerKey][innerKey] cell getStorageFieldL2(int fieldName, int outerKey, int innerKey) impure method_id { (cell field, int exists) = cl::dict256::get( getStorageFieldL1(fieldName, outerKey), innerKey ); if (exists) { return field; } return cl::nullObject(); } int getStorageFieldL2(int fieldName, int outerKey, int innerKey) impure method_id { (int field, int exists) = cl::dict256::get( getStorageFieldL1(fieldName, outerKey), innerKey ); if (exists) { return field; } return -1; }

Contracts/uufzrOFC2iK4s4tt2xoOC+Oyrg8PhndXshBxkUnwkwo=

Verified Sources