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

package/src/protocol/msglibs/simpleMsglib/smlManager/handler.fc

@@ -0,0 +1,281 @@
+;;; =============================================================
+;; Simple Message Library is intended for testing purposes ONLY
+;; It is purposely left unsecure on nearly every interface
+;;; =============================================================
+
+#include "../../../core/abstract/protocolHandler.fc";
+#include "../../../../funC++/baseInterface.fc";
+
+#include "../../BytesEncoder.fc";
+
+#include "../../../../classes/msgdata/ExtendedMd.fc";
+#include "../../../../classes/msgdata/MdObj.fc";
+#include "../../../../classes/msgdata/MdAddress.fc";
+#include "../../../../classes/msgdata/AddMsglib.fc";
+#include "../../../../classes/msgdata/MsglibSendCallback.fc";
+#include "../../../../classes/msgdata/SetSmlManagerConfig.fc";
+#include "../../../../classes/msgdata/Deploy.fc";
+#include "../../../../classes/msgdata/InitSmlConnection.fc";
+#include "../../../../classes/msgdata/LzSend.fc";
+#include "../../../../classes/lz/Path.fc";
+#include "../../../../classes/lz/MsglibInfo.fc";
+#include "../../../../classes/lz/Packet.fc";
+#include "../../../../classes/lz/SmlJobAssigned.fc";
+
+#include "../../../endpoint/storage.fc";
+#include "../../../channel/storage.fc";
+#include "../smlConnection/interface.fc";
+#include "../smlConnection/storage.fc";
+
+#include "../../interface.fc";
+#include "../../../interfaces.fc";
+#include "interface.fc";
+#include "storage.fc";
+#include "../../../channel/interface.fc";
+
+;;; ====================HELPER FUNCTIONS====================
+
+;; Derive the endpoint address for a given destination EID
+int _deriveEndpointAddress(int dstEid) impure inline method_id {
+    cell $storage = getContractStorage();
+    cell $endpointStorage = Endpoint::New(
+        $storage.cl::get<uint32>(SmlManager::eid),
+        dstEid,
+        $storage.cl::get<address>(SmlManager::controllerAddress)
+    );
+    return computeContractAddress(
+        $endpointStorage,
+        $storage.cl::get<cellRef>(SmlManager::endpointCode)
+    );
+}
+
+;; Derive the channel address for a given path
+int _deriveChannelAddress(cell $path) impure inline method_id {
+    cell $storage = getContractStorage();
+    int dstEid = $path.cl::get<uint32>(lz::Path::dstEid);
+    int endpointAddress = _deriveEndpointAddress(dstEid);
+    return computeContractAddress(
+        Channel::New(
+            $storage.cl::get<address>(SmlManager::controllerAddress),
+            $path,
+            endpointAddress
+        ),
+        $storage.cl::get<cellRef>(SmlManager::channelCode)
+    );
+}
+
+int _deriveConnectionAddress(cell $path) impure inline method_id {
+    return computeContractAddress(
+        SmlConnection::New(
+            getContractAddress(),
+            $path
+        ),
+        getContractStorage().cl::get<cellRef>(SmlManager::smlConnectionCode)
+    );
+}
+
+() assertConnection(cell $extendedMd) impure inline {
+    throw_unless(
+        SmlManager::ERROR::onlyConnection,
+        getCaller() == computeContractAddress(
+            $extendedMd.cl::get<objRef>(md::ExtendedMd::obj),
+            getContractStorage().cl::get<cellRef>(SmlManager::smlConnectionCode)
+        )
+    );
+}
+
+;;; ================INTERFACE FUNCTIONS=====================
+
+(cell, tuple) _initialize(cell $md) impure inline {
+    return preamble();
+}
+
+int _getEventSink() inline {
+    return getContractAddress();
+}
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (
+        (op == SmlManager::OP::SET_MSGLIB_CONFIG)
+        | (op == SmlManager::OP::SML_MANAGER_COMMIT_PACKET)
+        | (op == MsglibManager::OP::GET_MSGLIB_INFO)
+        | (op == MsglibManager::OP::DEPLOY_CONNECTION)
+        | (op == SmlManager::OP::SML_MANAGER_COMMIT_PACKET_CALLBACK)
+    ) {
+        ;; op code
+        ;; open and public calls
+        return ();
+    } elseif (
+        (op == SmlManager::OP::SML_MANAGER_SEND)
+    ) {
+        ;; assert connection
+        assertConnection($md);
+    } else {
+        ;; we must put a check for all opcodes to make sure we don't
+        ;; mistakenly miss an opp code's permissions
+        throw(BaseInterface::ERROR::invalidOpcode);
+    }
+}
+
+;;; ==========================HANDLERS=====================================
+
+;; @in permissionless
+;; @in_md ExtendedMd { SetSmlManagerConfig, unused, unused }
+tuple setMsglibConfig(cell $mdExtended) impure inline method_id {
+    ;; permissionless setting of fees, this is NOT safe for a real msglib
+    (cell $storage, tuple actions) = preamble();
+
+    ;; These other extended values arent used,
+    ;; but it makes the config call adhere to the expected interface
+    ;; Pull the config md from the extendedMd that gets passed
+    cell $SmlManagerConfig = $mdExtended.cl::get<objRef>(md::ExtendedMd::md);
+
+    setContractStorage(
+        $storage
+            .cl::set(
+                SmlManager::nativeFee,
+                $SmlManagerConfig.cl::get<coins>(md::SetSmlManagerConfig::nativeFee)
+            )
+            .cl::set(
+                SmlManager::zroFee,
+                $SmlManagerConfig.cl::get<coins>(md::SetSmlManagerConfig::zroFee)
+            )
+    );
+
+    actions~pushAction<event>(SmlManager::event::SET_MSGLIB_CONFIG, $SmlManagerConfig);
+
+    return actions;
+}
+
+;; @in channel/handler.fc/send
+;; @in_md LzSend
+;; @out channel/handler.fc/msglibSendCallback
+;; @out_md msglibSendCallback
+tuple smlManagerSend(cell $extendedMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $lzSend = $extendedMd.cl::get<objRef>(md::ExtendedMd::md);
+
+    int nativeFee = $storage.cl::get<coins>(SmlManager::nativeFee);
+
+    ;;--------------------------
+    ;; PACKET V1 CODEC
+    ;;--------------------------
+    cell $packetObj = $lzSend.cl::get<objRef>(md::LzSend::packet);
+    cell packet = BytesEncoder::build<PacketV1>($packetObj)
+        .BytesEncoder::serialize();
+
+    cell $msglibSendCallbackMd = md::MsglibSendCallback::New(
+        nativeFee,
+        $storage.cl::get<coins>(SmlManager::zroFee),
+        $lzSend,
+        packet, ;; encoded Packet
+        serializePayees(
+            unsafeTuple([
+                [getContractAddress(), nativeFee]
+            ])
+        ),
+        PacketV1::nonceOffsetBytes,
+        PacketV1::nonceBytes,
+        PacketV1::guidOffsetBytes,
+        PacketV1::guidBytes,
+        lz::SmlJobAssigned::New(nativeFee),
+        Channel::NO_ERROR
+    );
+
+    actions~pushAction<call>(
+        $extendedMd.cl::get<address>(md::ExtendedMd::forwardingAddress), ;; channelAddress
+        Channel::OP::MSGLIB_SEND_CALLBACK,
+        md::MdAddress::New(
+            $msglibSendCallbackMd,
+            getContractAddress()
+        )
+    );
+
+    return actions;
+}
+
+;; @in permissionless external message
+;; @in_md msglibCommitPacket { packet_header: [objRef], message: [cellRef] }
+;; @out_success => smlConnection/handler.fc/msglibConnectionCommitPacket
+;; @out_md_success => ExtendedMd(ep_commit_verification, _, _)
+;; @out_failure => caller (refund, failure)
+tuple smlManagerCommitPacket(cell $mdAddress) impure inline method_id {
+    (_, tuple actions) = preamble();
+
+    cell $packet = $mdAddress.cl::get<objRef>(md::MdAddress::md);
+
+    int connectionAddress = _deriveConnectionAddress(
+        lz::Path::reverse($packet.cl::get<objRef>(lz::Packet::path))
+    );
+
+    ;; @notice In Simple Msglib,
+    ;; we purposely do not verify that the message hash is the same as the stored message hash
+    actions~pushAction<call>(
+        connectionAddress,
+        SmlConnection::OP::SML_CONNECTION_COMMIT_PACKET,
+        $mdAddress
+    );
+
+    return actions;
+}
+
+;; @in endpoint/handler.fc/getMsgLib
+;; @in_md AddMsglib
+;; @out endpoint/handler.fc/getMsglibInfoCallback
+;; @out_md MsglibInfo
+tuple getMsgLibInfo(cell $addMsglibMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $msglibInfo = lz::MsglibInfo::New(
+        getContractAddress(), ;; for SML, the manager IS the msglib
+        $storage.cl::get<cellRef>(SmlManager::smlConnectionCode),
+        SmlConnection::New(
+            getContractAddress(), ;; connection is owned by the manager
+            lz::Path::endpointPath(
+                $storage.cl::get<uint32>(SmlManager::eid),
+                $addMsglibMd.cl::get<uint32>(md::AddMsglib::dstEid)
+            )
+        )
+    );
+
+    actions~pushAction<call>(
+        getCaller(),
+        Endpoint::OP::GET_MSGLIB_INFO_CALLBACK,
+        $msglibInfo
+    );
+
+    return actions;
+}
+
+;; @in smlConnection
+;; @in_md MdObj { Packet, SmlConnection (initial storage) }
+tuple smlManagerCommitPacketCallback(cell $mdObj) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    return actions;
+}
+
+;; @in permissionless (OApp)
+;; @in_md Deploy
+tuple deployConnection(cell $deploy) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $path = lz::Path::New(
+        $storage.cl::get<uint32>(SmlManager::eid),
+        getCaller(),
+        $deploy.cl::get<uint32>(md::Deploy::dstEid),
+        $deploy.cl::get<address>(md::Deploy::dstOApp)
+    );
+
+    actions~pushAction<deployAndCall>(
+        $storage.cl::get<cellRef>(SmlManager::smlConnectionCode),
+        SmlConnection::New(getContractAddress(), $path),
+        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        BaseInterface::OP::INITIALIZE,
+        md::InitSmlConnection::New(_deriveChannelAddress($path)),
+        0
+    );
+    return actions;
+}

package/src/protocol/msglibs/simpleMsglib/smlManager/interface.fc

@@ -0,0 +1,14 @@
+#include "../../../../funC++/constants.fc";
+
+const int SmlManager::OP::SET_MSGLIB_CONFIG = "SmlManager::OP::SET_MSGLIB_CONFIG"c;
+const int SmlManager::OP::SML_MANAGER_COMMIT_PACKET_CALLBACK = "SmlManager::OP::SML_MANAGER_COMMIT_PACKET_CALLBACK"c;
+const int SmlManager::OP::SML_MANAGER_COMMIT_PACKET = "SmlManager::OP::SML_MANAGER_COMMIT_PACKET"c;
+
+const int SmlManager::OP::SML_MANAGER_SEND = "SmlManager::OP::SML_MANAGER_SEND"c;
+
+;; EVENTS
+const int SmlManager::event::SET_MSGLIB_CONFIG = "SET_MSGLIB_CONFIG"u;
+
+const int SmlManager::ERROR::packetHeaderNotFound = "packetHeaderNotFound"c & ERRORCODE_MASK;
+const int SmlManager::ERROR::optionsNotEmpty = "optionsNotEmpty"c & ERRORCODE_MASK;
+const int SmlManager::ERROR::onlyConnection = "onlyConnection"c & ERRORCODE_MASK;

package/src/protocol/msglibs/simpleMsglib/smlManager/main.fc

@@ -0,0 +1,24 @@
+#include "handler.fc";
+#include "interface.fc";
+
+#include "../../../core/abstract/protocolMain.fc";
+#include "../../interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == SmlManager::OP::SET_MSGLIB_CONFIG) {
+        return setMsglibConfig($md);
+    } elseif (op == SmlManager::OP::SML_MANAGER_SEND) {
+        return smlManagerSend($md);
+    } elseif (op == SmlManager::OP::SML_MANAGER_COMMIT_PACKET) {
+        return smlManagerCommitPacket($md);
+    } elseif (op == SmlManager::OP::SML_MANAGER_COMMIT_PACKET_CALLBACK) {
+        return smlManagerCommitPacketCallback($md);
+    } elseif (op == MsglibManager::OP::GET_MSGLIB_INFO) {
+        return getMsgLibInfo($md);
+    } elseif (op == MsglibManager::OP::DEPLOY_CONNECTION) {
+        return deployConnection($md);
+    } else {
+        throw(BaseInterface::ERROR::invalidOpcode);
+    }
+    return empty_tuple();
+}

package/src/protocol/msglibs/simpleMsglib/smlManager/storage.fc

@@ -0,0 +1,38 @@
+#include "../../../core/baseStorage.fc";
+
+const int SmlManager::NAME = "smlMgr"u;
+
+const int SmlManager::baseStorage = 0;
+
+const int SmlManager::eid = 1;
+const int SmlManager::verison = 2;
+
+;; configurations, only owner?
+const int SmlManager::nativeFee = 3;
+const int SmlManager::zroFee = 4;
+
+;; Dict256 hash(header) => hash(message)
+const int SmlManager::packets = 5;
+const int SmlManager::controllerAddress = 6;
+const int SmlManager::endpointCode = 7;
+const int SmlManager::channelCode = 8;
+const int SmlManager::smlConnectionCode = 9;
+
+;; @owner LayerZero admin EOA
+cell SmlManager::New(int owner, int eid, int version, int controllerAddress, cell endpointCode, cell channelCode, cell smlConnectionCode) method_id {
+    return cl::declare(
+        SmlManager::NAME,
+        unsafeTuple([
+            [cl::t::objRef, BaseStorage::New(owner)], ;; SmlManager::baseStorage
+            [cl::t::uint32, eid], ;; SmlManager::eid
+            [cl::t::uint8, version], ;; SmlManager::version
+            [cl::t::coins, 0], ;; SmlManager::nativeFee
+            [cl::t::coins, 0], ;; SmlManager::zroFee
+            [cl::t::dict256, cl::dict256::New()], ;; SmlManager::packets
+            [cl::t::address, controllerAddress], ;; SmlManager::controllerAddress
+            [cl::t::cellRef, endpointCode], ;; SmlManager::endpointCode
+            [cl::t::cellRef, channelCode], ;; SmlManager::channelCode
+            [cl::t::cellRef, smlConnectionCode] ;; SmlManager::smlConnectionCode
+        ])
+    );
+}

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

@@ -0,0 +1 @@
+const int UltraLightNode::OP::ULN_CONNECTION_VERIFY_CALLBACK = "UltraLightNode::OP::ULN_CONNECTION_VERIFY_CALLBACK"c;

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

@@ -0,0 +1,10 @@
+;; these numbers *MUST* be updated every time the interface function names change
+;; nativeFee, event
+;; (int, tuple) ulnWorker::quote(cell $storage, cell $borrowedStorage, cell $lzSend) method_id;
+const int UlnWorkerInterface::quote = 107686; ;; ulnWorker::quote
+
+;; tuple ulnWorker::setConfig(cell $storage, cell $md) method_id;
+const int UlnWorkerInterface::setConfig = 95983; ;; ulnWorker::setConfig
+
+const int UlnWorkerInterface::ERROR::UNKNOWN_OPTIONS = 2047;
+const int UlnWorkerInterface::ERROR::ZERO_LZ_COMPOSE_GAS_PROVIDED = 2046;

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

@@ -0,0 +1,51 @@
+;; 1) If RUNVM successful and M (number of returnable elements is set) it returns M elements. If M not set - returns all.
+;; 2) if RUNVM successful but there is not enough elements on stack (M) it is considered as exception in child VM with exit_code=-3 exit_arg=0.
+;; 3) if RUNVM fails with exception - only one element is returned - exit arg (not to be mistaken with exit_code)
+;; 4) in case of OOG, exit_code = -14 and exit_arg is amount of gas
+
+;; RunVM inputs: x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] - x'_1 
+;; RunVm outputs: x'_m exitcode [data'] [c4'] [c5] [g_c]
+
+;; the inputs have to be packed in a tuple
+;; and the number of outputs is set by the nOutputs
+tuple safePackedInputsRunVm(
+    tuple inputs,
+    int methodIdCRC,
+    int nOutputs,
+    slice code,
+    int gasLimit
+) impure method_id asm """
+    // Setup                 // callerStack: [ inputs, methodIdCRC, nOutputs, code,  gasLimit ] ; len(callerStack) = 5
+    //                       // STACK [ ..., inputs, methodIdCRC, nOutputs, code, nOutputs, gasLimit ]
+    DEPTH 5 PUSHINT SUB      // STACK [ ..., inputs, methodIdCRC, nOutputs, code, gasLimit, len(callerStack) ]
+    3 PUSHINT SETGLOBVAR     // STACK [ ..., inputs, methodIdCRC, nOutputs, code, gasLimit ]
+    // Globvars[3] = len(...)
+
+    // Arrange the stack for RUNVM
+    // nArgs is actually numberOfInputs + 1
+    2 PUSHINT                 // STACK [ ..., inputs, methodIdCRC, nOutputs, code, gasLimit, nArgs ]
+    s1 XCHG0                  // STACK [ ..., inputs, methodIdCRC, nOutputs, code, nArgs, gasLimit ]
+    s1 s3 XCHG                // STACK [ ..., inputs, methodIdCRC, nArgs, code, nOutputs, gasLimit ]
+
+    // Run the given methodId in a sandbox child VM with flag 256 + 8 + 1
+    // +1 : set c3 to code
+    // +8: take gas limit g_l from stack, return consumed gas g_c
+    // +256: pop integer r, return exactly r values from the top of the stack (only if exitcode=0 or 1; if not enough then exitcode=stack_underflow)
+    // here, r := nOutputs
+
+    265 RUNVM
+                            // STACK [ ..., childStack]
+                            // childStack is capped at nOutputs
+
+    // Cleanup the return values
+    // 1. Figure out the length of the childStack
+    DEPTH                   // STACK [ ..., childStack, len(...) + len(childStack) ]
+    3 PUSHINT GETGLOBVAR    // STACK [ ..., childStack, len(...) + len(childStack), len(...) ]
+    // calculate len(childStack) = len(currentStack) - len(...)
+    SUB ABS                 // STACK [ ..., childStack, len(childStack) ]
+
+    // 2. Turn the entire child stack into a tuple
+    // Tuplevar takes x1, ..., xn and n, and turns it into a tuple (x1, ..., xn)
+    // wouldn't know how many elements to take without the n
+    TUPLEVAR                // STACK [ ..., tuple[*childStack] ]
+""";

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

@@ -0,0 +1,49 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::Attestation::NAME = "Attest"u;
+
+;; field names
+const int lz::Attestation::hash = 0; ;; hash
+const int lz::Attestation::confirmations = 1; ;; uint64
+
+const int lz::Attestation::bits = _HEADER_WIDTH + 256 + 64;
+const int lz::Attestation::refs = 0;
+;; As long as the first 128 bits of the header match the below number,
+;; the attestation is parseable by classlib
+const int lz::Attestation::leading16Bytes = 0x417474657374815ED897BFFF;
+
+cell lz::Attestation::New(int hash, int confirmations) inline method_id {
+    return cl::declare(
+        lz::Attestation::NAME,
+        unsafeTuple([
+            [cl::t::uint256, hash],         ;; lz::Attestation::hash
+            [cl::t::uint64, confirmations]  ;; lz::Attestation::confirmations
+        ])
+    );
+}
+
+() lz::Attestation::validate(cell $self) impure inline method_id {
+    ;; low-level destructuring for efficiency
+    slice selfSlice = $self.begin_parse();
+    (int bits, int refs) = selfSlice.slice_bits_refs();
+    throw_unless(
+        cl::ERROR::MALFORMED_OBJECT,
+        (bits == lz::Attestation::bits)
+        & (refs == lz::Attestation::refs)
+        & (selfSlice~load_uint(128) == lz::Attestation::leading16Bytes)
+    );
+}
+
+int lz::Attestation::confirmable(cell $self, int hash, int confirmations) impure inline method_id {
+    ;; low-level destructuring for efficiency
+    slice selfSlice = $self.begin_parse().sdskipfirst(_HEADER_WIDTH);
+
+    ;; Equivalent to the below
+    ;;      ($self.cl::get<uint256>(lz::Attestation::hash) == hash)
+    ;;    & ($self.cl::get<uint64>(lz::Attestation::confirmations) <= confirmations);
+
+    return (
+        (selfSlice~load_uint256() == hash) & (selfSlice~load_uint64() <= confirmations)
+    );
+}

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

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

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

@@ -0,0 +1,23 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required storage name
+const int ExecutorFeePaidEvent::NAME = "ExcFeePaid"u;
+
+const int ExecutorFeePaidEvent::CONSTS::NULL_WORKER_ID = 0;
+
+;; field names
+const int ExecutorFeePaidEvent::executorAddress = 0;
+const int ExecutorFeePaidEvent::feePaid = 1;
+
+cell ExecutorFeePaidEvent::New(
+    int executorAddress,
+    int feePaid
+) inline method_id {
+    return cl::declare(
+        ExecutorFeePaidEvent::NAME,
+        unsafeTuple([
+            [cl::t::address, executorAddress],   ;; ExecutorFeePaidEvent::executorAddress
+            [cl::t::coins, feePaid]              ;; ExecutorFeePaidEvent::feePaid
+        ])
+    );
+}

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

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

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

@@ -0,0 +1,62 @@
+#include "../../../../funC++/classlib.fc";
+
+#include "UlnSendConfig.fc";
+#include "UlnReceiveConfig.fc";
+
+;; required storage name
+const int md::InitUlnConnection::NAME = "initUlnCon"u;
+
+;; field names
+const int md::InitUlnConnection::ulnSendConfigOApp = 0;
+const int md::InitUlnConnection::ulnReceiveConfigOApp = 1;
+const int md::InitUlnConnection::endpointAddress = 2;
+const int md::InitUlnConnection::channelAddress = 3;
+
+cell md::InitUlnConnection::New(
+    cell $ulnSendConfigOApp,
+    cell $ulnReceiveConfigOApp,
+    int endpointAddress,
+    int channelAddress
+) inline method_id {
+    return cl::declare(
+        md::InitUlnConnection::NAME,
+        unsafeTuple([
+            [cl::t::objRef, $ulnSendConfigOApp],      ;; md::InitUlnConnection::ulnSendConfigOApp
+            [cl::t::objRef, $ulnReceiveConfigOApp],   ;; md::InitUlnConnection::ulnReceiveConfigOApp
+            [cl::t::address, endpointAddress],        ;; md::InitUlnConnection::endpointAddress
+            [cl::t::address, channelAddress]          ;; md::InitUlnConnection::channelAddress
+        ])
+    );
+}
+
+cell md::InitUlnConnection::NewOnlyConfig(
+    cell $ulnSendConfigOApp,
+    cell $ulnReceiveConfigOApp
+) inline method_id {
+    return md::InitUlnConnection::New(
+        $ulnSendConfigOApp,
+        $ulnReceiveConfigOApp,
+        NULLADDRESS,
+        NULLADDRESS
+    );
+}
+
+;; Ensure the Uln receive config does not contain garbage bits etc. that would cause
+;; undefined behaviors in the protocol
+cell InitUlnConnection::sanitize(cell $initUlnConnection) impure {
+    cell $ulnSendConfigOApp = $initUlnConnection
+        .cl::get<objRef>(md::InitUlnConnection::ulnSendConfigOApp);
+    cell $ulnReceiveConfigOApp = $initUlnConnection
+        .cl::get<objRef>(md::InitUlnConnection::ulnReceiveConfigOApp);
+    int endpointAddress = $initUlnConnection
+        .cl::get<address>(md::InitUlnConnection::endpointAddress);
+    int channelAddress = $initUlnConnection
+        .cl::get<address>(md::InitUlnConnection::channelAddress);
+
+    return md::InitUlnConnection::New(
+        UlnSendConfig::sanitize($ulnSendConfigOApp),
+        UlnReceiveConfig::sanitize($ulnReceiveConfigOApp),
+        endpointAddress,
+        channelAddress
+    );
+}

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

@@ -0,0 +1,18 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required md name
+const int md::InitUlnManager::NAME = "InitUlnMgr"u;
+
+;; field names
+const int md::InitUlnManager::endpointCode = 0;
+const int md::InitUlnManager::channelCode = 1;
+
+cell md::InitUlnManager::New(cell endpointCode, cell channelCode) inline method_id {
+    return cl::declare(
+        md::InitUlnManager::NAME,
+        unsafeTuple([
+            [cl::t::cellRef, endpointCode],   ;; md::InitUlnManager::endpointCode
+            [cl::t::cellRef, channelCode]     ;; md::InitUlnManager::channelCode
+        ])
+    );
+}

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

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

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

@@ -0,0 +1,18 @@
+#include "../../../../funC++/classlib.fc";
+
+;; required md name
+const int md::SetAdminWorkerAddresses::NAME = "adminwork"u;
+
+;; field names
+
+;; AddressList
+const int md::SetAdminWorkerAddresses::adminWorkers = 0;
+
+cell md::SetAdminWorkerAddresses::New(cell adminWorkers) inline method_id {
+    return cl::declare(
+        md::SetAdminWorkerAddresses::NAME,
+        unsafeTuple([
+            [cl::t::cellRef, adminWorkers] ;; md::SetAdminWorkerAddresses::adminWorkers
+        ])
+    );
+}