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

package/src/funC++/constants.fc

@@ -0,0 +1,64 @@
+const int ERRORCODE_MASK = 0x7ff;
+const int CLASSLIB::ERROR::INVALID_FIELD_TYPE = "CLASSLIB::ERROR::INVALID_FIELD_TYPE"c & ERRORCODE_MASK;
+const int CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR = "CLASSLIB::ERROR::WRONG_ORDER_CONSTRUCTOR"c & ERRORCODE_MASK;
+
+const int MAX_U8    = 0xFF;
+const int MAX_U16   = 0xFFFF;
+const int MAX_U32   = 0xFFFFFFFF;
+const int MAX_U64   = 0xFFFFFFFFFFFFFFFF;
+const int MAX_U128  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+const int MAX_U256  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+const int MAX_COINS = 1329227995784915872903807060280344575; ;; 2^120 - 1
+
+const ADDR_TYPE_NONE = 0;
+const ADDR_TYPE_EXTERN = 1;
+const ADDR_TYPE_STD = 2;
+const ADDR_TYPE_VAR = 3;
+
+const int TRUE = -1;
+const int FALSE = 0;
+const int MASTERCHAIN = -1;
+const int BASECHAIN = 0;
+
+;; 0b011000 tag - 0, ihr_disabled - 1, bounce - 1, bounced - 0, src = adr_none$00
+const int SEND_MSG_BOUNCEABLE = 0x18;
+;; 0b010000 tag - 0, ihr_disabled - 1, bounce - 0, bounced - 0, src = adr_none$00
+const int SEND_MSG_NON_BOUNCEABLE = 0x10;
+
+;; MODIFIER
+const NORMAL = 0;
+const PAID_EXTERNALLY = 1;
+const IGNORE_ERRORS = 2;
+
+;; SEND MODES
+const BOUNCE_IF_FAIL = 16;
+const DESTROY_IF_ZERO = 32;
+const CARRY_REMAINING_GAS = 64;
+const CARRY_ALL_BALANCE = 128;
+
+;; SENDMSG modes
+const SUB_BALANCE_MSG = 64;
+const SUB_BALANCE_CONTRACT = 128;
+const ONLY_ESTIMATE_FEES = 1024;
+
+;; SEND MODES QUIETED
+const QDESTROY_IF_ZERO = 34;
+const QCARRY_REMAINING_GAS = 66;
+const QCARRY_ALL_BALANCE = 130;
+
+const RESERVE_EXACTLY    = 0;
+const RESERVE_ALL_EXCEPT = 1;
+const RESERVE_AT_MOST    = 2;
+const EXTRN_DO_NOT_FAIL  = 2;
+const BALANCE_INCREASED  = 4;
+const BALANCE_DECREASED  = 8;
+const int RESERVE_BOUNCE_ON_ACTION_FAIL = 16;
+
+;; a lot of different constants, because arithmetic manipulation of constants is not optimized
+const MAX_CELL_BITS = 1023;
+const MAX_CELL_BYTES = 127;
+const MAX_CELL_WHOLE_BYTE_BITS = MAX_CELL_BYTES * 8;
+const MAX_CELL_BIT_INDEX = 1022;
+const MAX_CELL_REFS = 4;
+
+const int NULLADDRESS = 0;

package/src/funC++/contractMain.fc

@@ -0,0 +1,84 @@
+;;; ================================================================
+;; The base main function for LayerZero Endpoint, UltraLightNode, and OApp
+;;; ================================================================
+#include "baseInterface.fc";
+#include "classlib.fc";
+#include "constants.fc";
+#include "stdlib.fc";
+#include "stringlib.fc";
+#include "txnContext.fc";
+#include "actions/utils.fc";
+#include "abstract/contractMainAbstract.fc";
+#include "handlerCore.fc";
+
+;;; ===============================
+;; Base main - low-level builtin context
+
+() main(int myBalance, int msgValue, cell inMsgFull, slice inMsgBody) impure inline {
+    initTxnContext(myBalance, msgValue, inMsgFull, inMsgBody);
+
+    if (txnIsBounced()) {
+        return ();
+    }
+
+    authenticateIfNecessary();
+
+    ;; ignore empty messages
+    if (inMsgBody.slice_empty?()) {
+        return ();
+    }
+
+    int op = getOpcode();
+    cell $md = getMsgData();
+
+    checkPermissions(op, $md);
+    
+    if (op == BaseInterface::OP::EVENT) {
+        throw(BaseInterface::ERROR::eventEmitted);
+    }
+
+    tuple actions = null();
+    if (op == BaseInterface::OP::INITIALIZE) {
+        actions = initialize($md);
+    } else {
+        assertInitialized();
+        actions = _executeOpcode(op, $md);
+    }
+
+    int outflowNanos = actions.at(ACTIONS_OUTFLOW);
+    ;; Storage fees are deducted from the contract balance
+    ;; Any amount that is explicitly deposited into this contract (getRentNanos())
+    ;; is reserved to prevent it from being sent downstream
+    int baseline = (getContractBalance() - storage_fees()) - (getMsgValue() - getDonationNanos());
+    ;; TODO: can we safely remove this assertion and instead rely on raw_reserve to revert?
+    throw_unless(37, baseline >= outflowNanos);
+    raw_reserve(baseline - outflowNanos, RESERVE_EXACTLY);
+
+    ;; Whether there is any value left to refund to the origin
+    int msgValueRemaining = true;
+    ;; the index of the action to be processed
+    int actionIndex = 1;
+    int numActions = actions.tlen();
+    while (actionIndex < numActions) {
+        ;; ========================================
+        ;; Loop management
+        tuple action = actions.tuple_at(actionIndex);
+        int actionType = action.int_at(0); ;; name is always the first index
+        actionIndex += 1;
+
+        ;; Applies a moving flag where if a single action returns false, then the false flag persists
+        msgValueRemaining = msgValueRemaining & _executeAction(actionType, action);
+    }
+
+    ;; If any value remains, we should refund it to the origin
+    if (msgValueRemaining) {
+        cell msg = begin_cell()
+            .store_uint(SEND_MSG_NON_BOUNCEABLE, 6)
+            .store_slice(getOriginStd())
+            .store_coins(0)
+            .store_uint(1, 107)
+            .store_ref(empty_cell())
+            .end_cell();
+        send_raw_message(msg, CARRY_ALL_BALANCE);
+    }
+}

package/src/funC++/dataStructures/DeterministicInsertionCircularQueue.fc

@@ -0,0 +1,155 @@
+;;; =================== DeterministicInsertionCircularQueue.fc ===================
+;; the DeterministicInsertionCircularQueue is a deterministic-gas circular buffer
+;; that stores key-value pairs along with one piece of metadata (8-bits) per entry.
+#include "../utils.fc";
+#include "../stdlib.fc";
+
+const int DeterministicInsertionCircularQueue::statusBits = 8;
+const int DeterministicInsertionCircularQueue::keyBits = 64;
+
+const int DeterministicInsertionCircularQueue::invalidKey = -1;
+const int DeterministicInsertionCircularQueue::invalidStatus = -1;
+const int DeterministicInsertionCircularQueue::ERROR::invalidObject = "DeterministicInsertionCircularQueue::ERROR::invalidObject"c & ERRORCODE_MASK;
+
+cell DeterministicInsertionCircularQueue::_buildLevel(int level, cell initialContents) inline {
+    if (level == 0) {
+        return begin_cell()
+            .store_ref(initialContents)
+            .store_ref(initialContents)
+            .store_ref(initialContents)
+            .store_ref(initialContents)
+            .end_cell();
+    } else {
+        int nextLevel = level - 1;
+        return begin_cell()
+            .store_ref(DeterministicInsertionCircularQueue::_buildLevel(nextLevel, initialContents))
+            .store_ref(DeterministicInsertionCircularQueue::_buildLevel(nextLevel, initialContents))
+            .store_ref(DeterministicInsertionCircularQueue::_buildLevel(nextLevel, initialContents))
+            .store_ref(DeterministicInsertionCircularQueue::_buildLevel(nextLevel, initialContents))
+            .end_cell();
+    }
+}
+
+;; Given a well-formed commit_verification_queue
+;; get the content of the queue at a given relative nonce
+;; (actual key, entry, status, exists)
+(int, cell, int, int) DeterministicInsertionCircularQueue::get(cell self, int key) inline {
+    int position = key % MAX_CELL_BITS;
+
+    slice commitSlice = self
+        .begin_parse()
+        .preload_ref_at(position / 256)
+        .begin_parse()
+        .preload_ref_at((position % 256) / 64)
+        .begin_parse()
+        .preload_ref_at((position % 64) / 16)
+        .begin_parse()
+        .preload_ref_at((position % 16) / 4)
+        .begin_parse()
+        .preload_ref_at(position % 4)
+        .begin_parse();
+
+    ;; guaranteed to always have state stored
+    int exists = commitSlice~load_bool();
+    int state = commitSlice~load_uint(DeterministicInsertionCircularQueue::statusBits);
+    if (exists) {
+        return (
+            commitSlice.preload_uint(DeterministicInsertionCircularQueue::keyBits),
+            commitSlice.preload_first_ref(),
+            state,
+            exists
+        );
+    }
+    return (
+        DeterministicInsertionCircularQueue::invalidKey,
+        empty_cell(),
+        DeterministicInsertionCircularQueue::invalidStatus,
+        exists
+    );
+}
+
+cell DeterministicInsertionCircularQueue::_setRaw(cell self, int key, cell newLeaf) inline {
+    int slot = key % MAX_CELL_BITS;
+    slice queueSlice = self.begin_parse();
+    int l0_idx = slot / 256;
+    int l1_idx = (slot % 256) / 64;
+    int l2_idx = (slot % 64) / 16;
+    int l3_idx = (slot % 16) / 4;
+    int leaf_idx = slot % 4;
+
+    slice l0Slice = queueSlice.preload_ref_at(l0_idx).begin_parse();
+    slice l1Slice = l0Slice.preload_ref_at(l1_idx).begin_parse();
+    slice l2Slice = l1Slice.preload_ref_at(l2_idx).begin_parse();
+    slice l3Slice = l2Slice.preload_ref_at(l3_idx).begin_parse();
+
+    cell new_l3 = begin_cell()
+        .store_slice(scutfirst(l3Slice, 0, leaf_idx))
+        .store_ref(newLeaf)
+        .store_slice(scutlast(l3Slice, 0, 3 - leaf_idx))
+        .end_cell();
+
+    cell new_l2 = begin_cell()
+        .store_slice(scutfirst(l2Slice, 0, l3_idx))
+        .store_ref(new_l3)
+        .store_slice(scutlast(l2Slice, 0, 3 - l3_idx))
+        .end_cell();
+
+    cell new_l1 = begin_cell()
+        .store_slice(scutfirst(l1Slice, 0, l2_idx))
+        .store_ref(new_l2)
+        .store_slice(scutlast(l1Slice, 0, 3 - l2_idx))
+        .end_cell();
+
+    cell new_l0 = begin_cell()
+        .store_slice(scutfirst(l0Slice, 0, l1_idx))
+        .store_ref(new_l1)
+        .store_slice(scutlast(l0Slice, 0, 3 - l1_idx))
+        .end_cell();
+
+    return (
+        begin_cell()
+            .store_slice(scutfirst(queueSlice, 0, l0_idx))
+            .store_ref(new_l0)
+            .store_slice(scutlast(queueSlice, 0, 3 - l0_idx))
+            .end_cell()
+    );
+}
+
+;; self
+cell DeterministicInsertionCircularQueue::set(cell self, int key, cell $obj, int newState) inline {
+    return DeterministicInsertionCircularQueue::_setRaw(
+        self,
+        key,
+        begin_cell()
+            .store_bool(true) ;; occupied
+            .store_uint(newState, DeterministicInsertionCircularQueue::statusBits)
+            .store_uint(key, DeterministicInsertionCircularQueue::keyBits)
+            .store_ref($obj)
+            .end_cell()
+    );
+}
+
+cell DeterministicInsertionCircularQueue::delete(cell self, int key) inline {
+    return DeterministicInsertionCircularQueue::_setRaw(
+        self,
+        key,
+        begin_cell()
+            .store_bool(false) ;; occupied
+            .store_uint(0, DeterministicInsertionCircularQueue::statusBits)
+            .store_uint(0, DeterministicInsertionCircularQueue::keyBits)
+            .store_ref(empty_cell())
+            .end_cell()
+    );
+}
+
+cell DeterministicInsertionCircularQueue::create() method_id {
+    ;; ceil(log4(MAX_CELL_BITS)) == 4
+    ;; build the initial contents of each leaf in the outer scope to save gas
+    cell initialContents = begin_cell()
+        .store_bool(false) ;; unoccupied
+        .store_uint(0, DeterministicInsertionCircularQueue::statusBits) ;; value not used until set
+        .store_uint(0, DeterministicInsertionCircularQueue::keyBits) ;; value not used until set
+        .store_ref(empty_cell()) ;; value not used until set
+        .end_cell();
+    return DeterministicInsertionCircularQueue::_buildLevel(4, initialContents);
+}

package/src/funC++/dataStructures/PipelinedOutOfOrder.fc

@@ -0,0 +1,93 @@
+;;; ==============================================================================
+;; Pipelined Out-of-Order data structure
+;; this data structure defines a bitmap that is used to track a stream of
+;; commands that are executed out-of-order in a bounded-depth pipeline
+#include "../classlib.fc";
+#include "../utils.fc";
+
+const int POOO::NAME = "POOO"u;
+
+const int POOO::nextEmpty = 0;
+const int POOO::bitmap = 1;
+
+const int POOO::ERROR::negativeIndex = "POOO::ERROR::negativeIndex"c & ERRORCODE_MASK;
+
+;; Algorithm:
+;; 1. Extract the first `index` bits from the original bitmap.
+;; 2. Append a '1' bit to the extracted bits.
+;; 3. Append the remaining bits from the original bitmap after the first `index` bits to form a new bitmap.
+
+;; Returns:
+;; 1. The number of leading ones (`leadingOnes`).
+;; 2. A new cell that contains:
+;;    - The remaining bits after the leading ones from the original bitmap.
+;;    - A number of trailing zero bits equal to `leadingOnes`.
+
+;; Parameters:
+;; - `bitmapCell`: The original bitmap in the form of a cell.
+;; - `index`: The position up to which the first part of the bitmap is extracted.
+cell POOO::set(cell $self, int absoluteIndex) impure inline method_id {
+    throw_if(POOO::ERROR::negativeIndex, absoluteIndex < 0);
+
+    slice bitmapSlice = $self.cl::get<cellRef>(POOO::bitmap).begin_parse();
+    int nextEmpty = $self.cl::get<uint64>(POOO::nextEmpty);
+    if (absoluteIndex < nextEmpty) {
+        return $self;
+    }
+    int index = absoluteIndex - nextEmpty;
+
+    (int leadingOnes, slice remainingBitmap) = ldones(
+        begin_cell()
+            .store_slice(scutfirst(bitmapSlice, index, 0))
+            .store_uint(1, 1)
+            .store_slice(scutlast(bitmapSlice, MAX_CELL_BITS - index - 1, 0))
+            .as_slice()
+    );
+    return $self
+        .cl::set(
+            POOO::bitmap,
+            begin_cell()
+                .store_slice(remainingBitmap)
+                .store_zeroes(leadingOnes)
+                .end_cell()
+        )
+        .cl::set(POOO::nextEmpty, nextEmpty + leadingOnes);
+}
+
+cell POOO::New() inline method_id {
+    return cl::declare(
+        POOO::NAME,
+        unsafeTuple([
+            [cl::t::uint64, 1], ;; nextEmpty
+            [cl::t::cellRef, begin_cell().store_zeroes(MAX_CELL_BITS).end_cell()] ;; bitmap
+        ])
+    );
+}
+
+cell POOO::NewWithBitsSets(int startingBit, int endingBit) method_id {
+    return cl::declare(
+        POOO::NAME,
+        unsafeTuple([
+            [cl::t::uint64, 1],
+            [cl::t::cellRef, begin_cell()
+                .store_zeroes(1)
+                .store_ones(endingBit - startingBit)
+                .store_zeroes(MAX_CELL_BITS - endingBit)
+                .end_cell()
+            ]
+        ])
+    );
+}
+
+int POOO::isBitSet(cell $self, int absoluteIdx) inline method_id {
+    int relativeIdx = absoluteIdx - $self.cl::get<uint64>(POOO::nextEmpty);
+    return $self
+        .cl::get<cellRef>(POOO::bitmap)
+        .begin_parse()
+        .preload_bits_offset(relativeIdx, 1)
+        .preload_uint(1) == 1;
+}
+
+int POOO::maxSettableBit(cell $self) inline method_id {
+    return $self.cl::get<uint64>(POOO::nextEmpty) + MAX_CELL_BIT_INDEX;
+}

package/src/funC++/handlerCore.fc

@@ -0,0 +1,30 @@
+;;; ==========================================
+;; This file contains the utility functions for all handler functions that follow
+;; LayerZero Labs handler convention.
+;;; ==========================================
+#include "actions/utils.fc";
+
+#include "baseInterface.fc";
+
+#include "constants.fc";
+#include "stringlib.fc";
+#include "txnContext.fc";
+
+#include "abstract/handlerAbstract.fc";
+
+;;; ===================REQUIRED VIRTUAL FUNCTIONS=======================
+;; todo: split into permissions and utils?
+
+(cell, tuple) preamble() impure inline {
+    return (getContractStorage(), emptyActions());
+}
+
+() checkPermissions(int op, cell $md) impure inline {
+    if (op == BaseInterface::OP::EVENT) {
+        return ();
+    } elseif (op == BaseInterface::OP::INITIALIZE) {
+        assertOwner();
+    } else {
+        _checkPermissions(op, $md);
+    }
+}