@layerzerolabs/layerzero-v2-ton 3.0.12-ton.0

package/src/classes/msgdata/SetEpConfig.fc

@@ -0,0 +1,33 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::SetEpConfig::NAME = "SetEpCfg"u;
+
+;; 'md::SetEpConfig::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 md::SetEpConfig::useDefaults = 0;
+const int md::SetEpConfig::sendMsglibManager = 1;
+const int md::SetEpConfig::receiveMsglibManager = 2;
+const int md::SetEpConfig::timeoutReceiveMsglibManager = 3;
+const int md::SetEpConfig::timeoutReceiveMsglibExpiry = 4;
+
+cell md::SetEpConfig::New(
+    int useDefaults,
+    int sendMsglibManager,
+    int receiveMsglibManager,
+    int timeoutReceiveMsglibManager,
+    int timeoutReceiveMsglibExpiry
+) inline method_id {
+    return cl::declare(
+        md::SetEpConfig::NAME,
+        unsafeTuple([
+            [cl::t::bool, useDefaults],                     ;; md::SetEpConfig::useDefaults
+            [cl::t::address, sendMsglibManager],            ;; md::SetEpConfig::sendMsglibManager
+            [cl::t::address, receiveMsglibManager],         ;; md::SetEpConfig::receiveMsglibManager
+            [cl::t::address, timeoutReceiveMsglibManager],  ;; md::SetEpConfig::timeoutReceiveMsglibManager
+            [cl::t::uint64, timeoutReceiveMsglibExpiry]     ;; md::SetEpConfig::timeoutReceiveMsglibExpiry
+        ])
+    );
+}

package/src/classes/msgdata/SetPeer.fc

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

package/src/classes/msgdata/SetSmlManagerConfig.fc

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

package/src/funC++/abstract/contractMainAbstract.fc

@@ -0,0 +1,3 @@
+;; todo: comments
+tuple _executeOpcode(int op, cell $md) impure inline;
+int _executeAction(int actionType, tuple action) impure inline;

package/src/funC++/abstract/handlerAbstract.fc

@@ -0,0 +1,12 @@
+;; todo: comments
+() assertInitialized() impure inline;
+
+() checkPermissions(int op, cell $md) impure inline;
+
+tuple initialize(cell $md) impure inline;
+
+() authenticateIfNecessary() impure inline;
+
+() assertOwner() impure inline;
+() _checkPermissions(int op, cell $md) impure inline;
+

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

@@ -0,0 +1,51 @@
+#include "utils.fc";
+#include "../stdlib.fc";
+#include "../stringlib.fc";
+
+const int action::call::NAME = "actionCall"u;
+
+const int action::call::to = 1;
+const int action::call::opcode = 2;
+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::New(int to, int opcode, cell $md) inline {
+    return unsafeTuple([action::call::NAME, to, opcode, $md]);
+}
+
+;; returns true if equals
+int action::call::equals(tuple self, tuple other) {
+    int equalMdField = compareObjectFields(self.cell_at(action::call::md), other.cell_at(action::call::md));
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (self.int_at(action::call::to) == other.int_at(action::call::to))
+        & (self.int_at(action::call::opcode) == other.int_at(action::call::opcode))
+        & (equalMdField == -1)
+    );
+}
+
+;; overloaded when you want to pass 0 outflowNanos
+tuple _newAction<call>(int to, int opcode, cell $body) inline {
+    return action::call::New(to, opcode, $body);
+}
+
+;; overloaded when you want to pass 0 outflowNanos
+(tuple, ()) ~pushAction<call>(tuple actions, int to, int opcode, cell $body) inline {
+    return (actions.tpush(_newAction<call>(to, opcode, $body)), ());
+}
+
+int executeCall(tuple callAction) impure inline {
+    sendTerminalAction(
+        callAction.int_at(action::call::to),
+        buildLayerzeroMessageBody(
+            0,
+            callAction.int_at(action::call::opcode),
+            callAction.cell_at(action::call::md)
+        ),
+        null(),
+        NORMAL
+    );
+    return false;
+}

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

@@ -0,0 +1,118 @@
+#include "utils.fc";
+#include "../stdlib.fc";
+
+;;; =======================================================
+;; Deploys a contract defined by the given code and storage object,
+;; and calls the contract with the given message data.
+;; Typical usage will be to deploy and initialize
+;;; =======================================================
+const int action::deploy::NAME = "deploy"u;
+
+const int action::deploy::code = 1;
+const int action::deploy::storage = 2;
+const int action::deploy::donationNanos = 3;
+const int action::deploy::opcode = 4;
+const int action::deploy::md = 5;
+;; @info reserve donationNanos nanoton as the deployed contract's rent + value
+;; @info in addition to the message value, use from_balance nanoton
+;; from the contract's balance to pay for the deploy
+;; @info e.g., if from_balance == outflowNanos, the entire rent is paid from the deployer
+;; contract's balance
+const int action::deploy::outflowNanos = 6;
+
+;; @terminal
+tuple action::deploy::New(
+    cell code,
+    cell $storage,
+    int donationNanos,
+    int opcode,
+    cell $md,
+    int outflowNanos
+) inline {
+    return unsafeTuple(
+        [action::deploy::NAME, code, $storage, donationNanos, opcode, $md, outflowNanos]
+    );
+}
+
+int action::deploy::equals(tuple self, tuple other) {
+    int equalDataField = compareObjectFields(
+        self.cell_at(action::deploy::storage),
+        other.cell_at(action::deploy::storage)
+    );
+    int equalMdField = compareObjectFields(
+        self.cell_at(action::deploy::md),
+        other.cell_at(action::deploy::md)
+    );
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (self.cell_at( action::deploy::code ).cell_hash() == other.cell_at( action::deploy::code ).cell_hash())
+        & (equalDataField == -1)
+        & (self.int_at(action::deploy::donationNanos) == other.int_at(action::deploy::donationNanos))
+        & (self.int_at(action::deploy::opcode) == other.int_at(action::deploy::opcode))
+        & (equalMdField == -1)
+        & (self.int_at(action::deploy::outflowNanos) == other.int_at(action::deploy::outflowNanos))
+    );
+}
+
+tuple _newAction<deployAndCall>(
+    cell code,
+    cell $storage,
+    int donationNanos,
+    int opcode,
+    cell $md,
+    int outflowNanos
+) inline {
+    return action::deploy::New(
+        code,
+        $storage,
+        donationNanos,
+        opcode,
+        $md,
+        outflowNanos
+    );
+}
+
+(tuple, ()) ~pushAction<deployAndCall>(
+    tuple actions,
+    cell code,
+    cell $storage,
+    int donationNanos,
+    int opcode,
+    cell $md,
+    int outflowNanos
+) inline {
+    return (
+        actions
+            .tpush(_newAction<deployAndCall>(
+                code,
+                $storage,
+                donationNanos,
+                opcode,
+                $md,
+                outflowNanos
+            )),
+        ()
+    );
+}
+
+int executeDeploy(tuple action) impure inline {
+    cell $storageObj = action.cell_at(action::deploy::storage);
+    cell codeCell = action.cell_at(action::deploy::code);
+
+    sendTerminalAction(
+        computeContractAddress($storageObj, codeCell),
+        buildLayerzeroMessageBody(
+            action.int_at(action::deploy::donationNanos),
+            action.int_at(action::deploy::opcode),
+            action.cell_at(action::deploy::md)
+        ),
+        begin_cell()
+            .store_uint(6, 5)
+            .store_ref(codeCell)
+            .store_ref($storageObj)
+            .end_cell(),
+        NORMAL
+    );
+
+    return false;
+}

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

@@ -0,0 +1,28 @@
+#include "utils.fc";
+#include "../stdlib.fc";
+
+const int action::destroy::NAME = "destroy"u;
+
+const int action::destroy::to = 1;
+const int action::destroy::opcode = 2;
+const int action::destroy::md = 3;
+
+;; @terminal
+tuple action::destroy::New(int to, int opcode, cell $md) inline {
+    return unsafeTuple([action::destroy::NAME, to, opcode, $md]);
+}
+
+;; returns true if equals
+int action::destroy::equals(tuple self, tuple other) {
+    int equalMdField = compareObjectFields(
+        self.cell_at(action::destroy::md),
+        other.cell_at(action::destroy::md)
+    );
+
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (self.int_at(action::destroy::to) == other.int_at(action::destroy::to))
+        & (self.int_at(action::destroy::opcode) == other.int_at(action::destroy::opcode))
+        & (equalMdField == -1)
+    );
+}

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

@@ -0,0 +1,57 @@
+#include "utils.fc";
+#include "../stdlib.fc";
+
+#include "call.fc";
+
+const int action::dispatch::NAME = "dispatch"u;
+
+const int action::dispatch::to = 1;
+const int action::dispatch::opcode = 2;
+const int action::dispatch::md = 3;
+const int action::dispatch::gasNanos = 4;
+
+;; 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::dispatch::New(int to, int opcode, cell $md, int gasNanos) inline {
+    return unsafeTuple([action::dispatch::NAME, to, opcode, $md, gasNanos]);
+}
+
+;; returns true if equals
+int action::dispatch::equals(tuple self, tuple other) {
+    int equalMdField = compareObjectFields(
+        self.cell_at(action::dispatch::md),
+        other.cell_at(action::dispatch::md)
+    );
+    return (
+        (self.int_at(0) == other.int_at(0 )) ;; NAME
+        & (self.int_at(action::dispatch::to) == other.int_at(action::dispatch::to))
+        & (self.int_at(action::dispatch::opcode) == other.int_at(action::dispatch::opcode))
+        & (equalMdField == -1)
+        & (self.int_at(action::dispatch::gasNanos) == other.int_at(action::dispatch::gasNanos))
+    );
+}
+
+tuple _newAction<dispatch>(int to, int opcode, cell $body, int gasNanos) inline {
+    return action::dispatch::New(to, opcode, $body, gasNanos);
+}
+
+;; overloaded when you want to pass 0 outflowNanos
+(tuple, ()) ~pushAction<dispatch>(tuple actions, int to, int opcode, cell $body, int gasNanos) inline {
+    return (actions.tpush(_newAction<dispatch>(to, opcode, $body, gasNanos)), ());
+}
+
+int executeDispatch(tuple dispatchAction) {
+    sendNonTerminalAction(
+        SEND_MSG_BOUNCEABLE,
+        dispatchAction.int_at(action::dispatch::gasNanos),
+        dispatchAction.int_at(action::call::to),
+        buildLayerzeroMessageBody(
+            0,
+            dispatchAction.int_at(action::call::opcode),
+            dispatchAction.cell_at(action::call::md)
+        ),
+        NORMAL
+    );
+    return true;
+}

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

@@ -0,0 +1,69 @@
+#include "../baseInterface.fc";
+#include "../classlib.fc";
+#include "utils.fc";
+
+const int action::event::NAME = "event"u;
+
+const int action::event::bodyIndex = 1;
+
+const int action::event::topic = 0;
+const int action::event::body = 1;
+const int action::event::initialStorage = 2;
+
+;; Interface function you must implement to get the event sink
+int _getEventSink() impure inline;
+
+;; @info Events in LZ contracts are internal messages to an event sink
+;; where the resulting transaction always reverts
+;; @non-terminal
+tuple action::event::New(int topic, cell $body, cell $initialStorage) inline method_id {
+    cell $eventObj = cl::declare(
+        action::event::NAME,
+        unsafeTuple([
+            [cl::t::uint256, topic],
+            [cl::t::objRef, $body],
+            [cl::t::objRef, $initialStorage]
+        ])
+    );
+    return unsafeTuple([action::event::NAME, $eventObj]);
+}
+
+;; returns true if equals
+int action::event::equals(tuple self, tuple other) {
+    int equalEventObj = compareObjectFields(
+        self.cell_at(action::event::bodyIndex),
+        other.cell_at(action::event::bodyIndex)
+    );
+
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (equalEventObj == -1)
+    );
+}
+
+;; interface this function because it requires passing the 'getInitialStorage' from the baseHandler
+;; tuple _newAction<event>(int topic, cell $body) impure inline {
+;;     return action::event::New(topic, $body, getInitialStorage());
+;; }
+
+tuple _newAction<event>(int topic, cell $body) impure inline;
+
+(tuple, ()) ~pushAction<event>(tuple actions, int topic, cell $body) impure inline {
+    return (actions.tpush(_newAction<event>(topic, $body)), ());
+}
+
+int executeEvent(tuple action) impure inline {
+    ;; send event to event sink
+    sendNonTerminalAction(
+        SEND_MSG_NON_BOUNCEABLE,
+        0,
+        _getEventSink(),
+        buildLayerzeroMessageBody(
+            0,
+            BaseInterface::OP::EVENT,
+            action.cell_at(action::event::bodyIndex)
+        ),
+        PAID_EXTERNALLY
+    );
+    return true;
+}

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

@@ -0,0 +1,52 @@
+#include "utils.fc";
+#include "../stdlib.fc";
+
+const int action::payment::NAME = "payment"u;
+
+;; @info the address to pay
+const int action::payment::toAddress = 1;
+;; @info the amount to pay, in nanotons
+const int action::payment::amount = 2;
+;; @info the amount of value to provision from this contract's balance
+const int action::payment::outflowNanos = 3;
+
+;; @non-terminal
+tuple action::payment::New(int toAddress, int amount, int outflowNanos) inline {
+    return unsafeTuple([action::payment::NAME, toAddress, amount, outflowNanos]);
+}
+
+;; returns true if equals
+int action::payment::equals(tuple self, tuple other) {
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (self.int_at(action::payment::toAddress) == other.int_at(action::payment::toAddress))
+        & (self.int_at(action::payment::amount) == other.int_at(action::payment::amount))
+        & (self.int_at(action::payment::outflowNanos) == other.int_at(action::payment::outflowNanos))
+    );
+}
+
+tuple _newAction<payment>(int toAddress, int amount, int outflowNanos) inline {
+    return action::payment::New(toAddress, amount, outflowNanos);
+}
+
+(tuple, ()) ~pushAction<payment>(tuple actions, int toAddress, int amount, int outflowNanos) inline {
+    if (outflowNanos > 0) {
+        actions = actions
+            .tset(ACTIONS_OUTFLOW, actions.int_at(ACTIONS_OUTFLOW) + outflowNanos);
+    }
+    return (actions.tpush(_newAction<payment>(toAddress, amount, outflowNanos)), ());
+}
+
+int executePayment(tuple action) impure inline {
+    sendNonTerminalAction(
+        SEND_MSG_NON_BOUNCEABLE,
+        get_forward_fee(BASECHAIN, 0, 1) +
+        action.int_at(action::payment::amount),
+        action.int_at(action::payment::toAddress),
+        empty_cell(),
+        NORMAL
+    );
+
+    ;; TODO-riley comment the purpose of this return value
+    return true;
+}

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

@@ -0,0 +1,76 @@
+#include "../stdlib.fc";
+#include "utils.fc";
+
+const int action::sendJettons::NAME = "sendJetton"u;
+
+;; @info the wallet of this contract's jetton wallet
+const int action::sendJettons::walletAddress = 1;
+;; @info the address to pay
+const int action::sendJettons::toAddress = 2;
+
+;; @info the amount to pay
+const int action::sendJettons::amount = 3;
+
+const int action::sendJettons::responseAddress = 4;
+
+;; Op codes:
+;; This because we cannot import it directly, this is effectively
+;; const op::transfer_notification = 0x7362d09c;
+;; const op::transfer = 0xf8a7ea5;
+const int Jetton::OP::TRANSFER_NOTIFICATION = 0x7362d09c;
+const int Jetton::OP::TRANSFER = 0xf8a7ea5;
+
+;; @terminal
+tuple action::sendJettons::New(int walletAddress, int toAddress, int amount, int responseAddress) inline {
+    return unsafeTuple([action::sendJettons::NAME, walletAddress, toAddress, amount, responseAddress]);
+}
+
+;; returns true if equals
+int action::sendJettons::equals(tuple self, tuple other) {
+    return (
+        (self.int_at(0) == other.int_at(0)) ;; NAME
+        & (self.int_at(action::sendJettons::walletAddress) == other.int_at(action::sendJettons::walletAddress))
+        & (self.int_at(action::sendJettons::toAddress) == other.int_at(action::sendJettons::toAddress))
+        & (self.int_at(action::sendJettons::amount) == other.int_at(action::sendJettons::amount))
+        & (self.int_at(action::sendJettons::responseAddress) == other.int_at(action::sendJettons::responseAddress))
+    );
+}
+
+tuple _newAction<sendJettons>(int walletAddress, int toAddress, int amount, int responseAddress) inline {
+    return action::sendJettons::New(walletAddress, toAddress, amount, responseAddress);
+}
+
+(tuple, ()) ~pushAction<sendJettons>(
+    tuple actions,
+    int walletAddress,
+    int toAddress,
+    int amount,
+    int responseAddress
+) inline {
+    return (actions.tpush(_newAction<sendJettons>(walletAddress, toAddress, amount, responseAddress)), ());
+}
+
+cell buildJettonMessageBody(int toAddress, int amount, int responseAddress) inline {
+    return beginTonMessage(Jetton::OP::TRANSFER) ;; opcode, query_id
+        .store_coins(amount) ;; jetton amount
+        .store_slice(hashpartToBasechainAddressStd(toAddress)) ;; to address address
+        .store_slice(hashpartToBasechainAddressStd(responseAddress)) ;; response address
+        .store_maybe_ref(null()) ;; custom_payload
+        .store_coins(0) ;; forward_ton_amount
+        .store_maybe_ref(null()) ;; either_forward_payload is stored as a maybe_ref
+        .end_cell();
+}
+
+int executeSendJettons(tuple dispatchAction) {
+    sendTerminalAction(
+        dispatchAction.int_at(action::sendJettons::walletAddress),
+        buildJettonMessageBody(
+            dispatchAction.int_at(action::sendJettons::toAddress),
+            dispatchAction.int_at(action::sendJettons::amount),
+            dispatchAction.int_at(action::sendJettons::responseAddress)
+        ),
+        null(),
+        NORMAL
+    );
+    return false;
+}

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

@@ -0,0 +1,49 @@
+#include "../utils.fc";
+#include "../stdlib.fc";
+#include "../txnContext.fc";
+
+;; Small file for now, but a placeholder for generic actions utility functions
+
+const int ACTIONS_OUTFLOW = 0;
+
+tuple emptyActions() inline {
+    return unsafeTuple([0]);
+}
+
+;;; ======================================================================================
+;; @info terminal actions are always sent using all non-reserved balance on the contract
+() sendTerminalAction(int toAddress, cell messageBody, cell stateInit, int extraFlags) impure inline {
+    builder b = begin_cell()
+        .store_uint(SEND_MSG_BOUNCEABLE, 6)
+        .store_slice(hashpartToBasechainAddressStd(toAddress))
+        .store_coins(0);
+    b = stateInit.is_null()
+    ? b.store_uint(1, 107)
+    : b.store_uint(7, 108).store_ref(stateInit);
+    send_raw_message(b.store_ref(messageBody).end_cell(), CARRY_ALL_BALANCE | extraFlags);
+}
+
+;; @info non-terminal actions must specify the amount of funds to send
+() sendNonTerminalAction(int bounceable, int amount, int toAddress, cell messageBody, int extraFlags) impure inline {
+    cell msg = begin_cell()
+        .store_uint(bounceable, 6)
+        .store_slice(hashpartToBasechainAddressStd(toAddress))
+        .store_coins(amount)
+        .store_uint(1, 107)
+        .store_ref(messageBody)
+        .end_cell();
+    send_raw_message(msg, extraFlags);
+}
+;; @param donationNanos: the amount of TON that the sender intended to be
+;; withheld within our contract
+;; @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 ret = beginTonMessage(opcode)
+        .store_coins(donationNanos)
+        .store_slice(getOriginStd())
+        .store_ref($md)
+        .end_cell();
+    return ret;
+}

package/src/funC++/baseInterface.fc

@@ -0,0 +1,16 @@
+#include "constants.fc";
+
+const int BaseInterface::event::AUTHENTICATED = "AUTHENTICATED"u;
+const int BaseInterface::event::INITIALIZED = "INITIALIZED"u;
+
+const int BaseInterface::ERROR::notAuthenticated = "BaseInterface::ERROR::notAuthenticated"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::onlyOwner = "BaseInterface::ERROR::onlyOwner"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::notInitialized = "BaseInterface::ERROR::notInitialized"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::alreadyInitialized = "BaseInterface::ERROR::alreadyInitialized"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::invalidOpcode = "BaseInterface::ERROR::invalidOpcode"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::eventEmitted = "BaseInterface::ERROR::eventEmitted"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::invalidActionType = "BaseInterface::ERROR::invalidActionType"c & ERRORCODE_MASK;
+const int BaseInterface::ERROR::invalidEventSource = "BaseInterface::ERROR::invalidEventSource"c & ERRORCODE_MASK;
+
+const int BaseInterface::OP::INITIALIZE = "BaseInterface::OP::INITIALIZE"c;
+const int BaseInterface::OP::EVENT = "BaseInterface::OP::EVENT"c;