react-native-zcash 0.9.13 → 0.10.1-beta.1

package/ios/ZCashLightClientKit/Rust/ZcashRustBackend.swift

@@ -24,10 +24,51 @@ enum RustLogging: String {
     case trace
 }
 
+/// A description of the policy that is used to determine what notes are available for spending,
+/// based upon the number of confirmations (the number of blocks in the chain since and including
+/// the block in which a note was produced.)
+///
+/// See [`ZIP 315`] for details including the definitions of "trusted" and "untrusted" notes.
+///
+/// # Note
+///
+/// `trusted` and `untrusted` are both meant to be non-zero values.
+/// `0` will be treated as a request for a default value.
+///
+/// [`ZIP 315`]: https://zips.z.cash/zip-0315
+public struct SwiftConfirmationsPolicy {
+    /// NonZero, zero for default
+    let trusted: UInt32
+    /// NonZero, zero for default; if this is set to zero, `trusted` must also be set to zero
+    let untrusted: UInt32
+    let allowZeroConfShielding: Bool
+    
+    init(trusted: UInt32 = 3, untrusted: UInt32 = 10, allowZeroConfShielding: Bool = true) {
+        self.trusted = trusted
+        self.untrusted = untrusted
+        self.allowZeroConfShielding = allowZeroConfShielding
+    }
+    
+    public static func defaultTransferPolicy() -> Self {
+        SwiftConfirmationsPolicy.init()
+    }
+    
+    public static func defaultShieldingPolicy() -> Self {
+        SwiftConfirmationsPolicy.init(trusted: 1, untrusted: 1, allowZeroConfShielding: true)
+    }
+    
+    public func toBackend() -> ConfirmationsPolicy {
+        var libzcashlcConfirmationsPolicy = ConfirmationsPolicy()
+        libzcashlcConfirmationsPolicy.trusted = self.trusted
+        libzcashlcConfirmationsPolicy.untrusted = self.untrusted
+        libzcashlcConfirmationsPolicy.allow_zero_conf_shielding = self.allowZeroConfShielding
+        return libzcashlcConfirmationsPolicy
+    }
+}
+
 struct ZcashRustBackend: ZcashRustBackendWelding {
-    let minimumConfirmations: UInt32 = 10
-    let minimumShieldingConfirmations: UInt32 = 1
-    let useZIP317Fees = true
+    let confirmationsPolicy: SwiftConfirmationsPolicy = SwiftConfirmationsPolicy.defaultTransferPolicy()
+    let shieldingConfirmationsPolicy: SwiftConfirmationsPolicy = SwiftConfirmationsPolicy.defaultShieldingPolicy()
 
     let dbData: (String, UInt)
     let fsBlockDbRoot: (String, UInt)
@@ -36,6 +77,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     let keyDeriving: ZcashKeyDerivationBackendWelding
 
     let networkType: NetworkType
+    let sdkFlags: SDKFlags
 
     static var rustInitialized = false
 
@@ -57,7 +99,8 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         spendParamsPath: URL,
         outputParamsPath: URL,
         networkType: NetworkType,
-        logLevel: RustLogging = RustLogging.off
+        logLevel: RustLogging = RustLogging.off,
+        sdkFlags: SDKFlags
     ) {
         self.dbData = dbData.osStr()
         self.fsBlockDbRoot = fsBlockDbRoot.osPathStr()
@@ -65,6 +108,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         self.outputParamsPath = outputParamsPath.osPathStr()
         self.networkType = networkType
         self.keyDeriving = ZcashKeyDerivationBackend(networkType: networkType)
+        self.sdkFlags = sdkFlags
 
         if !Self.rustInitialized {
             Self.rustInitialized = true
@@ -73,7 +117,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     @DBActor
-    func listAccounts() async throws -> [Int32] {
+    func listAccounts() async throws -> [Account] {
         let accountsPtr = zcashlc_list_accounts(
             dbData.0,
             dbData.1,
@@ -86,18 +130,103 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
         defer { zcashlc_free_accounts(accountsPtr) }
 
-        var accounts: [Int32] = []
+        var accounts: [Account] = []
 
         for i in (0 ..< Int(accountsPtr.pointee.len)) {
-            let account = accountsPtr.pointee.ptr.advanced(by: i).pointee
-            accounts.append(Int32(account.account_index))
+            let accountUUIDPtr = accountsPtr.pointee.ptr.advanced(by: i).pointee
+            let accountUUID = AccountUUID(id: accountUUIDPtr.uuidArray)
+
+            let account = try await getAccount(for: accountUUID)
+            
+            accounts.append(account)
         }
 
         return accounts
     }
 
     @DBActor
-    func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey {
+    func getAccount(
+        for accountUUID: AccountUUID
+    ) async throws -> Account {
+        let accountPtr: UnsafeMutablePointer<FfiAccount>? = zcashlc_get_account(
+            dbData.0,
+            dbData.1,
+            networkType.networkId,
+            accountUUID.id
+        )
+        
+        guard let accountPtr else {
+            throw ZcashError.rustImportAccountUfvk(lastErrorMessage(fallback: "`getAccount` failed with unknown error"))
+        }
+        
+        defer { zcashlc_free_account(accountPtr) }
+
+        guard let validAccount = accountPtr.pointee.unsafeToAccount() else {
+            throw ZcashError.rustUUIDAccountNotFound(lastErrorMessage(fallback: "`getAccount` failed with unknown error"))
+        }
+        
+        return validAccount
+    }
+    
+    // swiftlint:disable:next function_parameter_count
+    @DBActor func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        treeState: TreeState,
+        recoverUntil: UInt32?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> AccountUUID {
+        var rUntil: Int64 = -1
+        
+        if let recoverUntil {
+            rUntil = Int64(recoverUntil)
+        }
+
+        let treeStateBytes = try treeState.serializedData(partial: false).bytes
+        
+        var kSource: [CChar]?
+
+        if let keySource {
+            kSource = [CChar](keySource.utf8CString)
+        }
+        
+        let index: UInt32 = zip32AccountIndex?.index ?? UINT32_MAX
+
+        let uuidPtr = zcashlc_import_account_ufvk(
+            dbData.0,
+            dbData.1,
+            [CChar](ufvk.utf8CString),
+            treeStateBytes,
+            UInt(treeStateBytes.count),
+            rUntil,
+            networkType.networkId,
+            purpose.rawValue,
+            [CChar](name.utf8CString),
+            kSource,
+            seedFingerprint,
+            index
+        )
+        
+        guard let uuidPtr else {
+            throw ZcashError.rustImportAccountUfvk(lastErrorMessage(fallback: "`importAccount` failed with unknown error"))
+        }
+        
+        defer { zcashlc_free_ffi_uuid(uuidPtr) }
+
+        return uuidPtr.pointee.unsafeToAccountUUID()
+    }
+    
+    @DBActor
+    func createAccount(
+        seed: [UInt8],
+        treeState: TreeState,
+        recoverUntil: UInt32?,
+        name: String,
+        keySource: String?
+    ) async throws -> UnifiedSpendingKey {
         var rUntil: Int64 = -1
         
         if let recoverUntil {
@@ -106,6 +235,12 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         
         let treeStateBytes = try treeState.serializedData(partial: false).bytes
         
+        var kSource: [CChar]?
+
+        if let keySource {
+            kSource = [CChar](keySource.utf8CString)
+        }
+
         let ffiBinaryKeyPtr = zcashlc_create_account(
             dbData.0,
             dbData.1,
@@ -114,7 +249,9 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
             treeStateBytes,
             UInt(treeStateBytes.count),
             rUntil,
-            networkType.networkId
+            networkType.networkId,
+            [CChar](name.utf8CString),
+            kSource
         )
 
         guard let ffiBinaryKeyPtr else {
@@ -149,7 +286,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
     @DBActor
     func proposeTransfer(
-        account: Int32,
+        accountUUID: AccountUUID,
         to address: String,
         value: Int64,
         memo: MemoBytes?
@@ -157,13 +294,12 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         let proposal = zcashlc_propose_transfer(
             dbData.0,
             dbData.1,
-            account,
+            accountUUID.id,
             [CChar](address.utf8CString),
             value,
             memo?.bytes,
             networkType.networkId,
-            minimumConfirmations,
-            useZIP317Fees
+            confirmationsPolicy.toBackend()
         )
 
         guard let proposal else {
@@ -172,7 +308,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
         defer { zcashlc_free_boxed_slice(proposal) }
 
-        return try FfiProposal(contiguousBytes: Data(
+        return try FfiProposal(serializedData: Data(
             bytes: proposal.pointee.ptr,
             count: Int(proposal.pointee.len)
         ))
@@ -181,16 +317,15 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     @DBActor
     func proposeTransferFromURI(
         _ uri: String,
-        account: Int32
+        accountUUID: AccountUUID
     ) async throws -> FfiProposal {
         let proposal = zcashlc_propose_transfer_from_uri(
             dbData.0,
             dbData.1,
-            account,
+            accountUUID.id,
             [CChar](uri.utf8CString),
             networkType.networkId,
-            minimumConfirmations,
-            useZIP317Fees
+            confirmationsPolicy.toBackend()
         )
 
         guard let proposal else {
@@ -199,34 +334,187 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
         defer { zcashlc_free_boxed_slice(proposal) }
 
-        return try FfiProposal(contiguousBytes: Data(
+        return try FfiProposal(serializedData: Data(
             bytes: proposal.pointee.ptr,
             count: Int(proposal.pointee.len)
         ))
     }
+    
+    @DBActor
+    func createPCZTFromProposal(
+        accountUUID: AccountUUID,
+        proposal: FfiProposal
+    ) async throws -> Pczt {
+        let proposalBytes = try proposal.serializedData(partial: false).bytes
+
+        let pcztPtr = proposalBytes.withUnsafeBufferPointer { proposalPtr in
+            zcashlc_create_pczt_from_proposal(
+                dbData.0,
+                dbData.1,
+                networkType.networkId,
+                proposalPtr.baseAddress,
+                UInt(proposalBytes.count),
+                accountUUID.id
+            )
+        }
+        
+        guard let pcztPtr else {
+            throw ZcashError.rustCreatePCZTFromProposal(lastErrorMessage(fallback: "`createPCZTFromProposal` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_boxed_slice(pcztPtr) }
+
+        return Pczt(
+            bytes: pcztPtr.pointee.ptr,
+            count: Int(pcztPtr.pointee.len)
+        )
+    }
+
+    func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt {
+        let pcztPtr: UnsafeMutablePointer<FfiBoxedSlice>? = pczt.withUnsafeBytes { buffer in
+            guard let bufferPtr = buffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                return nil
+            }
+
+            return zcashlc_redact_pczt_for_signer(
+                bufferPtr,
+                UInt(pczt.count)
+            )
+        }
+
+        guard let pcztPtr else {
+            throw ZcashError.rustRedactPCZTForSigner(lastErrorMessage(fallback: "`redactPCZTForSigner` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_boxed_slice(pcztPtr) }
+
+        return Pczt(
+            bytes: pcztPtr.pointee.ptr,
+            count: Int(pcztPtr.pointee.len)
+        )
+    }
+
+    func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool {
+        return pczt.withUnsafeBytes { buffer in
+            guard let bufferPtr = buffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                // Return `false` here so the caller proceeds to `addProofsToPCZT` and
+                // gets the same error.
+                return false
+            }
+
+            return zcashlc_pczt_requires_sapling_proofs(
+                bufferPtr,
+                UInt(pczt.count)
+            )
+        }
+    }
+
+    func addProofsToPCZT(
+        pczt: Pczt
+    ) async throws -> Pczt {
+        let pcztPtr: UnsafeMutablePointer<FfiBoxedSlice>? = pczt.withUnsafeBytes { buffer in
+            guard let bufferPtr = buffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                return nil
+            }
+            
+            return zcashlc_add_proofs_to_pczt(
+                bufferPtr,
+                UInt(pczt.count),
+                spendParamsPath.0,
+                spendParamsPath.1,
+                outputParamsPath.0,
+                outputParamsPath.1
+            )
+        }
+
+        guard let pcztPtr else {
+            throw ZcashError.rustAddProofsToPCZT(lastErrorMessage(fallback: "`addProofsToPCZT` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_boxed_slice(pcztPtr) }
+
+        return Pczt(
+            bytes: pcztPtr.pointee.ptr,
+            count: Int(pcztPtr.pointee.len)
+        )
+    }
 
     @DBActor
-    func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: UInt32?) async throws {
-        let result = zcashlc_decrypt_and_store_transaction(
-            dbData.0,
-            dbData.1,
-            txBytes,
-            UInt(txBytes.count),
-            Int64(minedHeight ?? 0),
-            networkType.networkId
+    func extractAndStoreTxFromPCZT(
+        pcztWithProofs: Pczt,
+        pcztWithSigs: Pczt
+    ) async throws -> Data {
+        let txidPtr: UnsafeMutablePointer<FfiBoxedSlice>? = pcztWithProofs.withUnsafeBytes { pcztWithProofsBuffer in
+            guard let pcztWithProofsBufferPtr = pcztWithProofsBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                return nil
+            }
+            
+            return pcztWithSigs.withUnsafeBytes { pcztWithSigsBuffer in
+                guard let pcztWithSigsBufferPtr = pcztWithSigsBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                    return nil
+                }
+                
+                return zcashlc_extract_and_store_from_pczt(
+                    dbData.0,
+                    dbData.1,
+                    networkType.networkId,
+                    pcztWithProofsBufferPtr,
+                    UInt(pcztWithProofs.count),
+                    pcztWithSigsBufferPtr,
+                    UInt(pcztWithSigs.count),
+                    spendParamsPath.0,
+                    spendParamsPath.1,
+                    outputParamsPath.0,
+                    outputParamsPath.1
+                )
+            }
+        }
+
+        guard let txidPtr else {
+            throw ZcashError.rustExtractAndStoreTxFromPCZT(lastErrorMessage(fallback: "`extractAndStoreTxFromPCZT` failed with unknown error"))
+        }
+
+        guard txidPtr.pointee.len == 32 else {
+            throw ZcashError.rustTxidPtrIncorrectLength(lastErrorMessage(fallback: "`extractAndStoreTxFromPCZT` failed with unknown error"))
+        }
+        
+        defer { zcashlc_free_boxed_slice(txidPtr) }
+
+        return Data(
+            bytes: txidPtr.pointee.ptr,
+            count: Int(txidPtr.pointee.len)
         )
+    }
+
+    @DBActor
+    func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: UInt32?) async throws -> Data {
+        var contiguousTxidBytes = ContiguousArray<UInt8>(Data(count: 32))
+
+        let result = contiguousTxidBytes.withUnsafeMutableBufferPointer { txidBytePtr in
+            zcashlc_decrypt_and_store_transaction(
+                dbData.0,
+                dbData.1,
+                txBytes,
+                UInt(txBytes.count),
+                Int64(minedHeight ?? 0),
+                networkType.networkId,
+                txidBytePtr.baseAddress
+            )
+        }
 
         guard result != 0 else {
             throw ZcashError.rustDecryptAndStoreTransaction(lastErrorMessage(fallback: "`decryptAndStoreTransaction` failed with unknown error"))
         }
+
+        return Data(contiguousTxidBytes)
     }
 
     @DBActor
-    func getCurrentAddress(account: Int32) async throws -> UnifiedAddress {
+    func getCurrentAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
         let addressCStr = zcashlc_get_current_address(
             dbData.0,
             dbData.1,
-            account,
+            accountUUID.id,
             networkType.networkId
         )
 
@@ -244,12 +532,13 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     @DBActor
-    func getNextAvailableAddress(account: Int32) async throws -> UnifiedAddress {
+    func getNextAvailableAddress(accountUUID: AccountUUID, receiverFlags: UInt32) async throws -> UnifiedAddress {
         let addressCStr = zcashlc_get_next_available_address(
             dbData.0,
             dbData.1,
-            account,
-            networkType.networkId
+            accountUUID.id,
+            networkType.networkId,
+            receiverFlags
         )
 
         guard let addressCStr else {
@@ -284,22 +573,18 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     @DBActor
-    func getTransparentBalance(account: Int32) async throws -> Int64 {
-        guard account >= 0 else {
-            throw ZcashError.rustGetTransparentBalanceNegativeAccount(Int(account))
-        }
-
+    func getTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
         let balance = zcashlc_get_total_transparent_balance_for_account(
             dbData.0,
             dbData.1,
             networkType.networkId,
-            account
+            accountUUID.id
         )
 
         guard balance >= 0 else {
             throw ZcashError.rustGetTransparentBalance(
-                Int(account),
-                lastErrorMessage(fallback: "Error getting Total Transparent balance from account \(account)")
+                accountUUID,
+                lastErrorMessage(fallback: "Error getting Total Transparent balance from accountUUID \(accountUUID.id)")
             )
         }
 
@@ -307,23 +592,19 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     @DBActor
-    func getVerifiedTransparentBalance(account: Int32) async throws -> Int64 {
-        guard account >= 0 else {
-            throw ZcashError.rustGetVerifiedTransparentBalanceNegativeAccount(Int(account))
-        }
-
+    func getVerifiedTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
         let balance = zcashlc_get_verified_transparent_balance_for_account(
             dbData.0,
             dbData.1,
             networkType.networkId,
-            account,
-            minimumShieldingConfirmations
+            accountUUID.id,
+            shieldingConfirmationsPolicy.toBackend()
         )
 
         guard balance >= 0 else {
             throw ZcashError.rustGetVerifiedTransparentBalance(
-                Int(account),
-                lastErrorMessage(fallback: "Error getting verified transparent balance from account \(account)")
+                accountUUID,
+                lastErrorMessage(fallback: "Error getting verified transparent balance from accountUUID \(accountUUID.id)")
             )
         }
 
@@ -427,11 +708,11 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
     }
 
     @DBActor
-    func listTransparentReceivers(account: Int32) async throws -> [TransparentAddress] {
+    func listTransparentReceivers(accountUUID: AccountUUID) async throws -> [TransparentAddress] {
         let encodedKeysPtr = zcashlc_list_transparent_receivers(
             dbData.0,
             dbData.1,
-            account,
+            accountUUID.id,
             networkType.networkId
         )
 
@@ -486,7 +767,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
     @DBActor
     func rewindToHeight(height: BlockHeight) async throws -> RewindResult {
-        var safeRewindHeight: Int64 = -1;
+        var safeRewindHeight: Int64 = -1
         let result = zcashlc_rewind_to_height(dbData.0, dbData.1, UInt32(height), networkType.networkId, &safeRewindHeight)
 
         if result >= 0 {
@@ -658,7 +939,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
     @DBActor
     func getWalletSummary() async throws -> WalletSummary? {
-        let summaryPtr = zcashlc_get_wallet_summary(dbData.0, dbData.1, networkType.networkId, minimumConfirmations)
+        let summaryPtr = zcashlc_get_wallet_summary(dbData.0, dbData.1, networkType.networkId, confirmationsPolicy.toBackend())
 
         guard let summaryPtr else {
             throw ZcashError.rustGetWalletSummary(lastErrorMessage(fallback: "`getWalletSummary` failed with unknown error"))
@@ -670,17 +951,42 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
             return nil
         }
 
-        var accountBalances: [UInt32: AccountBalance] = [:]
+        var accountBalances: [AccountUUID: 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()
+            accountBalances[AccountUUID(id: accountBalance.uuidArray)] = accountBalance.toAccountBalance()
+        }
+        
+        // Modify spendable `accountBalances` if chainTip hasn't been updated yet
+        if await !sdkFlags.chainTipUpdated {
+            accountBalances.forEach { key, _ in
+                if let accountBalance = accountBalances[key] {
+                    accountBalances[key] = AccountBalance(
+                        saplingBalance: PoolBalance(
+                            spendableValue: .zero,
+                            changePendingConfirmation: accountBalance.saplingBalance.changePendingConfirmation,
+                            valuePendingSpendability: accountBalance.saplingBalance.valuePendingSpendability
+                            + accountBalance.saplingBalance.spendableValue
+                        ),
+                        orchardBalance: PoolBalance(
+                            spendableValue: .zero,
+                            changePendingConfirmation: accountBalance.orchardBalance.changePendingConfirmation,
+                            valuePendingSpendability: accountBalance.orchardBalance.valuePendingSpendability
+                            + accountBalance.orchardBalance.spendableValue
+                        ),
+                        unshielded: .zero,
+                        awaitingResolution: accountBalance.unshielded
+                    )
+                }
+            }
         }
 
         return WalletSummary(
             accountBalances: accountBalances,
             chainTipHeight: BlockHeight(summaryPtr.pointee.chain_tip_height),
             fullyScannedHeight: BlockHeight(summaryPtr.pointee.fully_scanned_height),
+            recoveryProgress: summaryPtr.pointee.recovery_progress?.pointee.toScanProgress(),
             scanProgress: summaryPtr.pointee.scan_progress?.pointee.toScanProgress(),
             nextSaplingSubtreeIndex: UInt32(summaryPtr.pointee.next_sapling_subtree_index),
             nextOrchardSubtreeIndex: UInt32(summaryPtr.pointee.next_orchard_subtree_index)
@@ -750,7 +1056,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
 
     @DBActor
     func proposeShielding(
-        account: Int32,
+        accountUUID: AccountUUID,
         memo: MemoBytes?,
         shieldingThreshold: Zatoshi,
         transparentReceiver: String?
@@ -758,13 +1064,12 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         let proposal = zcashlc_propose_shielding(
             dbData.0,
             dbData.1,
-            account,
+            accountUUID.id,
             memo?.bytes,
             UInt64(shieldingThreshold.amount),
             transparentReceiver.map { [CChar]($0.utf8CString) },
             networkType.networkId,
-            minimumShieldingConfirmations,
-            useZIP317Fees
+            shieldingConfirmationsPolicy.toBackend()
         )
 
         guard let proposal else {
@@ -774,10 +1079,10 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         defer { zcashlc_free_boxed_slice(proposal) }
         
         guard proposal.pointee.ptr != nil else {
-            throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "Failed with nil pointer."))
+            return nil
         }
         
-        return try FfiProposal(contiguousBytes: Data(
+        return try FfiProposal(serializedData: Data(
             bytes: proposal.pointee.ptr,
             count: Int(proposal.pointee.len)
         ))
@@ -834,8 +1139,8 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
         return branchId
     }
     
-    @DBActor
-    func transactionDataRequests() async throws -> [TransactionDataRequest] {
+    // swiftlint:disable:next cyclomatic_complexity
+    @DBActor func transactionDataRequests() async throws -> [TransactionDataRequest] {
         let tDataRequestsPtr = zcashlc_transaction_data_requests(
             dbData.0,
             dbData.1,
@@ -859,15 +1164,47 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
                 tDataRequest = TransactionDataRequest.getStatus(FfiTxId(tuple: tDataRequestPtr.get_status).array)
             } else if tDataRequestPtr.tag == 1 {
                 tDataRequest = TransactionDataRequest.enhancement(FfiTxId(tuple: tDataRequestPtr.enhancement).array)
-            } else if tDataRequestPtr.tag == 2, let address = String(validatingUTF8: tDataRequestPtr.spends_from_address.address) {
-                let end = tDataRequestPtr.spends_from_address.block_range_end
+            } else if tDataRequestPtr.tag == 2, let address = String(validatingUTF8: tDataRequestPtr.transactions_involving_address.address) {
+                let end = tDataRequestPtr.transactions_involving_address.block_range_end
                 let blockRangeEnd: UInt32? = end > UInt32.max || end == -1 ? nil : UInt32(end)
-                
-                tDataRequest = TransactionDataRequest.spendsFromAddress(
-                    SpendsFromAddress(
+
+                let ffiRequestAt = tDataRequestPtr.transactions_involving_address.request_at
+                let requestAt: Date? = if ffiRequestAt == -1 {
+                    nil
+                } else if ffiRequestAt >= 0 {
+                    Date(timeIntervalSince1970: TimeInterval(ffiRequestAt))
+                } else {
+                    throw ZcashError.rustTransactionDataRequests("Invalid request_at")
+                }
+
+                let ffiTxStatusFilter = tDataRequestPtr.transactions_involving_address.tx_status_filter
+                let txStatusFilter = if ffiTxStatusFilter == TransactionStatusFilter_Mined {
+                    TransactionStatusFilter.mined
+                } else if ffiTxStatusFilter == TransactionStatusFilter_Mempool {
+                    TransactionStatusFilter.mempool
+                } else if ffiTxStatusFilter == TransactionStatusFilter_All {
+                    TransactionStatusFilter.all
+                } else {
+                    throw ZcashError.rustTransactionDataRequests("Invalid tx_status_filter")
+                }
+
+                let ffiOutputStatusFilter = tDataRequestPtr.transactions_involving_address.output_status_filter
+                let outputStatusFilter = if ffiOutputStatusFilter == OutputStatusFilter_Unspent {
+                    OutputStatusFilter.unspent
+                } else if ffiOutputStatusFilter == OutputStatusFilter_All {
+                    OutputStatusFilter.all
+                } else {
+                    throw ZcashError.rustTransactionDataRequests("Invalid output_status_filter")
+                }
+
+                tDataRequest = TransactionDataRequest.transactionsInvolvingAddress(
+                    TransactionsInvolvingAddress(
                         address: address,
-                        blockRangeStart: tDataRequestPtr.spends_from_address.block_range_start,
-                        blockRangeEnd: blockRangeEnd
+                        blockRangeStart: tDataRequestPtr.transactions_involving_address.block_range_start,
+                        blockRangeEnd: blockRangeEnd,
+                        requestAt: requestAt,
+                        txStatusFilter: txStatusFilter,
+                        outputStatusFilter: outputStatusFilter
                     )
                 )
             }
@@ -903,6 +1240,35 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
             transactionStatus
         )
     }
+    
+    @DBActor
+    func fixWitnesses() async {
+        zcashlc_fix_witnesses(dbData.0, dbData.1, networkType.networkId)
+    }
+    
+    @DBActor
+    func getSingleUseTransparentAddress(accountUUID: AccountUUID) async throws -> SingleUseTransparentAddress {
+        let singleUseTaddrPtr = zcashlc_get_single_use_taddr(
+            dbData.0,
+            dbData.1,
+            networkType.networkId,
+            accountUUID.id
+        )
+
+        guard let singleUseTaddrPtr else {
+            throw ZcashError.rustGetSingleUseTransparentAddress(
+                lastErrorMessage(fallback: "`getSingleUseTransparentAddress` failed with unknown error")
+            )
+        }
+
+        defer { zcashlc_free_single_use_taddr(singleUseTaddrPtr) }
+
+        return SingleUseTransparentAddress(
+            address: String(cString: singleUseTaddrPtr.pointee.address),
+            gapPosition: singleUseTaddrPtr.pointee.gap_position,
+            gapLimit: singleUseTaddrPtr.pointee.gap_limit
+        )
+    }
 }
 
 private extension ZcashRustBackend {
@@ -958,7 +1324,94 @@ extension String {
     }
 }
 
+extension FfiAddress {
+    /// converts an [`FfiAddress`] into a [`UnifiedAddress`]
+    /// - Note: This does not check that the converted value actually holds a valid UnifiedAddress
+    func unsafeToUnifiedAddress(_ networkType: NetworkType) -> UnifiedAddress {
+        .init(validatedEncoding: String(cString: address), networkType: networkType)
+    }
+}
+
+extension FfiAccount {
+    var uuidArray: [UInt8] {
+        withUnsafeBytes(of: uuid_bytes) { buf in
+            [UInt8](buf)
+        }
+    }
+
+    var seedFingerprintArray: [UInt8] {
+        withUnsafeBytes(of: seed_fingerprint) { buf in
+            [UInt8](buf)
+        }
+    }
+
+    /// converts an [`FfiAccount`] into a [`Account`]
+    /// - Note: This does not check that the converted value actually holds a valid Account
+    func unsafeToAccount() -> Account? {
+        // Invalid UUID check
+        guard uuidArray != [UInt8](repeating: 0, count: 16) else {
+            return nil
+        }
+        
+        // Invalid ZIP 32 account index
+        if hd_account_index == UInt32.max {
+            return .init(
+                id: AccountUUID(id: uuidArray),
+                name: account_name != nil ? String(cString: account_name) : nil,
+                keySource: key_source != nil ? String(cString: key_source) : nil,
+                seedFingerprint: nil,
+                hdAccountIndex: nil,
+                ufvk: nil
+            )
+        }
+        
+        let ufvkTyped = ufvk.map { UnifiedFullViewingKey(validatedEncoding: String(cString: $0)) }
+
+        // Valid ZIP32 account index
+        return .init(
+            id: AccountUUID(id: uuidArray),
+            name: account_name != nil ? String(cString: account_name) : nil,
+            keySource: key_source != nil ? String(cString: key_source) : nil,
+            seedFingerprint: seedFingerprintArray,
+            hdAccountIndex: Zip32AccountIndex(hd_account_index),
+            ufvk: ufvkTyped
+        )
+    }
+}
+
+extension FfiBoxedSlice {
+    /// converts an [`FfiBoxedSlice`] into a [`UnifiedSpendingKey`]
+    /// - Note: This does not check that the converted value actually holds a valid USK
+    func unsafeToUnifiedSpendingKey(network: NetworkType) -> UnifiedSpendingKey {
+        .init(
+            network: network,
+            bytes: self.ptr.toByteArray(length: Int(self.len))
+        )
+    }
+}
+
+extension FfiUuid {
+    var uuidArray: [UInt8] {
+        withUnsafeBytes(of: self.uuid_bytes) { buf in
+            [UInt8](buf)
+        }
+    }
+
+    /// converts an [`FfiUuid`] into a [`AccountUUID`]
+    func unsafeToAccountUUID() -> AccountUUID {
+        .init(
+            id: self.uuidArray
+        )
+    }
+}
+
 extension FFIBinaryKey {
+    var uuidArray: [UInt8] {
+        withUnsafeBytes(of: self.account_uuid) { buf in
+            [UInt8](buf)
+        }
+    }
+
     /// converts an [`FFIBinaryKey`] into a [`UnifiedSpendingKey`]
     /// - Note: This does not check that the converted value actually holds a valid USK
     func unsafeToUnifiedSpendingKey(network: NetworkType) -> UnifiedSpendingKey {
@@ -966,8 +1419,7 @@ extension FFIBinaryKey {
             network: network,
             bytes: self.encoding.toByteArray(
                 length: Int(self.encoding_len)
-            ),
-            account: self.account_id
+            )
         )
     }
 }
@@ -1013,6 +1465,12 @@ extension FfiBalance {
 }
 
 extension FfiAccountBalance {
+    var uuidArray: [UInt8] {
+        withUnsafeBytes(of: self.account_uuid) { buf in
+            [UInt8](buf)
+        }
+    }
+
     /// Converts an [`FfiAccountBalance`] into a [`AccountBalance`].
     func toAccountBalance() -> AccountBalance {
         .init(
@@ -1033,7 +1491,7 @@ extension FfiScanProgress {
     }
 }
 
-// swiftlint:disable large_tuple line_length
+// swiftlint:disable large_tuple line_length file_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] {