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

package/src/protocol/msglibs/ultralightnode/ulnManager/interface.fc

@@ -0,0 +1,59 @@
+#include "storage.fc";
+
+;; Deploy a new ULN (eid-shard)
+;; only-owner
+const int UlnManager::OP::DEPLOY_ULN = "UlnManager::OP::DEPLOY_ULN"c;
+;; Deploy a new connection (oApp path shard)
+;; called by OApp, seeded by SENDER
+const int MsglibManager::OP::DEPLOY_CONNECTION = "MsglibManager::OP::DEPLOY_CONNECTION"c;
+;; Set the default ULN config
+;; only-owner
+const int UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG = "UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG"c;
+
+const int UlnManager::OP::SET_DEFAULT_ULN_SEND_CONFIG = "UlnManager::OP::SET_DEFAULT_ULN_SEND_CONFIG"c;
+
+const int UlnManager::OP::SET_OAPP_ULN_SEND_CONFIG = "UlnManager::OP::SET_OAPP_ULN_SEND_CONFIG"c;
+
+;; Set the connection ULN config
+;; called by OApp, seeded by SENDER
+const int UlnManager::OP::SET_OAPP_ULN_RECEIVE_CONFIG = "UlnManager::OP::SET_OAPP_ULN_RECEIVE_CONFIG"c;
+
+;; Note: this is called withdraw treasury fees but really it's just withdraw anything you want
+const int UlnManager::OP::CLAIM_TREASURY_FEES = "UlnManager::OP::CLAIM_TREASURY_FEES"c;
+
+;; Register a new approved bytecode
+;; only-owner
+const int UlnManager::OP::REGISTER_WORKER_FEELIB_BYTECODE = "UlnManager::OP::REGISTER_WORKER_FEELIB_INFO"c;
+
+;; Add a new worker to the ULN
+;; only-owner
+const int UlnManager::OP::ADD_ULN_WORKER = "UlnManager::OP::ADD_ULN_WORKER"c;
+
+;; Set/Remove an admin worker
+;; only-owner
+const int UlnManager::OP::SET_ADMIN_WORKERS = "UlnManager::OP::SET_ADMIN_WORKERS"c;
+const int UlnManager::OP::SET_ULN_TREASURY_FEE_BPS = "UlnManager::OP::SET_ULN_TREASURY_FEE_BPS"c;
+
+const int UlnManager::OP::TRANSFER_OWNERSHIP = "UlnManager::OP::TRANSFER_OWNERSHIP"c;
+const int UlnManager::OP::CLAIM_OWNERSHIP = "UlnManager::OP::CLAIM_OWNERSHIP"c;
+
+const int UlnManager::ERROR::insufficientBalance = 161;
+const int UlnManager::ERROR::invalidEid = 162;
+const int UlnManager::ERROR::invalidWorkerInfo = 163;
+const int UlnManager::ERROR::workerIsNotAdmin = 164;
+const int UlnManager::ERROR::feelibBytecodesExceeded = 166;
+const int UlnManager::ERROR::invalidPath = 167;
+const int UlnManager::ERROR::invalidAdminWorkerList = 168;
+const int UlnManager::ERROR::onlyTentativeOwner = 169;
+const int UlnManager::ERROR::nullTentativeOwner = 170;
+
+const int UlnManager::event::ADMIN_WORKERS_SET = "UlnMgr::event::ADMIN_WORKERS_SET"u;
+const int UlnManager::event::OWNER_SET_TENTATIVE = "UlnMgr::event::OWNER_SET_TNTV"u;
+const int UlnManager::event::OWNER_SET = "UlnMgr::event::OWNER_SET"u;
+
+;; each additional cell seems to add about 110 gas
+;; so 7000 cells is about 770,000 gas.
+;; Workers based on the existing base worker each cost about 20-30 cells
+;; so 7000 cells is about 350-500 workers
+const int UlnManager::CONST::MAX_CUMULATIVE_BYTECODE_CELLS = 7000;
+const int UlnManager::CONST::MAX_ADMIN_WORKERS = 256;

package/src/protocol/msglibs/ultralightnode/ulnManager/main.fc

@@ -0,0 +1,40 @@
+#include "handler.fc";
+#include "interface.fc";
+
+#include "../../interface.fc"; ;; msglib interface
+
+#include "../../../core/abstract/protocolMain.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == UlnManager::OP::DEPLOY_ULN) {
+        return deployUln($md);
+    } elseif (op == MsglibManager::OP::DEPLOY_CONNECTION) {
+        return deployUlnConnection($md);
+    } elseif (op == MsglibManager::OP::GET_MSGLIB_INFO) {
+        return getMsglibInfo($md);
+    } elseif (op == UlnManager::OP::SET_DEFAULT_ULN_SEND_CONFIG) {
+        return setDefaultUlnSendConfig($md);
+    } elseif (op == UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG) {
+        return setDefaultUlnReceiveConfig($md);
+    } elseif (op == UlnManager::OP::SET_OAPP_ULN_RECEIVE_CONFIG) {
+        return setOAppUlnReceiveConfig($md);
+    } elseif (op == UlnManager::OP::SET_OAPP_ULN_SEND_CONFIG) {
+        return setOAppUlnSendConfig($md);
+    } elseif (op == UlnManager::OP::CLAIM_TREASURY_FEES) {
+        return claimTreasuryFees($md);
+    } elseif (op == UlnManager::OP::ADD_ULN_WORKER) {
+        return addWorkerFeelibToUln($md);
+    } elseif (op == UlnManager::OP::REGISTER_WORKER_FEELIB_BYTECODE) {
+        return registerWorkerFeelibBytecode($md);
+    } elseif (op == UlnManager::OP::SET_ADMIN_WORKERS) {
+        return setAdminWorkers($md);
+    } elseif (op == UlnManager::OP::SET_ULN_TREASURY_FEE_BPS) {
+        return setUlnTreasuryFeeBps($md);
+    } elseif (op == UlnManager::OP::TRANSFER_OWNERSHIP) {
+        return transferOwnership($md);
+    } elseif (op == UlnManager::OP::CLAIM_OWNERSHIP) {
+        return claimOwnership($md);
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return null();
+}

package/src/protocol/msglibs/ultralightnode/ulnManager/storage.fc

@@ -0,0 +1,44 @@
+#include "../../../core/baseStorage.fc";
+
+;; 3 years
+const int UlnManager::CONST::minRentSeconds = 3600 * 24 * 365 * 3;
+
+const int UlnManager::NAME = "ulnMgr"u;
+
+const int UlnManager::baseStorage = 0;
+
+;; Bytecodes
+const int UlnManager::ulnCode = 1;
+const int UlnManager::ulnConnectionCode = 2;
+const int UlnManager::controllerAddress = 3;
+const int UlnManager::eid = 4;
+const int UlnManager::endpointCode = 5;
+const int UlnManager::channelCode = 6;
+const int UlnManager::workerFeelibBytecodes = 7;
+const int UlnManager::adminWorkers = 8;
+const int UlnManager::tentativeOwner = 9;
+
+;; @owner LayerZero admin EOA
+cell UlnManager::New(
+    int owner,
+    cell ulnCode,
+    cell connectionCode,
+    int controllerAddress,
+    int eid
+) method_id {
+    return cl::declare(
+        UlnManager::NAME,
+        unsafeTuple([
+            [cl::t::objRef, BaseStorage::New(owner)],  ;; UlnManager::baseStorage
+            [cl::t::cellRef, ulnCode],                 ;; UlnManager::ulnCode
+            [cl::t::cellRef, connectionCode],          ;; UlnManager::ulnConnectionCode
+            [cl::t::address, controllerAddress],       ;; UlnManager::controllerAddress
+            [cl::t::uint32, eid],                      ;; UlnManager::eid
+            [cl::t::cellRef, empty_cell()],            ;; UlnManager::endpointCode
+            [cl::t::cellRef, empty_cell()],            ;; UlnManager::channelCode
+            [cl::t::dict256, cl::dict256::New()],      ;; UlnManager::workerBytecodes
+            [cl::t::cellRef, empty_cell()],            ;; UlnManager::adminWorkers
+            [cl::t::address, NULLADDRESS]              ;; UlnManager::tentativeOwner
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/common.fc

@@ -0,0 +1,27 @@
+#include "priceFeedFeeLib/storage.fc";
+
+const int TON::NativeDecimalsRate = 1000000000; ;; TONcoin is 9-decimal
+
+int _applyPremiumAndFloor(int feeInTON, int multiplierBps, int floorMarginUSD, int nativePriceUSD) impure inline {
+    int feeWithMultiplier = (feeInTON * multiplierBps) / 10000;
+
+    if (max(floorMarginUSD, nativePriceUSD) <= 0) {
+        return feeWithMultiplier;
+    }
+
+    int feeWithMargin = ((floorMarginUSD * TON::NativeDecimalsRate) / nativePriceUSD) + feeInTON;
+
+    return max(feeWithMargin, feeWithMultiplier);
+}
+
+int _remoteToNanoton(int remoteAmount, int priceRatio) impure inline {
+    return (remoteAmount * priceRatio) / PRICE_RATIO_DENOMINATOR;
+}
+
+int _applyPremiumToValue(int valueInTON, int multiplierBps) impure inline {
+    if (valueInTON > 0) {
+        return (valueInTON * multiplierBps) / 10000;
+    }
+    return 0;
+
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/handler.fc

@@ -0,0 +1,80 @@
+#include "../../../../../classes/msgdata/OptionsV1.fc";
+#include "../../../../../classes/msgdata/OptionsV2.fc";
+
+#include "../priceFeedFeeLib/storage.fc";
+#include "../../feeLibInterface.fc";
+#include "../../msgdata/UlnWorkerFeelibInfo.fc";
+
+#include "../common.fc";
+#include "storage.fc";
+
+const int DvnFeelib::EXECUTE_FIXED_BYTES = 260; ;; encoded: funcSigHash + params -> 4  + (32 * 2)
+const int DvnFeelib::SIGNATURE_RAW_BYTES = 65; ;; not encoded
+const int DvnFeelib::VERIFY_BYTES_ULN = 288;
+
+;; just validate options
+() _decodeOption(cell $options) impure inline_ref {
+    if (
+        (cl::typeof($options) == md::OptionsV1::NAME)
+        | (cl::typeof($options) == md::OptionsV2::NAME)
+        | cl::isNull($options)
+    ) {
+        return ();
+    } else {
+        throw(UlnWorkerInterface::ERROR::UNKNOWN_OPTIONS);
+    }
+    return ();
+}
+
+() _decodeOptions(cell $extraOptions, cell $enforcedOptions) impure inline_ref {
+    _decodeOption($extraOptions);
+    _decodeOption($enforcedOptions);
+    return ();
+}
+
+int _getCallDataSize(cell $myStorage) impure inline_ref {
+    int quorum = $myStorage.cl::get<uint64>(DvnFeelib::quorum);
+
+    int totalSignatureBytes = DvnFeelib::SIGNATURE_RAW_BYTES * quorum;
+    ;; align on 32-byte boundary
+    if ((totalSignatureBytes % 32) != 0) {
+        totalSignatureBytes += (32 - (totalSignatureBytes % 32));
+    }
+    return DvnFeelib::EXECUTE_FIXED_BYTES + DvnFeelib::VERIFY_BYTES_ULN + totalSignatureBytes + 32;
+}
+
+
+tuple ulnWorker::quote(tuple inputs) method_id {
+    cell $myStorage = inputs.cell_at(0);
+    cell $priceFeedInfo = inputs.cell_at(1);
+    cell $priceFeedStorage = $priceFeedInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage);
+    ;; cell $path = inputs.cell_at(2);
+    ;; int confirmations = inputs.int_at(3);
+    ;; int packetBytes = inputs.int_at(4);
+    cell $extraOptions = inputs.cell_at(5);
+    cell $enforcedOptions = inputs.cell_at(6);
+
+    _decodeOptions($extraOptions, $enforcedOptions);
+
+    (
+        int priceRatio,
+        int gasPriceInUnit,
+        int gasPerByte,
+        int nativePriceUsd
+    ) = PriceFeedFeelib::utils::deserializeStorage($priceFeedStorage);
+
+    int totalGas = $myStorage.cl::get<uint64>(DvnFeelib::gas) + (_getCallDataSize($myStorage) * gasPerByte);
+    ;; the gas fee in units of remote gas token (e.g., WEI for ETH)
+    int gasFeeInUnit = totalGas * gasPriceInUnit;
+
+    int totalGasFee = _applyPremiumAndFloor(
+        _remoteToNanoton(gasFeeInUnit, priceRatio),
+        $myStorage.cl::get<uint16>(DvnFeelib::multiplierBps),
+        $myStorage.cl::get<coins>(DvnFeelib::floorMarginUSD),
+        nativePriceUsd
+    );
+
+    return unsafeTuple(
+        [totalGasFee, null()]
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/main.fc

@@ -0,0 +1,4 @@
+#include "storage.fc";
+#include "handler.fc";
+
+() main() { }

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/dvnFeeLib/storage.fc

@@ -0,0 +1,26 @@
+#include "../../../../../funC++/classlib.fc";
+
+const int DvnFeelib::NAME = "UlnDvnFl"u;
+
+;; Bytecodes
+const int DvnFeelib::quorum = 0;
+const int DvnFeelib::gas = 1;
+const int DvnFeelib::multiplierBps = 2;
+const int DvnFeelib::floorMarginUSD = 3; ;; uses priceFeed PRICE_RATIO_DENOMINATOR
+
+cell DvnFeelib::New(
+    int quorum,
+    int gas,
+    int multiplierBps,
+    int floorMarginUSD
+) method_id {
+    return cl::declare(
+        DvnFeelib::NAME,
+        unsafeTuple([
+            [cl::t::uint64, quorum],        ;; DvnFeelib::quorum
+            [cl::t::uint64, gas],           ;; DvnFeelib::gas
+            [cl::t::uint16, multiplierBps], ;; DvnFeelib::multiplierBps
+            [cl::t::coins, floorMarginUSD]  ;; DvnFeelib::floorMarginUSD
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/executorFeeLib/handler.fc

@@ -0,0 +1,123 @@
+#include "../../../../../classes/msgdata/OptionsV1.fc";
+#include "../../../../../classes/msgdata/OptionsV2.fc";
+
+#include "../../feeLibInterface.fc";
+#include "../priceFeedFeeLib/storage.fc";
+#include "../../msgdata/UlnWorkerFeelibInfo.fc";
+
+#include "../common.fc";
+#include "storage.fc";
+
+(int, int) _decodeOption(int lzReceiveBaseGas, int lzComposeBaseGas, cell $options) impure inline {
+    int totalGas = 0;
+    int totalDstAmount = 0;
+
+    if (cl::typeof($options) == md::OptionsV1::NAME) {
+        totalGas += lzReceiveBaseGas
+            + $options.cl::get<uint256>(md::OptionsV1::lzReceiveGas);
+
+        totalDstAmount += $options.cl::get<uint256>(md::OptionsV1::lzReceiveValue)
+            + $options.cl::get<uint256>(md::OptionsV1::nativeDropAmount);
+    } elseif (cl::typeof($options) == md::OptionsV2::NAME) {
+        int lzComposeGas = $options.cl::get<uint256>(md::OptionsV2::lzComposeGas);
+        int lzComposeValue = $options.cl::get<uint256>(md::OptionsV2::lzComposeValue);
+
+        throw_if(
+            UlnWorkerInterface::ERROR::ZERO_LZ_COMPOSE_GAS_PROVIDED,
+            (lzComposeGas == 0) & (lzComposeValue > 0)
+        );
+
+        totalGas += lzReceiveBaseGas + $options.cl::get<uint256>(md::OptionsV2::lzReceiveGas);
+
+        totalDstAmount += $options.cl::get<uint256>(md::OptionsV2::lzReceiveValue)
+            + $options.cl::get<uint256>(md::OptionsV2::nativeDropAmount);
+
+        if (lzComposeGas > 0) {
+            totalGas += lzComposeGas + lzComposeBaseGas;
+            totalDstAmount += lzComposeValue;
+        }
+    } elseif (cl::isNull($options)) {
+        return (0, 0);
+    } else {
+        throw(UlnWorkerInterface::ERROR::UNKNOWN_OPTIONS);
+    }
+
+    return (totalGas, totalDstAmount);
+}
+
+(int, int) _decodeOptions(
+    int lzReceiveBaseGas,
+    int lzComposeBaseGas,
+    cell $extraOptions,
+    cell $enforcedOptions
+) impure inline {
+    int totalGas = 0;
+    int totalDstAmount = 0;
+
+    ifnot ($extraOptions.cl::isNull()) {
+        (int _totalGas, int _totalDstAmount) = _decodeOption(lzReceiveBaseGas, lzComposeBaseGas, $extraOptions);
+        totalGas += _totalGas;
+        totalDstAmount += _totalDstAmount;
+    }
+
+    ifnot ($enforcedOptions.cl::isNull()) {
+        (int _totalGas, int _totalDstAmount) = _decodeOption(lzReceiveBaseGas, lzComposeBaseGas, $enforcedOptions);
+        totalGas += _totalGas;
+        totalDstAmount += _totalDstAmount;
+    }
+
+    return (totalGas, totalDstAmount);
+}
+
+;; current gas consumed: 16276
+tuple ulnWorker::quote(tuple inputs) impure method_id {
+    cell $myStorage = inputs.cell_at(0);
+    cell $priceFeedInfo = inputs.cell_at(1);
+    cell $priceFeedStorage = $priceFeedInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage);
+    ;; cell $path = inputs.cell_at(2);
+    ;; int confirmations = inputs.int_at(3);
+    int packetBytes = inputs.int_at(4);
+    cell $extraOptions = inputs.cell_at(5);
+    cell $enforcedOptions = inputs.cell_at(6);
+
+    int multiplierBps = $myStorage.cl::get<uint16>(ExecutorFeelib::multiplierBps);
+
+    (
+        int totalRemoteGas,
+        int totalRemoteValue
+    ) = _decodeOptions(
+        $myStorage.cl::get<uint64>(ExecutorFeelib::lzReceiveBaseGas),
+        $myStorage.cl::get<uint64>(ExecutorFeelib::lzComposeBaseGas),
+        $extraOptions,
+        $enforcedOptions
+    );
+
+    (
+        int priceRatio,
+        int gasPriceInUnit,
+        int gasPerByte,
+        int nativePriceUsd
+    ) = PriceFeedFeelib::utils::deserializeStorage($priceFeedStorage);
+
+    ;; simple calculation of gas per byte
+    int gasForCalldata = packetBytes * gasPerByte;
+
+    int totalGasFeeInUnit = (totalRemoteGas + gasForCalldata) * gasPriceInUnit;
+
+    int totalGasFeeInNanoton = _applyPremiumAndFloor(
+        _remoteToNanoton(totalGasFeeInUnit, priceRatio),
+        multiplierBps,
+        $myStorage.cl::get<coins>(ExecutorFeelib::floorMarginUSD),
+        nativePriceUsd
+    );
+
+    ;; match order of operations of EVM at some loss of precision
+    int totalValueFeeInNanoton = _applyPremiumToValue(
+        _remoteToNanoton(totalRemoteValue, priceRatio),
+        multiplierBps
+    );
+
+    return unsafeTuple(
+        [totalGasFeeInNanoton + totalValueFeeInNanoton, null()]
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/executorFeeLib/main.fc

@@ -0,0 +1,4 @@
+#include "storage.fc";
+#include "handler.fc";
+
+() main() { }

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/executorFeeLib/storage.fc

@@ -0,0 +1,29 @@
+#include "../../../../../funC++/classlib.fc";
+
+const int ExecutorFeelib::NAME = "UlnExecutr"u;
+
+;; Bytecodes
+const int ExecutorFeelib::lzReceiveBaseGas = 0;
+const int ExecutorFeelib::multiplierBps = 1;
+const int ExecutorFeelib::floorMarginUSD = 2; ;; uses priceFeed PRICE_RATIO_DENOMINATOR
+const int ExecutorFeelib::nativeCap = 3;
+const int ExecutorFeelib::lzComposeBaseGas = 4;
+
+cell ExecutorFeelib::New(
+    int lzReceiveBaseGas,
+    int multiplierBps,
+    int floorMarginUSD,
+    int nativeCap,
+    int lzComposeBaseGas
+) method_id {
+    return cl::declare(
+        ExecutorFeelib::NAME,
+        unsafeTuple([
+            [cl::t::uint64, lzReceiveBaseGas],    ;; ExecutorFeelib::lzReceiveBaseGas
+            [cl::t::uint16, multiplierBps],       ;; ExecutorFeelib::multiplierBps
+            [cl::t::coins, floorMarginUSD],       ;; ExecutorFeelib::floorMarginUSD
+            [cl::t::coins, nativeCap],            ;; ExecutorFeelib::nativeCap
+            [cl::t::uint64, lzComposeBaseGas]     ;; ExecutorFeelib::lzComposeBaseGas
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/main.fc

@@ -0,0 +1,3 @@
+#include "ulnSendWorkerV1.fc";
+
+() main() { }

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/main.fc

@@ -0,0 +1 @@
+() main() { }

package/src/protocol/msglibs/ultralightnode/workerFeeLibs/priceFeedFeeLib/storage.fc

@@ -0,0 +1,39 @@
+#include "../../../../../funC++/classlib.fc";
+
+const int PriceFeedFeelib::NAME = "PFFeelib"u;
+
+const int PRICE_RATIO_DENOMINATOR = 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 100;
+
+;; Bytecodes
+const int PriceFeedFeelib::priceRatio = 0;
+const int PriceFeedFeelib::gasPriceInUnit = 1;
+const int PriceFeedFeelib::gasPerByte = 2;
+const int PriceFeedFeelib::nativePriceUsd = 3;
+
+;; @owner LayerZero admin EOA
+cell PriceFeedFeelib::New(
+    int priceRatio,
+    int gasPriceInUnit,
+    int gasPerByte,
+    int nativePriceUsd
+) method_id {
+    return cl::declare(
+        PriceFeedFeelib::NAME,
+        unsafeTuple([
+            [cl::t::coins, priceRatio],         ;; PriceFeedFeelib::priceRatio
+            [cl::t::uint64, gasPriceInUnit],    ;; PriceFeedFeelib::gasPriceInUnit
+            [cl::t::uint32, gasPerByte],        ;; PriceFeedFeelib::gasPerByte
+            [cl::t::coins, nativePriceUsd]      ;; PriceFeedFeelib::nativePriceUsd
+        ])
+    );
+}
+
+(int, int, int, int) PriceFeedFeelib::utils::deserializeStorage(cell $storage) inline {
+    ;; todo: optimize
+    return (
+        $storage.cl::get<coins>(PriceFeedFeelib::priceRatio),
+        $storage.cl::get<uint64>(PriceFeedFeelib::gasPriceInUnit),
+        $storage.cl::get<uint32>(PriceFeedFeelib::gasPerByte),
+        $storage.cl::get<coins>(PriceFeedFeelib::nativePriceUsd)
+    );
+}