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

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

@@ -0,0 +1,49 @@
+#include "interface.fc";
+
+#include "../msgdata/UlnReceiveConfig.fc";
+#include "../msgdata/UlnSendConfig.fc";
+
+#include "../../../core/baseStorage.fc";
+
+#include "../../../../funC++/dataStructures/PipelinedOutOfOrder.fc";
+
+const int UlnConnection::MAX_HASH_LOOKUPS = 1023;
+
+const int UlnConnection::NAME = "connection"u;
+
+const int UlnConnection::baseStorage = 0;
+const int UlnConnection::path = 1;
+;; the channel address is set during the initialize call
+const int UlnConnection::endpointAddress = 2;
+const int UlnConnection::channelAddress = 3;
+const int UlnConnection::ulnAddress = 4;
+
+;; EVM struct ExecutorConfig
+;; uint32 maxMessageSize;
+;; address executor;
+const int UlnConnection::UlnSendConfigOApp = 5; ;; UlnSendConfig
+const int UlnConnection::UlnReceiveConfigOApp = 6; ;; UlnReceiveConfig
+;; breaking from EVM, we are using a fixed size array for the DVN verifications, and DVNs can
+;; only verify a packet for a specific inbound nonce range.
+const int UlnConnection::hashLookups = 7; ;; map nonce -> map dvnAddress -> {hash,confirmations}
+const int UlnConnection::firstUnexecutedNonce = 8; ;; first nonce that has not been executed
+const int UlnConnection::commitPOOO = 9;
+
+;; @owner ulnManager
+cell UlnConnection::New(int owner, cell $path, int ulnAddress) method_id {
+    return cl::declare(
+        UlnConnection::NAME,
+        unsafeTuple([
+            [cl::t::objRef, BaseStorage::New(owner)],             ;; UlnConnection::baseStorage
+            [cl::t::objRef, $path],                               ;; UlnConnection::path
+            [cl::t::address, NULLADDRESS],                        ;; UlnConnection::endpointAddress
+            [cl::t::address, NULLADDRESS],                        ;; UlnConnection::channelAddress
+            [cl::t::address, ulnAddress],                         ;; UlnConnection::ulnAddress
+            [cl::t::objRef, UlnSendConfig::NewWithDefaults()],    ;; UlnConnection::UlnSendConfigOApp
+            [cl::t::objRef, UlnReceiveConfig::NewWithDefaults()], ;; UlnConnection::UlnReceiveConfigOApp
+            [cl::t::dict256, cl::dict256::New()],                 ;; UlnConnection::hashLookups
+            [cl::t::uint64, 1],                                   ;; UlnConnection::firstUnexecutedNonce
+            [cl::t::objRef, empty_cell()]                         ;; UlnConnection::commitPOOO
+        ])
+    );
+}

package/src/protocol/msglibs/ultralightnode/ulnConnection/utils.fc

@@ -0,0 +1,141 @@
+#include "interface.fc";
+
+#include "../msgdata/Attestation.fc";
+#include "../msgdata/UlnReceiveConfig.fc";
+#include "../msgdata/UlnSendConfig.fc";
+
+;;; ===============================GETTERS===========================
+
+cell UlnConnection::utils::getHashLookup(cell $self, int nonce, int dvnAddress) impure inline {
+    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
+    
+    (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
+    ifnot (exists) {
+        return cl::nullObject();
+    }
+
+    (cell $attestation, int exists) = addressLookup.cl::dict256::get<cellRef>(dvnAddress);
+    ifnot (exists) {
+        return cl::nullObject();
+    }
+
+    return $attestation;
+}
+
+;;; ===============================SETTERS===========================
+
+cell UlnConnection::utils::setHashLookup(
+    cell $self,
+    int nonce,
+    int dvnAddress,
+    cell $attestation
+) impure inline {
+    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
+    (cell addressLookup, _) = hashLookups.cl::dict256::get<cellRef>(nonce);
+
+    ;; insert the attestation
+    addressLookup = addressLookup.cl::dict256::setRef(
+        dvnAddress,
+        $attestation
+    );
+
+    ;; save the attestation hash
+    hashLookups = hashLookups.cl::dict256::setRef(nonce, addressLookup);
+
+    return $self.cl::set(
+        UlnConnection::hashLookups,
+        hashLookups.cl::dict256::setRef(nonce, addressLookup)
+    );
+}
+
+cell UlnConnection::utils::deleteNonceAttestations(
+    cell $self,
+    int nonce
+) impure inline {
+    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
+    ;; delete is safe to call on a non-existent key
+    hashLookups = hashLookups.cl::dict256::delete(nonce);
+    return $self.cl::set(
+        UlnConnection::hashLookups,
+        hashLookups
+    );
+}
+
+;;; ===============================CHECKERS===========================
+
+;; returns true if the attestations are valid (meets the dvn threshold and confirmations)
+int UlnConnection::utils::isCommittable(
+    cell $self,
+    cell $defaultUlnReceiveConfig,
+    int nonce,
+    int hash
+) impure inline {
+    cell hashLookups = $self.cl::get<dict256>(UlnConnection::hashLookups);
+    (cell addressLookup, int exists) = hashLookups.cl::dict256::get<cellRef>(nonce);
+    ifnot (exists) {
+        return false;
+    }
+
+    ;; retrieve the DVNs from the config
+    (
+        cell requiredDVNs,
+        cell optionalDVNs,
+        int optionalDVNThreshold,
+        int requiredConfirmations,
+        _,
+        int isValid
+    ) = UlnReceiveConfig::utils::getCommitConfig(
+        $self.cl::get<objRef>(UlnConnection::UlnReceiveConfigOApp),
+        $defaultUlnReceiveConfig
+    );
+
+    ifnot (isValid) {
+        return false;
+    }
+
+    slice requiredDVNsSlice = requiredDVNs.begin_parse();
+    ;; iterate the requiredDVNs and make sure each has set the proper hash and confirmations
+    int address = requiredDVNsSlice~AddressList::next();
+    while (address > NULLADDRESS) {
+        (cell $attestation, int exists) = addressLookup.cl::dict256::get<cellRef>(address);
+        ;; if it doesn't exist it means we don't have the required DVN's attestation
+        ifnot (exists) {
+            return false;
+        } elseifnot ($attestation.lz::Attestation::confirmable(hash, requiredConfirmations)) {
+            ;; attestation hash...
+            ;; (1) doesn't match the hash passed in
+            ;; OR (2) the attestation confirmations are fewer than the required confirmations
+            return false;
+        }
+        address = requiredDVNsSlice~AddressList::next();
+    }
+
+    if (optionalDVNThreshold == 0) {
+        ;; if we don't have any optional DVNs, we're done
+        return true;
+    }
+
+    slice optionalDVNsSlice = optionalDVNs.begin_parse();
+    ;; iterate the optionalDVNs and make sure each has set the proper hash and confirmations
+    int address = optionalDVNsSlice~AddressList::next();
+    int count = 0;
+
+    while (address > NULLADDRESS) {
+        (cell $attestation, int attestationExists) = addressLookup.cl::dict256::get<cellRef>(address);
+        ;; if the attestation matches the hash and is greater than or equal to the confirmations
+        ;; we're looking for, increment the counter
+        if (attestationExists) {
+            if ($attestation.lz::Attestation::confirmable(hash, requiredConfirmations)) {
+                count = count + 1;
+            }
+            if (count == optionalDVNThreshold) {
+                ;; early exit if we hit the optional DVN threshold
+                return true;
+            }
+        }
+        address = optionalDVNsSlice~AddressList::next();
+    }
+
+    ;; threshold not met, return false
+    return false;
+}

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

@@ -0,0 +1,495 @@
+#include "../../../core/abstract/protocolHandler.fc";
+#include "../../../interfaces.fc";
+
+#include "../uln/interface.fc";
+#include "../ulnConnection/interface.fc";
+
+#include "../../../channel/storage.fc";
+#include "../../../endpoint/storage.fc";
+#include "../../../endpoint/interface.fc";
+
+#include "../../../../funC++/classlib.fc";
+#include "../../../../funC++/txnContext.fc";
+#include "../../../../funC++/utils.fc";
+#include "../../../../classes/lz/Path.fc";
+#include "../../../../classes/lz/MsglibInfo.fc";
+#include "../../../../classes/msgdata/CoinsAmount.fc";
+#include "../../../../classes/msgdata/Deploy.fc";
+#include "../../../../classes/msgdata/MdAddress.fc";
+#include "../../../../classes/msgdata/AddMsglib.fc";
+#include "../../../../classes/msgdata/MdEid.fc";
+#include "../../../../classes/msgdata/MdObj.fc";
+#include "../../../../classes/msgdata/Bool.fc";
+#include "../../../../classes/msgdata/SetAddress.fc";
+
+#include "../msgdata/UlnWorkerFeelibInfo.fc";
+#include "../msgdata/InitUln.fc";
+#include "../msgdata/InitUlnConnection.fc";
+#include "../msgdata/InitUlnManager.fc";
+#include "../msgdata/SetAdminWorkerAddresses.fc";
+#include "../msgdata/TreasuryFeeBps.fc";
+#include "../msgdata/UlnWorkerFeelibBytecode.fc";
+
+#include "interface.fc";
+#include "storage.fc";
+
+;;; ================INTERFACE FUNCTIONS=====================
+
+(cell, tuple) _initialize(cell $initUlnManager) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    return (
+        $storage
+            .cl::set(
+                UlnManager::endpointCode,
+                $initUlnManager.cl::get<cellRef>(md::InitUlnManager::endpointCode)
+            )
+            .cl::set(
+                UlnManager::channelCode,
+                $initUlnManager.cl::get<cellRef>(md::InitUlnManager::channelCode)
+            ),
+        actions
+    );
+}
+
+int _getEventSink() impure inline {
+    return getContractAddress();
+}
+
+() _assertOAppPath(cell $mdObj) impure inline {
+    cell $path = $mdObj.cl::get<objRef>(md::MdObj::obj);
+    cell $sanitizedPath = lz::Path::sanitize($path);
+    throw_unless(
+        UlnManager::ERROR::invalidPath,
+        getCaller() == $sanitizedPath.cl::get<address>(lz::Path::srcOApp)
+    );
+}
+
+() assertTentativeOwner() impure inline {
+    throw_unless(
+        UlnManager::ERROR::onlyTentativeOwner,
+        getCaller() == getContractStorage().cl::get<address>(UlnManager::tentativeOwner)
+    );
+}
+
+;;; ================PERMISSION FUNCTIONS=====================
+
+() _checkPermissions(int op, cell $md) impure inline {
+    if (
+        (op == UlnManager::OP::DEPLOY_ULN)
+        | (op == UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG)
+        | (op == UlnManager::OP::SET_DEFAULT_ULN_SEND_CONFIG)
+        | (op == UlnManager::OP::REGISTER_WORKER_FEELIB_BYTECODE)
+        | (op == UlnManager::OP::CLAIM_TREASURY_FEES)
+        | (op == UlnManager::OP::SET_ADMIN_WORKERS)
+        | (op == UlnManager::OP::SET_ULN_TREASURY_FEE_BPS)
+        | (op == UlnManager::OP::TRANSFER_OWNERSHIP)
+    ) {
+        ;; open to only owner
+        return assertOwner();
+    } elseif (
+        (op == MsglibManager::OP::GET_MSGLIB_INFO)
+        | (op == MsglibManager::OP::DEPLOY_CONNECTION)
+        | (op == UlnManager::OP::ADD_ULN_WORKER)
+    ) {
+        ;; open and public calls
+        return ();
+    } elseif (
+        (op == UlnManager::OP::SET_OAPP_ULN_RECEIVE_CONFIG)
+        | (op == UlnManager::OP::SET_OAPP_ULN_SEND_CONFIG)
+    ) {
+        return _assertOAppPath($md);
+    } elseif (op == UlnManager::OP::CLAIM_OWNERSHIP) {
+        return assertTentativeOwner();
+    } else {
+        ;; we must put a check for all opcodes to make sure we don't
+        ;; mistakenly miss an opcode's permissions
+        throw(BaseInterface::ERROR::invalidOpcode);
+    }
+}
+
+;;; ==========================HELPER FUNCTIONS=====================================
+
+int _calculateUlnAddress(cell $storage, int dstEid) impure inline method_id {
+    throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
+    return computeContractAddress(
+        Uln::New(getContractAddress(), $storage.cl::get<uint32>(UlnManager::eid), dstEid),
+        $storage.cl::get<cellRef>(UlnManager::ulnCode)
+    );
+}
+
+int _calculateEndpointAddress(cell $storage, int dstEid) impure inline method_id {
+    throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
+    return computeContractAddress(
+        Endpoint::New(
+            $storage.cl::get<uint32>(UlnManager::eid),
+            dstEid,
+            $storage.cl::get<address>(UlnManager::controllerAddress)
+        ),
+        $storage.cl::get<cellRef>(UlnManager::endpointCode)
+    );
+}
+
+int _calculateChannelAddress(cell $storage, cell $path) impure inline method_id {
+    return computeContractAddress(
+        Channel::New(
+            $storage.cl::get<address>(UlnManager::controllerAddress),
+            $path,
+            _calculateEndpointAddress($storage, $path.cl::get<uint32>(lz::Path::dstEid))
+        ),
+        $storage.cl::get<cellRef>(UlnManager::channelCode)
+    );
+}
+
+int _calculateUlnConnectionAddress(cell $storage, cell $path) impure inline method_id {
+    return computeContractAddress(
+        UlnConnection::New(
+            getContractAddress(),
+            $path,
+            _calculateUlnAddress($storage, $path.cl::get<uint32>(lz::Path::dstEid))
+        ),
+        $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode)
+    );
+}
+
+;;; ==========================HANDLERS=====================================
+
+;; @in_opcode UlnManager::OP::DEPLOY_ULN
+;; @in_md todo { eid }
+;; @permissions only-owner
+;; @out_actions deploy the uln for this particular eid
+tuple deployUln(cell $deploy) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+    throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
+
+    actions~pushAction<deployAndCall>(
+        $storage.cl::get<cellRef>(UlnManager::ulnCode),
+        Uln::New(
+            getContractAddress(),
+            $storage.cl::get<uint32>(UlnManager::eid),
+            dstEid
+        ),
+        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        BaseInterface::OP::INITIALIZE,
+        $deploy.cl::get<objRef>(md::Deploy::extraInfo).cl::set(
+            md::InitUln::connectionCode,
+            $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode)
+        ),
+        0
+    );
+    return actions;
+}
+
+;; @in_opcode MsglibManager::OP::DEPLOY_CONNECTION
+;; @in_md todo { oApp_path, shard }
+;; @permissions seeded by caller address
+;; @out_actions deploy the connection for this particular oApp path
+tuple deployUlnConnection(cell $deploy) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int dstEid = $deploy.cl::get<uint32>(md::Deploy::dstEid);
+
+    throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
+
+    cell $path = lz::Path::New(
+        $storage.cl::get<uint32>(UlnManager::eid),
+        getCaller(),
+        dstEid,
+        $deploy.cl::get<address>(md::Deploy::dstOApp)
+    );
+
+    cell $ulnConnection = UlnConnection::New(
+        getContractAddress(),
+        $path,
+        _calculateUlnAddress($storage, dstEid)
+    );
+
+    cell $initUlnConnection = $deploy.cl::get<objRef>(md::Deploy::extraInfo)
+        .cl::set(md::InitUlnConnection::endpointAddress, _calculateEndpointAddress($storage, dstEid))
+        .cl::set(md::InitUlnConnection::channelAddress, _calculateChannelAddress($storage, $path));
+
+    actions~pushAction<deployAndCall>(
+        $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode),
+        $ulnConnection,
+        $deploy.cl::get<coins>(md::Deploy::initialDeposit),
+        BaseInterface::OP::INITIALIZE,
+        InitUlnConnection::sanitize($initUlnConnection),
+        0
+    );
+
+    return actions;
+}
+
+tuple getMsglibInfo(cell $addMsglibMd) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int dstEid = $addMsglibMd.cl::get<uint32>(md::AddMsglib::dstEid);
+    throw_if(UlnManager::ERROR::invalidEid, dstEid == 0);
+
+    int ulnAddress = _calculateUlnAddress(
+        $storage,
+        dstEid
+    );
+
+    actions~pushAction<call>(
+        getCaller(),
+        Endpoint::OP::GET_MSGLIB_INFO_CALLBACK,
+        lz::MsglibInfo::New(
+            ulnAddress,
+            $storage.cl::get<cellRef>(UlnManager::ulnConnectionCode),
+            UlnConnection::New(
+                getContractAddress(),
+                lz::Path::endpointPath(
+                    $storage.cl::get<uint32>(UlnManager::eid),
+                    dstEid
+                ),
+                ulnAddress
+            )
+        )
+    );
+
+    return actions;
+}
+
+;; @in_opcode UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG
+tuple setDefaultUlnSendConfig(cell $mdEid) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    cell $UlnSendConfig = $mdEid.cl::get<objRef>(md::MdEid::md);
+
+    actions~pushAction<call>(
+        _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid)),
+        Uln::OP::SET_DEFAULT_ULN_SEND_CONFIG,
+        $UlnSendConfig
+    );
+
+    return actions;
+}
+
+;; @in_opcode UlnManager::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG
+tuple setDefaultUlnReceiveConfig(cell $mdEid) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    cell $UlnReceiveConfig = $mdEid.cl::get<objRef>(md::MdEid::md);
+
+    actions~pushAction<call>(
+        _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid)),
+        Uln::OP::SET_DEFAULT_ULN_RECEIVE_CONFIG,
+        $UlnReceiveConfig
+    );
+
+    return actions;
+}
+
+;; @in_opcode UlnManager::OP::SET_CONNECTION_ULN_CONFIG
+tuple setOAppUlnReceiveConfig(cell $mdObj) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $sendPath = $mdObj.cl::get<objRef>(md::MdObj::obj);
+
+    actions~pushAction<call>(
+        _calculateUlnConnectionAddress($storage, $sendPath),
+        UlnConnection::OP::SET_OAPP_ULN_RECEIVE_CONFIG,
+        $mdObj.cl::get<objRef>(md::MdObj::md)
+    );
+
+    return actions;
+}
+
+;; @in_opcode UlnManager::OP::SET_CONNECTION_ULN_CONFIG
+tuple setOAppUlnSendConfig(cell $mdObj) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $sendPath = $mdObj.cl::get<objRef>(md::MdObj::obj);
+
+    actions~pushAction<call>(
+        _calculateUlnConnectionAddress($storage, $sendPath),
+        UlnConnection::OP::SET_OAPP_ULN_SEND_CONFIG,
+        $mdObj.cl::get<objRef>(md::MdObj::md)
+    );
+
+    return actions;
+}
+
+;; @in_opcode UlnManager::OP::ADD_ULN_WORKER_INFO
+tuple registerWorkerFeelibBytecode(cell $ulnWorkerFeelibBytecode) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell bytecode = $ulnWorkerFeelibBytecode
+        .cl::get<cellRef>(md::UlnWorkerFeelibBytecode::bytecode);
+
+    cell $newStorage = $storage
+        .cl::nestedDict256::setRef(
+            UlnManager::workerFeelibBytecodes,
+            bytecode.cell_hash(),
+            bytecode
+        );
+
+    (_, _, _, int success) = compute_data_size?(
+        $newStorage.cl::get<dict256>(UlnManager::workerFeelibBytecodes),
+        UlnManager::CONST::MAX_CUMULATIVE_BYTECODE_CELLS
+    );
+
+    setContractStorage($newStorage);
+
+    throw_unless(UlnManager::ERROR::feelibBytecodesExceeded, success);
+
+    return actions;
+}
+
+tuple addWorkerFeelibToUln(cell $UlnWorkerFeelibInfo) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    cell $sanitizedUlnWorkerFeelibInfo = UlnWorkerFeelibInfo::sanitize(
+        $UlnWorkerFeelibInfo
+    ).cl::set(UlnWorkerFeelibInfo::workerAddress, getCaller());
+    ;; invariant: checkPermissions guarantees that getCaller() == $UlnWorkerFeelibInfo.workerAddress
+    int bytecodeId = $sanitizedUlnWorkerFeelibInfo
+        .cl::get<cellRef>(UlnWorkerFeelibInfo::workerFeelibBytecode)
+        .cell_hash();
+
+    (_, int bytecodeExists) = $storage
+        .cl::nestedDict256::get<cellRef>(UlnManager::workerFeelibBytecodes, bytecodeId);
+
+    throw_unless(UlnManager::ERROR::invalidWorkerInfo, bytecodeExists);
+
+    ;; only admin workers can add to the admin workers list on the uln
+    int useAdminSlot = $sanitizedUlnWorkerFeelibInfo.cl::get<bool>(UlnWorkerFeelibInfo::isAdmin);
+    if (useAdminSlot) {
+        throw_unless(
+            UlnManager::ERROR::invalidWorkerInfo,
+            AddressList::includes(
+                getCaller(),
+                $storage.cl::get<cellRef>(UlnManager::adminWorkers).begin_parse()
+            )
+        );
+    }
+
+    actions~pushAction<call>(
+        _calculateUlnAddress(
+            $storage,
+            $sanitizedUlnWorkerFeelibInfo.cl::get<uint32>(UlnWorkerFeelibInfo::dstEid)
+        ),
+        Uln::OP::UPDATE_WORKER_FEELIB,
+        $sanitizedUlnWorkerFeelibInfo
+    );
+
+    return actions;
+}
+
+tuple setAdminWorkers(cell $setAdminWorkerAddresses) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    cell adminWorkers = $setAdminWorkerAddresses
+        .cl::get<cellRef>(md::SetAdminWorkerAddresses::adminWorkers);
+
+    throw_unless(
+        UlnManager::ERROR::invalidAdminWorkerList,
+        AddressList::isValid(adminWorkers, UlnManager::CONST::MAX_ADMIN_WORKERS)
+    );
+
+    setContractStorage(
+        $storage.cl::set(UlnManager::adminWorkers, adminWorkers)
+    );
+
+    actions~pushAction<event>(
+        UlnManager::event::ADMIN_WORKERS_SET,
+        $setAdminWorkerAddresses
+    );
+
+    return actions;
+}
+
+tuple claimTreasuryFees(cell $coinsAmount) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+
+    int claimAmount = $coinsAmount.cl::get<coins>(md::CoinsAmount::amount);
+    (int myStateCellCount, int myStateBitCount) = getContractStateSize(
+        my_code(),
+        getContractStorage()
+    );
+
+    int minimumStorageFee = get_storage_fee(
+        BASECHAIN,
+        UlnManager::CONST::minRentSeconds,
+        myStateBitCount,
+        myStateCellCount
+    );
+
+    ;; Ensure the owner cannot rug the contract by pulling out all the rent
+    throw_if(
+        UlnManager::ERROR::insufficientBalance,
+        (getInitialContractBalance() - storage_fees() - claimAmount) < minimumStorageFee
+    );
+
+    actions~pushAction<payment>(getOrigin(), claimAmount, claimAmount);
+
+    return actions;
+}
+
+tuple setUlnTreasuryFeeBps(cell $mdEid) impure inline method_id {
+    (cell $storage, tuple actions) = preamble();
+    int ulnAddress = _calculateUlnAddress($storage, $mdEid.cl::get<uint32>(md::MdEid::eid));
+    cell $treasuryFeeBps = $mdEid.cl::get<objRef>(md::MdAddress::md);
+    actions~pushAction<call>(
+        ulnAddress,
+        Uln::OP::SET_TREASURY_FEE_BPS,
+        $treasuryFeeBps
+    );
+    return actions;
+}
+
+
+;; This will override an existing tentative owner
+;; Becuase we assert that the 'claimOwnership' can't be done by the 'null' address, it means
+;; if we want to burn the ownership, we will need to set it to a contract which only has ability to
+;; claim, but nothing else. This effectively burns it.
+tuple transferOwnership(cell $setAddress) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    setContractStorage(
+        $storage.cl::set(
+            UlnManager::tentativeOwner,
+            $setAddress.cl::get<address>(md::SetAddress::address)
+        )
+    );
+
+    actions~pushAction<event>(
+        UlnManager::event::OWNER_SET_TENTATIVE,
+        $setAddress
+    );
+
+    return actions;
+}
+
+tuple claimOwnership(cell $emptyMd) impure inline {
+    (cell $storage, tuple actions) = preamble();
+
+    ;; permissions check guarantees newOwner == $storage.tentativeOwner
+    int newOwner = $storage.cl::get<address>(UlnManager::tentativeOwner);
+
+    ;; this should be caught by the permission check, BUT let's be super safe about this
+    throw_if(UlnManager::ERROR::nullTentativeOwner, newOwner == NULLADDRESS);
+
+    ;; erase the tentative owner AND set that tentative owner to the actual owner
+    setContractStorage(
+        $storage
+            .cl::set(UlnManager::tentativeOwner, NULLADDRESS)
+            .cl::set(
+                UlnManager::baseStorage,
+                $storage
+                    .cl::get<objRef>(UlnManager::baseStorage)
+                    .cl::set(BaseStorage::owner, newOwner)
+            )
+    );
+
+    actions~pushAction<event>(
+        UlnManager::event::OWNER_SET,
+        md::SetAddress::New(newOwner)
+    );
+
+    return actions;
+}
+
+(int, int, int) version() impure method_id {
+    return (3, 0, 2);
+}