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

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@layerzerolabs/layerzero-v2-ton",
+  "version": "3.0.12-ton.0",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "build/",
+    "src/classes/*/*.fc",
+    "src/funC++/actions/*.fc",
+    "src/funC++/abstract/*.fc",
+    "src/funC++/dataStructures/*.fc",
+    "src/funC++/*.fc",
+    "src/funC++/actions/sendJettons.fc",
+    "src/protocol/",
+    "src/jettons/zro/*.fc",
+    "tests/testMain.fc",
+    "tests/baseContractTest.fc"
+  ],
+  "scripts": {
+    "build": "$npm_execpath clean-prebuild && $npm_execpath build-all && $npm_execpath compile",
+    "build-all": "$npm_execpath blueprint build --all",
+    "build-single": "$npm_execpath blueprint build",
+    "clean": "$npm_execpath clean-prebuild && rimraf .turbo",
+    "clean-prebuild": "rimraf build",
+    "compile": "GIT_ROOT=$(git rev-parse --show-toplevel) docker compose run --rm compiler && yarn generate-artifacts",
+    "crc16xmodem": "$npm_execpath ts-node scripts/crc16xmodem.ts",
+    "generate-artifacts": "$npm_execpath ts-node scripts/generateArtifacts.ts",
+    "start": "$npm_execpath blueprint run",
+    "test": "$npm_execpath jest --verbose",
+    "test-local": "$npm_execpath compile && $npm_execpath test"
+  },
+  "dependencies": {
+    "crc-32": "^1.2.2"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@ston-fi/funcbox": "^0.1.1",
+    "@ton/blueprint": "0.25.0-beta.1",
+    "@ton/core": "^0.59.0",
+    "@ton/crypto": "^3.3.0",
+    "@ton/sandbox": "^0.22.0",
+    "@ton/test-utils": "^0.4.2",
+    "@ton/ton": "^15.1.0",
+    "@types/jest": "^29.5.10",
+    "@types/node": "^20.10.5",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.4",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "~5.2.2"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  }
+}

package/src/classes/lz/Attestation.fc

@@ -0,0 +1,23 @@
+#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
+
+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
+        ])
+    );
+}
+
+int lz::Attestation::isValid(cell self, int hash, int confirmations) inline method_id {
+    return (self.cl::get<uint256>(lz::Attestation::hash) == hash) &
+    (self.cl::get<uint64>(lz::Attestation::confirmations) <= confirmations);
+}

package/src/classes/lz/Config.fc

@@ -0,0 +1,23 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::Config::NAME = "Config"u;
+
+;; field names
+const int lz::Config::path = 0;
+const int lz::Config::forwardingAddress = 1;
+const int lz::Config::opCode = 2;
+;; provide an arbitrary config md that can be forwarded anywhere in the lz protocol that a config is accepted
+const int lz::Config::config = 3;
+
+cell lz::Config::New(cell $path, int forwardingAddress, int opCode, cell $config) inline method_id {
+    return cl::declare(
+        lz::Config::NAME,
+        unsafeTuple([
+            [cl::t::objRef, $path],              ;; lz::Config::path
+            [cl::t::address, forwardingAddress], ;; lz::Config::forwardingAddress
+            [cl::t::uint32, opCode],             ;; lz::Config::opCode
+            [cl::t::objRef, $config]             ;; lz::Config::config
+        ])
+    );
+}

package/src/classes/lz/EpConfig.fc

@@ -0,0 +1,91 @@
+#include "../../funC++/classlib.fc";
+
+;; ERRORS
+const int lz::EpConfig::ERROR::sameMsglib = "sameMsglib"c & ERRORCODE_MASK;
+const int lz::EpConfig::ERROR::invalidTimeoutExpiry = "invalidTimeoutExpiry"c & ERRORCODE_MASK;
+const int lz::EpConfig::ERROR::invalidTimeoutReceiveMsglib = "invalidTimeoutReceiveMsglib"c & ERRORCODE_MASK;
+const int lz::EpConfig::VALID = 42069 & ERRORCODE_MASK;
+
+;; required storage name
+const int lz::EpConfig::NAME = "EpConfig"u;
+
+;; field names
+const int lz::EpConfig::useDefaults = 0;
+const int lz::EpConfig::sendMsglib = 1;
+const int lz::EpConfig::sendMsglibConnection = 2;
+const int lz::EpConfig::receiveMsglib = 3;
+const int lz::EpConfig::receiveMsglibConnection = 4;
+const int lz::EpConfig::timeoutReceiveMsglib = 5;
+const int lz::EpConfig::timeoutReceiveMsglibConnection = 6;
+const int lz::EpConfig::timeoutReceiveMsglibExpiry = 7;
+
+cell lz::EpConfig::NewWithConnection(
+    int useDefaults,
+    int sendMsglib,
+    int sendMsglibConnection,
+    int receiveMsglib,
+    int receiveMsglibConnection,
+    int timeoutReceiveMsglib,
+    int timeoutReceiveMsglibConnection,
+    int timeoutReceiveMsglibExpiry
+) inline method_id {
+    return cl::declare(
+        lz::EpConfig::NAME,
+        unsafeTuple([
+            [cl::t::bool, useDefaults], ;; lz::EpConfig::useDefaults,
+            [cl::t::address, sendMsglib], ;; lz::EpConfig::sendMsglib,
+            [cl::t::address, sendMsglibConnection], ;; lz::EpConfig::sendMsglibConnection,
+            [cl::t::address, receiveMsglib], ;; lz::EpConfig::receiveMsglib,
+            [cl::t::address, receiveMsglibConnection], ;; lz::EpConfig::receiveMsglibConnection,
+            [cl::t::address, timeoutReceiveMsglib], ;; lz::EpConfig::timeoutReceiveMsglib,
+            [cl::t::address, timeoutReceiveMsglibConnection], ;; lz::EpConfig::timeoutReceiveMsglibConnection,
+            [cl::t::uint64, timeoutReceiveMsglibExpiry] ;; lz::EpConfig::timeoutReceiveMsglibExpiry
+        ])
+    );
+}
+
+cell lz::EpConfig::New(
+    int useDefaults,
+    int sendMsglib,
+    int receiveMsglib,
+    int timeoutReceiveMsglib,
+    int timeoutReceiveMsglibExpiry
+) inline method_id {
+    return lz::EpConfig::NewWithConnection(
+        useDefaults,
+        sendMsglib,
+        NULLADDRESS,
+        receiveMsglib,
+        NULLADDRESS,
+        timeoutReceiveMsglib,
+        NULLADDRESS,
+        timeoutReceiveMsglibExpiry
+    );
+}
+
+cell lz::EpConfig::NewWithDefaults() inline method_id {
+    return lz::EpConfig::New(true, NULLADDRESS, NULLADDRESS, NULLADDRESS, 0);
+}
+
+cell lz::EpConfig::NewFrom(int sendMsglib, int receiveMsglib) inline method_id {
+    return lz::EpConfig::New(true, sendMsglib, receiveMsglib, NULLADDRESS, 0);
+}
+
+int lz::EpConfig::isValid(cell $epConfig) inline method_id {
+    int receiveMsglib = $epConfig.cl::get<address>(lz::EpConfig::receiveMsglib);
+    int timeoutReceiveMsglib = $epConfig.cl::get<address>(lz::EpConfig::timeoutReceiveMsglib);
+    int timeoutReceiveMsglibExpiry = $epConfig.cl::get<uint64>(lz::EpConfig::timeoutReceiveMsglibExpiry);
+
+    if ((timeoutReceiveMsglib == NULLADDRESS) & (timeoutReceiveMsglibExpiry != 0)) {
+        ;; If the timeout receive msglib is null, the expiry must be 0
+        return lz::EpConfig::ERROR::invalidTimeoutReceiveMsglib;
+    } elseif ((timeoutReceiveMsglib != NULLADDRESS) & (timeoutReceiveMsglibExpiry <= now())) {
+        ;; if the timeout receive msglib is not null, the expiry must be in the future
+        return lz::EpConfig::ERROR::invalidTimeoutExpiry;
+    } elseif ((receiveMsglib != NULLADDRESS) & (receiveMsglib == timeoutReceiveMsglib)) {
+        ;; the receive msglib and timeout receive msglib must be different
+        return lz::EpConfig::ERROR::sameMsglib;
+    }
+
+    return lz::EpConfig::VALID;
+}

package/src/classes/lz/MsglibInfo.fc

@@ -0,0 +1,31 @@
+#include "../../funC++/classlib.fc";
+#include "../../protocol/msglibs/interface.fc";
+
+;; required storage name
+const int lz::MsglibInfo::NAME = "MsglibInfo"u;
+
+;; field names
+const int lz::MsglibInfo::msglibAddress = 0;
+;; connectionCode + connectionInitStorage are used to programmatically derive the connection address
+const int lz::MsglibInfo::msglibConnectionCode = 1;
+const int lz::MsglibInfo::msglibConnectionInitStorage = 2;
+
+cell lz::MsglibInfo::New(int msglibAddress, cell msglibConnectionCode, cell msglibConnectionInitStorage) inline method_id {
+    return cl::declare(
+        lz::MsglibInfo::NAME,
+        unsafeTuple([
+            [cl::t::address, msglibAddress],             ;; lz::MsglibInfo::msglibAddress
+            [cl::t::cellRef, msglibConnectionCode],      ;; lz::MsglibInfo::msglibConnectionBytecode
+            [cl::t::objRef, msglibConnectionInitStorage] ;; lz::MsglibInfo::msglibConnectionInitStorage
+        ])
+    );
+}
+
+int lz::MsglibInfo::getMsglibConnectionAddress(cell $msglibInfo, cell $path) inline method_id {
+    return computeContractAddress(
+        $msglibInfo
+            .cl::get<objRef>(lz::MsglibInfo::msglibConnectionInitStorage)
+            .cl::set(MsglibConnection::PathFieldIdx, $path),
+        $msglibInfo.cl::get<cellRef>(lz::MsglibInfo::msglibConnectionCode)
+    );
+}

package/src/classes/lz/Packet.fc

@@ -0,0 +1,202 @@
+#include "../../funC++/classlib.fc";
+#include "../../funC++/constants.fc";
+
+#include "Path.fc";
+
+;; required storage name
+const int lz::Packet::NAME = "Packet"u;
+
+;; field names
+const int lz::Packet::path = 0;
+const int lz::Packet::message = 1;
+const int lz::Packet::nonce = 2;
+const int lz::Packet::guid = 3;
+
+const int lz::Packet::ERROR::INVALID_MESSAGE = "invalid_message"c & ERRORCODE_MASK;
+const int lz::Packet::ERROR::INVALID_NONCE = "invalid_nonce"c & ERRORCODE_MASK;
+const int lz::Packet::ERROR::INVALID_PACKET_FIELD = "invalid_packet_field"c & ERRORCODE_MASK;
+
+const int lz::Packet::MAX_RECEIVE_MESSAGE_CELLS = 32;
+const int lz::Packet::MAX_SEND_MESSAGE_CELLS = 255;
+
+cell lz::Packet::New(cell $path, cell message, int nonce) inline method_id {
+    return cl::declare(
+        lz::Packet::NAME,
+        unsafeTuple([
+            [cl::t::objRef, $path],             ;; lz::Packet::path
+            [cl::t::cellRef, message],          ;; lz::Packet::message
+            [cl::t::uint64, nonce],             ;; lz::Packet::nonce
+            [cl::t::uint256, 0]                 ;; lz::Packet::guid
+        ])
+    );
+}
+
+cell lz::Packet::nonceless(cell $path, cell message) inline method_id {
+    return lz::Packet::New($path, message, 0);
+}
+
+() lz::Packet::_assertValidLinkedList(cell head, int maxLen) impure inline {
+    slice messageSlice = head.begin_parse();
+    repeat (maxLen) {
+        (int sliceBits, int sliceRefs) = messageSlice.slice_bits_refs();
+        if (sliceRefs == 0) {
+            throw_if(lz::Packet::ERROR::INVALID_MESSAGE, sliceBits % 8 != 0);
+            return ();
+        } else {
+            throw_if(
+                lz::Packet::ERROR::INVALID_MESSAGE,
+                (sliceRefs != 1) | (sliceBits != MAX_CELL_WHOLE_BYTE_BITS)
+            );
+        }
+        messageSlice = messageSlice.preload_first_ref().begin_parse();
+    }
+    throw(lz::Packet::ERROR::INVALID_MESSAGE);
+}
+
+() lz::Packet::assertValidSendMessage(cell $self) impure inline {
+    lz::Packet::_assertValidLinkedList(
+        $self.cl::get<cellRef>(lz::Packet::message),
+        lz::Packet::MAX_SEND_MESSAGE_CELLS
+    );
+}
+
+() lz::Packet::assertValidReceiveMessage(cell $self) impure inline {
+    lz::Packet::_assertValidLinkedList(
+        $self.cl::get<cellRef>(lz::Packet::message),
+        lz::Packet::MAX_RECEIVE_MESSAGE_CELLS
+    );
+}
+
+int lz::Packet::calculateGuid(cell $path, int nonce) inline method_id {
+    return keccak256Builder(
+        begin_cell()
+            .store_uint64(nonce)
+            .store_uint32($path.cl::get<uint32>(lz::Path::srcEid))
+            .store_uint256($path.cl::get<address>(lz::Path::srcOApp))
+            .store_uint32($path.cl::get<uint32>(lz::Path::dstEid))
+            .store_uint256($path.cl::get<address>(lz::Path::dstOApp))
+    );
+}
+
+;; NOTE: this assumes that the placement of the first field is before the second field
+cell lz::Packet::replaceTwoFieldsAtOffsets(
+    cell encodedPacket,
+    int replacementValue1,
+    int replacementOffsetBytes1,
+    int field1Bytes,
+    int replacementValue2,
+    int replacementOffsetBytes2,
+    int field2Bytes
+) impure inline method_id {
+    int field1PosBits = (replacementOffsetBytes1 % MAX_CELL_BYTES) * 8;
+    int cell1Idx = replacementOffsetBytes1 / MAX_CELL_BYTES;
+    int field2PosBits = (replacementOffsetBytes2 % MAX_CELL_BYTES) * 8;
+    int cell2Idx = replacementOffsetBytes2 / MAX_CELL_BYTES;
+    slice itr = encodedPacket.begin_parse();
+    int field1Bits = field1Bytes * 8;
+    int field2Bits = field2Bytes * 8;
+    int field1EndPosBits = field1PosBits + field1Bits;
+    int field2EndPosBits = field2PosBits + field2Bits;
+
+    throw_if(
+        lz::Packet::ERROR::INVALID_PACKET_FIELD,
+        (max(field1Bytes, field2Bytes) > MAX_CELL_BYTES)
+        | (max(field1EndPosBits, field2EndPosBits) > MAX_CELL_WHOLE_BYTE_BITS)
+    );
+
+    ;; short-circuit the common case to save gas
+    if (cell2Idx == 0) {
+        return begin_cell()
+            .store_slice(scutfirst(itr, field1PosBits, 0))
+            .store_uint(replacementValue1, field1Bits)
+            .store_slice(subslice(
+                itr,
+                field1EndPosBits,
+                0,
+                field2PosBits - field1EndPosBits,
+                0
+            ))
+            .store_uint(replacementValue2, field2Bits)
+            .store_slice(scutlast(
+                itr,
+                itr.slice_bits() - field2EndPosBits,
+                itr.slice_refs()
+            ))
+            .end_cell();
+    }
+
+    tuple encodedPacketBuilders = empty_tuple();
+
+    int idx = 0;
+
+    do {
+        if ((idx == cell1Idx) & (cell1Idx == cell2Idx)) {
+            slice beforeFirstField = scutfirst(itr, field1PosBits, 0);
+
+            slice betweenFields = subslice(
+                itr,
+                (field1PosBits + field1Bits),
+                0,
+                (field2PosBits - field1PosBits - field1Bits),
+                0
+            );
+
+            slice afterSecondField = scutlast(
+                itr,
+                itr.slice_bits() - (field2Bits + field2PosBits),
+                itr.slice_refs()
+            );
+
+            encodedPacketBuilders~tpush(
+                begin_cell()
+                    .store_slice(beforeFirstField)
+                    .store_uint(replacementValue1, field1Bits)
+                    .store_slice(betweenFields)
+                    .store_uint(replacementValue2, field2Bits)
+                    .store_slice(afterSecondField)
+            );
+        } elseif (idx == cell1Idx) {
+            encodedPacketBuilders~tpush(
+                begin_cell()
+                .store_slice(scutfirst(itr, field1PosBits, 0))
+                .store_uint(replacementValue1, field1Bits)
+                .store_slice(
+                    scutlast(
+                        itr,
+                        itr.slice_bits() - (field1Bits + field1PosBits),
+                        itr.slice_refs()
+                    )
+                )
+            );
+        } elseif (idx == cell2Idx) {
+            encodedPacketBuilders~tpush(
+                begin_cell()
+                .store_slice(scutfirst(itr, field2PosBits, 0))
+                .store_uint(replacementValue2, field2Bits)
+                .store_slice(
+                    scutlast(
+                        itr,
+                        itr.slice_bits() - (field2Bits + field2PosBits),
+                        itr.slice_refs()
+                    )
+                )
+            );
+        } else {
+            encodedPacketBuilders~tpush(begin_cell().store_slice(itr));
+        }
+
+        if (itr.slice_refs() > 0) {
+            itr = itr.preload_first_ref().begin_parse();
+        }
+        idx += 1;
+    } until (idx >= cell2Idx);
+
+    cell curCell = encodedPacketBuilders.at(cell2Idx).end_cell();
+
+    while (cell2Idx > 0) {
+        cell2Idx -= 1;
+        curCell = encodedPacketBuilders.at(cell2Idx).store_ref(curCell).end_cell();
+    }
+
+    return curCell;
+}

package/src/classes/lz/Path.fc

@@ -0,0 +1,56 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::Path::NAME = "path"u;
+
+;; field names
+const int lz::Path::srcEid = 0;
+const int lz::Path::srcOApp = 1;
+const int lz::Path::dstEid = 2;
+const int lz::Path::dstOApp = 3;
+
+;; In all blockchains with atomic cross-contract call, we can use src/dst/srcOApp/dstOApp
+;; because the send channel doesn't exist (it's just a nonce).
+;; In TON, we need both send/receive channels, so we use srcOApp/dstOApp to provide
+;; a context-free way to refer to the two ends of the channel.
+;; The direction is inferred by the context of the contract (send vs receive).
+;; The srcOApp is the 256-bit hashpart of a standard address.
+cell lz::Path::New(int srcEid, int srcOApp, int dstEid, int dstOApp) inline method_id {
+    return cl::declare(
+        lz::Path::NAME,
+        unsafeTuple([
+            [cl::t::uint32, srcEid],    ;; lz::Path::srcEid
+            [cl::t::uint256, srcOApp],  ;; lz::Path::srcOApp
+            [cl::t::uint32, dstEid],    ;; lz::Path::dstEid
+            [cl::t::uint256, dstOApp]   ;; lz::Path::dstOApp
+        ])
+    );
+}
+
+cell lz::Path::endpointPath(int srcEid, int dstEid) inline {
+    return lz::Path::New(srcEid, NULLADDRESS, dstEid, NULLADDRESS);
+}
+
+cell lz::Path::reverse(cell $path) inline {
+    int srcEid = $path.cl::get<uint32>(lz::Path::srcEid);
+    int srcOapp = $path.cl::get<address>(lz::Path::srcOApp);
+    int dstEid = $path.cl::get<uint32>(lz::Path::dstEid);
+    int dstOapp = $path.cl::get<address>(lz::Path::dstOApp);
+    return lz::Path::New(dstEid, dstOapp, srcEid, srcOapp);
+
+}
+
+const int lz::Path::_srcEidOffset = _HEADER_WIDTH;
+const int lz::Path::_srcOAppOffset = lz::Path::_srcEidOffset + 32;
+const int lz::Path::_dstEidOffset = lz::Path::_srcOAppOffset + 256;
+;; low-level optimized version
+;; original: 12k gas
+;; optimized: 1k gas
+cell lz::Path::optimizedReverse(cell $path) inline {
+    slice pathSlice = $path.begin_parse();
+    return begin_cell()
+        .store_slice(pathSlice.scutfirst(_HEADER_WIDTH, 0))
+        .store_slice(pathSlice.preload_bits_offset(lz::Path::_dstEidOffset, 288)) ;; 32 + 256
+        .store_slice(pathSlice.preload_bits_offset(lz::Path::_srcEidOffset, 288)) ;; eid + address
+        .end_cell();
+}

package/src/classes/lz/ReceiveEpConfig.fc

@@ -0,0 +1,24 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::ReceiveEpConfig::NAME = "RcvMsglib"u;
+
+;; field names
+const int lz::ReceiveEpConfig::receiveMsglibConnectionAddress = 0;
+const int lz::ReceiveEpConfig::timeoutReceiveMsglibConnectionAddress = 1;
+const int lz::ReceiveEpConfig::expiry = 2;
+
+cell lz::ReceiveEpConfig::New(
+    int receiveMsglibConnectionAddress,
+    int timeoutReceiveMsglibConnectionAddress,
+    int expiry
+) inline method_id {
+    return cl::declare(
+        lz::ReceiveEpConfig::NAME,
+        unsafeTuple([
+            [cl::t::address, receiveMsglibConnectionAddress],        ;; lz::ReceiveEpConfig::receiveMsglibConnectionAddress
+            [cl::t::address, timeoutReceiveMsglibConnectionAddress], ;; lz::ReceiveEpConfig::timeoutReceiveMsglibConnectionAddress
+            [cl::t::uint64, expiry]                                  ;; lz::ReceiveEpConfig::expiry
+        ])
+    );
+}

package/src/classes/lz/SendEpConfig.fc

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

package/src/classes/lz/SmlJobAssigned.fc

@@ -0,0 +1,20 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::SmlJobAssigned::NAME = "SmlJobAssg"u;
+
+;; field names
+const int lz::SmlJobAssigned::executorAddress = 0;
+const int lz::SmlJobAssigned::fee = 1;
+
+const int lz::SmlJobAssigned::SmlExecutorAddress = 0xdeadbeef;
+
+cell lz::SmlJobAssigned::New(int fee) inline method_id {
+    return cl::declare(
+        lz::SmlJobAssigned::NAME,
+        unsafeTuple([
+            [cl::t::address, lz::SmlJobAssigned::SmlExecutorAddress], ;; lz::SmlJobAssigned::executorAddress
+            [cl::t::coins, fee]                                       ;; lz::SmlJobAssigned::fee
+        ])
+    );
+}

package/src/classes/lz/Worker.fc

@@ -0,0 +1,32 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int lz::Worker::NAME = "Worker"u;
+
+;; field names
+const int lz::Worker::owner = 0; ;; key
+;; allowlist of workers who are allowed to view my storage
+const int lz::Worker::viewAllowlist = 1;
+;; list of workers whose storage I depend on
+const int lz::Worker::viewDependencies = 2;
+const int lz::Worker::bytecodeLibrary = 3; ;; library cell
+const int lz::Worker::storage = 4;
+
+;; In all blockchains with atomic cross-contract call, we can use src/dst/sender/receiver
+;; because the send channel doesn't exist (it's just a nonce).
+;; In TON, we need both send/receive channels, so we use local/remote to provide
+;; a context-free way to refer to the two ends of the channel.
+;; The direction is inferred by the context of the contract (send vs receive).
+;; The srcOApp is the 256-bit hashpart of a standard address.
+cell lz::Worker::New(int owner, int pricefeedAddress, cell bytecode, cell $storage) inline method_id {
+    return cl::declare(
+        lz::Worker::NAME,
+        unsafeTuple([
+            [cl::t::address, owner],                ;; lz::Worker::owner
+            [cl::t::dict256, cl::dict256::New()],   ;; lz::Worker::viewAllowlist
+            [cl::t::dict256, cl::dict256::New()],   ;; lz::Worker::viewDependencies
+            [cl::t::cellRef, bytecode],             ;; lz::Worker::bytecodeLibrary
+            [cl::t::objRef, $storage]               ;; lz::Worker::storage
+        ])
+    );
+}

package/src/classes/msgdata/AddMsglib.fc

@@ -0,0 +1,18 @@
+#include "../../funC++/classlib.fc";
+
+;; required storage name
+const int md::AddMsglib::NAME = "addMsgLib"u;
+
+;; field names
+const int md::AddMsglib::msglibManagerAddress = 0;
+const int md::AddMsglib::dstEid = 1; ;; dstEid is not used by SML, only ULN
+
+cell md::AddMsglib::New(int msglibManagerAddress, int dstEid) inline method_id {
+    return cl::declare(
+        md::AddMsglib::NAME,
+        unsafeTuple([
+            [cl::t::address, msglibManagerAddress], ;; md::AddMsglib::msglibManagerAddress
+            [cl::t::uint32, dstEid]                 ;; md::AddMsglib::dstEid
+        ])
+    );
+}

package/src/classes/msgdata/Amount.fc

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

package/src/classes/msgdata/Bool.fc

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

package/src/classes/msgdata/ChannelNonceInfo.fc

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