@layerzerolabs/layerzero-v2-ton 3.0.18-ton.2 → 3.0.19-ton.1

package/src/protocol/msglibs/ultralightnode/uln/handler.fc

@@ -0,0 +1,803 @@
+#include "../../BytesEncoder.fc";
+
+#include "../feeLibInterface.fc";
+#include "../feeLibUtils.fc";
+
+#include "../msgdata/DvnFeesPaidEvent.fc";
+#include "../msgdata/ExecutorFeePaidEvent.fc";
+#include "../msgdata/InitUln.fc";
+#include "../msgdata/RentRefill.fc";
+#include "../msgdata/TreasuryFeeBps.fc";
+#include "../msgdata/UlnEvents.fc";
+#include "../msgdata/UlnSend.fc";
+#include "../msgdata/UlnSendConfig.fc";
+#include "../msgdata/UlnWorkerFeelibEvents.fc";
+#include "../msgdata/UlnWorkerFeelibInfo.fc";
+
+#include "../ulnConnection/interface.fc";
+#include "../ulnManager/interface.fc";
+
+#include "../../../interfaces.fc";
+#include "../../../channel/interface.fc";
+#include "../../../core/abstract/protocolHandler.fc";
+
+#include "../../../../classes/lz/Packet.fc";
+#include "../../../../classes/msgdata/ExtendedMd.fc";
+#include "../../../../classes/msgdata/LzSend.fc";
+#include "../../../../classes/msgdata/MdAddress.fc";
+#include "../../../../classes/msgdata/MdObj.fc";
+#include "../../../../classes/msgdata/MsglibSendCallback.fc";
+#include "../../../../classes/msgdata/SetAddress.fc";
+
+#include "interface.fc";
+#include "storage.fc";
+
+const int _quoteWorkersMethodId = 23432;
+;;; ================INTERFACE FUNCTIONS=====================
+
+(cell, tuple) _initialize(cell $initUln) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    $storage = $storage
+        .cl::set(
+            Uln::connectionCode,
+            $initUln.cl::get<cellRef>(md::InitUln::connectionCode)
+        )
+        .cl::set(
+            Uln::treasuryFeeBps,
+            $initUln.cl::get<uint16>(md::InitUln::treasuryFeeBps)
+        )
+        .cl::set(
+            Uln::remainingWorkerSlots,
+            Uln::MaxWorkerFeelibs - UlnManager::CONST::MAX_ADMIN_WORKERS
+        )
+        .cl::set(
+            Uln::remainingAdminWorkerSlots,
+            UlnManager::CONST::MAX_ADMIN_WORKERS
+        );
+
+    return ($storage, actions);
+}
+
+int _getEventSink() impure {
+    return getOwner();
+}
+
+() assertConnection(cell $ulnSendMd) impure inline {
+    cell connectionCode = getContractStorage().cl::get<cellRef>(Uln::connectionCode);
+
+    cell $connectionInitialStorage = $ulnSendMd
+        .cl::get<objRef>(md::UlnSend::connectionInitialStorage);
+
+    int providedUlnManagerAddress = $connectionInitialStorage
+        .cl::get<objRef>(BASE_STORAGE_INDEX)
+        .cl::get<address>(BaseStorage::owner);
+
+    ;; By construction, if the bytecode is valid and the uln manager address is correct,
+    ;; then the uln address cannot be incorrect (assuming no bug in the ULN connection bytecode).
+    throw_unless(
+        Uln::ERROR::notUlnConnection,
+        (providedUlnManagerAddress == getOwner())
+        & (computeContractAddress($connectionInitialStorage, connectionCode) == getCaller())
+    );
+}
+
+cell _failedMsglibSendCallback(cell $lzSend) impure inline {
+    return md::MsglibSendCallback::New(
+        0,
+        0,
+        $lzSend,
+        empty_cell(),
+        empty_cell(),
+        0,
+        0,
+        0,
+        0,
+        cl::nullObject(),
+        Uln::ErrorCode::WORKER_QUOTE_FAILED
+    );
+}
+
+cell _quote(cell $ulnSendMd, cell $storage) impure inline {
+    cell $lzSend = $ulnSendMd.cl::get<objRef>(md::UlnSend::lzSend);
+
+    int ownerAddress = $storage
+        .cl::get<objRef>(BASE_STORAGE_INDEX)
+        .cl::get<address>(BaseStorage::owner);
+
+    (
+        int quoteGasLimit,
+        int maxMsgBytes,
+        int executor,
+        cell requiredDVNs,
+        cell optionalDVNs,
+        int confirmations,
+        int isValid
+    ) = lz::UlnSendConfig::resolveUlnSendConfig(
+        $ulnSendMd.cl::get<objRef>(md::UlnSend::customUlnSendConfig),
+        $storage.cl::get<objRef>(Uln::defaultUlnSendConfig)
+    );
+
+    ifnot (isValid) {
+        return md::MdAddress::New(
+            _failedMsglibSendCallback($lzSend),
+            ownerAddress
+        );
+    }
+
+    int messageBytes = lz::Packet::_messageBytes($lzSend.cl::get<objRef>(md::LzSend::packet));
+
+    tuple returnStack = unsafeTuple([null()]);
+
+    if (messageBytes <= maxMsgBytes) {
+        returnStack = safePackedInputsRunVm(
+            unsafeTuple([
+                $storage,
+                $lzSend,
+                executor,
+                requiredDVNs,
+                optionalDVNs,
+                confirmations,
+                messageBytes,
+                $lzSend.cl::get<objRef>(md::LzSend::extraOptions),
+                $lzSend.cl::get<objRef>(md::LzSend::enforcedOptions)
+            ]),
+            _quoteWorkersMethodId,
+            1,
+            my_code().begin_parse(),
+            quoteGasLimit
+        );
+    }
+
+    cell $msglibSendCallback = returnStack.cell_at(0);
+    ifnot ($msglibSendCallback.is_cell()) {
+        return md::MdAddress::New(
+            _failedMsglibSendCallback($lzSend),
+            ownerAddress
+        );
+    }
+
+    return md::MdAddress::New(
+        $msglibSendCallback,
+        ownerAddress
+    );
+}
+
+;; caller is responsible for asserting the worker exists
+cell _removeWorker(cell $storage, cell $workerFeelibInfo) impure inline {
+    int workerAddress = $workerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress);
+    int workerSlotField = $workerFeelibInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin)
+        ? Uln::remainingAdminWorkerSlots
+        : Uln::remainingWorkerSlots;
+    return $storage
+        .cl::nestedDict256::delete(Uln::workerFeelibInfos, workerAddress)
+        .cl::set( workerSlotField, $storage.cl::get<uint16>(workerSlotField) + 1);
+}
+
+(int, cell) _quoteWorker(
+    cell $storage,
+    int workerAddress,
+    cell $path,
+    int confirmations,
+    int packetBytes,
+    cell $extraOptions,
+    cell $enforcedOptions
+) impure inline_ref method_id {
+    (cell $workerInfo, int workerExists) = $storage.cl::nestedDict256::get<cellRef>(
+        Uln::workerFeelibInfos,
+        workerAddress
+    );
+    ifnot (workerExists) {
+        return (-1, null());
+    }
+
+    (cell $friendInfo, int friendExists) = ($workerInfo, workerExists);
+    int friendWorkerAddress = $workerInfo
+        .cl::get<address>(UlnWorkerFeelibInfo::friendWorkerAddress);
+
+    ifnot (friendWorkerAddress == NULLADDRESS) {
+        ($friendInfo, friendExists) = $storage.cl::nestedDict256::get<cellRef>(
+            Uln::workerFeelibInfos,
+            friendWorkerAddress
+        );
+    }
+    ifnot (friendExists) {
+        return (-1, null());
+    }
+
+    tuple returnStack = safePackedInputsRunVm(
+        unsafeTuple(
+            [
+                $workerInfo.cl::get<objRef>(UlnWorkerFeelibInfo::workerFeelibStorage),
+                $friendInfo,
+                $path,
+                confirmations,
+                packetBytes,
+                $extraOptions,
+                $enforcedOptions
+            ]
+        ),
+        UlnWorkerInterface::quote,
+        1,
+        $workerInfo.cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode).begin_parse(),
+        MAX_U32 ;; gas limit doesn't matter for the inner call
+    );
+
+    tuple retVal = returnStack.tuple_at(0);
+    ;; if it's not a tuple, then the worker returned an error or went OOG
+    ifnot (retVal.is_tuple()) {
+        return (-1, null());
+    }
+
+    ;; the tuple must have exactly two items
+    ifnot (retVal.tlen() == 2) {
+        return (-1, null());
+    }
+
+    ;; the first item must be an int
+    int fee = retVal.int_at(0);
+    ifnot (fee.is_int()) {
+        return (-1, null());
+    }
+
+    ;; the second item must be a cell or null
+    cell event = retVal.cell_at(1);
+    ifnot ((event.is_cell()) | (event.is_null())) {
+        return (-1, null());
+    }
+
+    return (fee, event);
+}
+
+;; return null on failure, actions on success
+;; tuple _quoteWorkers(cell $lzSend, int executor, cell requiredDVNs, cell optionalDVNs) impure inline {
+cell _quoteWorkers(tuple args) impure inline method_id(23432) {
+    cell $storage = args.cell_at(0);
+    cell $lzSend = args.cell_at(1);
+    int executor = args.int_at(2);
+    cell requiredDVNsCell = args.cell_at(3);
+    cell optionalDVNsCell = args.cell_at(4);
+    int confirmations = args.int_at(5);
+    int packetBytes = args.int_at(6);
+    cell $extraOptions = args.cell_at(7);
+    cell $enforcedOptions = args.cell_at(8);
+    ;; quote the executor first
+    int totalNativeFee = 0;
+
+    slice requiredDVNs = requiredDVNsCell.begin_parse();
+    slice optionalDVNs = optionalDVNsCell.begin_parse();
+
+    cell $packet = $lzSend.cl::get<objRef>(md::LzSend::packet);
+    cell $path = $packet.cl::get<cellRef>(lz::Packet::path);
+
+    tuple payeesInfo = empty_tuple();
+    tuple workerEvents = UlnWorkerFeelibEventsBuilder::create();
+
+    while (requiredDVNs.slice_empty?() == false) {
+        int requiredDVNAddress = requiredDVNs~AddressList::next();
+        (int nativeFee, cell eventBody) = _quoteWorker(
+            $storage,
+            requiredDVNAddress,
+            $path,
+            confirmations,
+            packetBytes,
+            $extraOptions,
+            $enforcedOptions
+        );
+
+        if (nativeFee < 0) {
+            return null();
+        }
+
+        totalNativeFee += nativeFee;
+        payeesInfo = payeesInfo.tpush(unsafeTuple([requiredDVNAddress, nativeFee]));
+        workerEvents = workerEvents
+            .UlnWorkerFeelibEventsBuilder::push(requiredDVNAddress, eventBody);
+    }
+
+    while (optionalDVNs.slice_empty?() == false) {
+        int optionalDVNAddress = optionalDVNs~AddressList::next();
+        (int nativeFee, cell eventBody) = _quoteWorker(
+            $storage,
+            optionalDVNAddress,
+            $path,
+            confirmations,
+            packetBytes,
+            $extraOptions,
+            $enforcedOptions
+        );
+
+        if (nativeFee < 0) {
+            return null();
+        }
+
+        payeesInfo = payeesInfo.tpush(unsafeTuple([optionalDVNAddress, nativeFee]));
+        totalNativeFee += nativeFee;
+
+        workerEvents = workerEvents
+            .UlnWorkerFeelibEventsBuilder::push(optionalDVNAddress, eventBody);
+    }
+
+    ;; create the dvnPaidEvent
+    cell $dvnsFeesPaidEvent = DvnFeesPaidEvent::New(
+        requiredDVNsCell,
+        optionalDVNsCell,
+        serializePayees(payeesInfo)
+    );
+
+    (int executorFee, cell eventBody) = _quoteWorker(
+        $storage,
+        executor,
+        $path,
+        confirmations,
+        packetBytes,
+        $extraOptions,
+        $enforcedOptions
+    );
+
+    if (executorFee < 0) {
+        return null();
+    }
+
+    ;; add the executor fee
+    payeesInfo = payeesInfo.tpush(unsafeTuple([executor, executorFee]));
+    totalNativeFee += executorFee;
+
+    ;; add events from executor to workerEvents
+    workerEvents = workerEvents
+        .UlnWorkerFeelibEventsBuilder::push(executor, eventBody);
+
+    ;; create the executorPaidEvent
+    cell $executorFeePaidEvent = ExecutorFeePaidEvent::New(executor, executorFee);
+
+    ;; Handle treasury fee
+    int treasuryFee = totalNativeFee * $storage.cl::get<uint16>(Uln::treasuryFeeBps) / 10000;
+    payeesInfo = payeesInfo.tpush(
+        unsafeTuple([
+            $storage.cl::get<objRef>(BASE_STORAGE_INDEX).cl::get<address>(BaseStorage::owner),
+            treasuryFee
+        ])
+    );
+
+    cell ret = md::MsglibSendCallback::New(
+        totalNativeFee + treasuryFee,
+        0,
+        $lzSend,
+        BytesEncoder::build<PacketV1>($packet).BytesEncoder::serialize(),
+        serializePayees(payeesInfo),
+        PacketV1::nonceOffsetBytes,
+        PacketV1::nonceBytes,
+        PacketV1::guidOffsetBytes,
+        PacketV1::guidBytes,
+        UlnEvents::New(
+            UlnWorkerFeelibEvents::FromBuilder(workerEvents),
+            $dvnsFeesPaidEvent,
+            $executorFeePaidEvent
+        ),
+        Channel::NO_ERROR
+    );
+    return ret;
+}
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (op == Uln::OP::ULN_SEND) {
+        return assertConnection($md);
+    } elseif (
+        (op == Uln::OP::ULN_VERIFY)
+        | (op == Uln::OP::ULN_COMMIT_PACKET)
+    ) {
+        return ();
+    } elseif (
+        (op == Uln::OP::DEREGISTER_WORKER_FEELIB)
+        | (op == Uln::OP::COLLECT_WORKER_RENT)
+        | (op == Uln::OP::SET_WORKER_FEELIB_STORAGE)
+        | (op == Uln::OP::REFILL_WORKER_RENT)
+        | (op == Uln::OP::GC_ATTESTATIONS)
+    ) {
+        return ();
+    } elseif (
+        (op == Uln::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG)
+        | (op == Uln::OP::SET_DEFAULT_ULN_SEND_CONFIG)
+        | (op == Uln::OP::UPDATE_WORKER_FEELIB)
+        | (op == Uln::OP::SET_TREASURY_FEE_BPS)
+    ) {
+        return assertOwner();
+    } else {
+        ;; we must put a check for all opcodes to make sure we don't
+        ;; mistakenly miss an opp code's permissions
+        throw(BaseInterface::ERROR::invalidOpcode);
+    }
+}
+
+;;; ==========================HANDLERS=====================================
+
+tuple ulnQuote(cell $ulnSendMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $ulnSendMd.cl::get<address>(md::UlnSend::forwardingAddress),
+        Msglib::OP::RETURN_QUOTE,
+        _quote($ulnSendMd, $storage)
+    );
+
+    return actions;
+}
+
+tuple ulnSend(cell $ulnSendMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $ulnSendMd.cl::get<address>(md::UlnSend::forwardingAddress),
+        Channel::OP::MSGLIB_SEND_CALLBACK,
+        _quote($ulnSendMd, $storage)
+    );
+
+    return actions;
+}
+
+;; @in_opcode Msglibs::OP::ULN_COMMIT_VERIFICATION
+;; @in frame
+;; @in $mdAddress { address: UlnConnectionAddress, md: Packet }
+;; @permissions permissionless
+;; @out_actions call commit on connection
+tuple ulnCommitPacket(cell $mdAddress) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $mdAddress.cl::get<address>(md::MdAddress::address),
+        UlnConnection::OP::ULN_CONNECTION_COMMIT_PACKET,
+        md::MdObj::New(
+            $mdAddress.cl::get<objRef>(md::MdAddress::md),
+            $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig)
+        )
+    );
+
+    return actions;
+}
+
+;; @in_opcode Msglibs::OP::VERIFY
+;; @in external caller
+;; @in $mdAddress { address: UlnConnectionAddress, md: Verification }
+;; @permissions permissionless
+;; @out_actions call verify on connection
+;; @notice this is an optional function that will
+;; call ulnConnectionVerify on the connection using a default config
+tuple ulnVerify(cell $mdAddress) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $mdAddress.cl::get<address>(md::MdAddress::address),
+        UlnConnection::OP::ULN_CONNECTION_VERIFY,
+        md::ExtendedMd::New(
+            $mdAddress.cl::get<objRef>(md::MdAddress::md),
+            $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig),
+            getCaller()
+        )
+    );
+
+    return actions;
+}
+
+() _setWorkerInfo(cell $workerFeelibInfo) impure inline_ref {
+    cell $storage = getContractStorage();
+    int workerAddress = $workerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress);
+
+    ;; Restrict the size of the new storage to prevent DoS of our contract storage.
+    ;; The total worker bytecode size is capped by UlnManager::CONST::MAX_CUMULATIVE_BYTECODE_CELLS
+    ;; and enforced by the UlnManager, so here the only thing we need to check is the storage size
+    ;; of the workers, excluding their bytecode
+    (_, _, _, int success) = compute_data_size?(
+        $workerFeelibInfo.cl::set(UlnWorkerFeelibInfo::workerFeelibBytecode, empty_cell()),
+        Uln::WorkerFeelibInfo::MaxCells
+    );
+
+    throw_unless(Uln::ERROR::invalidWorkerStorage, success);
+
+    setContractStorage(
+        $storage
+            .cl::nestedDict256::setRef(
+                Uln::workerFeelibInfos,
+                workerAddress,
+                $workerFeelibInfo
+            )
+    );
+}
+
+tuple updateWorkerFeelib(cell $UlnWorkerFeelibInfo) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    int workerAddress = $UlnWorkerFeelibInfo.cl::get<address>(UlnWorkerFeelibInfo::workerAddress);
+
+    (cell $existingWorkerFeelibInfo, int exists) = cl::nestedDict256::get<cellRef>(
+        $storage,
+        Uln::workerFeelibInfos,
+        workerAddress
+    );
+
+    ifnot (exists) {
+        int isAdmin = $UlnWorkerFeelibInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin);
+        int workerSlotField = isAdmin ? Uln::remainingAdminWorkerSlots : Uln::remainingWorkerSlots;
+        int remainingWorkerSlots = $storage.cl::get<uint16>(workerSlotField);
+
+        if (remainingWorkerSlots == 0) {
+            ;; exit early if there are no remaining worker slots
+            actions~pushAction<event>(
+                Uln::event::ULN_WORKER_SLOTS_FULL,
+                $UlnWorkerFeelibInfo
+            );
+            return actions;
+        }
+
+        ifnot (isAdmin) {
+            ;; if it doesn't exist, we must collect the initial rent deposit
+            int initialRent = $UlnWorkerFeelibInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance);
+
+            throw_unless(Uln::ERROR::insufficientRent, initialRent >= Uln::CONST::INITIAL_RENT_NANOS);
+
+            actions~pushAction<payment>(
+                getOwner(),
+                initialRent,
+                0
+            );
+        }
+
+        $UlnWorkerFeelibInfo = $UlnWorkerFeelibInfo.cl::set(
+            UlnWorkerFeelibInfo::lastRentTimestamp,
+            now()
+        );
+
+        setContractStorage($storage.cl::set(workerSlotField, remainingWorkerSlots - 1));
+    } else {
+        ;; Do not allow workers to arbitrarily change their rent information
+        $UlnWorkerFeelibInfo = $UlnWorkerFeelibInfo
+            .cl::set(
+                UlnWorkerFeelibInfo::rentBalance,
+                $existingWorkerFeelibInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance)
+            )
+            .cl::set(
+                UlnWorkerFeelibInfo::lastRentTimestamp,
+                $existingWorkerFeelibInfo.cl::get<uint64>(UlnWorkerFeelibInfo::lastRentTimestamp)
+            );
+    }
+
+    _setWorkerInfo($UlnWorkerFeelibInfo);
+
+    actions~pushAction<event>(
+        Uln::event::ULN_WORKER_REGISTERED,
+        $UlnWorkerFeelibInfo
+    );
+
+    return actions;
+}
+
+tuple deregisterWorkerFeelib(cell $empty) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int workerAddress = getCaller();
+    (cell $UlnWorkerFeelibInfo, int exists) = cl::nestedDict256::get<cellRef>(
+        $storage,
+        Uln::workerFeelibInfos,
+        workerAddress
+    );
+
+    if (exists) {
+        setContractStorage(
+            _removeWorker($storage, $UlnWorkerFeelibInfo)
+        );
+        actions~pushAction<event>(
+            Uln::event::ULN_WORKER_DEREGISTERED,
+            $UlnWorkerFeelibInfo
+        );
+    }
+
+    return actions;
+}
+
+;; This function handles ALL worker configs including priceFeed updates
+;; @out_actions event
+tuple setWorkerFeelibStorage(cell $newStorage) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    (cell $workerInfo, int exists) = $storage.cl::nestedDict256::get<cellRef>(
+        Uln::workerFeelibInfos,
+        getCaller()
+    );
+    throw_unless(Uln::ERROR::nonexistentWorker, exists);
+
+    cell $updatedWorkerInfo = $workerInfo.cl::set(
+        UlnWorkerFeelibInfo::workerFeelibStorage,
+        $newStorage
+    );
+
+    ;; _setWorkerInfo does size assertions on worker storage
+    _setWorkerInfo($updatedWorkerInfo);
+
+    setContractStorage(
+        $storage
+            .cl::nestedDict256::setRef(
+                Uln::workerFeelibInfos,
+                getCaller(),
+                $updatedWorkerInfo
+            )
+    );
+
+    actions~pushAction<event>(
+        Uln::event::ULN_WORKER_STORAGE_SET,
+        $updatedWorkerInfo
+    );
+
+    actions~pushAction<call>(
+        getCaller(),
+        Uln::OP::SET_WORKER_FEELIB_STORAGE_CALLBACK,
+        $newStorage
+    );
+
+    return actions;
+}
+
+tuple refillWorkerRent(cell $rentRefill) {
+    (cell $storage, tuple actions) = preamble();
+
+    int workerAddress = $rentRefill.cl::get<address>(md::RentRefill::address);
+    int amount = $rentRefill.cl::get<coins>(md::RentRefill::amount);
+    (cell $workerInfo, int exists) = cl::nestedDict256::get<cellRef>(
+        $storage,
+        Uln::workerFeelibInfos,
+        workerAddress
+    );
+
+    throw_unless(Uln::ERROR::nonexistentWorker, exists);
+
+    int currentRentBalance = $workerInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance);
+
+    _setWorkerInfo(
+        $workerInfo.cl::set(UlnWorkerFeelibInfo::rentBalance, currentRentBalance + amount)
+    );
+
+    actions~pushAction<payment>(
+        getOwner(),
+        amount,
+        0
+    );
+
+    actions~pushAction<event>(
+        Uln::event::ULN_WORKER_RENT_REFILLED,
+        $rentRefill
+    );
+
+    return actions;
+}
+
+tuple collectWorkerRent(cell $setAddress) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    (cell $workerInfo, int exists) = cl::nestedDict256::get<cellRef>(
+        $storage,
+        Uln::workerFeelibInfos,
+        $setAddress.cl::get<address>(md::SetAddress::address)
+    );
+
+    throw_unless(Uln::ERROR::nonexistentWorker, exists);
+
+    ;; Admins do not pay rent
+    if ($workerInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin)) {
+        return emptyActions();
+    }
+
+    int currentTimestamp = now();
+    int elapsedTimestamp = currentTimestamp - $workerInfo.cl::get<uint64>(UlnWorkerFeelibInfo::lastRentTimestamp);
+    throw_unless(Uln::ERROR::invalidTimestamp, elapsedTimestamp > 0);
+
+    int totalRentOwed = elapsedTimestamp * Uln::CONST::RENT_NANOS_PER_SECOND;
+    int currentRentBalance = $workerInfo.cl::get<coins>(UlnWorkerFeelibInfo::rentBalance);
+
+    ;; if rentBalance is greater than totalRentOwed, we can update rentBalance and lastRentTimestamp
+    ;; else we must delete(evict) the worker from the workerInfos
+    if (currentRentBalance >= totalRentOwed) {
+        $workerInfo = $workerInfo
+            .cl::set(UlnWorkerFeelibInfo::rentBalance, currentRentBalance - totalRentOwed)
+            .cl::set(UlnWorkerFeelibInfo::lastRentTimestamp, currentTimestamp);
+
+        ;; update workerInfo in storage
+        _setWorkerInfo($workerInfo);
+
+        actions~pushAction<event>(
+            Uln::event::ULN_COLLECT_WORKER_RENT,
+            $workerInfo
+        );
+    } else {
+        setContractStorage(
+            _removeWorker($storage, $workerInfo)
+        );
+
+        actions~pushAction<event>(
+            Uln::event::ULN_WORKER_EVICTED,
+            $workerInfo
+        );
+    }
+
+    return actions;
+}
+
+tuple setDefaultUlnSendConfig(cell $ulnSendConfig) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $sanitizedUlnSendConfig = UlnSendConfig::sanitize($ulnSendConfig);
+
+    setContractStorage(
+        $storage.cl::set(
+            Uln::defaultUlnSendConfig,
+            $sanitizedUlnSendConfig
+        )
+    );
+
+    actions~pushAction<event>(
+        Uln::event::ULN_DEFAULT_SEND_CONFIG_SET,
+        $sanitizedUlnSendConfig
+    );
+
+    return actions;
+}
+
+tuple setDefaultUlnReceiveConfig(cell $ulnReceiveConfig) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $sanitizedUlnReceiveConfig = UlnReceiveConfig::sanitize($ulnReceiveConfig);
+
+    setContractStorage(
+        $storage.cl::set(
+            Uln::defaultUlnReceiveConfig,
+            $sanitizedUlnReceiveConfig
+        )
+    );
+    actions~pushAction<event>(
+        Uln::event::ULN_DEFAULT_RECEIVE_CONFIG_SET,
+        $sanitizedUlnReceiveConfig
+    );
+
+    return actions;
+}
+
+tuple setTreasuryFeeBps(cell $treasuryFeeBps) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int treasuryFeeBps = $treasuryFeeBps.cl::get<uint16>(md::TreasuryFeeBps::treasuryFeeBps);
+
+    throw_unless(Uln::ERROR::invalidTreasuryFeeBps, treasuryFeeBps <= 10000);
+
+    setContractStorage(
+        $storage.cl::set(
+            Uln::treasuryFeeBps,
+            treasuryFeeBps
+        )
+    );
+
+    actions~pushAction<event>(
+        Uln::event::ULN_TREASURY_FEE_BPS_SET,
+        $treasuryFeeBps
+    );
+
+    return actions;
+}
+
+;; Send the default config to the ULN connection to allow it to garbage collect
+;; attestations from DVNs that were removed from the configuration
+tuple garbageCollectInvalidAttestations(cell $mdAddress) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    actions~pushAction<call>(
+        $mdAddress.cl::get<address>(md::MdAddress::address),
+        UlnConnection::OP::GARBAGE_COLLECT_INVALID_ATTESTATIONS,
+        md::MdObj::New(
+            $mdAddress.cl::get<objRef>(md::MdAddress::md),
+            $storage.cl::get<objRef>(Uln::defaultUlnReceiveConfig)
+        )
+    );
+
+    return actions;
+}
+
+(int, int, int) version() impure method_id {
+    return (3, 0, 2);
+}