react-native-zcash 0.6.13 → 0.7.0

package/ios/ZCashLightClientKit/Rust/ZcashRustBackend.swift

@@ -9,11 +9,9 @@
 import Foundation
 
 
-let globalDBLock = NSLock()
-
-actor ZcashRustBackend: ZcashRustBackendWelding {
+struct ZcashRustBackend: ZcashRustBackendWelding {
     let minimumConfirmations: UInt32 = 10
-    let useZIP317Fees = false
+    let useZIP317Fees = true
 
     let dbData: (String, UInt)
     let fsBlockDbRoot: (String, UInt)
@@ -21,7 +19,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
     let outputParamsPath: (String, UInt)
     let keyDeriving: ZcashKeyDerivationBackendWelding
 
-    nonisolated let networkType: NetworkType
+    let networkType: NetworkType
 
     static var tracingEnabled = false
     /// Creates instance of `ZcashRustBackend`.
@@ -49,6 +47,31 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
+    @DBActor
+    func listAccounts() async throws -> [Int32] {
+        let accountsPtr = zcashlc_list_accounts(
+            dbData.0,
+            dbData.1,
+            networkType.networkId
+        )
+
+        guard let accountsPtr else {
+            throw ZcashError.rustListAccounts(lastErrorMessage(fallback: "`listAccounts` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_accounts(accountsPtr) }
+
+        var accounts: [Int32] = []
+
+        for i in (0 ..< Int(accountsPtr.pointee.len)) {
+            let account = accountsPtr.pointee.ptr.advanced(by: i).pointee
+            accounts.append(Int32(account.account_index))
+        }
+
+        return accounts
+    }
+
+    @DBActor
     func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey {
         var rUntil: Int64 = -1
         
@@ -58,7 +81,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         
         let treeStateBytes = try treeState.serializedData(partial: false).bytes
         
-        globalDBLock.lock()
         let ffiBinaryKeyPtr = zcashlc_create_account(
             dbData.0,
             dbData.1,
@@ -69,7 +91,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             rUntil,
             networkType.networkId
         )
-        globalDBLock.unlock()
 
         guard let ffiBinaryKeyPtr else {
             throw ZcashError.rustCreateAccount(lastErrorMessage(fallback: "`createAccount` failed with unknown error"))
@@ -80,49 +101,85 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return ffiBinaryKeyPtr.pointee.unsafeToUnifiedSpendingKey(network: networkType)
     }
 
-    func createToAddress(
-        usk: UnifiedSpendingKey,
+    @DBActor
+    func isSeedRelevantToAnyDerivedAccount(seed: [UInt8]) async throws -> Bool {
+        let result = zcashlc_is_seed_relevant_to_any_derived_account(
+            dbData.0,
+            dbData.1,
+            seed,
+            UInt(seed.count),
+            networkType.networkId
+        )
+
+        // -1 is the error sentinel.
+        guard result >= 0 else {
+            throw ZcashError.rustIsSeedRelevantToAnyDerivedAccount(lastErrorMessage(fallback: "`isSeedRelevantToAnyDerivedAccount` failed with unknown error"))
+        }
+
+        // 0 is false, 1 is true.
+        return result != 0
+    }
+
+    @DBActor
+    func proposeTransfer(
+        account: Int32,
         to address: String,
         value: Int64,
         memo: MemoBytes?
-    ) async throws -> Data {
-        var contiguousTxIdBytes = ContiguousArray<UInt8>([UInt8](repeating: 0x0, count: 32))
+    ) async throws -> FfiProposal {
+        let proposal = zcashlc_propose_transfer(
+            dbData.0,
+            dbData.1,
+            account,
+            [CChar](address.utf8CString),
+            value,
+            memo?.bytes,
+            networkType.networkId,
+            minimumConfirmations,
+            useZIP317Fees
+        )
 
-        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
-                )
-            }
+        guard let proposal else {
+            throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`proposeTransfer` failed with unknown error"))
         }
-        globalDBLock.unlock()
 
-        guard success else {
-            throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`createToAddress` failed with unknown error"))
-        }
+        defer { zcashlc_free_boxed_slice(proposal) }
 
-        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
-            Data(txIdBytePtr)
+        return try FfiProposal(contiguousBytes: Data(
+            bytes: proposal.pointee.ptr,
+            count: Int(proposal.pointee.len)
+        ))
+    }
+
+    @DBActor
+    func proposeTransferFromURI(
+        _ uri: String,
+        account: Int32
+    ) async throws -> FfiProposal {
+        let proposal = zcashlc_propose_transfer_from_uri(
+            dbData.0,
+            dbData.1,
+            account,
+            [CChar](uri.utf8CString),
+            networkType.networkId,
+            minimumConfirmations,
+            useZIP317Fees
+        )
+
+        guard let proposal else {
+            throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`proposeTransfer` failed with unknown error"))
         }
+
+        defer { zcashlc_free_boxed_slice(proposal) }
+
+        return try FfiProposal(contiguousBytes: Data(
+            bytes: proposal.pointee.ptr,
+            count: Int(proposal.pointee.len)
+        ))
     }
 
+    @DBActor
     func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: Int32) async throws {
-        globalDBLock.lock()
         let result = zcashlc_decrypt_and_store_transaction(
             dbData.0,
             dbData.1,
@@ -131,34 +188,20 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             UInt32(minedHeight),
             networkType.networkId
         )
-        globalDBLock.unlock()
 
         guard result != 0 else {
             throw ZcashError.rustDecryptAndStoreTransaction(lastErrorMessage(fallback: "`decryptAndStoreTransaction` failed with unknown error"))
         }
     }
 
-    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)"))
-        }
-
-        return balance
-    }
-
+    @DBActor
     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"))
@@ -173,15 +216,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return UnifiedAddress(validatedEncoding: address, networkType: networkType)
     }
 
+    @DBActor
     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"))
@@ -190,15 +232,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return result
     }
 
+    @DBActor
     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,7 +254,8 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return UnifiedAddress(validatedEncoding: address, networkType: networkType)
     }
 
-    func getMemo(txId: Data, outputIndex: UInt16) async throws -> Memo? {
+    @DBActor
+    func getMemo(txId: Data, outputPool: UInt32, outputIndex: UInt16) async throws -> Memo? {
         guard txId.count == 32 else {
             throw ZcashError.rustGetMemoInvalidTxIdLength
         }
@@ -221,30 +263,27 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         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)
+            success = zcashlc_get_memo(dbData.0, dbData.1, txId.bytes, outputPool, outputIndex, memoBytePtr.baseAddress, networkType.networkId)
         }
-        globalDBLock.unlock()
 
         guard success else { return nil }
 
         return (try? MemoBytes(contiguousBytes: contiguousMemoBytes)).flatMap { try? $0.intoMemo() }
     }
 
+    @DBActor
     func getTransparentBalance(account: Int32) async throws -> Int64 {
         guard account >= 0 else {
             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(
@@ -256,33 +295,12 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return balance
     }
 
-    func getVerifiedBalance(account: Int32) async throws -> Int64 {
-        globalDBLock.lock()
-        let balance = zcashlc_get_verified_balance(
-            dbData.0,
-            dbData.1,
-            account,
-            networkType.networkId,
-            minimumConfirmations
-        )
-        globalDBLock.unlock()
-
-        guard balance >= 0 else {
-            throw ZcashError.rustGetVerifiedBalance(
-                Int(account),
-                lastErrorMessage(fallback: "Error getting verified balance from account \(account)")
-            )
-        }
-
-        return balance
-    }
-
+    @DBActor
     func getVerifiedTransparentBalance(account: Int32) async throws -> Int64 {
         guard account >= 0 else {
             throw ZcashError.rustGetVerifiedTransparentBalanceNegativeAccount(Int(account))
         }
 
-        globalDBLock.lock()
         let balance = zcashlc_get_verified_transparent_balance_for_account(
             dbData.0,
             dbData.1,
@@ -290,7 +308,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             account,
             minimumConfirmations
         )
-        globalDBLock.unlock()
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedTransparentBalance(
@@ -302,31 +319,32 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return balance
     }
 
+    @DBActor
     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 {
         case 0: // ok
             return DbInitResult.success
         case 1:
             return DbInitResult.seedRequired
+        case 2:
+            return DbInitResult.seedNotRelevant
         default:
             throw ZcashError.rustInitDataDb(lastErrorMessage(fallback: "`initDataDb` failed with unknown error"))
         }
     }
 
+    @DBActor
     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"))
         }
     }
 
+    @DBActor
     func writeBlocksMetadata(blocks: [ZcashCompactBlock]) async throws {
         var ffiBlockMetaVec: [FFIBlockMeta] = []
 
@@ -376,9 +394,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,10 +402,9 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
+    @DBActor
     func latestCachedBlockHeight() async throws -> BlockHeight {
-        globalDBLock.lock()
         let height = zcashlc_latest_cached_block_height(fsBlockDbRoot.0, fsBlockDbRoot.1)
-        globalDBLock.unlock()
 
         if height >= 0 {
             return BlockHeight(height)
@@ -400,15 +415,14 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
+    @DBActor
     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"))
@@ -433,6 +447,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         return addresses
     }
 
+    @DBActor
     func putUnspentTransparentOutput(
         txid: [UInt8],
         index: Int,
@@ -440,7 +455,6 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         value: Int64,
         height: BlockHeight
     ) async throws {
-        globalDBLock.lock()
         let result = zcashlc_put_utxo(
             dbData.0,
             dbData.1,
@@ -453,33 +467,31 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
             Int32(height),
             networkType.networkId
         )
-        globalDBLock.unlock()
 
         guard result else {
             throw ZcashError.rustPutUnspentTransparentOutput(lastErrorMessage(fallback: "`putUnspentTransparentOutput` failed with unknown error"))
         }
     }
 
+    @DBActor
     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"))
         }
     }
 
+    @DBActor
     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"))
         }
     }
 
+    @DBActor
     func putSaplingSubtreeRoots(startIndex: UInt64, roots: [SubtreeRoot]) async throws {
         var ffiSubtreeRootsVec: [FfiSubtreeRoot] = []
 
@@ -528,9 +540,7 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
 
             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"))
@@ -538,20 +548,75 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
+    @DBActor
+    func putOrchardSubtreeRoots(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.rustPutOrchardSubtreeRootsAllocationProblem
+            }
+
+            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)
+
+            let res = zcashlc_put_orchard_subtree_roots(dbData.0, dbData.1, startIndex, rootsPtr, networkType.networkId)
+
+            guard res else {
+                throw ZcashError.rustPutOrchardSubtreeRoots(lastErrorMessage(fallback: "`putOrchardSubtreeRoots` failed with unknown error"))
+            }
+        }
+    }
+
+    @DBActor
     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"))
         }
     }
 
+    @DBActor
     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)
@@ -562,10 +627,9 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
+    @DBActor
     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)
@@ -576,27 +640,40 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         }
     }
 
-    func getScanProgress() async throws -> ScanProgress? {
-        globalDBLock.lock()
-        let result = zcashlc_get_scan_progress(dbData.0, dbData.1, networkType.networkId)
-        globalDBLock.unlock()
+    @DBActor
+    func getWalletSummary() async throws -> WalletSummary? {
+        let summaryPtr = zcashlc_get_wallet_summary(dbData.0, dbData.1, networkType.networkId, minimumConfirmations)
 
-        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)
+        guard let summaryPtr else {
+            throw ZcashError.rustGetWalletSummary(lastErrorMessage(fallback: "`getWalletSummary` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_wallet_summary(summaryPtr) }
+
+        if summaryPtr.pointee.fully_scanned_height < 0 {
+            return nil
         }
+
+        var accountBalances: [UInt32: AccountBalance] = [:]
+
+        for i in (0 ..< Int(summaryPtr.pointee.account_balances_len)) {
+            let accountBalance = summaryPtr.pointee.account_balances.advanced(by: i).pointee
+            accountBalances[accountBalance.account_id] = accountBalance.toAccountBalance()
+        }
+
+        return WalletSummary(
+            accountBalances: accountBalances,
+            chainTipHeight: BlockHeight(summaryPtr.pointee.chain_tip_height),
+            fullyScannedHeight: BlockHeight(summaryPtr.pointee.fully_scanned_height),
+            scanProgress: summaryPtr.pointee.scan_progress?.pointee.toScanProgress(),
+            nextSaplingSubtreeIndex: UInt32(summaryPtr.pointee.next_sapling_subtree_index),
+            nextOrchardSubtreeIndex: UInt32(summaryPtr.pointee.next_orchard_subtree_index)
+        )
     }
 
+    @DBActor
     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"))
@@ -623,53 +700,108 @@ actor ZcashRustBackend: ZcashRustBackendWelding {
         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()
+    @DBActor
+    func scanBlocks(fromHeight: Int32, fromState: TreeState, limit: UInt32 = 0) async throws -> ScanSummary {
+        let fromStateBytes = try fromState.serializedData(partial: false).bytes
 
-        guard result != 0 else {
+        let summaryPtr = zcashlc_scan_blocks(
+            fsBlockDbRoot.0,
+            fsBlockDbRoot.1,
+            dbData.0,
+            dbData.1,
+            fromHeight,
+            fromStateBytes,
+            UInt(fromStateBytes.count),
+            limit,
+            networkType.networkId
+        )
+
+        guard let summaryPtr else {
             throw ZcashError.rustScanBlocks(lastErrorMessage(fallback: "`scanBlocks` failed with unknown error"))
         }
+
+        defer { zcashlc_free_scan_summary(summaryPtr) }
+
+        return ScanSummary(
+            scannedRange: Range(uncheckedBounds: (
+                BlockHeight(summaryPtr.pointee.scanned_start),
+                BlockHeight(summaryPtr.pointee.scanned_end)
+            )),
+            spentSaplingNoteCount: summaryPtr.pointee.spent_sapling_note_count,
+            receivedSaplingNoteCount: summaryPtr.pointee.received_sapling_note_count
+        )
     }
 
-    func shieldFunds(
-        usk: UnifiedSpendingKey,
+    @DBActor
+    func proposeShielding(
+        account: Int32,
         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(
+        shieldingThreshold: Zatoshi,
+        transparentReceiver: String?
+    ) async throws -> FfiProposal? {
+        let proposal = zcashlc_propose_shielding(
+            dbData.0,
+            dbData.1,
+            account,
+            memo?.bytes,
+            UInt64(shieldingThreshold.amount),
+            transparentReceiver.map { [CChar]($0.utf8CString) },
+            networkType.networkId,
+            minimumConfirmations,
+            useZIP317Fees
+        )
+
+        guard let proposal else {
+            throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "`proposeShielding` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_boxed_slice(proposal) }
+
+        return try FfiProposal(contiguousBytes: Data(
+            bytes: proposal.pointee.ptr,
+            count: Int(proposal.pointee.len)
+        ))
+    }
+
+    @DBActor
+    func createProposedTransactions(
+        proposal: FfiProposal,
+        usk: UnifiedSpendingKey
+    ) async throws -> [Data] {
+        let proposalBytes = try proposal.serializedData(partial: false).bytes
+
+        let txIdsPtr = proposalBytes.withUnsafeBufferPointer { proposalPtr in
+            usk.bytes.withUnsafeBufferPointer { uskPtr in
+                zcashlc_create_proposed_transactions(
                     dbData.0,
                     dbData.1,
-                    uskBuffer.baseAddress,
+                    proposalPtr.baseAddress,
+                    UInt(proposalBytes.count),
+                    uskPtr.baseAddress,
                     UInt(usk.bytes.count),
-                    memo?.bytes,
-                    UInt64(shieldingThreshold.amount),
                     spendParamsPath.0,
                     spendParamsPath.1,
                     outputParamsPath.0,
                     outputParamsPath.1,
-                    networkType.networkId,
-                    minimumConfirmations,
-                    useZIP317Fees,
-                    txIdBytePtr.baseAddress
+                    networkType.networkId
                 )
             }
         }
-        globalDBLock.unlock()
 
-        guard success else {
-            throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "`shieldFunds` failed with unknown error"))
+        guard let txIdsPtr else {
+            throw ZcashError.rustCreateToAddress(lastErrorMessage(fallback: "`createToAddress` failed with unknown error"))
         }
 
-        return contiguousTxIdBytes.withUnsafeBufferPointer { txIdBytePtr in
-            Data(txIdBytePtr)
+        defer { zcashlc_free_txids(txIdsPtr) }
+
+        var txIds: [Data] = []
+
+        for i in (0 ..< Int(txIdsPtr.pointee.len)) {
+            let txId = FfiTxId(tuple: txIdsPtr.pointee.ptr.advanced(by: i).pointee)
+            txIds.append(Data(txId.array))
         }
+
+        return txIds
     }
 
     nonisolated func consensusBranchIdFor(height: Int32) throws -> Int32 {
@@ -778,3 +910,45 @@ extension Array where Element == FfiSubtreeRoot {
         }
     }
 }
+
+extension FfiBalance {
+    /// Converts an [`FfiBalance`] into a [`PoolBalance`].
+    func toPoolBalance() -> PoolBalance {
+        .init(
+            spendableValue: Zatoshi(self.spendable_value),
+            changePendingConfirmation: Zatoshi(self.change_pending_confirmation),
+            valuePendingSpendability: Zatoshi(self.value_pending_spendability)
+        )
+    }
+}
+
+extension FfiAccountBalance {
+    /// Converts an [`FfiAccountBalance`] into a [`AccountBalance`].
+    func toAccountBalance() -> AccountBalance {
+        .init(
+            saplingBalance: self.sapling_balance.toPoolBalance(),
+            orchardBalance: self.orchard_balance.toPoolBalance(),
+            unshielded: Zatoshi(self.unshielded)
+        )
+    }
+}
+
+extension FfiScanProgress {
+    /// Converts an [`FfiScanProgress`] into a [`ScanProgress`].
+    func toScanProgress() -> ScanProgress {
+        .init(
+            numerator: self.numerator,
+            denominator: self.denominator
+        )
+    }
+}
+
+// swiftlint:disable large_tuple line_length
+struct FfiTxId {
+    var tuple: (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8)
+    var array: [UInt8] {
+        withUnsafeBytes(of: self.tuple) { buf in
+            [UInt8](buf)
+        }
+    }
+}