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

package/src/workers/dvn/handler.fc

@@ -0,0 +1,332 @@
+#include "../core/interface.fc";
+
+#include "../../funC++/actions/call.fc";
+#include "../../funC++/actions/event.fc";
+
+#include "../../classes/msgdata/SetAddress.fc";
+
+#include "../msgdata/SignedRequest.fc";
+#include "../msgdata/SetQuorum.fc";
+#include "../msgdata/SetDict.fc";
+#include "../msgdata/ExecuteParams.fc";
+
+#include "../core/abstract/workerHandler.fc";
+#include "../../classes/msgdata/MdAddress.fc";
+#include "../proxy/interface.fc";
+#include "../../protocol/msglibs/ultralightnode/callbackOpcodes.fc";
+#include "../../protocol/msglibs/ultralightnode/msgdata/UlnVerification.fc";
+#include "../../protocol/msglibs/ultralightnode/uln/interface.fc";
+
+#include "interface.fc";
+#include "storage.fc";
+
+;;; Recovers public key from signature, identical to Bitcoin/Ethereum operations.
+;;; Takes 32-byte hash as uint256 hash; 65-byte signature as [uint1 v, uint256 r, uint256 s].
+;;; Returns (null, null, null, 0) on failure, (publickey, -1) on success. public key is returned as [uint8 h, uint256 x1, uint256 x2].
+;;; In the SEC (Standards for Efficient Cryptography) format, uncompressed public keys start with 0x04,
+;;; followed by the x and y coordinates of the point on the elliptic curve.
+;;; This prefix distinguishes uncompressed keys from compressed ones (which use 0x02 or 0x03).
+(int, int, int, int) ecrecover(int hash, int v, int r, int s) asm "ECRECOVER NULLSWAPIFNOT NULLSWAPIFNOT2";
+
+;;; Decodes a 65-byte signature into uint8 v, uint256 r, uint256 s
+(int, int, int) decodeSignature(cell signature) impure inline method_id {
+    slice signatureSlice = signature.begin_parse();
+
+    ;; Load r (first 32 bytes / 256 bits)  = the x-coordinate of a point on the elliptic curve.
+    int r = signatureSlice~load_uint(256);
+
+    ;; Load s (next 32 bytes / 256 bits)   = the y-coordinate of a point on the elliptic curve.
+    int s = signatureSlice~load_uint(256);
+
+    ;; Load v (last byte / 8 bits)         = the recovery ID.
+    int v = signatureSlice~load_uint(8);
+
+    ;; Adjust the 'v' value from 27/28 to 0/1 for passing to ecrecover.
+    return (v >= 27 ? v - 27 : v, r, s);
+}
+
+;;; Encodes [uint256 x1, uint256 x2] into a cell which represents the 64-byte public key
+cell encodePublicKey(int x1, int x2) inline method_id {
+    return begin_cell()
+        .store_uint256(x1)
+        .store_uint256(x2)
+        .end_cell();
+}
+
+;;; Verifies signatures on a dict256 of signatures
+;;; Signatures: Dict[publicKeyHash, signature]
+tuple _verifySignatures(tuple actions, int hash, cell signatures, cell verifiers, int quorum) impure inline {
+    int indexedPublicKeyHash = -1;
+    int validSignatures = 0;
+    ;; iterate over the signatures dict
+    do {
+        (indexedPublicKeyHash, cell signature) = signatures.cl::dict256::getNext<cellRef>(indexedPublicKeyHash);
+        if (indexedPublicKeyHash != -1) {
+            (int v, int r, int s) = decodeSignature(signature);
+            ;; recover the public key from the signature
+            (_, int x1, int x2, int signatureValid) = ecrecover(hash, v, r, s);
+            if (signatureValid) {
+                ;; encode the public key and hash it
+                int recoveredPublicKeyHash = encodePublicKey(x1, x2).cl::hash();
+                ;; check if the recovered public key is in the verifiers dict
+                ;; and matches the signature in the dict
+                (_, int verifierExists) = verifiers.cl::dict256::get(recoveredPublicKeyHash);
+                if ((verifierExists) & (recoveredPublicKeyHash == indexedPublicKeyHash)) {
+                    validSignatures += 1;
+                }
+            } else {
+                actions~pushAction<event>(
+                    Dvn::event::INVALID_SIGNATURE,
+                    begin_cell().store_uint256(indexedPublicKeyHash).end_cell()
+                );
+            }
+        }
+    } until (indexedPublicKeyHash == -1);
+
+    throw_if(Dvn::ERROR::notEnoughSignatures, validSignatures < quorum);
+
+    return actions;
+}
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Dvn::OP::VERIFY) {
+        return assertAdmin();
+    } elseif (
+        (op == UltraLightNode::OP::ULN_CONNECTION_VERIFY_CALLBACK)
+        | (op == Dvn::OP::SET_ADMINS_BY_QUORUM)
+    ) {
+        ;; NOP, so no need to check permissions
+        return ();
+    } elseif (
+        (op == Dvn::OP::SET_VERIFIERS)
+        | (op == Dvn::OP::SET_QUORUM)
+        | (op == Worker::OP::SET_ADMINS)
+        | (op == Worker::OP::SET_PROXY)
+        | (op == Worker::OP::CLAIM_TON)
+        | (op == Worker::OP::CALL_VIA_PROXY)
+    ) {
+        return assertAdmin();
+    } elseif (op == Proxy::OP::HANDLE_CALLBACK) {
+        return ();
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+}
+
+;;; ==========================HANDLERS=====================================
+
+tuple setVerifiers(cell $signedRequest) impure {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $setDict = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+
+    int incomingNonce = $setDict.cl::get<uint64>(md::SetDict::nonce);
+
+    throw_if(
+        Dvn::ERROR::invalidsetVerifiersNonce,
+        incomingNonce != $storage.cl::get<uint64>(Dvn::setVerifiersNonce)
+    );
+    
+    int opcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
+    throw_if(
+        Dvn::ERROR::invalidSignedOpcode,
+        opcode != Dvn::OP::SET_VERIFIERS
+    );
+
+    actions = _verifySignatures(
+        actions,
+        $setDict.cl::hash(),
+        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
+        $storage.cl::get<dict256>(Dvn::verifiers),
+        $storage.cl::get<uint64>(Dvn::quorum)
+    );
+
+    setContractStorage(
+        $storage
+            .cl::set(
+                Dvn::verifiers,
+                $setDict.cl::get<dict256>(md::SetDict::dict)
+            )
+            .cl::set(Dvn::setVerifiersNonce, incomingNonce + 1)
+    );
+
+    actions~pushAction<event>(Dvn::event::SET_VERIFIERS, $setDict);
+
+    return actions;
+}
+
+tuple setQuorum(cell $signedRequest) impure {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $setQuorum = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+
+    int incomingNonce = $setQuorum.cl::get<uint64>(md::SetQuorum::nonce);
+
+    throw_if(
+        Dvn::ERROR::invalidsetQuorumNonce,
+        incomingNonce != $storage.cl::get<uint64>(Dvn::setQuorumNonce)
+    );
+
+    int opcode = $setQuorum.cl::get<uint64>(md::SetQuorum::opcode);
+    throw_if(
+        Dvn::ERROR::invalidSignedOpcode,
+        opcode != Dvn::OP::SET_QUORUM
+    );
+
+    int newQuorum = $setQuorum.cl::get<uint64>(md::SetQuorum::quorum);
+
+    throw_if(
+        Dvn::ERROR::invalidQuorum,
+        newQuorum < 1
+    );
+
+    actions = _verifySignatures(
+        actions,
+        $setQuorum.cl::hash(),
+        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
+        $storage.cl::get<dict256>(Dvn::verifiers),
+        $storage.cl::get<uint64>(Dvn::quorum)
+    );
+
+    setContractStorage(
+        $storage
+            .cl::set(Dvn::quorum, newQuorum)
+            .cl::set(Dvn::setQuorumNonce, incomingNonce + 1)
+    );
+
+    actions~pushAction<event>(Dvn::event::SET_QUORUM, $setQuorum);
+
+    return actions;
+}
+
+tuple setAdminsByQuorum(cell $signedRequest) impure {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $setDict = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+
+    int incomingNonce = $setDict.cl::get<uint64>(md::SetDict::nonce);
+
+    throw_if(
+        Dvn::ERROR::invalidsetAdminsByQuorumNonce,
+        incomingNonce != $storage.cl::get<uint64>(Dvn::setAdminsByQuorumNonce)
+    );
+
+    int opcode = $setDict.cl::get<uint64>(md::SetDict::opcode);
+    throw_if(
+        Dvn::ERROR::invalidSignedOpcode,
+        opcode != Dvn::OP::SET_ADMINS_BY_QUORUM
+    );
+
+    actions = _verifySignatures(
+        actions,
+        $setDict.cl::hash(), 
+        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
+        $storage.cl::get<dict256>(Dvn::verifiers),
+        $storage.cl::get<uint64>(Dvn::quorum)
+    );
+
+    actions~pushAction<event>(Dvn::event::SET_ADMINS_BY_QUORUM, $setDict);
+
+    setContractStorage(
+        $storage
+            .setCoreStorage(
+                getCoreStorage().cl::set(
+                    WorkerCoreStorage::admins,
+                    $setDict.cl::get<dict256>(md::SetDict::dict)
+                )
+            )
+            .cl::set(Dvn::setAdminsByQuorumNonce, incomingNonce + 1)
+    );
+
+    return actions;
+}
+
+;; Calldata = mdAddress(verification, ulnConnectionAddress)
+tuple verify(cell $signedRequest) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $executeParams = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+
+    throw_if(
+        Dvn::ERROR::expired,
+        ;; now() counts as expired, per the EVM spec
+        $executeParams.cl::get<uint64>(md::ExecuteParams::expiration) <= now()
+    );
+
+    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    throw_if(
+        Dvn::ERROR::invalidSignedOpcode,
+        opcode != Uln::OP::ULN_VERIFY
+    );
+
+    actions = _verifySignatures(
+        actions,
+        $executeParams.cl::hash(),
+        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
+        $storage.cl::get<dict256>(Dvn::verifiers),
+        $storage.cl::get<uint64>(Dvn::quorum)
+    );
+
+    return _callContract(
+        actions,
+        md::ExecuteParams::New(
+            getProxyAddress(),
+            $executeParams,
+            0,
+            Proxy::OP::CALL_CONTRACT
+        )
+    );
+}
+
+tuple verifyCallback(cell $verifyStatus) impure inline {
+    (cell $storage, tuple actions) = preamble();
+    return actions;
+}
+
+tuple setProxyAdmins(cell $signedRequest) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $executeParams = $signedRequest.cl::get<objRef>(md::SignedRequest::request);
+
+    throw_if(
+        Dvn::ERROR::expired,
+        ;; now() counts as expired, per the EVM spec
+        $executeParams.cl::get<uint64>(md::ExecuteParams::expiration) <= now()
+    );
+
+    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    throw_if(
+        Dvn::ERROR::invalidSignedOpcode,
+        opcode != Worker::OP::SET_ADMINS
+    );
+
+    actions = _verifySignatures(
+        actions,
+        $executeParams.cl::hash(),
+        $signedRequest.cl::get<dict256>(md::SignedRequest::signatures),
+        $storage.cl::get<dict256>(Dvn::verifiers),
+        $storage.cl::get<uint64>(Dvn::quorum)
+    );
+
+    return _callContract(actions, $executeParams);
+}
+
+tuple setAdmins(cell $addressList) impure inline {
+    return _setAdmins(emptyActions(), $addressList);
+}
+
+tuple claimTon(cell $coinsAmount) impure inline {
+    return _claimTon(emptyActions(), $coinsAmount);
+}
+
+tuple setProxy(cell $setAddress) impure inline {
+    return _setProxyAddress(
+        emptyActions(),
+        $setAddress.cl::get<address>(md::SetAddress::address)
+    );
+}
+
+tuple callViaProxy(cell $executeParams) impure inline {
+    return _callViaProxy(emptyActions(), $executeParams);
+}

package/src/workers/dvn/interface.fc

@@ -0,0 +1,25 @@
+;;; ==========================OPCODES=====================================
+
+const int Dvn::OP::SET_VERIFIERS = "Dvn::OP::SET_VERIFIERS"c;
+const int Dvn::OP::SET_QUORUM = "Dvn::OP::SET_QUORUM"c;
+const int Dvn::OP::VERIFY = "Dvn::OP::VERIFY"c;
+const int Dvn::OP::SET_ADMINS_BY_QUORUM = "Dvn::OP::SET_ADMINS_BY_QUORUM"c;
+const int Dvn::OP::SET_PROXY_ADMINS = "Dvn::OP::SET_PROXY_ADMINS"c;
+
+;;; ==========================ERRORS=====================================
+const int Dvn::ERROR::expired = 1983;
+const int Dvn::ERROR::quorumNotMet = 1982;
+const int Dvn::ERROR::notEnoughSignatures = 1981;
+const int Dvn::ERROR::invalidsetQuorumNonce = 1980;
+const int Dvn::ERROR::invalidQuorum = 1979;
+const int Dvn::ERROR::invalidsetAdminsByQuorumNonce = 1978;
+
+const int Dvn::ERROR::invalidsetVerifiersNonce = 1977;
+const int Dvn::ERROR::invalidSignedOpcode = 1976;
+
+;;; ==========================EVENTS=====================================
+const int Dvn::event::INVALID_SIGNATURE = "Dvn::event::INVALID_SIGNATURE"u;
+const int Dvn::event::SET_VERIFIERS = "Dvn::event::SET_VERIFIERS"u;
+const int Dvn::event::SET_QUORUM = "Dvn::event::SET_QUORUM"u;
+const int Dvn::event::SET_ADMINS_BY_QUORUM = "Dvn::event::SET_ADMINS_BY_QUORUM"u;
+const int Dvn::event::VERIFY = "Dvn::event::VERIFY"u;

package/src/workers/dvn/main.fc

@@ -0,0 +1,36 @@
+#include "../proxy/interface.fc";
+
+#include "../../protocol/msglibs/ultralightnode/callbackOpcodes.fc";
+
+#include "../../protocol/core/abstract/protocolMain.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == Dvn::OP::VERIFY) {
+        return verify($md);
+    } elseif (op == UltraLightNode::OP::ULN_CONNECTION_VERIFY_CALLBACK) {
+        return verifyCallback($md);
+    } elseif (op == Dvn::OP::SET_VERIFIERS) {
+        return setVerifiers($md);
+    } elseif (op == Dvn::OP::SET_QUORUM) {
+        return setQuorum($md);
+    } elseif (op == Dvn::OP::SET_ADMINS_BY_QUORUM) {
+        return setAdminsByQuorum($md);
+    } elseif (op == Worker::OP::SET_ADMINS) {
+        return setAdmins($md);
+    } elseif (op == Worker::OP::SET_PROXY) {
+        return setProxy($md);
+    } elseif (op == Worker::OP::CLAIM_TON) {
+        return claimTon($md);
+    } elseif (op == Dvn::OP::SET_PROXY_ADMINS) {
+        return setProxyAdmins($md);
+    } elseif (op == Worker::OP::CALL_VIA_PROXY) {
+        return callViaProxy($md);
+    } elseif (op == Proxy::OP::HANDLE_CALLBACK) {
+        return emptyActions();
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return empty_tuple();
+}

package/src/workers/dvn/storage.fc

@@ -0,0 +1,27 @@
+#include "../core/workerCoreStorage.fc";
+
+;; required object name
+const int Dvn::NAME = "dvn"u;
+
+;; field names
+const int Dvn::workerCoreStorage = 0; ;; = WORKER_CORE_STORAGE_IDX;
+const int Dvn::quorum = 1;
+const int Dvn::verifiers = 2;
+const int Dvn::setQuorumNonce = 3;
+const int Dvn::setVerifiersNonce = 4;
+const int Dvn::setAdminsByQuorumNonce = 5;
+
+;; @owner manager
+cell Dvn::New(cell admins, int version, int quorum, cell verifiers) method_id {
+    return cl::declare(
+        Dvn::NAME,
+        unsafeTuple([
+            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)], ;; Dvn::workerCoreStorage
+            [cl::t::uint64, quorum],                                    ;; Dvn::quorum
+            [cl::t::dict256, verifiers],                                ;; Dvn::verifiers
+            [cl::t::uint64, 1],                                         ;; Dvn::setQuorumNonce
+            [cl::t::uint64, 1],                                         ;; Dvn::setVerifiersNonce
+            [cl::t::uint64, 1]                                         ;; Dvn::setAdminsByQuorumNonce
+        ])
+    );
+}

package/src/workers/executor/handler.fc

@@ -0,0 +1,110 @@
+#include "../core/abstract/workerHandler.fc";
+#include "../core/interface.fc";
+
+#include "../../classes/msgdata/MdAddress.fc";
+#include "../../classes/msgdata/MdObj.fc";
+#include "../../classes/msgdata/MsglibSendCallback.fc";
+#include "../../classes/msgdata/Nonce.fc";
+
+#include "../../protocol/msglibs/interface.fc";
+#include "../../protocol/msglibs/ultralightnode/uln/interface.fc";
+#include "../../protocol/channel/interface.fc";
+#include "../proxy/interface.fc";
+
+#include "../msgdata/NativeDrop.fc";
+
+
+#include "interface.fc";
+#include "storage.fc";
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Proxy::OP::HANDLE_CALLBACK) {
+        return ();
+    }
+    return assertAdmin();
+}
+
+;;; ==========================HANDLERS=====================================
+
+tuple _executorNativeDrop(tuple actions, cell $mdNativeDrop) impure inline {
+    cell $storage = getContractStorage();
+
+    int totalAmount = 0;
+    tuple payees = deserializePayees($mdNativeDrop.cl::get<cellRef>(md::NativeDrop::payees));
+
+    repeat (payees.tlen()) {
+        [int payeeAddress, int nativeAmount] = payees~tpopPayee();
+        actions~pushAction<payment>(
+            payeeAddress,
+            nativeAmount,
+            0
+        );
+        totalAmount += nativeAmount;
+    }
+
+    throw_if(
+        Executor::ERROR::nativeDropTotalCapExceeded,
+        totalAmount > $storage.cl::get<coins>(Executor::nativeDropTotalCap)
+    );
+
+    return actions;
+}
+
+tuple _executorLzReceivePrepare(tuple actions, cell $executeParams) impure inline {
+    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    throw_unless(
+        Worker::ERROR::DISALLOWED_INNER_OPCODE,
+        opcode == Channel::OP::LZ_RECEIVE_PREPARE
+    );
+
+    return _callContract(actions, $executeParams);
+}
+
+tuple executorNativeDrop(cell $mdNativeDrop) impure inline {
+    return _executorNativeDrop(emptyActions(), $mdNativeDrop);
+}
+
+tuple executorLzReceivePrepare(cell $executeParams) impure inline {
+    return _executorLzReceivePrepare(emptyActions(), $executeParams);
+}
+
+;; md: $mdNativeDrop
+;; obj: $executeParams for lzReceivePrepare
+tuple executorNativeDropAndLzReceivePrepare(cell $mdObj) impure inline {
+    return emptyActions()
+        ._executorNativeDrop($mdObj.cl::get<objRef>(md::MdObj::obj))
+        ._executorLzReceivePrepare($mdObj.cl::get<objRef>(md::MdObj::md));
+}
+
+tuple executorLzReceiveAlert(cell $executeParams) impure inline {
+    tuple actions = emptyActions();
+
+    int opcode = $executeParams.cl::get<uint32>(md::ExecuteParams::opcode);
+    throw_unless(
+        Worker::ERROR::DISALLOWED_INNER_OPCODE,
+        opcode == Channel::OP::EMIT_LZ_RECEIVE_ALERT
+    );
+
+    return _callContract(actions, $executeParams);
+}
+
+tuple setAdmins(cell $addressList) impure inline {
+    return _setAdmins(emptyActions(), $addressList);
+}
+
+tuple claimTon(cell $coinsAmount) impure inline {
+    return _claimTon(emptyActions(), $coinsAmount);
+}
+
+tuple setProxy(cell $setAddress) impure inline {
+    return _setProxyAddress(
+        emptyActions(),
+        $setAddress.cl::get<address>(md::SetAddress::address)
+    );
+}
+
+tuple callViaProxy(cell $executeParams) impure inline {
+    return _callViaProxy(emptyActions(), $executeParams);
+}

package/src/workers/executor/interface.fc

@@ -0,0 +1,19 @@
+;; --------- Opcodes ---------
+
+
+;; Native drop a batch of native tokens
+const int Executor::OP::NATIVE_DROP = "Executor::OP::NATIVE_DROP"c;
+
+const int Executor::OP::LZ_RECEIVE_PREPARE = "Executor::OP::LZ_RECEIVE_PREPARE"c;
+
+
+;; Native drop a batch of native tokens and execute a packet
+const int Executor::OP::NATIVE_DROP_AND_LZ_RECEIVE_PREPARE = "Executor::OP::NATIVE_DROP_AND_LZ_RECEIVE_PREPARE"c;
+
+const int Executor::OP::LZ_RECEIVE_ALERT = "Executor::OP::LZ_RECEIVE_ALERT"c;
+
+;; --------- Events ---------
+const int Executor::event::LZ_RECEIVE_ALERT = "Executor::event::LZ_RCV_ALERT"u;
+
+;; --------- Errors ---------
+const int Executor::ERROR::nativeDropTotalCapExceeded = 1951;

package/src/workers/executor/main.fc

@@ -0,0 +1,26 @@
+#include "../../protocol/core/abstract/protocolMain.fc";
+
+#include "handler.fc";
+#include "interface.fc";
+
+tuple _executeOpcode(int op, cell $md) impure inline {
+    if (op == Executor::OP::NATIVE_DROP) {
+        return executorNativeDrop($md);
+    } elseif (op == Executor::OP::NATIVE_DROP_AND_LZ_RECEIVE_PREPARE) {
+        return executorNativeDropAndLzReceivePrepare($md);
+    } elseif (op == Executor::OP::LZ_RECEIVE_ALERT) {
+        return executorLzReceiveAlert($md);
+    } elseif (op == Worker::OP::SET_ADMINS) {
+        return setAdmins($md);
+    } elseif (op == Worker::OP::CLAIM_TON) {
+        return claimTon($md);
+    } elseif (op == Worker::OP::CALL_VIA_PROXY) {
+        return callViaProxy($md);
+    } elseif (op == Worker::OP::SET_PROXY) {
+        return setProxy($md);
+    } elseif (op == Proxy::OP::HANDLE_CALLBACK) {
+        return emptyActions();
+    }
+    throw(BaseInterface::ERROR::invalidOpcode);
+    return empty_tuple();
+}

package/src/workers/executor/storage.fc

@@ -0,0 +1,19 @@
+#include "../core/workerCoreStorage.fc";
+
+;; required object name
+const int Executor::NAME = "executor"u;
+
+;; field names
+const int Executor::workerCoreStorage = 0;   ;; = WORKER_CORE_STORAGE_IDX
+const int Executor::nativeDropTotalCap = 1;
+
+;; @owner manager
+cell Executor::New(cell admins, int version, int nativeDropTotalCap) method_id {
+    return cl::declare(
+        Executor::NAME,
+        unsafeTuple([
+            [cl::t::objRef, WorkerCoreStorage::New(admins, NULLADDRESS, version)], ;; Executor::workerCoreStorage
+            [cl::t::coins, nativeDropTotalCap]                                     ;; Executor::nativeDropTotalCap
+        ])
+    );
+}

package/src/workers/msgdata/ExecuteParams.fc

@@ -0,0 +1,29 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::ExecuteParams::NAME = "execParams"u;
+
+;; struct ExecuteParam {
+;;     uint32 vid; // no vid?
+;;     address target;
+;;     bytes callData;
+;;     uint256 expiration;
+;; }
+
+;; field names
+const int md::ExecuteParams::target = 0;
+const int md::ExecuteParams::callData = 1;
+const int md::ExecuteParams::expiration = 2;
+const int md::ExecuteParams::opcode = 3;
+
+cell md::ExecuteParams::New(int target, cell callData, int expiration, int opcode) method_id {
+    return cl::declare(
+        md::ExecuteParams::NAME,
+        unsafeTuple([
+            [cl::t::address, target],             ;; md::ExecuteParams::target
+            [cl::t::objRef, callData],            ;; md::ExecuteParams::callData
+            [cl::t::uint64, expiration],          ;; md::ExecuteParams::expiration
+            [cl::t::uint32, opcode]               ;; md::ExecuteParams::opcode
+        ])
+    );
+}

package/src/workers/msgdata/NativeDrop.fc

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

package/src/workers/msgdata/ProxyMessage.fc

@@ -0,0 +1,20 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::ProxyMessage::NAME = "ProxyMsg"u;
+
+;; field names
+const int md::ProxyMessage::destination = 0;
+const int md::ProxyMessage::opcode = 1;
+const int md::ProxyMessage::data = 2;
+
+cell md::ProxyMessage::New(int destination, int opcode, cell data) method_id {
+    return cl::declare(
+        md::ProxyMessage::NAME,
+        unsafeTuple([
+            [cl::t::address, destination],  ;; md::ProxyMessage::destination
+            [cl::t::uint32, opcode],        ;; md::ProxyMessage::opcode
+            [cl::t::dict256, data]          ;; md::ProxyMessage::data
+        ])
+    );
+}

package/src/workers/msgdata/SetDict.fc

@@ -0,0 +1,20 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::SetDict::NAME = "setDct"u;
+
+;; field names
+const int md::SetDict::nonce = 0;
+const int md::SetDict::opcode = 1;
+const int md::SetDict::dict = 2;
+
+cell md::SetDict::New(int nonce, int opcode, cell _dict) inline method_id {
+    return cl::declare(
+        md::SetDict::NAME,
+        unsafeTuple([
+            [cl::t::uint64, nonce],  ;; md::SetDict::nonce
+            [cl::t::uint64, opcode], ;; md::SetDict::opcode
+            [cl::t::dict256, _dict]  ;; md::SetDict::dict
+        ])
+    );
+}