@layerzerolabs/layerzero-v2-ton 3.0.13-ton.0 → 3.0.18-ton.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @layerzerolabs/layerzero-v2-ton
 
+## 3.0.18-ton.0
+
+### Patch Changes
+
+- uln302
+
+## 3.0.14-ton.0
+
+### Patch Changes
+
+- fix ton images
+
 ## 3.0.13-ton.0
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/layerzero-v2-ton",
-  "version": "3.0.13-ton.0",
+  "version": "3.0.18-ton.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,6 +12,11 @@
       "import": "./build/*.json",
       "require": "./build/*.json"
     },
+    "./src/multisig/bocs/*.json": {
+      "default": "./src/multisig/bocs/*.json",
+      "import": "./src/multisig/bocs/*.json",
+      "require": "./src/multisig/bocs/*.json"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",
@@ -27,11 +32,12 @@
     "src/protocol/",
     "src/jettons/zro/*.fc",
     "tests/testMain.fc",
-    "tests/baseContractTest.fc"
+    "tests/baseContractTest.fc",
+    "src/multisig/bocs/MultiSig.compiled.json",
+    "src/multisig/bocs/MultiSigOrder.compiled.json"
   ],
   "scripts": {
-    "build": "$npm_execpath clean-prebuild && $npm_execpath build-all && $npm_execpath compile",
-    "build-all": "$npm_execpath blueprint build --all",
+    "build": "$npm_execpath clean-prebuild && $npm_execpath blueprint build --all",
     "build-single": "$npm_execpath blueprint build",
     "clean": "$npm_execpath clean-prebuild && rimraf .turbo",
     "clean-prebuild": "rimraf build",

package/src/classes/lz/EpConfig.fc

@@ -1,9 +1,9 @@
 #include "../../funC++/classlib.fc";
 
 ;; ERRORS
-const int lz::EpConfig::ERROR::sameMsglib = "sameMsglib"c & ERRORCODE_MASK;
-const int lz::EpConfig::ERROR::invalidTimeoutExpiry = "invalidTimeoutExpiry"c & ERRORCODE_MASK;
-const int lz::EpConfig::ERROR::invalidTimeoutReceiveMsglib = "invalidTimeoutReceiveMsglib"c & ERRORCODE_MASK;
+const int lz::EpConfig::ERROR::sameMsglib = 1025;
+const int lz::EpConfig::ERROR::invalidTimeoutExpiry = 1026;
+const int lz::EpConfig::ERROR::invalidTimeoutReceiveMsglib = 1027;
 const int lz::EpConfig::VALID = 42069 & ERRORCODE_MASK;
 
 ;; required storage name

package/src/classes/lz/Packet.fc

@@ -12,9 +12,9 @@ const int lz::Packet::message = 1;
 const int lz::Packet::nonce = 2;
 const int lz::Packet::guid = 3;
 
-const int lz::Packet::ERROR::INVALID_MESSAGE = "invalid_message"c & ERRORCODE_MASK;
-const int lz::Packet::ERROR::INVALID_NONCE = "invalid_nonce"c & ERRORCODE_MASK;
-const int lz::Packet::ERROR::INVALID_PACKET_FIELD = "invalid_packet_field"c & ERRORCODE_MASK;
+const int lz::Packet::ERROR::INVALID_MESSAGE = 1089;
+const int lz::Packet::ERROR::INVALID_NONCE = 1090;
+const int lz::Packet::ERROR::INVALID_PACKET_FIELD = 1091;
 
 const int lz::Packet::MAX_RECEIVE_MESSAGE_CELLS = 32;
 const int lz::Packet::MAX_SEND_MESSAGE_CELLS = 255;
@@ -35,6 +35,19 @@ cell lz::Packet::nonceless(cell $path, cell message) inline method_id {
     return lz::Packet::New($path, message, 0);
 }
 
+;; assumes that the message is a valid single-linked list
+int lz::Packet::_messageBytes(cell $self) impure inline {
+    slice messageSlice = $self.cl::get<cellRef>(lz::Packet::message).begin_parse();
+    (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
+    int messageBytes = sliceBits / 8;
+    while (sliceRefs > 0) {
+        messageSlice = messageSlice.preload_first_ref().begin_parse();
+        (sliceBits, sliceRefs) = messageSlice.slice_bits_refs();
+        messageBytes += (sliceBits / 8);
+    }
+    return messageBytes;
+}
+
 () lz::Packet::_assertValidLinkedList(cell head, int maxLen) impure inline {
     slice messageSlice = head.begin_parse();
     repeat (maxLen) {

package/src/classes/lz/Path.fc

@@ -46,7 +46,7 @@ const int lz::Path::_dstEidOffset = lz::Path::_srcOAppOffset + 256;
 ;; low-level optimized version
 ;; original: 12k gas
 ;; optimized: 1k gas
-cell lz::Path::optimizedReverse(cell $path) inline {
+cell lz::Path::optimizedReverse(cell $path) impure inline {
     slice pathSlice = $path.begin_parse();
     return begin_cell()
         .store_slice(pathSlice.scutfirst(_HEADER_WIDTH, 0))
@@ -54,3 +54,12 @@ cell lz::Path::optimizedReverse(cell $path) inline {
         .store_slice(pathSlice.preload_bits_offset(lz::Path::_srcEidOffset, 288)) ;; eid + address
         .end_cell();
 }
+
+cell lz::Path::sanitize(cell $path) impure {
+    return lz::Path::New(
+        $path.cl::get<uint32>(lz::Path::srcEid),
+        $path.cl::get<address>(lz::Path::srcOApp),
+        $path.cl::get<uint32>(lz::Path::dstEid),
+        $path.cl::get<address>(lz::Path::dstOApp)
+    );
+}

package/src/classes/msgdata/Deploy.fc

@@ -7,14 +7,26 @@ const int md::Deploy::NAME = "deploy"u;
 const int md::Deploy::initialDeposit = 0;
 const int md::Deploy::dstEid = 1;
 const int md::Deploy::dstOApp = 2;
+const int md::Deploy::extraInfo = 3;
 
 cell md::Deploy::New(int initialDeposit, int dstEid, int dstOApp) inline method_id {
     return cl::declare(
         md::Deploy::NAME,
         unsafeTuple([
-            [cl::t::coins, initialDeposit], ;; md::Deploy::initialDeposit
-            [cl::t::uint32, dstEid],        ;; md::Deploy::dstEid
-            [cl::t::uint256, dstOApp]       ;; md::Deploy::dstOApp
+            [cl::t::coins, initialDeposit],    ;; md::Deploy::initialDeposit
+            [cl::t::uint32, dstEid],           ;; md::Deploy::dstEid
+            [cl::t::uint256, dstOApp],         ;; md::Deploy::dstOApp
+            [cl::t::objRef, cl::nullObject()]  ;; md::Deploy::extraInfo
         ])
     );
 }
+
+cell md::Deploy::NewWithExtraInfo(
+    int initialDeposit,
+    int dstEid,
+    int dstOApp,
+    cell $extraInfo
+) method_id {
+    return md::Deploy::New(initialDeposit, dstEid, dstOApp)
+        .cl::set(md::Deploy::extraInfo, $extraInfo);
+}

package/src/classes/msgdata/LzSend.fc

@@ -46,7 +46,7 @@ cell md::lzSend::fillRequestInfo(
     int requestId,
     int sendMsglib,
     int sendMsglibConnection
-) inline {
+) inline method_id {
     slice lzSendSlice = $lzSend.begin_parse();
     return begin_cell()
         .store_slice(lzSendSlice.scutfirst(_HEADER_WIDTH, 0))

package/src/classes/msgdata/OptionsV2.fc

@@ -7,8 +7,9 @@ const int md::OptionsV2::NAME = "OptionsV2"u;
 const int md::OptionsV2::lzReceiveGas = 0;
 const int md::OptionsV2::lzReceiveValue = 1;
 const int md::OptionsV2::lzComposeGas = 2;
-const int md::OptionsV2::nativeDropAddress = 3;
-const int md::OptionsV2::nativeDropAmount = 4;
+const int md::OptionsV2::lzComposeValue = 3;
+const int md::OptionsV2::nativeDropAddress = 4;
+const int md::OptionsV2::nativeDropAmount = 5;
 
 ;; This is used to demonstrate that we are capable of having different options objects
 ;; This is not finalized and the 'V2' shouldnt be considered a 'valid' options type in the protocol YET
@@ -18,16 +19,18 @@ cell md::OptionsV2::New(
     int lzReceiveGas,
     int lzReceiveValue,
     int lzComposeGas,
+    int lzComposeValue,
     int nativeDropAddress,
     int nativeDropAmount
-) inline method_id {
+) inline {
     return cl::declare(
         md::OptionsV2::NAME,
         unsafeTuple([
             [cl::t::uint256, lzReceiveGas],          ;; md::OptionsV2::lzReceiveGas
             [cl::t::uint256, lzReceiveValue],        ;; md::OptionsV2::lzReceiveValue
             [cl::t::uint256, lzComposeGas],          ;; md::OptionsV2::lzComposeGas
-            [cl::t::address, nativeDropAddress],    ;; md::OptionsV2::nativeDropAddress
+            [cl::t::uint256, lzComposeValue],        ;; md::OptionsV2::lzComposeValue
+            [cl::t::address, nativeDropAddress],     ;; md::OptionsV2::nativeDropAddress
             [cl::t::uint256, nativeDropAmount]       ;; md::OptionsV2::nativeDropAmount
         ])
     );

package/src/funC++/abstract/contractMainAbstract.fc

@@ -1,3 +1,14 @@
-;; todo: comments
+;; _executeOpcode is executed at the start of contractMain, after checking permissions.
+;; Each contract implements a list of opcodes, which calls a handler as the entry point
+;; of that opcode. The contract must be initialized in order to start executing opcodes.
+;; @in the opcode to execute
+;; @in the message data extracted from txnContext
+;; @out tuple of resultant actions
 tuple _executeOpcode(int op, cell $md) impure inline;
+
+;; Actions are executed after the opcode is executed. Each opcode must emit a tuple
+;; of actions, where each action is executed after the opcode is executed in order.
+;; @in the action to execute
+;; @in the value of the action
+;; @out a bool that determines if excess balance is to be sent back to the origin.
 int _executeAction(int actionType, tuple action) impure inline;

package/src/funC++/abstract/handlerAbstract.fc

@@ -1,12 +1,20 @@
-;; todo: comments
+;; Assert that the owner has sent an INITIALIZE opcode to this contract
 () assertInitialized() impure inline;
 
+;; Assert the identity of the caller for a given opcode
 () checkPermissions(int op, cell $md) impure inline;
 
+;; Initialize this contract
 tuple initialize(cell $md) impure inline;
 
+;; Authentication = the owner has deployed and sent at least one transaction to this contract
+;; unauthenticated contracts cannot perform any actions.
+;; Authentication enables sharded contracts to trust the identity and intention of other shards
 () authenticateIfNecessary() impure inline;
 
+;; Assert the caller is the owner of this contract
 () assertOwner() impure inline;
-() _checkPermissions(int op, cell $md) impure inline;
 
+;; Asserts permissions of caller for permissioned opcodes before executing opcode
+;; @see contractMainAbstract.fc
+() _checkPermissions(int op, cell $md) impure inline;

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

@@ -1,6 +1,4 @@
 #include "utils.fc";
-#include "../stdlib.fc";
-#include "../stringlib.fc";
 
 const int action::call::NAME = "actionCall"u;
 
@@ -16,8 +14,12 @@ tuple action::call::New(int to, int opcode, cell $md) inline {
 }
 
 ;; returns true if equals
-int action::call::equals(tuple self, tuple other) {
+int action::call::equals(tuple self, tuple other) inline {
     int equalMdField = compareObjectFields(self.cell_at(action::call::md), other.cell_at(action::call::md));
+    if (equalMdField != -1) {
+        ~strdump("call: not equal md field at idx ");
+        ~dump(equalMdField);
+    }
     return (
         (self.int_at(0) == other.int_at(0)) ;; NAME
         & (self.int_at(action::call::to) == other.int_at(action::call::to))

package/src/funC++/baseInterface.fc

@@ -3,14 +3,15 @@
 const int BaseInterface::event::AUTHENTICATED = "AUTHENTICATED"u;
 const int BaseInterface::event::INITIALIZED = "INITIALIZED"u;
 
-const int BaseInterface::ERROR::notAuthenticated = "BaseInterface::ERROR::notAuthenticated"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::onlyOwner = "BaseInterface::ERROR::onlyOwner"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::notInitialized = "BaseInterface::ERROR::notInitialized"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::alreadyInitialized = "BaseInterface::ERROR::alreadyInitialized"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::invalidOpcode = "BaseInterface::ERROR::invalidOpcode"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::eventEmitted = "BaseInterface::ERROR::eventEmitted"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::invalidActionType = "BaseInterface::ERROR::invalidActionType"c & ERRORCODE_MASK;
-const int BaseInterface::ERROR::invalidEventSource = "BaseInterface::ERROR::invalidEventSource"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::notAuthenticated = 257;
+const int BaseInterface::ERROR::onlyOwner = 258;
+const int BaseInterface::ERROR::notInitialized = 259;
+const int BaseInterface::ERROR::alreadyInitialized = 260;
+const int BaseInterface::ERROR::invalidOpcode = 261;
+const int BaseInterface::ERROR::eventEmitted = 262;
+const int BaseInterface::ERROR::invalidActionType = 263;
+const int BaseInterface::ERROR::invalidEventSource = 264;
 
 const int BaseInterface::OP::INITIALIZE = "BaseInterface::OP::INITIALIZE"c;
+const int BaseInterface::OP::EMPTY = 0;
 const int BaseInterface::OP::EVENT = "BaseInterface::OP::EVENT"c;

package/src/funC++/classlib.fc

@@ -21,7 +21,8 @@ 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 cl::ERROR::INVALID_CLASS = 1057;
+const int cl::ERROR::MALFORMED_OBJECT = 1058;
 
 const int DEBUG = 0;
 
@@ -66,10 +67,6 @@ 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 {
@@ -171,7 +168,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 method_id {
+cell cl::declare(int name, tuple fields) inline {
     tuple classBuilder = unsafeTuple([null(), begin_cell()]);
 
     if (DEBUG) {
@@ -207,13 +204,15 @@ cell cl::declare(int name, tuple fields) inline method_id {
                 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 (fieldBits == 0) {
+            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());
+                }
             }
         }
 
@@ -295,35 +294,35 @@ cell cl::nullObject() inline method_id {
 }
 
 ;;; ====================== Class Setter ======================
-int cl::getFieldType::asm(slice self, int fieldInfoOffset ) asm """
+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 """
+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 """
+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 """
+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 """
+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 )
@@ -460,10 +459,6 @@ cell cl::get<cellRef>(cell $self, int fieldName) inline method_id {
     );
 }
 
-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);
 }
@@ -523,6 +518,7 @@ int typeofField(cell $self, int fieldName) inline {
 }
 
 ;; 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) {
@@ -551,7 +547,8 @@ int compareObjectFields(cell $lhs, cell $rhs) impure inline {
             fieldIndex = INVALID_CLASS_MEMBER;
         }
         if (malformed) {
-            str::console::log<int>("Malformed field: ", fieldIndex);
+            ~strdump("Malformed field");
+            ~dump(fieldIndex);
             return fieldIndex;
         }
         fieldIndex += 1;
@@ -634,17 +631,17 @@ slice _typeToStr(int fieldType) {
 
 ;;; ====================== Dictionary functions ======================
 
-slice uint256ToSlice(int val) inline method_id {
+slice uint256ToSlice(int val) inline {
     return begin_cell().store_uint256(val).as_slice();
 }
 
-int sliceToUint256(slice s) inline method_id {
+int sliceToUint256(slice s) 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() inline method_id {
+cell cl::dict256::New() inline {
     return empty_cell();
 }
 
@@ -767,7 +764,7 @@ cell cl::dict256::delete(cell dict, int key) {
     return (-1, null());
 }
 
-int cl::dict256::size(cell dict) inline {
+int cl::dict256::size(cell dict) inline method_id {
     int count = 0;
     (int pivot, _) = dict.cl::dict256::getMin<slice>();
     while (pivot >= 0) {
@@ -779,7 +776,7 @@ int cl::dict256::size(cell dict) inline {
 
 ;;; ====================== Nested Dict Helpers ======================
 
-forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) inline method_id {
+forall X -> cell cl::nestedDict256::set(cell $self, int fieldName, int key, X val) inline {
     return $self.cl::set(
         fieldName,
         $self
@@ -788,29 +785,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 method_id {
+cell cl::nestedDict256::setRef(cell $self, int fieldName, int key, cell val) 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 method_id {
+cell cl::nestedDict256::delete(cell $self, int fieldName, int key) 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 method_id {
+(int, int) cl::nestedDict256::get<uint256>(cell $self, int fieldName, int key) 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 method_id {
+(slice, int) cl::nestedDict256::get<slice>(cell $self, int fieldName, int key) inline {
     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 {
+(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);

package/src/funC++/constants.fc

@@ -1,6 +1,6 @@
 const int ERRORCODE_MASK = 0x7ff;
-const int CLASSLIB::ERROR::INVALID_FIELD_TYPE = "CLASSLIB::ERROR::INVALID_FIELD_TYPE"c & ERRORCODE_MASK;
-const int CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR = "CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR"c & ERRORCODE_MASK;
+const int CLASSLIB::ERROR::INVALID_FIELD_TYPE = 1058;
+const int CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR = 1059;
 
 const int MAX_U8    = 0xFF;
 const int MAX_U16   = 0xFFFF;

package/src/funC++/contractMain.fc

@@ -40,6 +40,8 @@
     tuple actions = null();
     if (op == BaseInterface::OP::INITIALIZE) {
         actions = initialize($md);
+    } elseif (op == BaseInterface::OP::EMPTY) {
+        actions = emptyActions();
     } else {
         assertInitialized();
         actions = _executeOpcode(op, $md);

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

@@ -0,0 +1,89 @@
+#include "../utils.fc";
+
+const int AddressList::addressBits = 256;
+;; you can create an address list from a tuple of addresses [integers]
+cell AddressList::serialize(tuple addressList) impure inline {
+    tuple addressListBuilder = unsafeTuple([begin_cell()]);
+    int idx = 0;
+    while (idx < addressList.tlen()) {
+        builder curBuilder = addressListBuilder.at(addressListBuilder.tlen() - 1);
+        if ((curBuilder.builder_bits() + AddressList::addressBits) > MAX_CELL_BITS) {
+            addressListBuilder = addressListBuilder.tpush(begin_cell());
+            curBuilder = addressListBuilder.at(addressListBuilder.tlen() - 1);
+        }
+        addressListBuilder = addressListBuilder
+            .tset(
+                addressListBuilder.tlen() - 1,
+                curBuilder.store_uint256(addressList.int_at(idx))
+            );
+        idx = idx + 1;
+    }
+    builder ret = addressListBuilder~tpop();
+    while (addressListBuilder.tlen() > 0) {
+        builder head = addressListBuilder~tpop();
+        ret = head.store_ref(ret.end_cell());
+    }
+    return ret.end_cell();
+}
+
+;; the "iterator" is the remaining slice
+(slice, int) ~AddressList::next(slice addressListSlice) impure inline {
+    if (addressListSlice.slice_bits() == 0) {
+        if (addressListSlice.slice_refs_empty?()) {
+            return (addressListSlice, NULLADDRESS);
+        } else {
+            addressListSlice = addressListSlice.preload_first_ref().begin_parse();
+        }
+    }
+    return addressListSlice.load_uint256();
+}
+
+;; Check that the addresslist is a valid linked list of addresses with no extra refs or bytes
+int AddressList::isValid(cell addressList, int maxCount) {
+    slice addressListSlice = addressList.begin_parse();
+    int count = 0;
+    while (addressListSlice.slice_empty?() == false) {
+        (int bits, int refs) = addressListSlice.slice_bits_refs();
+        if ((refs > 1) | ((refs == 1) & ((bits % 256) != 0))) {
+            return false;
+        }
+        repeat (bits / 256) {
+            count += 1;
+            int address = addressListSlice~load_uint256();
+            if ((address == NULLADDRESS) | (count > maxCount)) {
+                return false;
+            }
+        }
+        if (addressListSlice.slice_refs() > 0) {
+            addressListSlice = addressListSlice.preload_first_ref().begin_parse();
+        }
+    }
+
+    return true;
+}
+
+int AddressList::includes(int address, slice addressListSlice) impure inline {
+    int storedAddress = addressListSlice~AddressList::next();
+    while (storedAddress > NULLADDRESS) {
+        if (storedAddress == address) {
+            return true;
+        }
+        storedAddress = addressListSlice~AddressList::next();
+    }
+    return false;
+}
+
+int AddressList::length(cell addressList) impure inline {
+    slice addressListSlice = addressList.begin_parse();
+    int count = 0;
+    int dvnAddress = addressListSlice~AddressList::next();
+    while (dvnAddress > NULLADDRESS) {
+        count += 1;
+        dvnAddress = addressListSlice~AddressList::next();
+    }
+    return count;
+}
+
+cell AddressList::empty() impure inline {
+    return empty_cell();
+}

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

@@ -9,7 +9,7 @@ const int DeterministicInsertionCircularQueue::keyBits = 64;
 
 const int DeterministicInsertionCircularQueue::invalidKey = -1;
 const int DeterministicInsertionCircularQueue::invalidStatus = -1;
-const int DeterministicInsertionCircularQueue::ERROR::invalidObject = "DeterministicInsertionCircularQueue::ERROR::invalidObject"c & ERRORCODE_MASK;
+const int DeterministicInsertionCircularQueue::ERROR::invalidObject = 1185;
 
 cell DeterministicInsertionCircularQueue::_buildLevel(int level, cell initialContents) inline {
     if (level == 0) {

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

@@ -10,7 +10,7 @@ const int POOO::NAME = "POOO"u;
 const int POOO::nextEmpty = 0;
 const int POOO::bitmap = 1;
 
-const int POOO::ERROR::negativeIndex = "POOO::ERROR::negativeIndex"c & ERRORCODE_MASK;
+const int POOO::ERROR::negativeIndex = 1153;
 
 ;; Algorithm:
 ;; 1. Extract the first `index` bits from the original bitmap.
@@ -54,6 +54,30 @@ cell POOO::set(cell $self, int absoluteIndex) impure inline method_id {
         .cl::set(POOO::nextEmpty, nextEmpty + leadingOnes);
 }
 
+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 startIndex = start - nextEmpty;
+    int endIndex = end - nextEmpty;
+
+    (int leadingOnes, slice remainingBitmap) = ldones(
+        begin_cell()
+            .store_slice(scutfirst(bitmapSlice, startIndex, 0))
+            .store_ones(endIndex - startIndex)
+            .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,

package/src/funC++/handlerCore.fc

@@ -24,6 +24,8 @@
         return ();
     } elseif (op == BaseInterface::OP::INITIALIZE) {
         assertOwner();
+    } elseif (op == BaseInterface::OP::EMPTY) {
+        return ();
     } else {
         _checkPermissions(op, $md);
     }

package/src/funC++/stdlib.fc

@@ -182,7 +182,7 @@ int check_data_signature(slice data, slice signature, int public_key) asm "CHKSI
 (int, int, int, int) compute_data_size?(cell c, int max_cells) asm "CDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
 
 ;;; A non-quiet version of [slice_compute_data_size?] that throws a cell overflow exception (8) on failure.
-(int, int, int, int) slice_compute_data_size?(cell c, int max_cells) asm "SDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
+(int, int, int, int) slice_compute_data_size?(slice s, int max_cells) asm "SDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
 
 ;;; Throws an exception with exit_code excno if cond is not 0 (commented since implemented in compilator)
 ;; () throw_if(int excno, int cond) impure asm "THROWARGIF";