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

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

@@ -0,0 +1,110 @@
+#include "../../../funC++/handlerCore.fc";
+#include "../../../funC++/actions/call.fc";
+#include "../../../funC++/actions/deploy.fc";
+#include "../../../funC++/actions/event.fc";
+#include "../../../funC++/actions/payment.fc";
+
+#include "../baseStorage.fc";
+
+int getOwner() impure inline {
+    return getContractStorage()
+        .cl::get<objRef>(BASE_STORAGE_INDEX)
+        .cl::get<address>(BaseStorage::owner);
+}
+
+cell getInitialStorage() impure inline {
+    return getContractStorage()
+        .cl::get<objRef>(BASE_STORAGE_INDEX)
+        .cl::get<objRef>(BaseStorage::initialStorage);
+}
+
+;;; ==========================================
+;; Modifiers
+() assertAuthenticated() impure inline {
+    cell $baseStorage = getContractStorage().cl::get<objRef>(BASE_STORAGE_INDEX);
+    throw_unless(
+        BaseInterface::ERROR::notAuthenticated,
+        $baseStorage.cl::get<bool>(BaseStorage::authenticated)
+    );
+}
+
+() assertInitialized() impure inline {
+    cell $baseStorage = getContractStorage().cl::get<objRef>(BASE_STORAGE_INDEX);
+    throw_unless(
+        BaseInterface::ERROR::notInitialized,
+        $baseStorage.cl::get<bool>(BaseStorage::initialized)
+    );
+}
+
+;; 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)
+    );
+}
+
+;; Step 1: authenticate
+() authenticate() impure {
+    assertOwner();
+    cell $storage = getContractStorage();
+
+    setContractStorage(
+        $storage
+            .cl::set(
+                BASE_STORAGE_INDEX,
+                $storage
+                    .cl::get<objRef>(BASE_STORAGE_INDEX)
+                    .cl::set(
+                        BaseStorage::initialStorage,
+                        getContractStorage()
+                    )
+                    .cl::set(BaseStorage::authenticated, true)
+            )
+    );
+}
+
+() authenticateIfNecessary() impure inline {
+    if (getContractStorage()
+        .cl::get<objRef>(BASE_STORAGE_INDEX)
+        .cl::get<bool>(BaseStorage::authenticated) == false
+    ) {
+        authenticate();
+    }
+}
+
+(cell, tuple) _initialize(cell $md) 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)
+    ) {
+        return emptyActions();
+    }
+
+    (cell $storage, tuple actions) = _initialize($md);
+
+    setContractStorage(
+        $storage
+            .cl::set(
+                BASE_STORAGE_INDEX,
+                $storage
+                    .cl::get<objRef>(BASE_STORAGE_INDEX)
+                    .cl::set(BaseStorage::initialized, true)
+            )
+    );
+
+    return actions;
+}
+
+;; declared inside of the actions/event.fc
+;; We declare it here because it saves the need for declaring initialStorage everytime we call event
+tuple _newAction<event>(int topic, cell $body) impure inline {
+    return action::event::New(topic, $body, getInitialStorage());
+}

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

@@ -0,0 +1,30 @@
+;;; ================================================================
+;; The base main function for LayerZero Endpoint, UltraLightNode, and OApp
+;;; ================================================================
+#include "../../../funC++/actions/call.fc";
+#include "../../../funC++/actions/deploy.fc";
+#include "../../../funC++/actions/dispatch.fc";
+#include "../../../funC++/actions/event.fc";
+#include "../../../funC++/actions/payment.fc";
+
+#include "../../../funC++/contractMain.fc";
+#include "../../../funC++/handlerCore.fc";
+
+int _executeAction(int actionType, tuple action) impure inline {
+    if (actionType == action::event::NAME) {
+        return executeEvent(action);
+    } elseif (actionType == action::call::NAME) {
+        return executeCall(action);
+    } elseif (actionType == action::payment::NAME) {
+        return executePayment(action);
+    } elseif (actionType == action::dispatch::NAME) {
+        return executeDispatch(action);
+    } elseif (actionType == action::deploy::NAME) {
+        return executeDeploy(action);
+    } else {
+        throw(BaseInterface::ERROR::invalidActionType);
+    }
+
+    ;; compiler freaks out if you dont have something here returning an int, but this should never be reached
+    return false;
+}

package/src/protocol/core/baseStorage.fc

@@ -1,6 +1,5 @@
-#include "../../funC++/baseInterface.fc";
 #include "../../funC++/classlib.fc";
-#include "../../funC++/actions/utils.fc";
+#include "../../funC++/baseInterface.fc";
 
 ;; !!! If you put this storage anywhere other than index 0 of your custom contract storage,
 ;; you are gunna have a bad time

package/src/protocol/endpoint/handler.fc

@@ -0,0 +1,426 @@
+#include "../core/abstract/protocolHandler.fc";
+
+#include "../../classes/lz/SendEpConfig.fc";
+#include "../../classes/lz/MsglibInfo.fc";
+#include "../../classes/lz/ReceiveEpConfig.fc";
+#include "../../classes/lz/Packet.fc";
+#include "../../classes/lz/Path.fc";
+#include "../../classes/lz/EpConfig.fc";
+
+#include "../../classes/msgdata/ExtendedMd.fc";
+#include "../../classes/msgdata/MdAddress.fc";
+#include "../../classes/msgdata/MdObj.fc";
+#include "../../classes/msgdata/AddMsglib.fc";
+#include "../../classes/msgdata/InitEndpoint.fc";
+#include "../../classes/msgdata/LzSend.fc";
+#include "../../classes/msgdata/SetEpConfig.fc";
+
+#include "../../funC++/txnContext.fc";
+
+#include "../channel/storage.fc";
+#include "../interfaces.fc";
+#include "interface.fc";
+#include "storage.fc";
+
+;;; ==========================HELPER FUNCTIONS=====================================
+
+;; In LayerZero-TON, the msglib manager address is the outward facing alias for the messagelib
+;; that all users and admins specify in configurations etc.
+;; Within the protocol scope, the channel directly communicates `to` the Messagelib Connection
+;; shard and receives communication `from` some other arbitrary messagelib shard (for efficiency).
+;; shard addresses, this is where the validity of the messagelib is checked (i.e., that no
+;; unauthorized messagelib can be chosen in a configuration).
+;; @return (msglibAddress: address, msglibConnectionAddress: address)
+(int, int) _msglibManagerToShards(int msglibManagerAddress, cell $path) impure inline method_id {
+    if (msglibManagerAddress == NULLADDRESS) {
+        return (NULLADDRESS, NULLADDRESS);
+    }
+
+    (cell $msglibInfo, int exists) = getContractStorage()
+        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, msglibManagerAddress);
+
+    throw_unless(
+        Endpoint::ERROR::unauthorizedMsglib,
+        exists
+    );
+
+    throw_unless(
+        Endpoint::ERROR::unresolvedMsglib,
+        $msglibInfo.cl::hash() != cl::nullObject().cl::hash()
+    );
+
+    return (
+        $msglibInfo.cl::get<address>(lz::MsglibInfo::msglibAddress),
+        lz::MsglibInfo::getMsglibConnectionAddress($msglibInfo, $path)
+    );
+}
+
+;; Derive the channel address for a given path
+int _getChannelAddress(cell $path) inline method_id {
+    cell $storage = getContractStorage();
+    return computeContractAddress(
+        $storage
+            .cl::get<objRef>(Endpoint::channelStorageInit)
+            .cl::set(Channel::path, $path),
+        $storage.cl::get<cellRef>(Endpoint::channelCode)
+    );
+}
+
+;; resolve manager addresses into msglib addresses
+;; throws if the msglib manager is not registered or resolved
+cell _getEpConfigFromManagerAddresses(cell $setEpConfigMd, cell $path) inline method_id {
+    int sendMsglibManager = $setEpConfigMd.cl::get<address>(md::SetEpConfig::sendMsglibManager);
+    (int sendMsglib, int sendMsglibConnection) = _msglibManagerToShards(
+        sendMsglibManager,
+        $path
+    );
+
+    int receiveMsglibManager = $setEpConfigMd.cl::get<address>(md::SetEpConfig::receiveMsglibManager);
+    (int receiveMsglib, int receiveMsglibConnection) = _msglibManagerToShards(
+        receiveMsglibManager,
+        $path
+    );
+
+    int timeoutReceiveMsglibManager = $setEpConfigMd.cl::get<address>(md::SetEpConfig::timeoutReceiveMsglibManager);
+    (int timeoutReceiveMsglib, int timeoutReceiveMsglibConnection) = _msglibManagerToShards(
+        timeoutReceiveMsglibManager,
+        $path
+    );
+
+    throw_if(
+        Endpoint::ERROR::sameTimeoutAndReceive,
+        (receiveMsglibManager == timeoutReceiveMsglibManager) & (receiveMsglibManager != NULLADDRESS)
+    );
+
+    return lz::EpConfig::NewWithConnection(
+        $setEpConfigMd.cl::get<bool>(md::SetEpConfig::useDefaults),
+        sendMsglib,
+        sendMsglibConnection,
+        receiveMsglib,
+        receiveMsglibConnection,
+        timeoutReceiveMsglib,
+        timeoutReceiveMsglibConnection,
+        $setEpConfigMd.cl::get<uint64>(md::SetEpConfig::timeoutReceiveMsglibExpiry)
+    );
+}
+
+(int, int) _getMsglibAndConnectionDefaults(int key, cell $path) inline method_id {
+    cell $msglibInfo = getContractStorage().cl::get<objRef>(key);
+    if (cl::isNull($msglibInfo)) {
+        return (NULLADDRESS, NULLADDRESS);
+    }
+    return (
+        $msglibInfo.cl::get<address>(lz::MsglibInfo::msglibAddress),
+        lz::MsglibInfo::getMsglibConnectionAddress($msglibInfo, $path)
+    );
+}
+
+(int, int) _getSendMsglibAndConnectionDefaults(cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(Endpoint::defaultSendLibInfo, $path);
+}
+
+(int, int) getReceiveMsglibAndConnectionDefaults(cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(Endpoint::defaultReceiveLibInfo, $path);
+}
+
+(int, int) getTimeoutReceiveMsglibAndConnectionDefaults(cell $path) inline method_id {
+    return _getMsglibAndConnectionDefaults(Endpoint::defaultTimeoutReceiveLibInfo, $path);
+}
+
+() _assertAuthorizedMsglib() impure inline method_id {
+    (_, int exists) = getContractStorage()
+        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, getCaller());
+
+    throw_unless(Endpoint::ERROR::unauthorizedMsglib, exists);
+}
+
+;;; ================INTERFACE FUNCTIONS=====================
+
+(cell, tuple) _initialize(cell $initEndpoint) impure inline {
+    (cell $storage, tuple actions) = preamble();
+    return (
+        $storage
+            .cl::set(
+                Endpoint::channelCode,
+                $initEndpoint.cl::get<cellRef>(md::InitEndpoint::channelCode)
+            )
+            .cl::set(
+                Endpoint::channelStorageInit,
+                Channel::New(
+                    getOwner(),
+                    lz::Path::endpointPath(
+                        $storage.cl::get<uint32>(Endpoint::eid),
+                        $storage.cl::get<uint32>(Endpoint::dstEid)
+                    ),
+                    getContractAddress()
+                )
+            ),
+        actions
+    );
+}
+
+int _getEventSink() impure inline {
+    return getContractStorage()
+        .cl::get<objRef>(Endpoint::baseStorage)
+        .cl::get<address>(BaseStorage::owner);
+}
+
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Endpoint::OP::ENDPOINT_SEND) {
+        throw_unless(Endpoint::ERROR::notOApp,
+            getCaller() == $md
+                .cl::get<objRef>(md::LzSend::packet)
+                .cl::get<objRef>(lz::Packet::path)
+                .cl::get<address>(lz::Path::srcOApp)
+        );
+    } elseif (op == Endpoint::OP::ENDPOINT_COMMIT_PACKET) {
+        ;; open and public calls
+        return ();
+    } elseif (
+        (op == Endpoint::OP::SET_EP_CONFIG_OAPP)
+        | (op == Endpoint::OP::SET_EP_CONFIG_DEFAULTS)
+        | (op == Endpoint::OP::ADD_MSGLIB)
+    ) {
+        return assertOwner(); ;; controller
+    } elseif (op == Endpoint::OP::GET_MSGLIB_INFO_CALLBACK) {
+        return _assertAuthorizedMsglib();
+    } 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 controller/handler.fc/setEpConfigDefaults
+;; @in_md setEpConfig
+;; @out controller/handler.fc/emit_event
+;; @permissions owner
+;; We MIGHT not support defaults for certain connections/dstEids
+tuple setEpConfigDefaults(cell $setEpConfigMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $path = lz::Path::endpointPath(
+        $storage.cl::get<uint32>(Endpoint::eid),
+        $storage.cl::get<uint32>(Endpoint::dstEid)
+    );
+
+    int sendLibManager = $setEpConfigMd
+        .cl::get<address>(md::SetEpConfig::sendMsglibManager);
+
+    int receiveLibManager = $setEpConfigMd
+        .cl::get<address>(md::SetEpConfig::receiveMsglibManager);
+    
+    int timeoutReceiveLibManager = $setEpConfigMd
+        .cl::get<address>(md::SetEpConfig::timeoutReceiveMsglibManager);
+
+    (cell $sendLibInfo, int sendLibExists) = getContractStorage()
+        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, sendLibManager);
+
+    (cell $receiveLibInfo, int receiveLibExists) = getContractStorage()
+        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, receiveLibManager);
+
+    (cell $timeoutReceiveLibInfo, int timeoutReceiveLibExists) = getContractStorage()
+        .cl::nestedDict256::get<cellRef>(Endpoint::msglibs, timeoutReceiveLibManager);
+
+    int expiry = $setEpConfigMd.cl::get<uint64>(md::SetEpConfig::timeoutReceiveMsglibExpiry);
+    throw_unless(
+        Endpoint::ERROR::unauthorizedMsglib,
+          (sendLibExists | (sendLibManager == NULLADDRESS))
+        & (receiveLibExists | (receiveLibManager == NULLADDRESS))
+        & (timeoutReceiveLibExists | (timeoutReceiveLibManager == NULLADDRESS))
+    );
+    throw_if(
+        Endpoint::ERROR::sameTimeoutAndReceive,
+        (timeoutReceiveLibManager != NULLADDRESS) & (timeoutReceiveLibManager == receiveLibManager)
+    );
+    throw_unless(
+        Endpoint::ERROR::invalidExpiry,
+          ((timeoutReceiveLibManager == NULLADDRESS) & (expiry == 0))
+        | ((timeoutReceiveLibManager != NULLADDRESS) & (expiry > now()))
+    );
+
+    ;; make sure the manager addresses can be resolved
+    int validity = _getEpConfigFromManagerAddresses($setEpConfigMd, $path).lz::EpConfig::isValid();
+    ;; The above block validates *all* the inputs, meaning this throw_if will actually never
+    ;; throw. We leave it in because it doesn't hurt, might as well keep it.
+    ;; The extra gas cost is inconsequential because this is a configuration flow.
+    throw_if(validity, validity != lz::EpConfig::VALID);
+
+    setContractStorage(
+        $storage
+            .cl::set(Endpoint::defaultSendLibInfo, $sendLibInfo)
+            .cl::set(Endpoint::defaultReceiveLibInfo, $receiveLibInfo)
+            .cl::set(Endpoint::defaultTimeoutReceiveLibInfo, $timeoutReceiveLibInfo)
+            .cl::set(Endpoint::defaultExpiry, expiry)
+    );
+
+    ;; push the event
+    actions~pushAction<event>(Endpoint::event::EP_CONFIG_DEFAULTS_SET, $setEpConfigMd);
+
+    return actions;
+}
+
+;; @in controller/handler.fc/setEpConfig
+;; @in_md ExtendedMd(channelAddress, setEpConfig)
+;; @out channel/handler.fc/setEpConfig
+;; @out_md ExtendedMd(defaultEpConfig, setEpConfig)
+;; @permissions owner
+tuple setEpConfigOApp(cell $mdObj) impure inline method_id {
+    (_, tuple actions) = preamble();
+
+    ;; extract the md params
+    cell $setEpConfigOApp = $mdObj.cl::get<objRef>(md::MdObj::md);
+    cell $path = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $resolvedEpConfigOApp = _getEpConfigFromManagerAddresses($setEpConfigOApp, $path);
+
+    ;; send message to channel and forward the ep config defaults
+    actions~pushAction<call>(
+        _getChannelAddress($path),
+        Channel::OP::SET_EP_CONFIG_OAPP,
+        $resolvedEpConfigOApp
+    );
+
+    return actions;
+}
+
+;; @in oApp/handler.fc/send
+;; @in_md lzSend
+;; @out channel/handler.fc/send
+;; @out_md MdObj(lzSend, defaultSendConfig)
+;; @permissions OApp
+tuple endpointSend(cell $lzSend) impure inline method_id {
+    (_, tuple actions) = preamble();
+    ;; already asserted caller identity matches the request contents in checkPermissions()
+    cell $packet = $lzSend.cl::get<objRef>(md::LzSend::packet);
+    cell $path = $packet.cl::get<objRef>(lz::Packet::path);
+
+    ;; Invariant: if a msglib is set as a default msglib, it must be resolved
+    ;; thus, _getSendMsglibAndConnectionDefaults should never revert
+    (int sendMsglib, int sendMsglibConnection) = _getSendMsglibAndConnectionDefaults($path);
+
+    actions~pushAction<call>(
+        _getChannelAddress($path),
+        Channel::OP::CHANNEL_SEND,
+        md::MdObj::New($lzSend, lz::SendEpConfig::New(sendMsglib, sendMsglibConnection))
+    );
+    return actions;
+}
+
+;; @in msglib/handler.fc/commitVerification
+;; @in_md ExtendedMd(msglib_addr, _, endpointCommitPacket)
+;; @out channel/handler.fc/endpointCommitPacket
+;; @out_md ExtendedMd(msglib_addr, defaultEpConfig, endpointCommitPacket)
+tuple endpointCommitPacket(cell $packet) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $receivePath = $packet.cl::get<objRef>(lz::Packet::path);
+
+    ;; Assert we are the correct endpoint for this commit request
+    ;; the srcEid of the packet should match the dstEid of the endpoint contract
+    throw_if(
+        Endpoint::ERROR::wrongPath,
+        ($receivePath.cl::get<uint32>(lz::Path::srcEid) != $storage.cl::get<uint32>(Endpoint::dstEid))
+        | ($receivePath.cl::get<uint32>(lz::Path::dstEid) != $storage.cl::get<uint32>(Endpoint::eid))
+    );
+
+    cell $sendPath = $receivePath.lz::Path::optimizedReverse();
+    int channelAddress = computeContractAddress(
+        $storage
+            .cl::get<objRef>(Endpoint::channelStorageInit)
+            .cl::set(Channel::path, $sendPath),
+        $storage.cl::get<cellRef>(Endpoint::channelCode)
+    );
+
+    (_, int receiveMsglibConnection) = getReceiveMsglibAndConnectionDefaults($sendPath);
+    (_, int timeoutReceiveMsglibConnection) = getTimeoutReceiveMsglibAndConnectionDefaults(
+        $sendPath
+    );
+
+    actions~pushAction<call>(
+        channelAddress,
+        Channel::OP::CHANNEL_COMMIT_PACKET,
+        md::ExtendedMd::New(
+            $packet,
+            lz::ReceiveEpConfig::New(
+                receiveMsglibConnection,
+                timeoutReceiveMsglibConnection,
+                $storage.cl::get<uint64>(Endpoint::defaultExpiry)
+            ),
+            getCaller()
+        )
+    );
+
+    return actions;
+}
+
+;; @permissions controller
+;; @in controller/handler.fc/addMsglib
+;; @in_md resolve_msglib (msglib manager address)
+;; @out msglib controller/handler.fc/resolve_msglib
+;; @out_md resolve_msglib (msglib manager address, eid)
+tuple addMsglib(cell $addMsglib) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    ;; Not necessary to check dstEid in $addMsglib is correct, because
+    ;; the controller derives our address based on dstEid, so it cannot be wrong.
+
+    int msglibManagerAddress = $addMsglib.cl::get<address>(md::AddMsglib::msglibManagerAddress);
+    (cell $msglibInfo, int exists) = $storage.cl::nestedDict256::get<cellRef>(
+        Endpoint::msglibs,
+        msglibManagerAddress
+    );
+
+    ifnot (exists) {
+        ;; Check that we havent exceeded the max number of msglibs
+        int currentNumMsglibs = $storage.cl::get<uint8>(Endpoint::numMsglibs);
+        throw_unless(Endpoint::ERROR::numMsglibsExceeded, currentNumMsglibs < MAX_MSGLIBS);
+
+        setContractStorage(
+            $storage
+                .cl::nestedDict256::setRef(
+                    Endpoint::msglibs,
+                    msglibManagerAddress,
+                    cl::nullObject()
+                )
+                .cl::set(Endpoint::numMsglibs, currentNumMsglibs + 1)
+        );
+    }
+
+    ;; if the previous addMsglib ran out of gas, it can be retried
+    if ((~ exists) | $msglibInfo.cl::isNull()) {
+        ;; Call the msglib manager to resolve the correct msglib contract
+        ;; address for this endpoint's remote eid
+        actions~pushAction<call>(
+            msglibManagerAddress,
+            MsglibManager::OP::GET_MSGLIB_INFO,
+            $addMsglib
+        );
+    }
+
+    return actions;
+}
+
+;; @in Any MsglibManager that was added in addMsglib
+;; @in_md MsglibInfo
+;; @out refund
+tuple getMsglibInfoCallback(cell $msglibInfo) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    ;; the storedMsglibInfo is asserted to exist in checkPermissions
+    (cell $storedMsglibInfo, _) = $storage.cl::nestedDict256::get<cellRef>(
+        Endpoint::msglibs,
+        getCaller()
+    );
+
+    throw_unless(Endpoint::ERROR::msglibInfoExists, $storedMsglibInfo.cl::isNull());
+
+    setContractStorage(
+        $storage.cl::nestedDict256::setRef(Endpoint::msglibs, getCaller(), $msglibInfo)
+    );
+
+    return actions;
+}

package/src/protocol/endpoint/interface.fc

@@ -0,0 +1,20 @@
+;; OPCODES
+const int Endpoint::OP::ENDPOINT_SEND = "Endpoint::OP::ENDPOINT_SEND"c;
+const int Endpoint::OP::ENDPOINT_COMMIT_PACKET = "Endpoint::OP::ENDPOINT_COMMIT_PACKET"c;
+const int Endpoint::OP::SET_EP_CONFIG_DEFAULTS = "Endpoint::OP::SET_EP_CONFIG_DEFAULTS"c;
+const int Endpoint::OP::SET_EP_CONFIG_OAPP = "Endpoint::OP::SET_EP_CONFIG_OAPP"c;
+const int Endpoint::OP::ADD_MSGLIB = "Endpoint::OP::ADD_MSGLIB"c;
+const int Endpoint::OP::GET_MSGLIB_INFO_CALLBACK = "Endpoint::OP::GET_MSGLIB_INFO_CALLBACK"c;
+
+;; EVENTS
+const int Endpoint::event::EP_CONFIG_DEFAULTS_SET = "EP_CONFIG_DEFAULTS_SET"u;
+
+;; ERRORS
+const int Endpoint::ERROR::notOApp = 97;
+const int Endpoint::ERROR::wrongPath = 98;
+const int Endpoint::ERROR::unauthorizedMsglib = 99;
+const int Endpoint::ERROR::invalidExpiry = 100;
+const int Endpoint::ERROR::unresolvedMsglib = 101;
+const int Endpoint::ERROR::msglibInfoExists = 102;
+const int Endpoint::ERROR::numMsglibsExceeded = 103;
+const int Endpoint::ERROR::sameTimeoutAndReceive = 104;

package/src/protocol/endpoint/main.fc

@@ -0,0 +1,23 @@
+#include "../core/abstract/protocolMain.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == Endpoint::OP::ENDPOINT_SEND) {
+        return endpointSend($md);
+    } elseif (op == Endpoint::OP::ENDPOINT_COMMIT_PACKET) {
+        return endpointCommitPacket($md);
+    } elseif (op == Endpoint::OP::SET_EP_CONFIG_DEFAULTS) {
+        return setEpConfigDefaults($md);
+    } elseif (op == Endpoint::OP::SET_EP_CONFIG_OAPP) {
+        return setEpConfigOApp($md);
+    } elseif (op == Endpoint::OP::ADD_MSGLIB) {
+        return addMsglib($md);
+    } elseif (op == Endpoint::OP::GET_MSGLIB_INFO_CALLBACK) {
+        return getMsglibInfoCallback($md);
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return empty_tuple();
+}
+ 

package/src/protocol/interfaces.fc

@@ -0,0 +1,4 @@
+#include "channel/interface.fc";
+#include "controller/interface.fc";
+#include "endpoint/interface.fc";
+#include "msglibs/interface.fc";