react-native-zcash 0.4.2 → 0.6.0

package/ios/ZCashLightClientKit/Rust/ZcashRustBackend.swift

@@ -9,6 +9,8 @@
 import Foundation
 
 
+let globalDBLock = NSLock()
+
 actor ZcashRustBackend: ZcashRustBackendWelding {
     let minimumConfirmations: UInt32 = 10
     let useZIP317Fees = false
@@ -21,6 +23,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
 
     nonisolated let networkType: NetworkType
 
+    static var tracingEnabled = false
     /// Creates instance of `ZcashRustBackend`.
     /// - Parameters:
     ///   - dbData: `URL` pointing to file where data database will be.
@@ -30,23 +33,43 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     ///   - spendParamsPath: `URL` pointing to spend parameters file.
     ///   - outputParamsPath: `URL` pointing to output parameters file.
     ///   - networkType: Network type to use.
-    init(dbData: URL, fsBlockDbRoot: URL, spendParamsPath: URL, outputParamsPath: URL, networkType: NetworkType) {
+    ///   - enableTracing: this sets up whether the tracing system will dump logs onto the OSLogger system or not.
+    ///   **Important note:** this will enable the tracing **for all instances** of ZcashRustBackend, not only for this one.
+    init(dbData: URL, fsBlockDbRoot: URL, spendParamsPath: URL, outputParamsPath: URL, networkType: NetworkType, enableTracing: Bool = false) {
         self.dbData = dbData.osStr()
         self.fsBlockDbRoot = fsBlockDbRoot.osPathStr()
         self.spendParamsPath = spendParamsPath.osPathStr()
         self.outputParamsPath = outputParamsPath.osPathStr()
         self.networkType = networkType
         self.keyDeriving = ZcashKeyDerivationBackend(networkType: networkType)
+
+        if enableTracing && !Self.tracingEnabled {
+            Self.tracingEnabled = true
+            Self.enableTracing()
+        }
     }
 
-    func createAccount(seed: [UInt8]) async throws -> UnifiedSpendingKey {
+    func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey {
+        var rUntil: Int64 = -1
+        
+        if let recoverUntil {
+            rUntil = Int64(recoverUntil)
+        }
+        
+        let treeStateBytes = try treeState.serializedData(partial: false).bytes
+        
+        globalDBLock.lock()
         let ffiBinaryKeyPtr = zcashlc_create_account(
             dbData.0,
             dbData.1,
             seed,
             UInt(seed.count),
+            treeStateBytes,
+            UInt(treeStateBytes.count),
+            rUntil,
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard let ffiBinaryKeyPtr else {
             throw ZcashError.rustCreateAccount(lastErrorMessage(fallback: "`createAccount` failed with unknown error"))
@@ -62,34 +85,44 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         to address: String,
         value: Int64,
         memo: MemoBytes?
-    ) async throws -> Int64 {
-        let result = usk.bytes.withUnsafeBufferPointer { uskPtr in
-            zcashlc_create_to_address(
-                dbData.0,
-                dbData.1,
-                uskPtr.baseAddress,
-                UInt(usk.bytes.count),
-                [CChar](address.utf8CString),
-                value,
-                memo?.bytes,
-                spendParamsPath.0,
-                spendParamsPath.1,
-                outputParamsPath.0,
-                outputParamsPath.1,
-                networkType.networkId,
-                minimumConfirmations,
-                useZIP317Fees
-            )
+    ) async throws -> Data {
+        var contiguousTxIdBytes = ContiguousArray<UInt8>([UInt8](repeating: 0x0, count: 32))
+
+        globalDBLock.lock()
+        let success = contiguousTxIdBytes.withUnsafeMutableBufferPointer { txIdBytePtr in
+            usk.bytes.withUnsafeBufferPointer { uskPtr in
+                zcashlc_create_to_address(
+                    dbData.0,
+                    dbData.1,
+                    uskPtr.baseAddress,
+                    UInt(usk.bytes.count),
+                    [CChar](address.utf8CString),
+                    value,
+                    memo?.bytes,
+                    spendParamsPath.0,
+                    spendParamsPath.1,
+                    outputParamsPath.0,
+                    outputParamsPath.1,
+                    networkType.networkId,
+                    minimumConfirmations,
+                    useZIP317Fees,
+                    txIdBytePtr.baseAddress
+                )
+            }
         }
+        globalDBLock.unlock()
 
-        guard result > 0 else {
+        guard success else {
             throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`createToAddress` failed with unknown error"))
         }
 
-        return result
+        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
+            Data(txIdBytePtr)
+        }
     }
 
     func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: Int32) async throws {
+        globalDBLock.lock()
         let result = zcashlc_decrypt_and_store_transaction(
             dbData.0,
             dbData.1,
@@ -98,6 +131,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             UInt32(minedHeight),
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard result != 0 else {
             throw ZcashError.rustDecryptAndStoreTransaction(lastErrorMessage(fallback: "`decryptAndStoreTransaction` failed with unknown error"))
@@ -105,7 +139,9 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getBalance(account: Int32) async throws -> Int64 {
+        globalDBLock.lock()
         let balance = zcashlc_get_balance(dbData.0, dbData.1, account, networkType.networkId)
+        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetBalance(Int(account), lastErrorMessage(fallback: "Error getting total balance from account \(account)"))
@@ -115,12 +151,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getCurrentAddress(account: Int32) async throws -> UnifiedAddress {
+        globalDBLock.lock()
         let addressCStr = zcashlc_get_current_address(
             dbData.0,
             dbData.1,
             account,
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard let addressCStr else {
             throw ZcashError.rustGetCurrentAddress(lastErrorMessage(fallback: "`getCurrentAddress` failed with unknown error"))
@@ -136,12 +174,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getNearestRewindHeight(height: Int32) async throws -> Int32 {
+        globalDBLock.lock()
         let result = zcashlc_get_nearest_rewind_height(
             dbData.0,
             dbData.1,
             height,
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard result > 0 else {
             throw ZcashError.rustGetNearestRewindHeight(lastErrorMessage(fallback: "`getNearestRewindHeight` failed with unknown error"))
@@ -151,12 +191,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getNextAvailableAddress(account: Int32) async throws -> UnifiedAddress {
+        globalDBLock.lock()
         let addressCStr = zcashlc_get_next_available_address(
             dbData.0,
             dbData.1,
             account,
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard let addressCStr else {
             throw ZcashError.rustGetNextAvailableAddress(lastErrorMessage(fallback: "`getNextAvailableAddress` failed with unknown error"))
@@ -171,26 +213,19 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return UnifiedAddress(validatedEncoding: address, networkType: networkType)
     }
 
-    func getReceivedMemo(idNote: Int64) async -> Memo? {
-        var contiguousMemoBytes = ContiguousArray<UInt8>(MemoBytes.empty().bytes)
-        var success = false
-
-        contiguousMemoBytes.withUnsafeMutableBufferPointer { memoBytePtr in
-            success = zcashlc_get_received_memo(dbData.0, dbData.1, idNote, memoBytePtr.baseAddress, networkType.networkId)
+    func getMemo(txId: Data, outputIndex: UInt16) async throws -> Memo? {
+        guard txId.count == 32 else {
+            throw ZcashError.rustGetMemoInvalidTxIdLength
         }
 
-        guard success else { return nil }
-
-        return (try? MemoBytes(contiguousBytes: contiguousMemoBytes)).flatMap { try? $0.intoMemo() }
-    }
-
-    func getSentMemo(idNote: Int64) async -> Memo? {
         var contiguousMemoBytes = ContiguousArray<UInt8>(MemoBytes.empty().bytes)
         var success = false
 
-        contiguousMemoBytes.withUnsafeMutableBytes { memoBytePtr in
-            success = zcashlc_get_sent_memo(dbData.0, dbData.1, idNote, memoBytePtr.baseAddress, networkType.networkId)
+        globalDBLock.lock()
+        contiguousMemoBytes.withUnsafeMutableBufferPointer { memoBytePtr in
+            success = zcashlc_get_memo(dbData.0, dbData.1, txId.bytes, outputIndex, memoBytePtr.baseAddress, networkType.networkId)
         }
+        globalDBLock.unlock()
 
         guard success else { return nil }
 
@@ -202,12 +237,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             throw ZcashError.rustGetTransparentBalanceNegativeAccount(Int(account))
         }
 
+        globalDBLock.lock()
         let balance = zcashlc_get_total_transparent_balance_for_account(
             dbData.0,
             dbData.1,
             networkType.networkId,
             account
         )
+        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetTransparentBalance(
@@ -220,6 +257,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getVerifiedBalance(account: Int32) async throws -> Int64 {
+        globalDBLock.lock()
         let balance = zcashlc_get_verified_balance(
             dbData.0,
             dbData.1,
@@ -227,6 +265,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             networkType.networkId,
             minimumConfirmations
         )
+        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedBalance(
@@ -243,6 +282,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             throw ZcashError.rustGetVerifiedTransparentBalanceNegativeAccount(Int(account))
         }
 
+        globalDBLock.lock()
         let balance = zcashlc_get_verified_transparent_balance_for_account(
             dbData.0,
             dbData.1,
@@ -250,6 +290,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             account,
             minimumConfirmations
         )
+        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedTransparentBalance(
@@ -262,7 +303,11 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func initDataDb(seed: [UInt8]?) async throws -> DbInitResult {
-        switch zcashlc_init_data_database(dbData.0, dbData.1, seed, UInt(seed?.count ?? 0), networkType.networkId) {
+        globalDBLock.lock()
+        let initResult = zcashlc_init_data_database(dbData.0, dbData.1, seed, UInt(seed?.count ?? 0), networkType.networkId)
+        globalDBLock.unlock()
+
+        switch initResult {
         case 0: // ok
             return DbInitResult.success
         case 1:
@@ -272,59 +317,10 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
-    func initAccountsTable(ufvks: [UnifiedFullViewingKey]) async throws {
-        var ffiUfvks: [FFIEncodedKey] = []
-        for ufvk in ufvks {
-            guard !ufvk.encoding.containsCStringNullBytesBeforeStringEnding() else {
-                throw ZcashError.rustInitAccountsTableViewingKeyCotainsNullBytes
-            }
-
-            guard self.keyDeriving.isValidUnifiedFullViewingKey(ufvk.encoding) else {
-                throw ZcashError.rustInitAccountsTableViewingKeyIsInvalid
-            }
-
-            let ufvkCStr = [CChar](String(ufvk.encoding).utf8CString)
-
-            let ufvkPtr = UnsafeMutablePointer<CChar>.allocate(capacity: ufvkCStr.count)
-            ufvkPtr.initialize(from: ufvkCStr, count: ufvkCStr.count)
-
-            ffiUfvks.append(
-                FFIEncodedKey(account_id: ufvk.account, encoding: ufvkPtr)
-            )
-        }
-
-        var contiguousUVKs = ContiguousArray(ffiUfvks)
-
-        var result = false
-
-        contiguousUVKs.withContiguousMutableStorageIfAvailable { ufvksPtr in
-            result = zcashlc_init_accounts_table_with_keys(
-                dbData.0,
-                dbData.1,
-                ufvksPtr.baseAddress,
-                UInt(ufvks.count),
-                networkType.networkId
-            )
-        }
-
-        defer {
-            for ufvk in ffiUfvks {
-                ufvk.encoding.deallocate()
-            }
-        }
-
-        guard result else {
-            let message = lastErrorMessage(fallback: "`initAccountsTable` failed with unknown error")
-            if message.isDbNotEmptyErrorMessage() {
-                throw ZcashError.rustInitAccountsTableDataDbNotEmpty
-            } else {
-                throw ZcashError.rustInitAccountsTable(message)
-            }
-        }
-    }
-
     func initBlockMetadataDb() async throws {
+        globalDBLock.lock()
         let result = zcashlc_init_block_metadata_db(fsBlockDbRoot.0, fsBlockDbRoot.1)
+        globalDBLock.unlock()
 
         guard result else {
             throw ZcashError.rustInitBlockMetadataDb(lastErrorMessage(fallback: "`initBlockMetadataDb` failed with unknown error"))
@@ -380,7 +376,9 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
 
             fsBlocks.initialize(to: meta)
 
+            globalDBLock.lock()
             let res = zcashlc_write_block_metadata(fsBlockDbRoot.0, fsBlockDbRoot.1, fsBlocks)
+            globalDBLock.unlock()
 
             guard res else {
                 throw ZcashError.rustWriteBlocksMetadata(lastErrorMessage(fallback: "`writeBlocksMetadata` failed with unknown error"))
@@ -388,51 +386,29 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
-    func initBlocksTable(
-        height: Int32,
-        hash: String,
-        time: UInt32,
-        saplingTree: String
-    ) async throws {
-        guard !hash.containsCStringNullBytesBeforeStringEnding() else {
-            throw ZcashError.rustInitBlocksTableHashContainsNullBytes
-        }
+    func latestCachedBlockHeight() async throws -> BlockHeight {
+        globalDBLock.lock()
+        let height = zcashlc_latest_cached_block_height(fsBlockDbRoot.0, fsBlockDbRoot.1)
+        globalDBLock.unlock()
 
-        guard !saplingTree.containsCStringNullBytesBeforeStringEnding() else {
-            throw ZcashError.rustInitBlocksTableSaplingTreeContainsNullBytes
-        }
-
-        let result = zcashlc_init_blocks_table(
-            dbData.0,
-            dbData.1,
-            height,
-            [CChar](hash.utf8CString),
-            time,
-            [CChar](saplingTree.utf8CString),
-            networkType.networkId
-        )
-
-        guard result != 0 else {
-            let message = lastErrorMessage(fallback: "`initBlocksTable` failed with unknown error")
-            if message.isDbNotEmptyErrorMessage() {
-                throw ZcashError.rustInitBlocksTableDataDbNotEmpty
-            } else {
-                throw ZcashError.rustInitBlocksTable(message)
-            }
+        if height >= 0 {
+            return BlockHeight(height)
+        } else if height == -1 {
+            return BlockHeight.empty()
+        } else {
+            throw ZcashError.rustLatestCachedBlockHeight(lastErrorMessage(fallback: "`latestCachedBlockHeight` failed with unknown error"))
         }
     }
 
-    func latestCachedBlockHeight() async -> BlockHeight {
-        return BlockHeight(zcashlc_latest_cached_block_height(fsBlockDbRoot.0, fsBlockDbRoot.1))
-    }
-
     func listTransparentReceivers(account: Int32) async throws -> [TransparentAddress] {
+        globalDBLock.lock()
         let encodedKeysPtr = zcashlc_list_transparent_receivers(
             dbData.0,
             dbData.1,
             account,
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard let encodedKeysPtr else {
             throw ZcashError.rustListTransparentReceivers(lastErrorMessage(fallback: "`listTransparentReceivers` failed with unknown error"))
@@ -464,6 +440,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         value: Int64,
         height: BlockHeight
     ) async throws {
+        globalDBLock.lock()
         let result = zcashlc_put_utxo(
             dbData.0,
             dbData.1,
@@ -476,29 +453,17 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             Int32(height),
             networkType.networkId
         )
+        globalDBLock.unlock()
 
         guard result else {
             throw ZcashError.rustPutUnspentTransparentOutput(lastErrorMessage(fallback: "`putUnspentTransparentOutput` failed with unknown error"))
         }
     }
 
-    func validateCombinedChain(limit: UInt32 = 0) async throws {
-        let result = zcashlc_validate_combined_chain(fsBlockDbRoot.0, fsBlockDbRoot.1, dbData.0, dbData.1, limit, networkType.networkId)
-
-        switch result {
-        case -1:
-            return
-        case 0:
-            throw ZcashError.rustValidateCombinedChainValidationFailed(
-                lastErrorMessage(fallback: "`validateCombinedChain` failed with unknown error")
-            )
-        default:
-            throw ZcashError.rustValidateCombinedChainInvalidChain(result)
-        }
-    }
-
     func rewindToHeight(height: Int32) async throws {
+        globalDBLock.lock()
         let result = zcashlc_rewind_to_height(dbData.0, dbData.1, height, networkType.networkId)
+        globalDBLock.unlock()
 
         guard result else {
             throw ZcashError.rustRewindToHeight(height, lastErrorMessage(fallback: "`rewindToHeight` failed with unknown error"))
@@ -506,15 +471,162 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func rewindCacheToHeight(height: Int32) async throws {
+        globalDBLock.lock()
         let result = zcashlc_rewind_fs_block_cache_to_height(fsBlockDbRoot.0, fsBlockDbRoot.1, height)
+        globalDBLock.unlock()
 
         guard result else {
             throw ZcashError.rustRewindCacheToHeight(lastErrorMessage(fallback: "`rewindCacheToHeight` failed with unknown error"))
         }
     }
 
-    func scanBlocks(limit: UInt32 = 0) async throws {
-        let result = zcashlc_scan_blocks(fsBlockDbRoot.0, fsBlockDbRoot.1, dbData.0, dbData.1, limit, networkType.networkId)
+    func putSaplingSubtreeRoots(startIndex: UInt64, roots: [SubtreeRoot]) async throws {
+        var ffiSubtreeRootsVec: [FfiSubtreeRoot] = []
+
+        for root in roots {
+            let hashPtr = UnsafeMutablePointer<UInt8>.allocate(capacity: root.rootHash.count)
+
+            let contiguousHashBytes = ContiguousArray(root.rootHash.bytes)
+
+            let result: Void? = contiguousHashBytes.withContiguousStorageIfAvailable { hashBytesPtr in
+                // swiftlint:disable:next force_unwrapping
+                hashPtr.initialize(from: hashBytesPtr.baseAddress!, count: hashBytesPtr.count)
+            }
+
+            guard result != nil else {
+                defer {
+                    hashPtr.deallocate()
+                    ffiSubtreeRootsVec.deallocateElements()
+                }
+                throw ZcashError.rustPutSaplingSubtreeRootsAllocationProblem
+            }
+
+            ffiSubtreeRootsVec.append(
+                FfiSubtreeRoot(
+                    root_hash_ptr: hashPtr,
+                    root_hash_ptr_len: UInt(contiguousHashBytes.count),
+                    completing_block_height: UInt32(root.completingBlockHeight)
+                )
+            )
+        }
+
+        var contiguousFfiRoots = ContiguousArray(ffiSubtreeRootsVec)
+
+        let len = UInt(contiguousFfiRoots.count)
+
+        let rootsPtr = UnsafeMutablePointer<FfiSubtreeRoots>.allocate(capacity: 1)
+
+        defer {
+            ffiSubtreeRootsVec.deallocateElements()
+            rootsPtr.deallocate()
+        }
+
+        try contiguousFfiRoots.withContiguousMutableStorageIfAvailable { ptr in
+            var roots = FfiSubtreeRoots()
+            roots.ptr = ptr.baseAddress
+            roots.len = len
+
+            rootsPtr.initialize(to: roots)
+
+            globalDBLock.lock()
+            let res = zcashlc_put_sapling_subtree_roots(dbData.0, dbData.1, startIndex, rootsPtr, networkType.networkId)
+            globalDBLock.unlock()
+
+            guard res else {
+                throw ZcashError.rustPutSaplingSubtreeRoots(lastErrorMessage(fallback: "`putSaplingSubtreeRoots` failed with unknown error"))
+            }
+        }
+    }
+
+    func updateChainTip(height: Int32) async throws {
+        globalDBLock.lock()
+        let result = zcashlc_update_chain_tip(dbData.0, dbData.1, height, networkType.networkId)
+        globalDBLock.unlock()
+
+        guard result else {
+            throw ZcashError.rustUpdateChainTip(lastErrorMessage(fallback: "`updateChainTip` failed with unknown error"))
+        }
+    }
+
+    func fullyScannedHeight() async throws -> BlockHeight? {
+        globalDBLock.lock()
+        let height = zcashlc_fully_scanned_height(dbData.0, dbData.1, networkType.networkId)
+        globalDBLock.unlock()
+
+        if height >= 0 {
+            return BlockHeight(height)
+        } else if height == -1 {
+            return nil
+        } else {
+            throw ZcashError.rustFullyScannedHeight(lastErrorMessage(fallback: "`fullyScannedHeight` failed with unknown error"))
+        }
+    }
+
+    func maxScannedHeight() async throws -> BlockHeight? {
+        globalDBLock.lock()
+        let height = zcashlc_max_scanned_height(dbData.0, dbData.1, networkType.networkId)
+        globalDBLock.unlock()
+
+        if height >= 0 {
+            return BlockHeight(height)
+        } else if height == -1 {
+            return nil
+        } else {
+            throw ZcashError.rustMaxScannedHeight(lastErrorMessage(fallback: "`maxScannedHeight` failed with unknown error"))
+        }
+    }
+
+    func getScanProgress() async throws -> ScanProgress? {
+        globalDBLock.lock()
+        let result = zcashlc_get_scan_progress(dbData.0, dbData.1, networkType.networkId)
+        globalDBLock.unlock()
+
+        if result.denominator == 0 {
+            switch result.numerator {
+            case 0:
+                return nil
+            default:
+                throw ZcashError.rustGetScanProgress(lastErrorMessage(fallback: "`getScanProgress` failed with unknown error"))
+            }
+        } else {
+            return ScanProgress(numerator: result.numerator, denominator: result.denominator)
+        }
+    }
+
+    func suggestScanRanges() async throws -> [ScanRange] {
+        globalDBLock.lock()
+        let scanRangesPtr = zcashlc_suggest_scan_ranges(dbData.0, dbData.1, networkType.networkId)
+        globalDBLock.unlock()
+
+        guard let scanRangesPtr else {
+            throw ZcashError.rustSuggestScanRanges(lastErrorMessage(fallback: "`suggestScanRanges` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_scan_ranges(scanRangesPtr) }
+
+        var scanRanges: [ScanRange] = []
+
+        for i in (0 ..< Int(scanRangesPtr.pointee.len)) {
+            let scanRange = scanRangesPtr.pointee.ptr.advanced(by: i).pointee
+
+            scanRanges.append(
+                ScanRange(
+                    range: Range(uncheckedBounds: (
+                        BlockHeight(scanRange.start),
+                        BlockHeight(scanRange.end)
+                    )),
+                    priority: ScanRange.Priority(scanRange.priority)
+                )
+            )
+        }
+
+        return scanRanges
+    }
+
+    func scanBlocks(fromHeight: Int32, limit: UInt32 = 0) async throws {
+        globalDBLock.lock()
+        let result = zcashlc_scan_blocks(fsBlockDbRoot.0, fsBlockDbRoot.1, dbData.0, dbData.1, fromHeight, limit, networkType.networkId)
+        globalDBLock.unlock()
 
         guard result != 0 else {
             throw ZcashError.rustScanBlocks(lastErrorMessage(fallback: "`scanBlocks` failed with unknown error"))
@@ -525,30 +637,39 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         usk: UnifiedSpendingKey,
         memo: MemoBytes?,
         shieldingThreshold: Zatoshi
-    ) async throws -> Int64 {
-        let result = usk.bytes.withUnsafeBufferPointer { uskBuffer in
-            zcashlc_shield_funds(
-                dbData.0,
-                dbData.1,
-                uskBuffer.baseAddress,
-                UInt(usk.bytes.count),
-                memo?.bytes,
-                UInt64(shieldingThreshold.amount),
-                spendParamsPath.0,
-                spendParamsPath.1,
-                outputParamsPath.0,
-                outputParamsPath.1,
-                networkType.networkId,
-                minimumConfirmations,
-                useZIP317Fees
-            )
+    ) async throws -> Data {
+        var contiguousTxIdBytes = ContiguousArray<UInt8>([UInt8](repeating: 0x0, count: 32))
+
+        globalDBLock.lock()
+        let success = contiguousTxIdBytes.withUnsafeMutableBufferPointer { txIdBytePtr in
+            usk.bytes.withUnsafeBufferPointer { uskBuffer in
+                zcashlc_shield_funds(
+                    dbData.0,
+                    dbData.1,
+                    uskBuffer.baseAddress,
+                    UInt(usk.bytes.count),
+                    memo?.bytes,
+                    UInt64(shieldingThreshold.amount),
+                    spendParamsPath.0,
+                    spendParamsPath.1,
+                    outputParamsPath.0,
+                    outputParamsPath.1,
+                    networkType.networkId,
+                    minimumConfirmations,
+                    useZIP317Fees,
+                    txIdBytePtr.baseAddress
+                )
+            }
         }
+        globalDBLock.unlock()
 
-        guard result > 0 else {
+        guard success else {
             throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "`shieldFunds` failed with unknown error"))
         }
 
-        return result
+        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
+            Data(txIdBytePtr)
+        }
     }
 
     nonisolated func consensusBranchIdFor(height: Int32) throws -> Int32 {
@@ -562,6 +683,12 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 }
 
+private extension ZcashRustBackend {
+    static func enableTracing() {
+        zcashlc_init_on_load(false)
+    }
+}
+
 private extension ZcashRustBackend {
     nonisolated func lastErrorMessage(fallback: String) -> String {
         let errorLen = zcashlc_last_error_length()
@@ -643,3 +770,11 @@ extension Array where Element == FFIBlockMeta {
         }
     }
 }
+
+extension Array where Element == FfiSubtreeRoot {
+    func deallocateElements() {
+        self.forEach { element in
+            element.root_hash_ptr.deallocate()
+        }
+    }
+}