react-native-zcash 0.6.10 → 0.6.11

package/ios/ZCashLightClientKit/Rust/ZcashRustBackend.swift

@@ -9,8 +9,6 @@
 import Foundation
 
 
-let globalDBLock = NSLock()
-
 actor ZcashRustBackend: ZcashRustBackendWelding {
     let minimumConfirmations: UInt32 = 10
     let useZIP317Fees = false
@@ -23,7 +21,6 @@ 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.
@@ -33,43 +30,23 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     ///   - spendParamsPath: `URL` pointing to spend parameters file.
     ///   - outputParamsPath: `URL` pointing to output parameters file.
     ///   - networkType: Network type to use.
-    ///   - 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) {
+    init(dbData: URL, fsBlockDbRoot: URL, spendParamsPath: URL, outputParamsPath: URL, networkType: NetworkType) {
         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], 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()
+    func createAccount(seed: [UInt8]) async throws -> UnifiedSpendingKey {
         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"))
@@ -85,44 +62,34 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         to address: String,
         value: Int64,
         memo: MemoBytes?
-    ) 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
-                )
-            }
+    ) 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
+            )
         }
-        globalDBLock.unlock()
 
-        guard success else {
+        guard result > 0 else {
             throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`createToAddress` failed with unknown error"))
         }
 
-        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
-            Data(txIdBytePtr)
-        }
+        return result
     }
 
     func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: Int32) async throws {
-        globalDBLock.lock()
         let result = zcashlc_decrypt_and_store_transaction(
             dbData.0,
             dbData.1,
@@ -131,7 +98,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             UInt32(minedHeight),
             networkType.networkId
         )
-        globalDBLock.unlock()
 
         guard result != 0 else {
             throw ZcashError.rustDecryptAndStoreTransaction(lastErrorMessage(fallback: "`decryptAndStoreTransaction` failed with unknown error"))
@@ -139,9 +105,7 @@ 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)"))
@@ -151,14 +115,12 @@ 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"))
@@ -174,14 +136,12 @@ 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"))
@@ -191,14 +151,12 @@ 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"))
@@ -213,19 +171,26 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return UnifiedAddress(validatedEncoding: address, networkType: networkType)
     }
 
-    func getMemo(txId: Data, outputIndex: UInt16) async throws -> Memo? {
-        guard txId.count == 32 else {
-            throw ZcashError.rustGetMemoInvalidTxIdLength
+    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)
         }
 
+        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
 
-        globalDBLock.lock()
-        contiguousMemoBytes.withUnsafeMutableBufferPointer { memoBytePtr in
-            success = zcashlc_get_memo(dbData.0, dbData.1, txId.bytes, outputIndex, memoBytePtr.baseAddress, networkType.networkId)
+        contiguousMemoBytes.withUnsafeMutableBytes { memoBytePtr in
+            success = zcashlc_get_sent_memo(dbData.0, dbData.1, idNote, memoBytePtr.baseAddress, networkType.networkId)
         }
-        globalDBLock.unlock()
 
         guard success else { return nil }
 
@@ -237,14 +202,12 @@ 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(
@@ -257,7 +220,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func getVerifiedBalance(account: Int32) async throws -> Int64 {
-        globalDBLock.lock()
         let balance = zcashlc_get_verified_balance(
             dbData.0,
             dbData.1,
@@ -265,7 +227,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             networkType.networkId,
             minimumConfirmations
         )
-        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedBalance(
@@ -282,7 +243,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             throw ZcashError.rustGetVerifiedTransparentBalanceNegativeAccount(Int(account))
         }
 
-        globalDBLock.lock()
         let balance = zcashlc_get_verified_transparent_balance_for_account(
             dbData.0,
             dbData.1,
@@ -290,7 +250,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             account,
             minimumConfirmations
         )
-        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedTransparentBalance(
@@ -303,11 +262,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     func initDataDb(seed: [UInt8]?) async throws -> DbInitResult {
-        globalDBLock.lock()
-        let initResult = zcashlc_init_data_database(dbData.0, dbData.1, seed, UInt(seed?.count ?? 0), networkType.networkId)
-        globalDBLock.unlock()
-
-        switch initResult {
+        switch zcashlc_init_data_database(dbData.0, dbData.1, seed, UInt(seed?.count ?? 0), networkType.networkId) {
         case 0: // ok
             return DbInitResult.success
         case 1:
@@ -317,10 +272,59 @@ 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"))
@@ -376,9 +380,7 @@ 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"))
@@ -386,29 +388,51 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
-    func latestCachedBlockHeight() async throws -> BlockHeight {
-        globalDBLock.lock()
-        let height = zcashlc_latest_cached_block_height(fsBlockDbRoot.0, fsBlockDbRoot.1)
-        globalDBLock.unlock()
+    func initBlocksTable(
+        height: Int32,
+        hash: String,
+        time: UInt32,
+        saplingTree: String
+    ) async throws {
+        guard !hash.containsCStringNullBytesBeforeStringEnding() else {
+            throw ZcashError.rustInitBlocksTableHashContainsNullBytes
+        }
 
-        if height >= 0 {
-            return BlockHeight(height)
-        } else if height == -1 {
-            return BlockHeight.empty()
-        } else {
-            throw ZcashError.rustLatestCachedBlockHeight(lastErrorMessage(fallback: "`latestCachedBlockHeight` failed with unknown error"))
+        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)
+            }
+        }
+    }
+
+    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"))
@@ -440,7 +464,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         value: Int64,
         height: BlockHeight
     ) async throws {
-        globalDBLock.lock()
         let result = zcashlc_put_utxo(
             dbData.0,
             dbData.1,
@@ -453,17 +476,29 @@ 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"))
@@ -471,162 +506,15 @@ 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 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()
+    func scanBlocks(limit: UInt32 = 0) async throws {
+        let result = zcashlc_scan_blocks(fsBlockDbRoot.0, fsBlockDbRoot.1, dbData.0, dbData.1, limit, networkType.networkId)
 
         guard result != 0 else {
             throw ZcashError.rustScanBlocks(lastErrorMessage(fallback: "`scanBlocks` failed with unknown error"))
@@ -637,39 +525,30 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         usk: UnifiedSpendingKey,
         memo: MemoBytes?,
         shieldingThreshold: Zatoshi
-    ) 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
-                )
-            }
+    ) 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
+            )
         }
-        globalDBLock.unlock()
 
-        guard success else {
+        guard result > 0 else {
             throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "`shieldFunds` failed with unknown error"))
         }
 
-        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
-            Data(txIdBytePtr)
-        }
+        return result
     }
 
     nonisolated func consensusBranchIdFor(height: Int32) throws -> Int32 {
@@ -683,12 +562,6 @@ 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()
@@ -770,11 +643,3 @@ extension Array where Element == FFIBlockMeta {
         }
     }
 }
-
-extension Array where Element == FfiSubtreeRoot {
-    func deallocateElements() {
-        self.forEach { element in
-            element.root_hash_ptr.deallocate()
-        }
-    }
-}