@layerzerolabs/layerzero-v2-ton 3.0.22-ton.2 → 3.0.24

package/src/funC++/classlib.fc

@@ -14,7 +14,6 @@ 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 INVALID_TYPE = 13;
 
 const int DICT256_KEYLEN = 256;
 
@@ -44,7 +43,6 @@ const int _HEADER_WIDTH = _BASIC_HEADER_WIDTH + _MAX_CLASS_FIELDS * _FIELD_INFO_
 const int FIELD_TYPE_IDX = 0;
 const int FIELD_VAL_IDX = 1;
 
-
 ;;; ====================== Class functions ======================
 ;; returns type width in bits
 int _getTypeWidth(int clType) inline {
@@ -59,7 +57,7 @@ int cl::hash(cell $obj) impure inline {
     return $obj.cell_hash();
 }
 
-int cl::isNull(cell $obj) impure inline {
+int cl::isNullObject(cell $obj) impure inline {
     return $obj.cell_is_empty();
 }
 
@@ -123,83 +121,95 @@ int cl::equalObjTypeShallow(cell $a, cell $b) {
 }
 
 int cl::typeof(cell $obj) inline method_id {
-    if (cl::isNull($obj)) {
+    if (cl::isNullObject($obj)) {
         return cl::NULL_CLASS_NAME;
     }
     return $obj.begin_parse().preload_uint(_NAME_WIDTH);
 }
 
 cell cl::declare(int name, tuple fields) 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);
 
-    ;; 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;
+    ;; 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)
+    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) {
-        ;; ======================
-        ;; loop management
+        ;; 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 ((curDataOffset + fieldBits) > MAX_CELL_BITS) {
-            ;; move to the next cell
-            curDataCell += 1;
-            curDataOffset = 0;
-            if (curDataCell >= classBuilder.tlen()) {
-                classBuilder = classBuilder.tpush(begin_cell());
+
+        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());
+                }
             }
-        }
-        if (fieldBits == 0) {
+        } else {
+            ;; For reference types (fieldBits == 0)
+            ;; If adding this ref would exceed cell ref limit
             if ((curRefOffset + 1) > curCellMaxRefs) {
-                ;; move to the next cell
-                curRefCell += 1;
-                curRefOffset = 0;
-                curCellMaxRefs = MAX_CELL_REFS;
+                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 {
-            cell field_val = field.cell_at(FIELD_VAL_IDX);
-            classBuilder = classBuilder.tset(curRefCell,
-                cast_to_builder(classBuilder.at(curRefCell))
-                    .store_ref(field_val)
-            );
+            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)
@@ -209,9 +219,11 @@ cell cl::declare(int name, tuple fields) inline {
         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
@@ -223,10 +235,12 @@ cell cl::declare(int name, tuple fields) inline {
         }
     }
 
+    ;; 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();
     }
@@ -247,37 +261,46 @@ cell cl::nullObject() inline method_id {
 
 ;;; ====================== 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]
+// 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 """
-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]
+// 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 """
-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]
+// 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 """
-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]
+// 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 """
-SDSUBSTR       // STACK [substring]
-s1 XCHG0
-PLDUX          // STACK [10BitUnsignInt] (CC +1 )
+// 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) inline method_id {
@@ -308,10 +331,6 @@ 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));
-    } 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)
@@ -334,8 +353,6 @@ 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
@@ -361,9 +378,8 @@ int cl::get<uint>(cell $self, int fieldName, int width) inline method_id {
 
     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);
+    } else {
+        return cl::preload_bits_offset_3::asm(width, headerSlice.preload_ref_at(fieldCellIndex).begin_parse(), fieldOffset,  width);
     }
 }
 
@@ -573,7 +589,7 @@ cell cl::dict256::New() inline {
 
 (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 (null(), false);
     }
     return dict.udict_get?(DICT256_KEYLEN, key);
 }
@@ -588,11 +604,11 @@ cell cl::dict256::New() inline {
 
 (cell, int) cl::dict256::get<cellRef>(cell dict, int key) inline method_id {
     if (dict.cell_is_empty()) {
-        return (empty_cell(), false);
+        return (null(), false);
     }
     (cell ret, int exists) = dict.udict_get_ref?(DICT256_KEYLEN, key);
     ifnot (exists) {
-        return (empty_cell(), false);
+        return (null(), false);
     }
     return (ret, true);
 }
@@ -607,6 +623,7 @@ cell cl::dict256::setRef(cell dict, int key, cell val) inline method_id {
     }
     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()) {
@@ -740,7 +757,7 @@ cell cl::nestedDict256::delete(cell $self, int fieldName, int key) inline {
 (cell, int) cl::nestedDict256::get<cellRef>(cell $self, int fieldName, int key) inline {
     (slice s, int exists) = $self.cl::get<dict256>(fieldName).cl::dict256::get(key);
     if (exists) {
-        return (s.preload_first_ref(), exists);
+        return (s.preload_first_ref(), true);
     }
-    return (empty_cell(), exists);
+    return (null(), false);
 }

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

@@ -44,7 +44,6 @@ int AddressList::isValid(cell addressList, int maxCount) {
     int count = 0;
     while (addressListSlice.slice_empty?() == false) {
         (int bits, int refs) = addressListSlice.slice_bits_refs();
-        ;; todo: more test coverage
         if ((refs > 1) | ((bits % 256) != 0)) {
             return false;
         }

package/src/protocol/channel/storage.fc

@@ -44,7 +44,7 @@ cell Channel::New(int owner, cell $path, int endpointAddress) inline method_id {
             [cl::t::address, endpointAddress],                  ;; Channel::endpointAddress
             [cl::t::objRef, lz::EpConfig::NewWithDefaults()],   ;; Channel::epConfigOApp
             [cl::t::uint64, 0],                                 ;; Channel::outboundNonce
-            [cl::t::dict256, empty_cell()],                     ;; Channel::sendRequestQueue
+            [cl::t::dict256, cl::dict256::New()],               ;; Channel::sendRequestQueue
             [cl::t::uint64, 0],                                 ;; Channel::sendRequestId
             [cl::t::objRef, POOO::New()],                       ;; Channel::commitPOOO
             [cl::t::objRef, POOO::New()],                       ;; Channel::executePOOO

package/src/protocol/endpoint/handler.fc

@@ -44,9 +44,9 @@
         exists
     );
 
-    throw_unless(
+    throw_if(
         Endpoint::ERROR::unresolvedMsglib,
-        $msglibInfo.cl::hash() != cl::nullObject().cl::hash()
+        cl::isNullObject($msglibInfo) 
     );
 
     return (
@@ -106,7 +106,7 @@ cell _getEpConfigFromManagerAddresses(cell $setEpConfigMd, cell $path) inline me
 
 (int, int) _getMsglibAndConnectionDefaults(int key, cell $path) inline method_id {
     cell $msglibInfo = getContractStorage().cl::get<objRef>(key);
-    if (cl::isNull($msglibInfo)) {
+    if (cl::isNullObject($msglibInfo)) {
         return (NULLADDRESS, NULLADDRESS);
     }
     return (
@@ -250,6 +250,16 @@ tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
     ;; The extra gas cost is inconsequential because this is a configuration flow.
     throw_if(validity, validity != lz::EpConfig::VALID);
 
+    if ($sendLibInfo.is_null()) {
+        $sendLibInfo = cl::nullObject();
+    }
+    if ($receiveLibInfo.is_null()) {
+        $receiveLibInfo = cl::nullObject();
+    }
+    if ($timeoutReceiveLibInfo.is_null()) {
+        $timeoutReceiveLibInfo = cl::nullObject();
+    }
+
     setContractStorage(
         $storage
             .cl::set(Endpoint::defaultSendLibInfo, $sendLibInfo)
@@ -388,10 +398,7 @@ tuple addMsglib(cell $addMsglib) impure inline method_id {
                 )
                 .cl::set(Endpoint::numMsglibs, currentNumMsglibs + 1)
         );
-    }
 
-    ;; if the previous addMsglib ran out of gas, it can be retried
-    if ((~ exists) | $msglibInfo.cl::isNull()) {
         ;; Call the msglib manager to resolve the correct msglib contract
         ;; address for this endpoint's remote eid
         actions~pushAction<call>(
@@ -399,6 +406,15 @@ tuple addMsglib(cell $addMsglib) impure inline method_id {
             MsglibManager::OP::GET_MSGLIB_INFO,
             $addMsglib
         );
+    } else {
+    ;; if the previous addMsglib ran out of gas, it can be retried
+        if (cl::isNullObject($msglibInfo)) {
+            actions~pushAction<call>(
+                msglibManagerAddress,
+                MsglibManager::OP::GET_MSGLIB_INFO,
+                $addMsglib
+            );
+        }
     }
 
     return actions;
@@ -416,7 +432,7 @@ tuple getMsglibInfoCallback(cell $msglibInfo) impure inline method_id {
         getCaller()
     );
 
-    throw_unless(Endpoint::ERROR::msglibInfoExists, $storedMsglibInfo.cl::isNull());
+    throw_unless(Endpoint::ERROR::msglibInfoExists, cl::isNullObject($storedMsglibInfo));
 
     setContractStorage(
         $storage.cl::nestedDict256::setRef(Endpoint::msglibs, getCaller(), $msglibInfo)

package/src/protocol/msglibs/ultralightnode/feeLibUtils.fc

@@ -15,7 +15,8 @@ tuple safePackedInputsRunVm(
     slice code,
     int gasLimit
 ) impure method_id asm """
-    // Setup                 // callerStack: [ inputs, methodIdCRC, nOutputs, code,  gasLimit ] ; len(callerStack) = 5
+    // STACK: left -> right: bottom -> top //
+    // Setup                 // STACK [ inputs, methodIdCRC, nOutputs, code,  gasLimit ] ; len(callerStack) = 5
     //                       // STACK [ ..., inputs, methodIdCRC, nOutputs, code, nOutputs, gasLimit ]
     DEPTH 5 PUSHINT SUB      // STACK [ ..., inputs, methodIdCRC, nOutputs, code, gasLimit, len(callerStack) ]
     3 PUSHINT SETGLOBVAR     // STACK [ ..., inputs, methodIdCRC, nOutputs, code, gasLimit ]

package/src/protocol/msglibs/ultralightnode/uln/handler.fc

@@ -171,7 +171,7 @@ cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
         : Uln::remainingWorkerSlots;
     return $storage
         .cl::nestedDict256::delete(Uln::workerFeelibInfos, workerAddress)
-        .cl::set( workerSlotField, $storage.cl::get<uint16>(workerSlotField) + 1);
+        .cl::set(workerSlotField, $storage.cl::get<uint16>(workerSlotField) + 1);
 }
 
 (int, cell) _quoteWorker(
@@ -191,7 +191,7 @@ cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
         return (-1, null());
     }
 
-    (cell $friendInfo, int friendExists) = ($workerInfo, workerExists);
+    (cell $friendInfo, int friendExists) = ($workerInfo, true);
     int friendWorkerAddress = $workerInfo
         .cl::get<address>(UlnWorkerFeelibInfo::friendWorkerAddress);
 
@@ -387,6 +387,7 @@ cell _quoteWorkers(tuple args) impure inline method_id(23432) {
     } elseif (
         (op == Uln::OP::ULN_VERIFY)
         | (op == Uln::OP::ULN_COMMIT_PACKET)
+        | (op == Uln::OP::ULN_QUOTE)
     ) {
         return ();
     } elseif (
@@ -547,7 +548,9 @@ tuple updateWorkerFeelib(cell $UlnWorkerFeelibInfo) impure inline method_id {
             now()
         );
 
-        setContractStorage($storage.cl::set(workerSlotField, remainingWorkerSlots - 1));
+        setContractStorage(
+            $storage.cl::set(workerSlotField, remainingWorkerSlots - 1)
+        );
     } else {
         ;; Do not allow workers to arbitrarily change their rent information
         $UlnWorkerFeelibInfo = $UlnWorkerFeelibInfo
@@ -574,11 +577,10 @@ tuple updateWorkerFeelib(cell $UlnWorkerFeelibInfo) impure inline method_id {
 tuple deregisterWorkerFeelib(cell $empty) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int workerAddress = getCaller();
     (cell $UlnWorkerFeelibInfo, int exists) = cl::nestedDict256::get<cellRef>(
         $storage,
         Uln::workerFeelibInfos,
-        workerAddress
+        getCaller() ;; = workerAddress
     );
 
     if (exists) {
@@ -599,10 +601,13 @@ tuple deregisterWorkerFeelib(cell $empty) impure inline method_id {
 tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    int workerAddress = getCaller();
+
     (cell $workerInfo, int exists) = $storage.cl::nestedDict256::get<cellRef>(
         Uln::workerFeelibInfos,
-        getCaller()
+        workerAddress
     );
+
     throw_unless(Uln::ERROR::nonexistentWorker, exists);
 
     cell $updatedWorkerInfo = $workerInfo.cl::set(
@@ -617,7 +622,7 @@ tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
         $storage
             .cl::nestedDict256::setRef(
                 Uln::workerFeelibInfos,
-                getCaller(),
+                workerAddress,
                 $updatedWorkerInfo
             )
     );
@@ -628,7 +633,7 @@ tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
     );
 
     actions~pushAction<call>(
-        getCaller(),
+        workerAddress,
         Uln::OP::SET_WORKER_FEELIB_STORAGE_CALLBACK,
         $newStorage
     );
@@ -682,7 +687,7 @@ tuple collectWorkerRent(cell $setAddress) impure inline method_id {
 
     ;; Admins do not pay rent
     if ($workerInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin)) {
-        return emptyActions();
+        return actions;
     }
 
     int currentTimestamp = now();
@@ -693,7 +698,6 @@ tuple collectWorkerRent(cell $setAddress) impure inline method_id {
     int currentRentBalance = $workerInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance);
 
     ;; if rentBalance is greater than totalRentOwed, we can update rentBalance and lastRentTimestamp
-    ;; else we must delete(evict) the worker from the workerInfos
     if (currentRentBalance >= totalRentOwed) {
         $workerInfo = $workerInfo
             .cl::set(UlnWorkerFeelibInfo::rentBalance, currentRentBalance - totalRentOwed)
@@ -707,6 +711,7 @@ tuple collectWorkerRent(cell $setAddress) impure inline method_id {
             $workerInfo
         );
     } else {
+        ;; else we must delete(evict) the worker from the workerInfos
         setContractStorage(
             _removeWorker($storage, $workerInfo)
         );
@@ -751,6 +756,7 @@ tuple setDefaultUlnReceiveConfig(cell $ulnReceiveConfig) impure inline method_id
             $sanitizedUlnReceiveConfig
         )
     );
+
     actions~pushAction<event>(
         Uln::event::ULN_DEFAULT_RECEIVE_CONFIG_SET,
         $sanitizedUlnReceiveConfig
@@ -798,6 +804,8 @@ tuple garbageCollectInvalidAttestations(cell $mdAddress) impure inline method_id
     return actions;
 }
 
+;; todo-thomas: I'm not sure if we can read tensors (or tuples for that matter)
+;; from the view functions using the RPC call, maybe it should be one integer?
 (int, int, int) version() impure method_id {
     return (3, 0, 2);
 }

package/src/protocol/msglibs/ultralightnode/ulnConnection/handler.fc

@@ -99,7 +99,7 @@ int _committable(
             nonce,
             dvnAddress
         );
-        if ($attestation.cl::isNull()) {
+        if ($attestation.cl::isNullObject()) {
             return false;
         }
         if (
@@ -123,7 +123,7 @@ int _committable(
         );
 
         ;; Nested if, else case is simply to do nothing
-        ifnot ($attestation.cl::isNull()) {
+        ifnot ($attestation.cl::isNullObject()) {
             if (
                 ($attestation.cl::get<uint64>(lz::Attestation::confirmations) >= requiredConfirmations)
                 & ($attestation.cl::get<uint256>(lz::Attestation::hash) == packetHash)
@@ -196,7 +196,7 @@ int verifiedView(int dvnAddress, int nonce, int packetHash, int requiredConfirma
         dvnAddress
     );
 
-    if ($attestation.cl::isNull()) {
+    if ($attestation.cl::isNullObject()) {
         return false;
     }
 
@@ -391,11 +391,10 @@ tuple garbageCollectInvalidAttestations(cell $mdObj) impure inline method_id {
     cell $newStorage = UlnConnection::utils::deleteNonceAttestations($storage, nonce);
 
     ;; iterate the required DVNs
-
     int requiredDVNAddress = requiredDVNsSlice~AddressList::next();
     while (requiredDVNAddress > NULLADDRESS) {
         cell $attestation = UlnConnection::utils::getHashLookup($storage, nonce, requiredDVNAddress);
-        ifnot ($attestation.cl::isNull()) {
+        ifnot (cl::isNullObject($attestation)) {
             $newStorage = UlnConnection::utils::setHashLookup(
                 $newStorage,
                 nonce,
@@ -409,7 +408,7 @@ tuple garbageCollectInvalidAttestations(cell $mdObj) impure inline method_id {
    int optionalDVNAddress = optionalDVNsSlice~AddressList::next();
     while (optionalDVNAddress > NULLADDRESS) {
         cell $attestation = UlnConnection::utils::getHashLookup($storage, nonce, optionalDVNAddress);
-        ifnot ($attestation.cl::isNull()) {
+        ifnot (cl::isNullObject($attestation)) {
             $newStorage = UlnConnection::utils::setHashLookup(
                 $newStorage,
                 nonce,

package/src/protocol/msglibs/ultralightnode/ulnConnection/utils.fc

@@ -31,7 +31,11 @@ cell UlnConnection::utils::setHashLookup(
     cell $attestation
 ) impure inline {
     cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
-    (cell addressLookup, _) = hashLookups.cl::dict256::get<cellRef>(nonce);
+    (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
+
+    ifnot (exists) {
+        addressLookup = cl::dict256::New();
+    }
 
     ;; insert the attestation
     addressLookup = addressLookup.cl::dict256::setRef(dvnAddress, $attestation);

package/src/protocol/msglibs/ultralightnode/ulnManager/handler.fc

@@ -113,7 +113,11 @@ int _getEventSink() impure inline {
 int _calculateUlnAddress(cell $storage, int dstEid) impure inline method_id {
     throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
     return computeContractAddress(
-        Uln::New(getContractAddress(), $storage.cl::get<uint32>(UlnManager::eid), dstEid),
+        Uln::New(
+            getContractAddress(), 
+            $storage.cl::get<uint32>(UlnManager::eid), 
+            dstEid
+        ),
         $storage.cl::get<cellRef>(UlnManager::ulnCode)
     );
 }
@@ -321,7 +325,7 @@ tuple registerWorkerFeelibBytecode(cell $ulnWorkerFeelibBytecode) impure inline
     cell $newStorage = $storage
         .cl::nestedDict256::setRef(
             UlnManager::workerFeelibBytecodes,
-            bytecode.cell_hash(),
+            bytecode.cl::hash(),
             bytecode
         );
 
@@ -330,10 +334,10 @@ tuple registerWorkerFeelibBytecode(cell $ulnWorkerFeelibBytecode) impure inline
         UlnManager::CONST::MAX_CUMULATIVE_BYTECODE_CELLS
     );
 
-    setContractStorage($newStorage);
-
     throw_unless(UlnManager::ERROR::feelibBytecodesExceeded, success);
 
+    setContractStorage($newStorage);
+
     return actions;
 }
 
@@ -438,7 +442,6 @@ tuple setUlnTreasuryFeeBps(cell $mdEid) impure inline method_id {
     return actions;
 }
 
-
 ;; This will override an existing tentative owner
 ;; Becuase we assert that the 'claimOwnership' can't be done by the 'null' address, it means
 ;; if we want to burn the ownership, we will need to set it to a contract which only has ability to

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/handler.fc

@@ -17,7 +17,7 @@ const int DvnFeelib::VERIFY_BYTES_ULN = 288;
     if (
         (cl::typeof($options) == md::OptionsV1::NAME)
         | (cl::typeof($options) == md::OptionsV2::NAME)
-        | cl::isNull($options)
+        | cl::isNullObject($options)
     ) {
         return ();
     } else {