@layerzerolabs/layerzero-v2-ton 3.0.19-ton.0 → 3.0.19-ton.1

package/src/protocol/msglibs/ultralightnode/msgdata/TreasuryFeeBps.fc

@@ -0,0 +1,16 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required md name
+const int md::TreasuryFeeBps::NAME = "tfeebps"u;
+
+;; field names
+const int md::TreasuryFeeBps::treasuryFeeBps = 0;
+
+cell md::TreasuryFeeBps::New(int treasuryFeeBps) inline method_id {
+    return cl::declare(
+        md::TreasuryFeeBps::NAME,
+        unsafeTuple([
+            [cl::t::uint16, treasuryFeeBps]     ;; md::TreasuryFeeBps::treasuryFeeBps
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnEvents.fc

@@ -0,0 +1,26 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int UlnEvents::NAME = "UlnEvents"u;
+
+const int UlnEvents::CONSTS::NULL_WORKER_ID = 0;
+
+;; field names
+const int UlnEvents::workerEvents = 0;
+const int UlnEvents::dvnFeesPaidEvent = 1;
+const int UlnEvents::executorFeePaidEvent = 2;
+
+cell UlnEvents::New(
+    cell workerEvents,
+    cell dvnFeesPaidEvent,
+    cell executorFeePaidEvent
+) inline method_id {
+    return cl::declare(
+        UlnEvents::NAME,
+        unsafeTuple([
+            [cl::t::objRef, workerEvents],          ;; UlnEvents::workerEvents
+            [cl::t::objRef, dvnFeesPaidEvent],      ;; UlnEvents::dvnFeesPaidEvent
+            [cl::t::objRef, executorFeePaidEvent]   ;; UlnEvents::executorFeePaidEvent
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnReceiveConfig.fc

@@ -0,0 +1,249 @@
+#include "../../../../funC++/classlib.fc";
+
+#include "../../../../funC++/dataStructures/AddressList.fc";
+
+const int UlnReceiveConfig::CONST::NIL_ADDRESS = MAX_U256;
+
+const int UlnReceiveConfig::COMMIT_PACKET_INTERNAL_MESSAGE_COUNT = 4;
+;; connection -> endpoint -> channel -> connection
+const int UlnReceiveConfig::ERROR::DVN_CONFIG_ERROR = 321;
+
+;; Maximum number of DVNs allowed in the config is 8 required + 8 optional = 16 total.
+;; The hashlookups is a mapping of nonce -> address -> attestation
+;; meaning that 16 DVNs will require (2 * 16) - 1 cells for the dictionary tree inner nodes
+;; and 16 cells for the attestations = 63 cells per nonce.
+;; We allow up to 1000 nonces in the hashlookups, so the maximum number of cells required
+;; for the hashlookups is 1000 * 63 = 63000 cells.
+;; This leaves 2535 cells for the fixed-size storage and bytecode of this contract, which is
+;; sufficient.
+const int UlnReceiveConfig::MaxRequiredDVNs = 8;
+const int UlnReceiveConfig::MaxOptionalDVNs = 4;
+
+;; required storage name
+const int UlnReceiveConfig::NAME = "UlnRecvCfg"u;
+
+;; field names
+
+;; EVM struct ExecutorConfig
+;; uint32 maxMessageSize;
+;; address executor;
+
+const int UlnReceiveConfig::minCommitPacketGasNull = 0; ;; bool
+const int UlnReceiveConfig::minCommitPacketGas = 1; ;; uint32
+const int UlnReceiveConfig::confirmationsNull = 2; ;; bool
+const int UlnReceiveConfig::confirmations = 3; ;; uint64
+const int UlnReceiveConfig::requiredDVNsNull = 4; ;; bool
+const int UlnReceiveConfig::requiredDVNs = 5; ;; address[] will be stored as a dictionary
+const int UlnReceiveConfig::optionalDVNsNull = 6; ;; bool
+const int UlnReceiveConfig::optionalDVNs = 7; ;; address[] will be stored as a dictionary
+const int UlnReceiveConfig::optionalDVNThreshold = 8; ;; uint8
+
+const int UlnReceiveConfig::ERROR::OPTIONAL_THRESHOLD_TOO_LARGE = 385;
+const int UlnReceiveConfig::ERROR::OPTIONAL_THRESHOLD_TOO_LOW = 386;
+const int UlnReceiveConfig::ERROR::DVN_COUNTS_ALL_NIL = 387;
+const int UlnReceiveConfig::ERROR::INVALID_MIN_COMMIT_PACKET_GAS = 388;
+
+;; EVM struct UlnReceiveConfig
+;; uint64 confirmations;
+;; // we store the length of required DVNs and optional DVNs instead of using DVN.length directly to save gas
+;; uint8 requiredDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
+;; uint8 optionalDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
+;; uint8 optionalDVNThreshold; // (0, optionalDVNCount]
+;; address[] requiredDVNs; // no duplicates. sorted an an ascending order. allowed overlap with optionalDVNs
+;; address[] optionalDVNs; // no duplicates. sorted an an ascending order. allowed overlap with requiredDVNs
+
+cell UlnReceiveConfig::New(
+    int useDefaultMinCommitPacketGas,
+    int minCommitPacketGas,
+    int useDefaultConfirmations,
+    int confirmations,
+    int useDefaultRequiredDVNs,
+    cell requiredDVNs,
+    int useDefaultOptionalDVNs,
+    cell optionalDVNs,
+    int optionalDVNThreshold
+) impure method_id {
+    return cl::declare(
+        UlnReceiveConfig::NAME,
+        unsafeTuple([
+            [cl::t::bool, useDefaultMinCommitPacketGas],
+            [cl::t::uint32, minCommitPacketGas],   ;; UlnReceiveConfig::minCommitPacketGas
+            [cl::t::bool, useDefaultConfirmations],
+            [cl::t::uint64, confirmations],        ;; UlnReceiveConfig::confirmations
+            [cl::t::bool, useDefaultRequiredDVNs],
+            [cl::t::cellRef, requiredDVNs],        ;; UlnReceiveConfig::requiredDVNs
+            [cl::t::bool, useDefaultOptionalDVNs],
+            [cl::t::cellRef, optionalDVNs],        ;; UlnReceiveConfig::requiredDVNs
+            [cl::t::uint8, optionalDVNThreshold]   ;; UlnReceiveConfig::optionalDVNThreshold
+        ])
+    );
+}
+
+;; Important assumption: the gas consumption of the endpoint will not increase past
+;; 1 million gas per handler in any future update of the TVM.
+int UlnReceiveConfig::MaxCommitPacketValueAssertion() method_id {
+    (_, _, _, _, int gasLimit, _, _, _, _) = parseGasLimitsPrices(BASECHAIN);
+    gasLimit = max(gasLimit, 1000000);
+
+    return (
+        _gasToNanoton(gasLimit * UlnReceiveConfig::COMMIT_PACKET_INTERNAL_MESSAGE_COUNT)
+        + (
+            UlnReceiveConfig::COMMIT_PACKET_INTERNAL_MESSAGE_COUNT
+            * get_forward_fee(false, MAX_U8 * MAX_CELL_BITS, MAX_U8)
+        )
+    );
+}
+
+cell UlnReceiveConfig::NewWithDefaults() inline method_id {
+    return UlnReceiveConfig::New(
+        true,
+        0,
+        true,
+        0,
+        true,
+        AddressList::empty(),
+        true,
+        AddressList::empty(),
+        0
+    );
+}
+
+int UlnReceiveConfig::utils::getConfirmations(
+    cell $UlnReceiveConfig,
+    cell $defaultUlnReceiveConfig
+) impure inline {
+    if ($UlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::confirmationsNull)) {
+        return $defaultUlnReceiveConfig.cl::get<uint64>(UlnReceiveConfig::confirmations);
+    }
+    return $UlnReceiveConfig.cl::get<uint64>(UlnReceiveConfig::confirmations);
+}
+
+(cell, cell, int) UlnReceiveConfig::utils::getVerifyConfig(
+    cell $customUlnReceiveConfig,
+    cell $defaultUlnReceiveConfig
+) impure inline {
+    int isValid = true;
+
+    cell requiredDVNs = $customUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::requiredDVNs);
+    cell optionalDVNs = $customUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::optionalDVNs);
+
+    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::requiredDVNsNull)) {
+        isValid &= ($defaultUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::requiredDVNsNull) == false);
+        requiredDVNs = $defaultUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::requiredDVNs);
+    }
+
+    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull)) {
+        isValid &= ($defaultUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull) == false);
+        optionalDVNs = $defaultUlnReceiveConfig.cl::get<cellRef>(UlnReceiveConfig::optionalDVNs);
+    }
+
+    return (requiredDVNs, optionalDVNs, isValid);
+}
+
+(cell, cell, int, int, int, int) UlnReceiveConfig::utils::getCommitConfig(
+    cell $customUlnReceiveConfig,
+    cell $defaultUlnReceiveConfig
+) inline method_id {
+    (cell $requiredDVNs, cell $optionalDVNs, int isValid) = UlnReceiveConfig::utils::getVerifyConfig(
+        $customUlnReceiveConfig,
+        $defaultUlnReceiveConfig
+    );
+
+    int optionalDVNThreshold = $customUlnReceiveConfig
+        .cl::get<uint8>(UlnReceiveConfig::optionalDVNThreshold);
+    int commitPacketGas = $customUlnReceiveConfig
+        .cl::get<uint32>(UlnReceiveConfig::minCommitPacketGas);
+
+
+    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull)) {
+        optionalDVNThreshold = $defaultUlnReceiveConfig
+            .cl::get<uint8>(UlnReceiveConfig::optionalDVNThreshold);
+    }
+
+    if ($customUlnReceiveConfig.cl::get<bool>(UlnReceiveConfig::minCommitPacketGasNull)) {
+        commitPacketGas = $defaultUlnReceiveConfig
+            .cl::get<uint32>(UlnReceiveConfig::minCommitPacketGas);
+    }
+
+    int confirmations = UlnReceiveConfig::utils::getConfirmations(
+        $customUlnReceiveConfig,
+        $defaultUlnReceiveConfig
+    );
+
+    return ($requiredDVNs, $optionalDVNs, optionalDVNThreshold, confirmations, commitPacketGas, isValid);
+}
+
+;; Ensure the Uln receive config does not contain garbage bits etc. that would cause
+;; undefined behaviors in the protocol
+cell UlnReceiveConfig::sanitize(cell $ulnReceiveConfigOApp) impure {
+    int useDefaultMinCommitPacketGas = 
+        $ulnReceiveConfigOApp.cl::get<bool>(UlnReceiveConfig::minCommitPacketGasNull);
+    int minCommitPacketGas = 
+        $ulnReceiveConfigOApp.cl::get<uint32>(UlnReceiveConfig::minCommitPacketGas);
+    int useDefaultConfirmations = 
+        $ulnReceiveConfigOApp.cl::get<bool>(UlnReceiveConfig::confirmationsNull);
+    int confirmations = 
+        $ulnReceiveConfigOApp.cl::get<uint64>(UlnReceiveConfig::confirmations);
+    int useDefaultRequiredDVNs = 
+        $ulnReceiveConfigOApp.cl::get<bool>(UlnReceiveConfig::requiredDVNsNull);
+    cell requiredDVNs = 
+        $ulnReceiveConfigOApp.cl::get<cellRef>(UlnReceiveConfig::requiredDVNs);
+    int useDefaultOptionalDVNs = 
+        $ulnReceiveConfigOApp.cl::get<bool>(UlnReceiveConfig::optionalDVNsNull);
+    cell optionalDVNs = 
+        $ulnReceiveConfigOApp.cl::get<cellRef>(UlnReceiveConfig::optionalDVNs);
+    int optionalDVNThreshold = 
+        $ulnReceiveConfigOApp.cl::get<uint8>(UlnReceiveConfig::optionalDVNThreshold);
+
+    int numRequiredDVNs = requiredDVNs.AddressList::length();
+    int numOptionalDVNs = optionalDVNs.AddressList::length();
+
+    throw_unless(
+        UlnReceiveConfig::ERROR::DVN_CONFIG_ERROR,
+        AddressList::isValid(requiredDVNs, UlnReceiveConfig::MaxRequiredDVNs)
+        & AddressList::isValid(optionalDVNs, UlnReceiveConfig::MaxOptionalDVNs)
+    );
+
+    throw_if(
+        UlnReceiveConfig::ERROR::INVALID_MIN_COMMIT_PACKET_GAS,
+        (useDefaultMinCommitPacketGas == false)
+        & (minCommitPacketGas <= 0)
+    );
+
+    ;; Prevent a malicious OApp from setting the threshold to a value that would
+    ;; make it impossible to commit a packet
+    throw_if(
+        UlnReceiveConfig::ERROR::INVALID_MIN_COMMIT_PACKET_GAS,
+        _gasToNanoton(minCommitPacketGas) > UlnReceiveConfig::MaxCommitPacketValueAssertion()
+    );
+
+    throw_if(
+        UlnReceiveConfig::ERROR::OPTIONAL_THRESHOLD_TOO_LARGE,
+        optionalDVNThreshold > numOptionalDVNs
+    );
+
+    throw_if(
+        UlnReceiveConfig::ERROR::OPTIONAL_THRESHOLD_TOO_LOW,
+        (numOptionalDVNs > 0) & (optionalDVNThreshold <= 0)
+    );
+
+    throw_if(
+        UlnReceiveConfig::ERROR::DVN_COUNTS_ALL_NIL,
+        (useDefaultRequiredDVNs == false)
+        & (useDefaultOptionalDVNs == false)
+        & (numRequiredDVNs == 0)
+        & (numOptionalDVNs == 0)
+    );
+
+    return UlnReceiveConfig::New(
+        useDefaultMinCommitPacketGas,
+        minCommitPacketGas,
+        useDefaultConfirmations,
+        confirmations,
+        useDefaultRequiredDVNs,
+        requiredDVNs,
+        useDefaultOptionalDVNs,
+        optionalDVNs,
+        optionalDVNThreshold
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnSend.fc

@@ -0,0 +1,27 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int md::UlnSend::NAME = "UlnSend"u;
+
+;; field names
+const int md::UlnSend::lzSend = 0;
+const int md::UlnSend::customUlnSendConfig = 1;
+const int md::UlnSend::connectionInitialStorage = 2;
+const int md::UlnSend::forwardingAddress = 3;
+
+cell md::UlnSend::New(
+    cell $lzSend,
+    cell $customUlnSendConfig,
+    cell $connectionInitialStorage,
+    int forwardingAddress
+) inline method_id {
+    return cl::declare(
+        md::UlnSend::NAME,
+        unsafeTuple([
+            [cl::t::objRef, $lzSend],                   ;; md::UlnSend::lzSend
+            [cl::t::objRef, $customUlnSendConfig],      ;; md::UlnSend::customUlnSendConfig
+            [cl::t::objRef, $connectionInitialStorage], ;; md::UlnSend::connectionInitialStorage
+            [cl::t::address, forwardingAddress]         ;; md::UlnSend::forwardingAddress
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnSendConfig.fc

@@ -0,0 +1,170 @@
+#include "../../../../funC++/classlib.fc";
+
+#include "../../../../funC++/dataStructures/AddressList.fc";
+
+const int MAX_DVN_COUNT = 255; ;; uint8
+const int lz::UlnSendConfig::CONST::NIL_ADDRESS = MAX_U256;
+
+const int UlnSendConfig::ERROR::DVN_CONFIG_ERROR = 353;
+
+;; required storage name
+const int lz::UlnSendConfig::NAME = "UlnSendCfg"u;
+
+;; field names
+
+;; EVM struct ExecutorConfig
+;; uint32 maxMessageSize;
+;; address executor;
+
+;; Both side configs
+const int UlnSendConfig::workerQuoteGasLimit = 0;          ;; uint64, set to 0 for using default
+const int UlnSendConfig::maxMessageBytes = 1;              ;; uint32, set to 0 for using default
+const int UlnSendConfig::executorNull = 2;                 ;; bool
+const int UlnSendConfig::executor = 3;                     ;; address (set to NIL for using default)
+const int UlnSendConfig::requiredDVNsNull = 4;             ;; bool
+const int UlnSendConfig::requiredDVNs = 5;                 ;; address[] will be stored as a dictionary
+const int UlnSendConfig::optionalDVNsNull = 6;             ;; bool
+const int UlnSendConfig::optionalDVNs = 7;                 ;; address[] will be stored as a dictionary
+const int UlnSendConfig::confirmationsNull = 8;
+const int UlnSendConfig::confirmations = 9;
+
+;; these null flags above mean "try to resolve this field from the other config" if they're set to true.
+
+cell UlnSendConfig::New(
+    int workerQuoteGasLimit,
+    int maxMessageBytes,
+    int executorNull,
+    int executor,
+    int requiredDVNsNull,
+    cell requiredDVNs,
+    int optionalDVNsNull,
+    cell optionalDVNs,
+    int confirmationsNull,
+    int confirmations
+) impure method_id {
+    return cl::declare(
+        lz::UlnSendConfig::NAME,
+        unsafeTuple([
+            [cl::t::uint32, workerQuoteGasLimit], ;; lz::UlnSendConfig::workerQuoteGasLimit
+            [cl::t::uint32, maxMessageBytes],     ;; lz::UlnSendConfig::maxMessageBytes
+            [cl::t::bool, executorNull],          ;; lz::UlnSendConfig::executorNull
+            [cl::t::address, executor],           ;; lz::UlnSendConfig::executor
+            [cl::t::bool, requiredDVNsNull],      ;; lz::UlnSendConfig::requiredDVNsNull
+            [cl::t::cellRef, requiredDVNs],       ;; lz::UlnSendConfig::requiredDVNs
+            [cl::t::bool, optionalDVNsNull],      ;; lz::UlnSendConfig::optionalDVNsNull
+            [cl::t::cellRef, optionalDVNs],       ;; lz::UlnSendConfig::optionalDVNs
+            [cl::t::bool, confirmationsNull],     ;; lz::UlnSendConfig::confirmationsNull
+            [cl::t::uint64, confirmations]        ;; lz::UlnSendConfig::confirmations
+        ])
+    );
+}
+
+;; todo update these default values
+cell UlnSendConfig::NewWithDefaults() impure method_id {
+    return UlnSendConfig::New(
+        0,
+        0,
+        true,
+        NULLADDRESS,
+        true,
+        empty_cell(),
+        true,
+        empty_cell(),
+        true,
+        0
+    );
+}
+
+;; quoteGasLimit, maxMsgBytes, executor, requiredDVNs, optionalDVNs, confirmations, isValid
+(int, int, int, cell, cell, int, int) lz::UlnSendConfig::resolveUlnSendConfig(
+    cell $customUlnSendConfig,
+    cell $defaultUlnSendConfig
+) impure inline {
+    int isValid = true;
+
+    ;; low-level destructuring of customUlnSendConfig for efficiency
+    ;; 1. skip the header
+    slice customUlnSendConfigSlice = $customUlnSendConfig
+        .begin_parse()
+        .sskipfirst(_HEADER_WIDTH, 0);
+
+    ;; read all fields
+    ;; 32 + 32 + 1 + 256 + 1 + 1 + 1 + 64 = 388 bits of data + 2 refs
+    ;; all fit in the root cell with +350 bits for header (388 + 350 = 738 < 1023)
+    int quoteGasLimit = customUlnSendConfigSlice~load_uint32();
+    int maxMsgBytes = customUlnSendConfigSlice~load_uint32();
+    int executorNull = customUlnSendConfigSlice~load_bool();
+    int executor = customUlnSendConfigSlice~load_uint256();
+    int requiredDVNsNull = customUlnSendConfigSlice~load_bool();
+    cell requiredDVNs = customUlnSendConfigSlice~load_ref();
+    int optionalDVNsNull = customUlnSendConfigSlice~load_bool();
+    cell optionalDVNs = customUlnSendConfigSlice~load_ref();
+    int confirmationsNull = customUlnSendConfigSlice~load_bool();
+    int confirmations = customUlnSendConfigSlice~load_uint64();
+
+    if (quoteGasLimit == 0) {
+        quoteGasLimit = $defaultUlnSendConfig
+            .cl::get<uint32>(UlnSendConfig::workerQuoteGasLimit);
+    }
+
+    if (maxMsgBytes == 0) {
+        maxMsgBytes = $defaultUlnSendConfig
+            .cl::get<uint32>(UlnSendConfig::maxMessageBytes);
+    }
+
+    if (executorNull) {
+        isValid &= ($defaultUlnSendConfig.cl::get<bool>(UlnSendConfig::executorNull) == false);
+        executor = $defaultUlnSendConfig.cl::get<address>(UlnSendConfig::executor);
+    }
+
+    if (requiredDVNsNull) {
+        isValid &= ($defaultUlnSendConfig.cl::get<bool>(UlnSendConfig::requiredDVNsNull) == false);
+        requiredDVNs = $defaultUlnSendConfig.cl::get<cellRef>(UlnSendConfig::requiredDVNs);
+    }
+
+    if (optionalDVNsNull) {
+        isValid &= ($defaultUlnSendConfig.cl::get<bool>(UlnSendConfig::optionalDVNsNull) == false);
+        optionalDVNs = $defaultUlnSendConfig.cl::get<cellRef>(UlnSendConfig::optionalDVNs);
+    }
+
+    if (confirmationsNull) {
+        isValid &= ($defaultUlnSendConfig.cl::get<bool>(UlnSendConfig::confirmationsNull) == false);
+        confirmations = $defaultUlnSendConfig.cl::get<uint64>(UlnSendConfig::confirmations);
+    }
+
+    return (quoteGasLimit, maxMsgBytes, executor, requiredDVNs, optionalDVNs, confirmations, isValid);
+}
+
+;; Ensure the Uln send config does not contain garbage bits etc. that would cause
+;; undefined behaviors in the protocol
+cell UlnSendConfig::sanitize(cell $ulnSendConfig) impure inline_ref {
+    int workerQuoteGasLimit = $ulnSendConfig.cl::get<uint32>(UlnSendConfig::workerQuoteGasLimit);
+    int maxMessageBytes = $ulnSendConfig.cl::get<uint32>(UlnSendConfig::maxMessageBytes);
+    int useDefaultExecutor = $ulnSendConfig.cl::get<bool>(UlnSendConfig::executorNull);
+    int executor = $ulnSendConfig.cl::get<address>(UlnSendConfig::executor);
+    int useDefaultRequiredDVNs = $ulnSendConfig.cl::get<bool>(UlnSendConfig::requiredDVNsNull);
+    cell requiredDVNs = $ulnSendConfig.cl::get<cellRef>(UlnSendConfig::requiredDVNs);
+    int useDefaultOptionalDVNs = $ulnSendConfig.cl::get<bool>(UlnSendConfig::optionalDVNsNull);
+    cell optionalDVNs = $ulnSendConfig.cl::get<cellRef>(UlnSendConfig::optionalDVNs);
+    int useDefaultConfirmations = $ulnSendConfig.cl::get<bool>(UlnSendConfig::confirmationsNull);
+    int confirmations = $ulnSendConfig.cl::get<uint64>(UlnSendConfig::confirmations);
+
+    throw_unless(
+        UlnSendConfig::ERROR::DVN_CONFIG_ERROR,
+        AddressList::isValid(requiredDVNs, MAX_DVN_COUNT)
+        & AddressList::isValid(optionalDVNs, MAX_DVN_COUNT)
+    );
+
+    return UlnSendConfig::New(
+        workerQuoteGasLimit,
+        maxMessageBytes,
+        useDefaultExecutor,
+        executor,
+        useDefaultRequiredDVNs,
+        requiredDVNs,
+        useDefaultOptionalDVNs,
+        optionalDVNs,
+        useDefaultConfirmations,
+        confirmations
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnVerification.fc

@@ -0,0 +1,21 @@
+#include "Attestation.fc";
+
+;; required storage name
+const int md::UlnVerification::NAME = "UlnVerify"u;
+
+;; field names
+const int md::UlnVerification::nonce = 0; ;; hash
+const int md::UlnVerification::attestation = 1; ;; uint64
+
+cell md::UlnVerification::New(int nonce, int hash, int confirmations) inline method_id {
+    return cl::declare(
+        md::UlnVerification::NAME,
+        unsafeTuple([
+            [cl::t::uint64, nonce], ;; md::UlnVerification::nonce
+            [cl::t::objRef, lz::Attestation::New(
+                hash,
+                confirmations
+            )]                      ;; md::UlnVerification::attestation
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnWorkerFeelibBytecode.fc

@@ -0,0 +1,16 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int md::UlnWorkerFeelibBytecode::NAME = "Ulnbytecod"u;
+
+;; field names
+const int md::UlnWorkerFeelibBytecode::bytecode = 0; ;; cellRef
+
+cell md::UlnWorkerFeelibBytecode::New(cell bytecode) inline method_id {
+    return cl::declare(
+        md::UlnWorkerFeelibBytecode::NAME,
+        unsafeTuple([
+            [cl::t::cellRef, bytecode] ;; md::UlnWorkerFeelibBytecode::nonce
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnWorkerFeelibEvents.fc

@@ -0,0 +1,58 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int md::UlnWorkerFeelibEvents::NAME = "UlnWrkEvnt"u;
+
+;; field names
+const int md::UlnWorkerFeelibEvents::workerAddress = 0;
+const int md::UlnWorkerFeelibEvents::workerEvents = 1;
+const int md::UlnWorkerFeelibEvents::nextWorkerEvents = 2;
+
+cell md::UlnWorkerFeelibEvents::New(
+    int workerAddress,
+    cell $workerEvents,
+    cell $nextWorkerEvents
+) impure inline method_id {
+    return cl::declare(
+        md::UlnWorkerFeelibEvents::NAME,
+        unsafeTuple([
+            [cl::t::address, workerAddress],       ;; md::UlnWorkerFeelibEvents::workerAddress
+            [cl::t::objRef, $workerEvents],        ;; md::UlnWorkerFeelibEvents::workerEvents
+            [cl::t::objRef, $nextWorkerEvents]      ;; md::UlnWorkerFeelibEvents::nextWorkerEvents
+        ])
+    );
+}
+
+tuple UlnWorkerFeelibEventsBuilder::create() impure inline {
+    return empty_tuple();
+}
+
+tuple UlnWorkerFeelibEventsBuilder::push(
+    tuple eventBuilder,
+    int workerAddress,
+    cell eventBody
+) impure inline {
+    if (eventBody.is_null()) {
+        return eventBuilder;
+    }
+    return eventBuilder.tpush([workerAddress, eventBody]);
+}
+
+cell UlnWorkerFeelibEvents::FromBuilder(tuple eventBuilder) impure inline {
+    if (eventBuilder.tlen() == 0) {
+        ;; short-circuit the common case for efficiency
+        return cl::nullObject();
+    }
+
+    cell $workerEvents = cl::nullObject();
+    while (eventBuilder.tlen() > 0) {
+        [int workerAddress, cell $workerEventBody] = eventBuilder~tpop();
+        $workerEvents = md::UlnWorkerFeelibEvents::New(
+            workerAddress,
+            $workerEventBody,
+            $workerEvents
+        );
+    }
+
+    return $workerEvents;
+}

package/src/protocol/msglibs/ultralightnode/msgdata/UlnWorkerFeelibInfo.fc

@@ -0,0 +1,56 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int UlnWorkerFeelibInfo::NAME = "UlnWrkInfo"u;
+
+;; 'UlnWorkerFeelibInfo::useDefaults' is ONLY used during the oapp config set flow.
+;; When setting 'epConfigDefaults' as the owner, the flag doesnt matter, because call is for defaults
+
+;; field names
+const int UlnWorkerFeelibInfo::workerAddress = 0;
+const int UlnWorkerFeelibInfo::workerFeelibBytecode = 1;
+const int UlnWorkerFeelibInfo::workerFeelibStorage = 2;
+const int UlnWorkerFeelibInfo::friendWorkerAddress = 3;
+const int UlnWorkerFeelibInfo::dstEid = 4;
+const int UlnWorkerFeelibInfo::rentBalance = 5;
+const int UlnWorkerFeelibInfo::lastRentTimestamp = 6;
+const int UlnWorkerFeelibInfo::isAdmin = 7;
+
+cell UlnWorkerFeelibInfo::New(
+    int workerAddress,
+    cell workerFeelibBytecode,
+    cell workerFeelibStorage,
+    int friendWorkerAddress,
+    int dstEid,
+    int rentBalance,
+    int isAdmin
+) inline method_id {
+    return cl::declare(
+        UlnWorkerFeelibInfo::NAME,
+        unsafeTuple([
+            [cl::t::address, workerAddress],        ;; UlnWorkerFeelibInfo::workerAddress
+            [cl::t::cellRef, workerFeelibBytecode], ;; UlnWorkerFeelibInfo::workerFeelibBytecode
+            [cl::t::objRef, workerFeelibStorage],   ;; UlnWorkerFeelibInfo::workerFeelibStorage
+            [cl::t::address, friendWorkerAddress],  ;; UlnWorkerFeelibInfo::friendWorkerAddress
+            [cl::t::uint32, dstEid],                ;; UlnWorkerFeelibInfo::dstEid
+            [cl::t::coins, rentBalance],            ;; UlnWorkerFeelibInfo::rentBalance
+            [cl::t::uint64, 0],                     ;; UlnWorkerFeelibInfo::lastRentTimestamp
+            [cl::t::bool, isAdmin]                  ;; UlnWorkerFeelibInfo::isAdmin
+        ])
+    );
+}
+
+cell UlnWorkerFeelibInfo::sanitize(cell $ulnWorkerFeelibInfo) {
+    return UlnWorkerFeelibInfo::New(
+        $ulnWorkerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress),
+        $ulnWorkerFeelibInfo.cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode),
+        $ulnWorkerFeelibInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage),
+        $ulnWorkerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::friendWorkerAddress),
+        $ulnWorkerFeelibInfo.cl::get<uint32>(UlnWorkerFeelibInfo::dstEid),
+        $ulnWorkerFeelibInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance),
+        $ulnWorkerFeelibInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin)
+    ).cl::set(
+        UlnWorkerFeelibInfo::lastRentTimestamp,
+        $ulnWorkerFeelibInfo.cl::get<uint64>(UlnWorkerFeelibInfo::lastRentTimestamp)
+    );
+}

package/src/protocol/msglibs/ultralightnode/msgdata/VerificationStatus.fc

@@ -0,0 +1,18 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int md::VerificationStatus::NAME = "veristatus"u;
+
+;; field names
+const int md::VerificationStatus::nonce = 0; ;; hash
+const int md::VerificationStatus::status = 1; ;; uint32
+
+cell md::VerificationStatus::New(int nonce, int status) inline method_id {
+    return cl::declare(
+        md::VerificationStatus::NAME,
+        unsafeTuple([
+            [cl::t::uint64, nonce],    ;; md::VerificationStatus::nonce
+            [cl::t::uint32, status]    ;; md::VerificationStatus::status
+        ])
+    );
+}