@layerzerolabs/layerzero-v2-ton 3.0.59 → 3.0.60

package/src/classes/msgdata/CoinsAmount.fc

@@ -6,7 +6,7 @@ const int md::CoinsAmount::NAME = "coinsAmt"u;
 ;; field names
 const int md::CoinsAmount::amount = 0;
 
-cell md::CoinsAmount::New(int amount) inline method_id {
+cell md::CoinsAmount::New(int amount) impure inline method_id {
     return cl::declare(
         md::CoinsAmount::NAME,
         unsafeTuple([

package/src/classes/msgdata/CounterIncrement.fc

@@ -10,7 +10,7 @@ const int md::CounterIncrement::extraOptions = 2; ;; This is a reference to an '
 const int md::CounterIncrement::nativeFee = 3;
 const int md::CounterIncrement::zroFee = 4;
 
-cell md::CounterIncrement::New(int dstEid, int incrementType, cell $extraOptions, int nativeFee, int zroFee) inline method_id {
+cell md::CounterIncrement::New(int dstEid, int incrementType, cell $extraOptions, int nativeFee, int zroFee) impure inline method_id {
     return cl::declare(
         md::CounterIncrement::NAME,
         unsafeTuple([

package/src/classes/msgdata/Deploy.fc

@@ -9,7 +9,7 @@ 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 {
+cell md::Deploy::New(int initialDeposit, int dstEid, int dstOApp) impure inline method_id {
     return cl::declare(
         md::Deploy::NAME,
         unsafeTuple([

package/src/classes/msgdata/GetMsglibCallback.fc

@@ -7,7 +7,7 @@ const int md::getMsglibInfoCallback::NAME = "getMsgLbCb"u;
 const int md::getMsglibInfoCallback::msglibAddress = 0;
 const int md::getMsglibInfoCallback::connectionCode = 1;
 
-cell md::getMsglibInfoCallback::New(int msglibAddress, cell connectionCode) inline method_id {
+cell md::getMsglibInfoCallback::New(int msglibAddress, cell connectionCode) impure inline method_id {
     return cl::declare(
         md::getMsglibInfoCallback::NAME,
         unsafeTuple([

package/src/classes/msgdata/InitEndpoint.fc

@@ -6,7 +6,7 @@ const int md::InitEndpoint::NAME = "initEp"u;
 ;; field names
 const int md::InitEndpoint::channelCode = 0;
 
-cell md::InitEndpoint::New(cell channelCode) inline method_id {
+cell md::InitEndpoint::New(cell channelCode) impure inline method_id {
     return cl::declare(
         md::InitEndpoint::NAME,
         unsafeTuple([

package/src/classes/msgdata/LzReceivePrepare.fc

@@ -7,7 +7,7 @@ const int md::LzReceivePrepare::NAME = "lzrecvprep"u;
 const int md::LzReceivePrepare::nonce = 0;
 const int md::LzReceivePrepare::nanotons = 1;
 
-cell md::LzReceivePrepare::New(int nonce, int nanotons) method_id {
+cell md::LzReceivePrepare::New(int nonce, int nanotons) impure method_id {
     return cl::declare(
         md::LzReceivePrepare::NAME,
         unsafeTuple([

package/src/classes/msgdata/LzReceiveStatus.fc

@@ -38,7 +38,7 @@ cell md::LzReceiveStatus::NewFull(
     int sender,
     cell $packet,
     int executionStatus
-) inline method_id {
+) impure inline method_id {
     lz::Packet::_assertValidLinkedList(extraData, lz::Packet::MAX_RECEIVE_MESSAGE_CELLS);
     lz::Packet::_assertValidLinkedList(reason, lz::Packet::MAX_RECEIVE_MESSAGE_CELLS);
     return cl::declare(

package/src/classes/msgdata/LzSend.fc

@@ -23,7 +23,7 @@ cell md::LzSend::New(
     cell $enforcedOptions,
     cell $packet,
     cell callbackData
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::LzSend::NAME,
         unsafeTuple([

package/src/classes/msgdata/MdEid.fc

@@ -7,7 +7,7 @@ const int md::MdEid::NAME = "MdEid"u;
 const int md::MdEid::md = 0;
 const int md::MdEid::eid = 1;
 
-cell md::MdEid::New(cell $md, int eid) inline method_id {
+cell md::MdEid::New(cell $md, int eid) impure inline method_id {
     return cl::declare(
         md::MdEid::NAME,
         unsafeTuple([

package/src/classes/msgdata/MdObj.fc

@@ -7,7 +7,7 @@ const int md::MdObj::NAME = "MdObj"u;
 const int md::MdObj::md = 0;
 const int md::MdObj::obj = 1;
 
-cell md::MdObj::New(cell $md, cell $obj) inline method_id {
+cell md::MdObj::New(cell $md, cell $obj) impure inline method_id {
     return cl::declare(
         md::MdObj::NAME,
         unsafeTuple([

package/src/classes/msgdata/MessagingReceipt.fc

@@ -9,7 +9,7 @@ const int md::MessagingReceipt::nativeFeeActual = 1;
 const int md::MessagingReceipt::zroFeeActual = 2;
 const int md::MessagingReceipt::errorCode = 3;
 
-cell md::MessagingReceipt::New(cell $lzSend, int nativeFee, int zroFee, int errorCode) inline method_id {
+cell md::MessagingReceipt::New(cell $lzSend, int nativeFee, int zroFee, int errorCode) impure inline method_id {
     return cl::declare(
         md::MessagingReceipt::NAME,
         unsafeTuple([

package/src/classes/msgdata/MsglibSendCallback.fc

@@ -28,7 +28,7 @@ cell md::MsglibSendCallback::New(
     int guidBytes,
     cell $msglibSendEvents,
     int errorCode
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::MsglibSendCallback::NAME,
         unsafeTuple([
@@ -136,7 +136,7 @@ const int payees::_nativeAmountBits = 64;
 const int payees::_payeeBits = payees::_addressBits + payees::_nativeAmountBits;
 
 ;; Serializes 3 payees (256-bit address => 64-bit TON coin amount) per cell.
-cell serializePayees(tuple payeesInfo) inline {
+cell serializePayees(tuple payeesInfo) impure inline {
     int numPayees = payeesInfo.tlen();
     if (numPayees == 0) {
         return empty_cell();
@@ -164,7 +164,7 @@ cell serializePayees(tuple payeesInfo) inline {
 }
 
 ;; deserializePayees will ignore any bits beyond 960
-tuple deserializePayees(cell serializedPayees) inline {
+tuple deserializePayees(cell serializedPayees) impure inline {
     slice payeesSlice = serializedPayees.begin_parse();
     if (payeesSlice.slice_empty?()) {
         return empty_tuple();

package/src/classes/msgdata/Nonce.fc

@@ -6,7 +6,7 @@ const int md::Nonce::NAME = "nonce"u;
 ;; field names
 const int md::Nonce::nonce = 0;
 
-cell md::Nonce::New(int nonce) inline method_id {
+cell md::Nonce::New(int nonce) impure inline method_id {
     return cl::declare(
         md::Nonce::NAME,
         unsafeTuple([

package/src/classes/msgdata/OptionsExtended.fc

@@ -8,7 +8,7 @@ const int md::OptionsExtended::eid = 0;
 const int md::OptionsExtended::msgType = 1;
 const int md::OptionsExtended::options = 2;
 
-cell md::OptionsExtended::New(int eid, int msgType, cell $options) inline method_id {
+cell md::OptionsExtended::New(int eid, int msgType, cell $options) impure inline method_id {
     return cl::declare(
         md::OptionsExtended::NAME,
         unsafeTuple([

package/src/classes/msgdata/OptionsV1.fc

@@ -14,7 +14,7 @@ cell md::OptionsV1::New(
     int lzReceiveValue,
     int nativeDropAddress,
     int nativeDropAmount
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::OptionsV1::NAME,
         unsafeTuple([

package/src/classes/msgdata/OptionsV2.fc

@@ -22,7 +22,7 @@ cell md::OptionsV2::New(
     int lzComposeValue,
     int nativeDropAddress,
     int nativeDropAmount
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::OptionsV2::NAME,
         unsafeTuple([

package/src/classes/msgdata/PacketId.fc

@@ -7,7 +7,7 @@ const int md::PacketId::NAME = "pktId"u;
 const int md::PacketId::path = 0;
 const int md::PacketId::nonce = 1;
 
-cell md::PacketId::New(cell $path, int nonce) inline method_id {
+cell md::PacketId::New(cell $path, int nonce) impure inline method_id {
     return cl::declare(
         md::PacketId::NAME,
         unsafeTuple([

package/src/classes/msgdata/SetAddress.fc

@@ -6,7 +6,7 @@ const int md::SetAddress::NAME = "setAddress"u;
 ;; field names
 const int md::SetAddress::address = 0;
 
-cell md::SetAddress::New(int address) inline method_id {
+cell md::SetAddress::New(int address) impure inline method_id {
     return cl::declare(
         md::SetAddress::NAME,
         unsafeTuple([

package/src/classes/msgdata/SetEpConfig.fc

@@ -19,7 +19,7 @@ cell md::SetEpConfig::New(
     int receiveMsglibManager,
     int timeoutReceiveMsglibManager,
     int timeoutReceiveMsglibExpiry
-) inline method_id {
+) impure inline method_id {
     return cl::declare(
         md::SetEpConfig::NAME,
         unsafeTuple([

package/src/classes/msgdata/SetPeer.fc

@@ -7,7 +7,7 @@ const int md::SetPeer::NAME = "setPeer"u;
 const int md::SetPeer::eid = 0;
 const int md::SetPeer::peer = 1;
 
-cell md::SetPeer::New(int eid, int peer) inline method_id {
+cell md::SetPeer::New(int eid, int peer) impure inline method_id {
     return cl::declare(
         md::SetPeer::NAME,
         unsafeTuple([

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

@@ -9,12 +9,12 @@ const int action::rawCall::body = 2;
 ;; Call a method on the contract at address `to` with the given message data `md`
 ;; optionally provide value provisioned from this contract's balance
 ;; @terminal
-tuple action::rawCall::create(int to, cell body) inline {
+tuple action::rawCall::create(int to, cell body) impure inline {
     return unsafeTuple([action::rawCall::NAME, to, body]);
 }
 
 ;; returns true if equals
-int action::rawCall::equals(tuple self, tuple other) inline {
+int action::rawCall::equals(tuple self, tuple other) impure inline {
     return (
         (self.int_at(0) == other.int_at(0)) ;; NAME
         & (self.int_at(action::rawCall::to) == other.int_at(action::rawCall::to))
@@ -23,12 +23,12 @@ int action::rawCall::equals(tuple self, tuple other) inline {
 }
 
 ;; overloaded when you want to pass 0 outflowNanos
-tuple _newAction<rawCall>(int to, cell body) inline {
+tuple _newAction<rawCall>(int to, cell body) impure inline {
     return action::rawCall::create(to, body);
 }
 
 ;; overloaded when you want to pass 0 outflowNanos
-(tuple, ()) ~pushAction<rawCall>(tuple actions, int to, cell body) inline {
+(tuple, ()) ~pushAction<rawCall>(tuple actions, int to, cell body) impure inline {
     return (actions.tpush(_newAction<rawCall>(to, body)), ());
 }
 

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

@@ -10,12 +10,12 @@ const int action::call::md = 3;
 ;; Call a method on the contract at address `to` with the given message data `md`
 ;; optionally provide value provisioned from this contract's balance
 ;; @terminal
-tuple action::call::create(int to, int opcode, cell $md) inline {
+tuple action::call::create(int to, int opcode, cell $md) impure inline {
     return unsafeTuple([action::call::NAME, to, opcode, $md]);
 }
 
 ;; returns true if equals
-int action::call::equals(tuple self, tuple other) inline {
+int action::call::equals(tuple self, tuple other) impure 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 ");
@@ -30,12 +30,12 @@ int action::call::equals(tuple self, tuple other) inline {
 }
 
 ;; overloaded when you want to pass 0 outflowNanos
-tuple _newAction<call>(int to, int opcode, cell $body) inline {
+tuple _newAction<call>(int to, int opcode, cell $body) impure inline {
     return action::call::create(to, opcode, $body);
 }
 
 ;; overloaded when you want to pass 0 outflowNanos
-(tuple, ()) ~pushAction<call>(tuple actions, int to, int opcode, cell $body) inline {
+(tuple, ()) ~pushAction<call>(tuple actions, int to, int opcode, cell $body) impure inline {
     return (actions.tpush(_newAction<call>(to, opcode, $body)), ());
 }
 

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

@@ -27,13 +27,13 @@ tuple action::deploy::create(
     int opcode,
     cell $md,
     int outflowNanos
-) inline {
+) impure inline {
     return unsafeTuple(
         [action::deploy::NAME, code, $storage, donationNanos, opcode, $md, outflowNanos]
     );
 }
 
-int action::deploy::equals(tuple self, tuple other) {
+int action::deploy::equals(tuple self, tuple other) impure {
     int equalDataField = compareObjectFields(
         self.cell_at(action::deploy::storage),
         other.cell_at(action::deploy::storage)
@@ -60,7 +60,7 @@ tuple _newAction<deployAndCall>(
     int opcode,
     cell $md,
     int outflowNanos
-) inline {
+) impure inline {
     return action::deploy::create(
         code,
         $storage,
@@ -79,7 +79,7 @@ tuple _newAction<deployAndCall>(
     int opcode,
     cell $md,
     int outflowNanos
-) inline {
+) impure inline {
     return (
         actions
             .tpush(_newAction<deployAndCall>(

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

@@ -41,7 +41,7 @@ cell action::event::build(int topic, cell $body, cell $initialStorage) impure in
         .end_cell();
 }
 
-tuple action::event::create(int topic, cell $body, cell $initialStorage) inline {
+tuple action::event::create(int topic, cell $body, cell $initialStorage) impure inline {
     return unsafeTuple([
         action::event::NAME, 
         action::event::build(topic, $body, $initialStorage)
@@ -49,7 +49,7 @@ tuple action::event::create(int topic, cell $body, cell $initialStorage) inline
 }
 
 ;; returns true if equals
-int action::event::equals(tuple self, tuple other) {
+int action::event::equals(tuple self, tuple other) impure {
     int equalEventObj = compareObjectFields(
         self.cell_at(action::event::bodyIndex),
         other.cell_at(action::event::bodyIndex)

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

@@ -10,12 +10,12 @@ const int action::payment::amount = 2;
 const int action::payment::outflowNanos = 3;
 
 ;; @non-terminal
-tuple action::payment::create(int toAddress, int amount, int outflowNanos) inline {
+tuple action::payment::create(int toAddress, int amount, int outflowNanos) impure inline {
     return unsafeTuple([action::payment::NAME, toAddress, amount, outflowNanos]);
 }
 
 ;; returns true if equals
-int action::payment::equals(tuple self, tuple other) {
+int action::payment::equals(tuple self, tuple other) impure {
     return (
         (self.int_at(0) == other.int_at(0)) ;; NAME
         & (self.int_at(action::payment::toAddress) == other.int_at(action::payment::toAddress))
@@ -24,11 +24,11 @@ int action::payment::equals(tuple self, tuple other) {
     );
 }
 
-tuple _newAction<payment>(int toAddress, int amount, int outflowNanos) inline {
+tuple _newAction<payment>(int toAddress, int amount, int outflowNanos) impure inline {
     return action::payment::create(toAddress, amount, outflowNanos);
 }
 
-(tuple, ()) ~pushAction<payment>(tuple actions, int toAddress, int amount, int outflowNanos) inline {
+(tuple, ()) ~pushAction<payment>(tuple actions, int toAddress, int amount, int outflowNanos) impure inline {
     if (outflowNanos > 0) {
         actions = actions
             .tset(ACTIONS_OUTFLOW, actions.int_at(ACTIONS_OUTFLOW) + outflowNanos);

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

@@ -20,12 +20,12 @@ const int Jetton::OP::TRANSFER_NOTIFICATION = 0x7362d09c;
 const int Jetton::OP::TRANSFER = 0xf8a7ea5;
 
 ;; @terminal
-tuple action::sendJettons::create(int walletAddress, int toAddress, int amount, int responseAddress) inline {
+tuple action::sendJettons::create(int walletAddress, int toAddress, int amount, int responseAddress) impure inline {
     return unsafeTuple([action::sendJettons::NAME, walletAddress, toAddress, amount, responseAddress]);
 }
 
 ;; returns true if equals
-int action::sendJettons::equals(tuple self, tuple other) {
+int action::sendJettons::equals(tuple self, tuple other) impure {
     return (
         (self.int_at(0) == other.int_at(0)) ;; NAME
         & (self.int_at(action::sendJettons::walletAddress) == other.int_at(action::sendJettons::walletAddress))
@@ -35,7 +35,7 @@ int action::sendJettons::equals(tuple self, tuple other) {
     );
 }
 
-tuple _newAction<sendJettons>(int walletAddress, int toAddress, int amount, int responseAddress) inline {
+tuple _newAction<sendJettons>(int walletAddress, int toAddress, int amount, int responseAddress) impure inline {
     return action::sendJettons::create(walletAddress, toAddress, amount, responseAddress);
 }
 
@@ -45,11 +45,11 @@ tuple _newAction<sendJettons>(int walletAddress, int toAddress, int amount, int
     int toAddress,
     int amount,
     int responseAddress
-) inline {
+) impure inline {
     return (actions.tpush(_newAction<sendJettons>(walletAddress, toAddress, amount, responseAddress)), ());
 }
 
-cell buildJettonMessageBody(int toAddress, int amount, int responseAddress) inline {
+cell buildJettonMessageBody(int toAddress, int amount, int responseAddress) impure inline {
     return beginTonMessage(Jetton::OP::TRANSFER) ;; opcode, query_id
         .store_coins(amount) ;; jetton amount
         .store_slice(hashpartToBasechainAddressStd(toAddress)) ;; to address address
@@ -60,7 +60,7 @@ cell buildJettonMessageBody(int toAddress, int amount, int responseAddress) inli
         .end_cell();
 }
 
-int executeSendJettons(tuple dispatchAction) {
+int executeSendJettons(tuple dispatchAction) impure {
     sendTerminalAction(
         dispatchAction.int_at(action::sendJettons::walletAddress),
         buildJettonMessageBody(

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

@@ -37,7 +37,7 @@ tuple emptyActions() inline {
 ;; @info baseHandler::refund_addr is the last known "origin" of a message
 ;; flow, and is used to refund the sender if the handler does not
 ;; use all remaining value from the in_message
-cell buildLayerzeroMessageBody(int donationNanos, int opcode, cell $md) inline {
+cell buildLayerzeroMessageBody(int donationNanos, int opcode, cell $md) impure inline {
     cell ret = beginTonMessage(opcode)
         .store_coins(donationNanos)
         .store_slice(getOriginStd())

package/src/funC++/classlib.fc

@@ -45,7 +45,7 @@ const int FIELD_VAL_IDX = 1;
 
 ;;; ====================== Class functions ======================
 ;; returns type width in bits
-int _getTypeWidth(int clType) inline {
+int _getTypeWidth(int clType) impure inline {
     if (clType <= cl::t::uint256) {
         return 1 << clType; ;; type names are set up so this is true
     }
@@ -63,7 +63,7 @@ int cl::isNullObject(cell $obj) impure inline {
 
 ;; checks if a class lib object is flat, and contains no 'refs'
 ;; null is considered 'flat'
-int cl::noRefFields(cell $obj) {
+int cl::noRefFields(cell $obj) impure {
     slice headerSlice = $obj.begin_parse();
     int numRefs = headerSlice.slice_refs();
 
@@ -94,7 +94,7 @@ int cl::noRefFields(cell $obj) {
     return true;
 }
 
-int cl::equalObjTypeShallow(cell $a, cell $b) {
+int cl::equalObjTypeShallow(cell $a, cell $b) impure {
     slice aSlice = $a.begin_parse();
     slice bSlice = $b.begin_parse();
     int aRefs = aSlice.slice_refs();
@@ -120,7 +120,7 @@ int cl::equalObjTypeShallow(cell $a, cell $b) {
     return true;
 }
 
-int cl::typeof(cell $obj) inline method_id {
+int cl::typeof(cell $obj) impure inline method_id {
     if (cl::isNullObject($obj)) {
         return cl::NULL_CLASS_NAME;
     }
@@ -255,7 +255,7 @@ cell cl::declare(int name, tuple fields) impure inline {
         .end_cell();
 }
 
-cell cl::nullObject() inline method_id {
+cell cl::nullObject() impure inline method_id {
     return empty_cell();
 }
 
@@ -303,7 +303,7 @@ s1 XCHG0        // STACK [ substring, width1 ]
 PLDUX           // STACK [ 10BitUnsignInt ] ( CC + 1 )
 """;
 
-forall X -> cell cl::set(cell $self, int fieldName, X val) inline method_id {
+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);
@@ -360,7 +360,7 @@ const int _CELL_ID_WIDTH = 2; ;; the classlib backend supports up to 4 inner cel
 const int _DATA_OFFSET_WIDTH = 10; ;; 1023 bits per cell = 2**10 - 1
 
 
-int cl::get<uint>(cell $self, int fieldName, int width) inline method_id {
+int cl::get<uint>(cell $self, int fieldName, int width) impure inline method_id {
     slice headerSlice = $self.begin_parse();
 
     int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
@@ -374,7 +374,7 @@ int cl::get<uint>(cell $self, int fieldName, int width) inline method_id {
     }
 }
 
-cell cl::get<cellRef>(cell $self, int fieldName) inline method_id {
+cell cl::get<cellRef>(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);
@@ -391,54 +391,54 @@ cell cl::get<cellRef>(cell $self, int fieldName) inline method_id {
     ;
 }
 
-cell cl::get<objRef>(cell $self, int fieldName) inline method_id {
+cell cl::get<objRef>(cell $self, int fieldName) impure inline method_id {
     return cl::get<cellRef>($self, fieldName);
 }
 
-int cl::get<uint8>(cell $self, int fieldName) inline method_id {
+int cl::get<uint8>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 8);
 }
 
-int cl::get<uint16>(cell $self, int fieldName) inline method_id {
+int cl::get<uint16>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 16);
 }
 
-int cl::get<uint32>(cell $self, int fieldName) inline method_id {
+int cl::get<uint32>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 32);
 }
 
-int cl::get<uint64>(cell $self, int fieldName) inline method_id {
+int cl::get<uint64>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 64);
 }
 
-int cl::get<coins>(cell $self, int fieldName) inline method_id {
+int cl::get<coins>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 128);
 }
 
-int cl::get<uint256>(cell $self, int fieldName) inline method_id {
+int cl::get<uint256>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 256);
 }
 
-slice cl::get<std_address>(cell $self, int fieldName) inline method_id {
+slice cl::get<std_address>(cell $self, int fieldName) impure inline method_id {
     return hashpartToBasechainAddressStd(
         $self.cl::get<uint>(fieldName, 256)
     );
 }
 
-int cl::get<bool>(cell $self, int fieldName) inline method_id {
+int cl::get<bool>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 1) != 0;
 }
 
-cell cl::get<dict256>(cell $self, int fieldName) inline method_id {
+cell cl::get<dict256>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<cellRef>(fieldName);
 }
 
-int cl::get<address>(cell $self, int fieldName) inline method_id {
+int cl::get<address>(cell $self, int fieldName) impure inline method_id {
     return $self.cl::get<uint>(fieldName, 256);
 }
 
 ;;; =============== DEBUG / CONVENIENCE FUNCTIONS =================
-int typeofField(cell $self, int fieldName) inline {
+int typeofField(cell $self, int fieldName) impure inline {
     slice headerSlice = $self.begin_parse();
     int fieldInfoOffset = _BASIC_HEADER_WIDTH + (fieldName * _FIELD_INFO_WIDTH);
     return headerSlice
@@ -493,7 +493,7 @@ int objectsAreEqual(cell $lhs, cell $rhs) impure inline {
     return compareObjectFields($lhs, $rhs) == -1;
 }
 
-slice _typeToStr(int fieldType) {
+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";  }
@@ -586,28 +586,28 @@ tuple getContractStorageNestedField(int field, int nestedField) impure method_id
 
 ;;; ====================== Dictionary functions ======================
 
-slice uint256ToSlice(int val) inline {
+slice uint256ToSlice(int val) impure inline {
     return begin_cell().store_uint256(val).as_slice();
 }
 
-int sliceToUint256(slice s) inline {
+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() inline {
+cell cl::dict256::New() impure inline {
     return empty_cell();
 }
 
-(slice, int) cl::dict256::get(cell dict, int key) inline method_id {
+(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<uint256>(cell dict, int key) inline method_id {
+(int, int) cl::dict256::get<uint256>(cell dict, int key) impure inline method_id {
     (slice val, int exists) = cl::dict256::get(dict, key);
     if (exists) {
         return (sliceToUint256(val), true);
@@ -615,7 +615,7 @@ cell cl::dict256::New() inline {
     return (0, false);
 }
 
-(cell, int) cl::dict256::get<cellRef>(cell dict, int key) inline method_id {
+(cell, int) cl::dict256::get<cellRef>(cell dict, int key) impure inline method_id {
     if (dict.cell_is_empty()) {
         return (null(), false);
     }
@@ -626,7 +626,7 @@ cell cl::dict256::New() inline {
     return (ret, true);
 }
 
-cell cl::dict256::setRef(cell dict, int key, cell val) inline method_id {
+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,
@@ -637,7 +637,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 {
+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);
@@ -645,7 +645,7 @@ forall X -> cell cl::dict256::set(cell dict, int key, X val) inline {
     return dict.udict_set(DICT256_KEYLEN, key, _val);
 }
 
-cell cl::dict256::delete(cell dict, int key) {
+cell cl::dict256::delete(cell dict, int key) impure {
     if (dict.cell_is_empty()) {
         return dict;
     }

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

@@ -39,7 +39,7 @@ cell AddressList::serialize(tuple addressList) impure inline {
 }
 
 ;; Check that the addresslist is a valid linked list of addresses with no extra refs or bytes
-int AddressList::isValid(cell addressList, int maxCount) {
+int AddressList::isValid(cell addressList, int maxCount) impure {
     slice addressListSlice = addressList.begin_parse();
     int count = 0;
     while (addressListSlice.slice_empty?() == false) {