@layerzerolabs/layerzero-v2-ton 3.0.27 → 3.0.29

package/src/protocol/channel/storage.fc

@@ -6,7 +6,7 @@
 
 ;; maximum concurrent sendable inflight send requests
 ;; must be low to avoid permanent bricking
-const Channel::MAX_SEND_SLOTS = MAX_CELL_BITS;
+const int Channel::MAX_SEND_SLOTS = MAX_CELL_BITS;
 
 ;; required object name
 const int Channel::NAME = "channel"u;
@@ -52,4 +52,209 @@ cell Channel::New(int owner, cell $path, int endpointAddress) inline method_id {
             [cl::t::coins, 0]                                   ;; Channel::zroBalance
         ])
     );
+}
+
+;; ====================== Object Accessors =====================
+
+const int Channel::_endpointAddressOffset = _HEADER_WIDTH;
+const int Channel::_outboundNonceOffset = Channel::_endpointAddressOffset + 256;
+const int Channel::_sendRequestIdOffset = Channel::_outboundNonceOffset + 64;
+const int Channel::_zroBalanceOffset = Channel::_sendRequestIdOffset + 64;
+const int Channel::_sliceBits = Channel::_zroBalanceOffset + 128;
+
+cell Channel::getPath(cell $self) impure inline {
+    return $self.cellPreloadRefAt(1);
+}
+
+int Channel::getEndpointAddress(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(Channel::_endpointAddressOffset);
+}
+
+cell Channel::getCommitPOOO(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(2);
+}
+
+cell Channel::getExecutePOOO(cell $self) impure inline {
+    return $self.cellPreloadRefAt(2).cellPreloadRefAt(3);
+}
+
+cell Channel::getExecutionQueue(cell $self) impure inline {
+    return $self.cellPreloadRefAt(3).cellPreloadRefAt(0);
+}
+
+int Channel::getZroBalance(cell $self) impure inline {
+    return $self.cellPreloadCoinsAt(Channel::_zroBalanceOffset);
+}
+
+;; (epConfigOApp, commitPOOO, ExecutePOOO, executionQueue)
+(cell, cell, cell, cell) Channel::getCommitPacketInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2 = selfSlice.preloadRefSliceAt(2);
+    return (
+        ref2.preloadRefAt(0),
+        ref2.preloadRefAt(2),
+        ref2.preloadRefAt(3),
+        selfSlice.preloadRefAt(3).cellPreloadRefAt(0)
+    );
+}
+
+;; (executePOOO, executionQueue, path)
+(cell, cell, cell) Channel::getExecutePOOOAndExecutionQueueAndPath(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(2).cellPreloadRefAt(3),
+        selfSlice.preloadRefAt(3).cellPreloadRefAt(0),
+        selfSlice.preloadRefAt(1)
+    );
+}
+
+;; (epConfigOapp, path, sendRequestQueue, lastSendRequestId)
+(cell, cell, cell, int) Channel::getSendInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2 = selfSlice.preloadRefSliceAt(2);
+    return (
+        ref2.preloadRefAt(0),
+        selfSlice.preloadRefAt(1),
+        ref2.preloadRefAt(1),
+        selfSlice.preloadUint64At(Channel::_sendRequestIdOffset)
+    );
+}
+
+;; (sendRequestQueue, zroBalance, path, outBoundNonce)
+(cell, int, cell, int) Channel::getSendCallbackInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(2).cellPreloadRefAt(1),                          ;; sendRequestQueue
+        selfSlice.preloadCoinsAt(Channel::_zroBalanceOffset),                  ;; zroBalance
+        selfSlice.preloadRefAt(1),                                               ;; path
+        selfSlice.preloadUint64At(Channel::_outboundNonceOffset)                 ;; outboundNonce
+    );
+}
+
+;; (executionQueue, commitPOOO, path)
+(cell, cell, cell) Channel::getLzReceiveLockInformation(cell $self) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return (
+        selfSlice.preloadRefAt(3).cellPreloadRefAt(0),       ;; executionQueue
+        selfSlice.preloadRefAt(2).cellPreloadRefAt(2),       ;; commitPOOO
+        selfSlice.preloadRefAt(1)                            ;; path
+    );
+}
+
+;; ====================== Object Modifiers =====================
+
+cell Channel::setSendRequestQueue(cell $self, cell $sendRequestQueue) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    cell newRef2 = begin_cell()
+        .store_slice(ref2Slice.scutfirst(0, 1))
+        .store_ref($sendRequestQueue)
+        .store_slice(ref2Slice.scutlast(0, 2))
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Channel::_sliceBits, 2)) ;; store all the bits and the first 2 refs [0, 1]
+        .store_ref(newRef2) ;; store the new ref[2] which includes the new sendRequestQueue
+        .store_slice(selfSlice.scutlast(0, 1)) ;; store the last ref, ref[3]
+        .end_cell();
+}
+
+cell Channel::setExecutePOOO(cell $self, cell $executePOOO) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    cell newRef2 = begin_cell()
+        .store_slice(ref2Slice.scutfirst(0, 3))
+        .store_ref($executePOOO)
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Channel::_sliceBits, 2)) ;; store all the bits and the first 2 refs [0, 1]
+        .store_ref(newRef2) ;; store the new ref[2] which includes the new executePOOO
+        .store_slice(selfSlice.scutlast(0, 1)) ;; store the last ref, ref[3]
+        .end_cell();
+}
+
+cell Channel::setExecutionQueue(cell $self, cell $executionQueue) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    cell newRef3 = begin_cell()
+        .store_ref($executionQueue)
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Channel::_sliceBits, 3)) ;; store all the bits and the first 3 refs [0, 1, 2]
+        .store_ref(newRef3) ;; store the new ref[3] which includes the new executionQueue
+        .end_cell();
+}
+
+;; ====================== Object Composite Modifiers =====================
+
+cell Channel::setSendRequestQueueAndLastSendRequestId(cell $self, int lastSendRequestId, cell $sendRequestQueue) impure inline {
+    slice selfSlice = $self.begin_parse();
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+
+    cell newRef2 = begin_cell()
+        .store_slice(ref2Slice.scutfirst(0, 1))
+        .store_ref($sendRequestQueue)
+        .store_slice(ref2Slice.scutlast(0, 2))
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Channel::_sendRequestIdOffset, 2)) ;; store all the bits before the lastSendRequestId and the first 2 refs [0, 1]
+        .store_uint64(lastSendRequestId) ;; store the new lastSendRequestId = ref[2]
+        .store_ref(newRef2) ;; store the new ref[2] which includes the new sendRequestQueue
+        .store_slice(selfSlice.sskipfirst(Channel::_sendRequestIdOffset + 64, 3)) ;; store the whatever was after the lastSendRequestId and the last ref, only giving back ref[3]
+        .end_cell();
+}
+
+cell Channel::setOutboundNonceAndZroBalance(cell $self, int outboundNonce, int zroBalance) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    return begin_cell()
+        .store_slice(
+            selfSlice.scutfirst(Channel::_outboundNonceOffset, 4)
+        ) ;; store whatever's behind the outbound nonce and all the refs
+        .store_uint64(outboundNonce)
+        .store_slice(
+            selfSlice.subslice(
+                Channel::_sendRequestIdOffset, ;; start bits
+                0, ;; start refs
+                64, ;; bits
+                0 ;; refs
+            )
+        ) ;; store the next 64 bits = sendRequestId
+        .store_uint128(zroBalance)
+        .end_cell();
+}
+
+cell Channel::setCommitPOOOAndExecutionQueue(cell $self, cell $commitPOOO, cell $executionQueue) impure inline {
+    slice selfSlice = $self.begin_parse();
+
+    slice ref2Slice = selfSlice.preloadRefSliceAt(2);
+    cell newRef2 = begin_cell()
+        .store_slice(ref2Slice.scutfirst(0, 2)) ;; store the first 2 refs [0, 1]
+        .store_ref($commitPOOO)                   ;; store the new commitPOOO = ref[2]
+        .store_slice(ref2Slice.scutlast(0, 1)) ;; store the last ref, ref[3]
+        .end_cell();
+
+    cell newRef3 = begin_cell()
+        .store_ref($executionQueue) ;; store the new executionQueue = ref[0]
+        .end_cell();
+
+    return begin_cell()
+        .store_slice(selfSlice.scutfirst(Channel::_sliceBits, 2)) ;; store all the bits and the first 3 refs [0, 1]  
+        .store_ref(newRef2) ;; store the new ref[2] which includes the new commitPOOO
+        .store_ref(newRef3) ;; store the new ref[3] which includes the new executionQueue
+        .end_cell();  
+}
+
+cell Channel::setPath(cell $self, cell $path) impure inline {
+    slice selfSlice = $self.begin_parse();
+    return begin_cell()
+        .store_ref(selfSlice.preloadRefAt(0))
+        .store_ref($path) ;; change ref 1
+        .store_slice(sskipfirst(selfSlice, 0, 2)) ;; rest of it stays the same
+        .end_cell();
 }

package/src/protocol/controller/handler.fc

@@ -28,6 +28,7 @@
 
 #include "interface.fc";
 #include "storage.fc";
+#include "../../classes/msgdata/SetEpConfig.fc";
 
 ;;; ================INTERFACE FUNCTIONS=====================
 
@@ -60,7 +61,7 @@ int _getEventSink() inline {
         ;; safe for open and public calls
         return ();
     } elseif (op == Controller::OP::SET_EP_CONFIG_OAPP) {
-        cell $path = $md.cl::get<objRef>(md::ExtendedMd::obj);
+        cell $path = $md.cl::get<objRef>(md::ExtendedMd::obj).lz::Path::sanitize();
         throw_unless(
             Controller::ERROR::onlyOApp,
             getCaller() == $path.cl::get<address>(lz::Path::srcOApp)
@@ -153,7 +154,8 @@ int _verifyEventSender(int sender, cell $senderStorageInit) impure method_id {
 tuple deployEndpoint(cell $deploy) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+    cell $sanitizedDeploy = $deploy.md::Deploy::sanitize();
+    int dstEid = $sanitizedDeploy.cl::get<uint32>(md::Deploy::dstEid);
     throw_if(Controller::ERROR::invalidEid, dstEid == 0);
 
     int eid = $storage.cl::get<uint32>(Controller::eid);
@@ -161,7 +163,7 @@ tuple deployEndpoint(cell $deploy) impure inline method_id {
     actions~pushAction<deployAndCall>(
         $storage.cl::get<cellRef>(Controller::endpointCode),
         Endpoint::New(eid, dstEid, getContractAddress()),
-        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        $sanitizedDeploy.cl::get<coins>(md::Deploy::initialDeposit),
         BaseInterface::OP::INITIALIZE,
         md::InitEndpoint::New($storage.cl::get<cellRef>(Controller::channelCode)),
         0
@@ -179,14 +181,15 @@ tuple deployEndpoint(cell $deploy) impure inline method_id {
 tuple deployChannel(cell $deploy) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
-    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+    cell $sanitizedDeploy = $deploy.md::Deploy::sanitize();
+    int dstEid = $sanitizedDeploy.cl::get<uint32>(md::Deploy::dstEid);
 
     ;; create the path object
     cell $path = lz::Path::New(
         $storage.cl::get<uint32>(Controller::eid), ;; srcEid
         getCaller(), ;; srcOApp
         dstEid, ;; dstEid
-        $deploy.cl::get<uint256>(md::Deploy::dstOApp) ;; dstOApp
+        $sanitizedDeploy.cl::get<uint256>(md::Deploy::dstOApp) ;; dstOApp
     );
 
     ;; get the endpoint address
@@ -195,7 +198,7 @@ tuple deployChannel(cell $deploy) impure inline method_id {
     actions~pushAction<deployAndCall>(
         $storage.cl::get<cellRef>(Controller::channelCode),
         Channel::New(getContractAddress(), $path, endpointAddress),
-        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        $sanitizedDeploy.cl::get<coins>(md::Deploy::initialDeposit),
         BaseInterface::OP::INITIALIZE,
         cl::nullObject(),
         0
@@ -213,11 +216,12 @@ tuple setEpConfigDefaults(cell $mdEid) impure inline method_id {
     (_, tuple actions) = preamble();
 
     int dstEid = $mdEid.cl::get<uint32>(md::MdEid::eid);
+    cell $sanitizedSetEpConfig = $mdEid.cl::get<objRef>(md::MdEid::md).md::SetEpConfig::sanitize();
 
     actions~pushAction<call>(
         _calculateEndpointAddress(dstEid),
         Endpoint::OP::SET_EP_CONFIG_DEFAULTS,
-        $mdEid.cl::get<objRef>(md::MdEid::md)
+        $sanitizedSetEpConfig
     );
 
     return actions;
@@ -234,10 +238,16 @@ tuple setEpConfigOApp(cell $mdObj) impure inline method_id {
     (_, tuple actions) = preamble();
 
     ;; get the path and setEpConfigMd from the md
-    cell $path = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $sanitizedPath = $mdObj.cl::get<objRef>(md::MdObj::obj).lz::Path::sanitize();
+
+    ;; create a sanitized mdObj with the sanitized setEpConfig
+    $mdObj = md::MdObj::New(
+        $mdObj.cl::get<objRef>(md::MdObj::md).md::SetEpConfig::sanitize(),
+        $sanitizedPath
+    );
 
     actions~pushAction<call>(
-        _calculateEndpointAddress($path.cl::get<uint32>(lz::Path::dstEid)),
+        _calculateEndpointAddress($sanitizedPath.cl::get<uint32>(lz::Path::dstEid)),
         Endpoint::OP::SET_EP_CONFIG_OAPP,
         $mdObj
     );
@@ -248,12 +258,14 @@ tuple setEpConfigOApp(cell $mdObj) impure inline method_id {
 tuple addMsglib(cell $addMsglibMd) impure inline method_id {
     (_, tuple actions) = preamble();
 
+    cell $sanitizedAddMsglibMd = $addMsglibMd.md::AddMsglib::sanitize();
+
     actions~pushAction<call>(
         _calculateEndpointAddress(
-            $addMsglibMd.cl::get<uint32>(md::AddMsglib::dstEid)
+            $sanitizedAddMsglibMd.cl::get<uint32>(md::AddMsglib::dstEid)
         ),
         Endpoint::OP::ADD_MSGLIB,
-        $addMsglibMd
+        $sanitizedAddMsglibMd
     );
 
     return actions;
@@ -263,16 +275,18 @@ tuple addMsglib(cell $addMsglibMd) impure inline method_id {
 tuple depositZro(cell $path) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedPath = $path.lz::Path::sanitize();
+
     ;; The message format of jetton happens to align with funC++
     ;; but the jetton token amount is aliased as donationNanos
     int tokenAmount = getDonationNanos();
     setDonationNanos(0);
 
     ;; get the endpoint address
-    int endpointAddress = _calculateEndpointAddress($path.cl::get<uint32>(lz::Path::dstEid));
+    int endpointAddress = _calculateEndpointAddress($sanitizedPath.cl::get<uint32>(lz::Path::dstEid));
 
     int channelAddress = computeContractAddress(
-        Channel::New(getContractAddress(), $path, endpointAddress),
+        Channel::New(getContractAddress(), $sanitizedPath, endpointAddress),
         $storage.cl::get<cellRef>(Controller::channelCode)
     );
 
@@ -288,14 +302,16 @@ tuple depositZro(cell $path) impure inline method_id {
 tuple setZroWallet(cell $setAddress) impure inline method_id {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedSetAddress = $setAddress.md::SetAddress::sanitize();
+
     setContractStorage(
         $storage.cl::set(
             Controller::zroWallet,
-            $setAddress.cl::get<address>(md::SetAddress::address)
+            $sanitizedSetAddress.cl::get<address>(md::SetAddress::address)
         )
     );
 
-    actions~pushAction<event>(Controller::event::ZRO_WALLET_SET, $setAddress);
+    actions~pushAction<event>(Controller::event::ZRO_WALLET_SET, $sanitizedSetAddress);
     return actions;
 }
 
@@ -306,16 +322,18 @@ tuple setZroWallet(cell $setAddress) impure inline method_id {
 tuple transferOwnership(cell $setAddress) impure inline {
     (cell $storage, tuple actions) = preamble();
 
+    cell $sanitizedSetAddress = $setAddress.md::SetAddress::sanitize();
+
     setContractStorage(
         $storage.cl::set(
             Controller::tentativeOwner,
-            $setAddress.cl::get<address>(md::SetAddress::address)
+            $sanitizedSetAddress.cl::get<address>(md::SetAddress::address)
         )
     );
 
     actions~pushAction<event>(
         Controller::event::OWNER_SET_TENTATIVE,
-        $setAddress
+        $sanitizedSetAddress
     );
 
     return actions;

package/src/protocol/controller/main.fc

@@ -26,4 +26,4 @@ tuple _executeOpcode(int op, cell $md) impure inline {
         throw(BaseInterface::ERROR::invalidOpcode);
     }
     return empty_tuple();
-}
+}

package/src/protocol/core/abstract/protocolHandler.fc

@@ -7,48 +7,45 @@
 #include "../baseStorage.fc";
 
 int getOwner() impure inline {
-    return getContractStorage()
-        .cl::get<objRef>(BASE_STORAGE_INDEX)
-        .cl::get<address>(BaseStorage::owner);
+    return getBaseStorage().BaseStorage::getOwner();
 }
 
 cell getInitialStorage() impure inline {
-    return getContractStorage()
-        .cl::get<objRef>(BASE_STORAGE_INDEX)
-        .cl::get<objRef>(BaseStorage::initialStorage);
+    return getBaseStorage().BaseStorage::getInitialStorage();
 }
 
 ;;; ==========================================
 ;; Modifiers
 () assertAuthenticated() impure inline {
-    cell $baseStorage = getContractStorage().cl::get<objRef>(BASE_STORAGE_INDEX);
     throw_unless(
         BaseInterface::ERROR::notAuthenticated,
-        $baseStorage.cl::get<bool>(BaseStorage::authenticated)
+        getBaseStorage().BaseStorage::getAuthenticated()
     );
 }
 
 () assertInitialized() impure inline {
-    cell $baseStorage = getContractStorage().cl::get<objRef>(BASE_STORAGE_INDEX);
     throw_unless(
         BaseInterface::ERROR::notInitialized,
-        $baseStorage.cl::get<bool>(BaseStorage::initialized)
+        getBaseStorage().BaseStorage::getInitialized()
     );
 }
 
 ;; assert the ctx sender is the owner of this contract
 ;; expects the ctx to be populated. Does not require storage to be loaded
 () assertOwner() impure inline {
-    cell $baseStorage = getContractStorage().cl::get<objRef>(BASE_STORAGE_INDEX);
     throw_unless(
         BaseInterface::ERROR::onlyOwner,
-        getCaller() == $baseStorage.cl::get<address>(BaseStorage::owner)
+        getCaller() == getOwner()
     );
 }
 
 ;; Step 1: authenticate
 () authenticate() impure {
     assertOwner();
+    throw_if(
+        BaseInterface::ERROR::alreadyInitialized,
+        getBaseStorage().BaseStorage::getInitialized()
+    );
     cell $storage = getContractStorage();
 
     setContractStorage(
@@ -67,10 +64,7 @@ cell getInitialStorage() impure inline {
 }
 
 () authenticateIfNecessary() impure inline {
-    if (getContractStorage()
-        .cl::get<objRef>(BASE_STORAGE_INDEX)
-        .cl::get<bool>(BaseStorage::authenticated) == false
-    ) {
+    if (getBaseStorage().BaseStorage::getAuthenticated() == false) {
         authenticate();
     }
 }
@@ -80,11 +74,7 @@ cell getInitialStorage() impure inline {
 ;; Step 2: initialize
 tuple initialize(cell $md) impure inline {
     assertAuthenticated();
-    if (
-        getContractStorage()
-            .cl::get<objRef>(BASE_STORAGE_INDEX)
-            .cl::get<bool>(BaseStorage::initialized)
-    ) {
+    if (getBaseStorage().BaseStorage::getInitialized()) {
         return emptyActions();
     }
 

package/src/protocol/core/baseStorage.fc

@@ -30,4 +30,28 @@ cell BaseStorage::New(int owner) inline method_id {
             [cl::t::objRef, cl::nullObject()] ;; BaseStorage::initialStorage
         ])
     );
+}
+
+const int BaseStorage::_ownerOffset = _HEADER_WIDTH;
+const int BaseStorage::_authenticatedOffset = BaseStorage::_ownerOffset + 256;
+const int BaseStorage::_initializedOffset = BaseStorage::_authenticatedOffset + 1;
+
+int BaseStorage::getOwner(cell $self) impure inline {
+    return $self.cellPreloadAddressAt(BaseStorage::_ownerOffset);
+}
+
+int BaseStorage::getAuthenticated(cell $self) impure inline {
+    return $self.cellPreloadBoolAt(BaseStorage::_authenticatedOffset);
+}
+
+int BaseStorage::getInitialized(cell $self) impure inline {
+    return $self.cellPreloadBoolAt(BaseStorage::_initializedOffset);
+}
+
+cell BaseStorage::getInitialStorage(cell $self) impure inline {
+     return $self.cellPreloadRefAt(0);
+}
+
+cell getBaseStorage() impure inline method_id {
+    return getContractStorage().cellPreloadRefAt(BASE_STORAGE_INDEX);
 }