Merge pull request #1527 from Electric-Coin-Company/ffi-0.13.0

FFI 0.13.0

CHANGELOG.md

@@ -6,6 +6,10 @@ and this library adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 # Unreleased
 
+## Added
+- `SDKSynchronizer.redactPCZTForSigner`: Decrease the size of a PCZT for sending to a signer.
+- `SDKSynchronizer.PCZTRequiresSaplingProofs`: Check whether the Sapling parameters are required for a given PCZT.
+
 ## Updated
 - Methods returning an array of `ZcashTransaction.Overview` try to evaluate transaction's missing blockTime. This typically applies to an expired transaction.  
 

Example/ZcashLightClientSample/ZcashLightClientSample.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -176,8 +176,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/Electric-Coin-Company/zcash-light-client-ffi",
       "state" : {
-        "revision" : "11b0db058288b12ada9c5a95ed56f17f82d2868f",
-        "version" : "0.12.0"
+        "revision" : "a2e08b26000cba7c65c69f078b32db327e13bec7",
+        "version" : "0.13.0"
       }
     }
   ],

Package.resolved

@@ -5,8 +5,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/grpc/grpc-swift.git",
       "state" : {
-        "revision" : "07123ed731671e800ab8d641006613612e954746",
-        "version" : "1.23.1"
+        "revision" : "8c5e99d0255c373e0330730d191a3423c57373fb",
+        "version" : "1.24.2"
       }
     },
     {
@@ -68,8 +68,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/apple/swift-nio-extras.git",
       "state" : {
-        "revision" : "363da63c1966405764f380c627409b2f9d9e710b",
-        "version" : "1.21.0"
+        "revision" : "2e9746cfc57554f70b650b021b6ae4738abef3e6",
+        "version" : "1.24.1"
       }
     },
     {
@@ -122,8 +122,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/Electric-Coin-Company/zcash-light-client-ffi",
       "state" : {
-        "revision" : "31a97a1478bc0354abdf208722b670f7fd3d9f8c",
-        "version" : "0.11.0"
+        "revision" : "a2e08b26000cba7c65c69f078b32db327e13bec7",
+        "version" : "0.13.0"
       }
     }
   ],

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.24.2"),
         .package(url: "https://github.com/stephencelis/SQLite.swift.git", from: "0.15.3"),
-        .package(url: "https://github.com/Electric-Coin-Company/zcash-light-client-ffi", exact: "0.12.0")
+        .package(url: "https://github.com/Electric-Coin-Company/zcash-light-client-ffi", exact: "0.13.0")
     ],
     targets: [
         .target(

Sources/ZcashLightClientKit/Account/AccountMetadataKey.swift

@@ -0,0 +1,96 @@
+//
+//  AccountMetadataKey.swift
+//  ZcashLightClientKit
+//
+//  Created by Jack Grigg on 25/02/2025.
+//
+
+import Foundation
+import libzcashlc
+
+/// A ZIP 325 Account Metadata Key.
+public class AccountMetadataKey {
+    private let accountMetadataKeyPtr: OpaquePointer
+    private let networkType: NetworkType
+
+    /// Derives a ZIP 325 Account Metadata Key from the given seed.
+    init(
+        from seed: [UInt8],
+        accountIndex: Zip32AccountIndex,
+        networkType: NetworkType
+    ) async throws {
+        let accountMetadataKeyPtr = seed.withUnsafeBufferPointer { seedBufferPtr in
+            return zcashlc_derive_account_metadata_key(
+                seedBufferPtr.baseAddress,
+                UInt(seed.count),
+                LCZip32Index(accountIndex.index),
+                networkType.networkId
+            )
+        }
+
+        guard let accountMetadataKeyPtr else {
+            throw ZcashError.rustDeriveAccountMetadataKey(lastErrorMessage(fallback: "`deriveAccountMetadataKey` failed with unknown error"))
+        }
+
+        self.accountMetadataKeyPtr = accountMetadataKeyPtr
+        self.networkType = networkType
+    }
+
+    deinit {
+        zcashlc_free_account_metadata_key(accountMetadataKeyPtr)
+    }
+
+    /// Derives a metadata key for private use from this ZIP 325 Account Metadata Key.
+    ///
+    /// - Parameter ufvk: the external UFVK for which a metadata key is required, or `null` if the
+    ///   metadata key is "inherent" (for the same account as the Account Metadata Key).
+    /// - Parameter privateUseSubject: a globally unique non-empty sequence of at most 252 bytes
+    ///   that identifies the desired private-use context.
+    ///
+    /// If `ufvk` is null, this function will return a single 32-byte metadata key.
+    ///
+    /// If `ufvk` is non-null, this function will return one metadata key for every FVK item
+    /// contained within the UFVK, in preference order. As UFVKs may in general change over
+    /// time (due to the inclusion of new higher-preference FVK items, or removal of older
+    /// deprecated FVK items), private usage of these keys should always follow preference
+    /// order:
+    /// - For encryption-like private usage, the first key in the array should always be
+    ///   used, and all other keys ignored.
+    /// - For decryption-like private usage, each key in the array should be tried in turn
+    ///   until metadata can be recovered, and then the metadata should be re-encrypted
+    ///   under the first key.
+    public func derivePrivateUseMetadataKey(
+        ufvk: String?,
+        privateUseSubject: [UInt8]
+    ) async throws -> [Data] {
+        var kSource: [CChar]?
+        if let ufvk {
+            kSource = [CChar](ufvk.utf8CString)
+        }
+
+        let keysPtr = privateUseSubject.withUnsafeBufferPointer { privateUseSubjectBufferPtr in
+            return zcashlc_derive_private_use_metadata_key(
+                accountMetadataKeyPtr,
+                kSource,
+                privateUseSubjectBufferPtr.baseAddress,
+                UInt(privateUseSubject.count),
+                networkType.networkId
+            )
+        }
+
+        guard let keysPtr else {
+            throw ZcashError.rustDerivePrivateUseMetadataKey(lastErrorMessage(fallback: "`derivePrivateUseMetadataKey` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_txids(keysPtr) }
+
+        var keys: [Data] = []
+
+        for i in (0 ..< Int(keysPtr.pointee.len)) {
+            let txId = FfiTxId(tuple: keysPtr.pointee.ptr.advanced(by: i).pointee)
+            keys.append(Data(txId.array))
+        }
+
+        return keys
+    }
+}

Sources/ZcashLightClientKit/ClosureSynchronizer.swift

@@ -100,7 +100,17 @@ public protocol ClosureSynchronizer {
         proposal: Proposal,
         completion: @escaping (Result<Pczt, Error>) -> Void
     )
-    
+
+    func redactPCZTForSigner(
+        pczt: Pczt,
+        completion: @escaping (Result<Pczt, Error>) -> Void
+    )
+
+    func PCZTRequiresSaplingProofs(
+        pczt: Pczt,
+        completion: @escaping (Bool) -> Void
+    )
+
     func addProofsToPCZT(
         pczt: Pczt,
         completion: @escaping (Result<Pczt, Error>) -> Void

Sources/ZcashLightClientKit/CombineSynchronizer.swift

@@ -96,6 +96,14 @@ public protocol CombineSynchronizer {
         proposal: Proposal
     ) -> SinglePublisher<Pczt, Error>
 
+    func redactPCZTForSigner(
+        pczt: Pczt
+    ) -> SinglePublisher<Pczt, Error>
+
+    func PCZTRequiresSaplingProofs(
+        pczt: Pczt
+    ) -> SinglePublisher<Bool, Never>
+
     func addProofsToPCZT(
         pczt: Pczt
     ) -> SinglePublisher<Pczt, Error>

Sources/ZcashLightClientKit/Error/Sourcery/generateErrorCode.sh

@@ -3,7 +3,7 @@
 scriptDir=${0:a:h}
 cd "${scriptDir}"
 
-sourcery_version=2.2.5
+sourcery_version=2.2.6
 
 if which sourcery >/dev/null; then
     if [[ $(sourcery --version) != $sourcery_version ]]; then

Sources/ZcashLightClientKit/Error/ZcashError.swift

@@ -1,4 +1,4 @@
-// Generated using Sourcery 2.2.5 — https://github.com/krzysztofzablocki/Sourcery
+// Generated using Sourcery 2.2.6 — https://github.com/krzysztofzablocki/Sourcery
 // DO NOT EDIT
 
 /*
@@ -392,6 +392,34 @@ public enum ZcashError: Equatable, Error {
     /// - `rustError` contains error generated by the rust layer.
     /// ZRUST0073
     case rustTxidPtrIncorrectLength(_ rustError: String)
+    /// Error from rust layer when calling ZcashRustBackend.redactPCZTForSigner
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0074
+    case rustRedactPCZTForSigner(_ rustError: String)
+    /// Error from rust layer when calling AccountMetadatKey.init with a seed.
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0075
+    case rustDeriveAccountMetadataKey(_ rustError: String)
+    /// Error from rust layer when calling AccountMetadatKey.derivePrivateUseMetadataKey
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0076
+    case rustDerivePrivateUseMetadataKey(_ rustError: String)
+    /// Error from rust layer when calling TorClient.isolatedClient
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0077
+    case rustTorIsolatedClient(_ rustError: String)
+    /// Error from rust layer when calling TorClient.connectToLightwalletd
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0078
+    case rustTorConnectToLightwalletd(_ rustError: String)
+    /// Error from rust layer when calling TorLwdConn.fetchTransaction
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0079
+    case rustTorLwdFetchTransaction(_ rustError: String)
+    /// Error from rust layer when calling TorLwdConn.submit
+    /// - `rustError` contains error generated by the rust layer.
+    /// ZRUST0080
+    case rustTorLwdSubmit(_ rustError: String)
     /// SQLite query failed when fetching all accounts from the database.
     /// - `sqliteError` is error produced by SQLite library.
     /// ZADAO0001
@@ -767,6 +795,13 @@ public enum ZcashError: Equatable, Error {
         case .rustExtractAndStoreTxFromPCZT: return "Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT"
         case .rustUUIDAccountNotFound: return "Error from rust layer when calling ZcashRustBackend.getAccount"
         case .rustTxidPtrIncorrectLength: return "Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT"
+        case .rustRedactPCZTForSigner: return "Error from rust layer when calling ZcashRustBackend.redactPCZTForSigner"
+        case .rustDeriveAccountMetadataKey: return "Error from rust layer when calling AccountMetadatKey.init with a seed."
+        case .rustDerivePrivateUseMetadataKey: return "Error from rust layer when calling AccountMetadatKey.derivePrivateUseMetadataKey"
+        case .rustTorIsolatedClient: return "Error from rust layer when calling TorClient.isolatedClient"
+        case .rustTorConnectToLightwalletd: return "Error from rust layer when calling TorClient.connectToLightwalletd"
+        case .rustTorLwdFetchTransaction: return "Error from rust layer when calling TorLwdConn.fetchTransaction"
+        case .rustTorLwdSubmit: return "Error from rust layer when calling TorLwdConn.submit"
         case .accountDAOGetAll: return "SQLite query failed when fetching all accounts from the database."
         case .accountDAOGetAllCantDecode: return "Fetched accounts from SQLite but can't decode them."
         case .accountDAOFindBy: return "SQLite query failed when seaching for accounts in the database."
@@ -959,6 +994,13 @@ public enum ZcashError: Equatable, Error {
         case .rustExtractAndStoreTxFromPCZT: return .rustExtractAndStoreTxFromPCZT
         case .rustUUIDAccountNotFound: return .rustUUIDAccountNotFound
         case .rustTxidPtrIncorrectLength: return .rustTxidPtrIncorrectLength
+        case .rustRedactPCZTForSigner: return .rustRedactPCZTForSigner
+        case .rustDeriveAccountMetadataKey: return .rustDeriveAccountMetadataKey
+        case .rustDerivePrivateUseMetadataKey: return .rustDerivePrivateUseMetadataKey
+        case .rustTorIsolatedClient: return .rustTorIsolatedClient
+        case .rustTorConnectToLightwalletd: return .rustTorConnectToLightwalletd
+        case .rustTorLwdFetchTransaction: return .rustTorLwdFetchTransaction
+        case .rustTorLwdSubmit: return .rustTorLwdSubmit
         case .accountDAOGetAll: return .accountDAOGetAll
         case .accountDAOGetAllCantDecode: return .accountDAOGetAllCantDecode
         case .accountDAOFindBy: return .accountDAOFindBy

Sources/ZcashLightClientKit/Error/ZcashErrorCode.swift

@@ -1,4 +1,4 @@
-// Generated using Sourcery 2.2.5 — https://github.com/krzysztofzablocki/Sourcery
+// Generated using Sourcery 2.2.6 — https://github.com/krzysztofzablocki/Sourcery
 // DO NOT EDIT
 
 /*
@@ -209,6 +209,20 @@ public enum ZcashErrorCode: String {
     case rustUUIDAccountNotFound = "ZRUST0072"
     /// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
     case rustTxidPtrIncorrectLength = "ZRUST0073"
+    /// Error from rust layer when calling ZcashRustBackend.redactPCZTForSigner
+    case rustRedactPCZTForSigner = "ZRUST0074"
+    /// Error from rust layer when calling AccountMetadatKey.init with a seed.
+    case rustDeriveAccountMetadataKey = "ZRUST0075"
+    /// Error from rust layer when calling AccountMetadatKey.derivePrivateUseMetadataKey
+    case rustDerivePrivateUseMetadataKey = "ZRUST0076"
+    /// Error from rust layer when calling TorClient.isolatedClient
+    case rustTorIsolatedClient = "ZRUST0077"
+    /// Error from rust layer when calling TorClient.connectToLightwalletd
+    case rustTorConnectToLightwalletd = "ZRUST0078"
+    /// Error from rust layer when calling TorLwdConn.fetchTransaction
+    case rustTorLwdFetchTransaction = "ZRUST0079"
+    /// Error from rust layer when calling TorLwdConn.submit
+    case rustTorLwdSubmit = "ZRUST0080"
     /// SQLite query failed when fetching all accounts from the database.
     case accountDAOGetAll = "ZADAO0001"
     /// Fetched accounts from SQLite but can't decode them.

Sources/ZcashLightClientKit/Error/ZcashErrorCodeDefinition.swift

@@ -414,6 +414,34 @@ enum ZcashErrorDefinition {
     /// - `rustError` contains error generated by the rust layer.
     // sourcery: code="ZRUST0073"
     case rustTxidPtrIncorrectLength(_ rustError: String)
+    /// Error from rust layer when calling ZcashRustBackend.redactPCZTForSigner
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0074"
+    case rustRedactPCZTForSigner(_ rustError: String)
+    /// Error from rust layer when calling AccountMetadatKey.init with a seed.
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0075"
+    case rustDeriveAccountMetadataKey(_ rustError: String)
+    /// Error from rust layer when calling AccountMetadatKey.derivePrivateUseMetadataKey
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0076"
+    case rustDerivePrivateUseMetadataKey(_ rustError: String)
+    /// Error from rust layer when calling TorClient.isolatedClient
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0077"
+    case rustTorIsolatedClient(_ rustError: String)
+    /// Error from rust layer when calling TorClient.connectToLightwalletd
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0078"
+    case rustTorConnectToLightwalletd(_ rustError: String)
+    /// Error from rust layer when calling TorLwdConn.fetchTransaction
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0079"
+    case rustTorLwdFetchTransaction(_ rustError: String)
+    /// Error from rust layer when calling TorLwdConn.submit
+    /// - `rustError` contains error generated by the rust layer.
+    // sourcery: code="ZRUST0080"
+    case rustTorLwdSubmit(_ rustError: String)
 
     // MARK: - Account DAO
 

Sources/ZcashLightClientKit/Initializer.swift

@@ -40,6 +40,11 @@ public struct LightWalletEndpoint {
         self.singleCallTimeoutInMillis = singleCallTimeoutInMillis
         self.streamingCallTimeoutInMillis = streamingCallTimeoutInMillis
     }
+
+    var urlString: String {
+        return String(
+            format: "%@://%@:%d", secure ? "https" : "http", host, port)
+    }
 }
 
 /// This contains URLs from which can the SDK fetch files that contain sapling parameters.

Sources/ZcashLightClientKit/Model/WalletTypes.swift

@@ -16,6 +16,7 @@ public struct Account: Equatable, Hashable, Codable, Identifiable {
     public let keySource: String?
     public let seedFingerprint: [UInt8]?
     public let hdAccountIndex: Zip32AccountIndex?
+    public let ufvk: UnifiedFullViewingKey?
 }
 
 public struct UnifiedSpendingKey: Equatable, Undescribable {
@@ -50,7 +51,7 @@ public struct TransparentAccountPrivKey: Equatable, Undescribable {
 }
 
 /// A ZIP 316 Unified Full Viewing Key.
-public struct UnifiedFullViewingKey: Equatable, StringEncoded, Undescribable {
+public struct UnifiedFullViewingKey: Equatable, StringEncoded, Undescribable, Hashable, Codable {
     let encoding: String
 
     public var stringEncoded: String { encoding }

Sources/ZcashLightClientKit/Rust/ZcashRustBackend.swift

@@ -325,7 +325,48 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
             count: Int(pcztPtr.pointee.len)
         )
     }
-    
+
+    @DBActor
+    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)
+        )
+    }
+
+    @DBActor
+    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)
+            )
+        }
+    }
+
     @DBActor
     func addProofsToPCZT(
         pczt: Pczt
@@ -1184,17 +1225,21 @@ extension FfiAccount {
                 name: account_name != nil ? String(cString: account_name) : nil,
                 keySource: key_source != nil ? String(cString: key_source) : nil,
                 seedFingerprint: nil,
-                hdAccountIndex: 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)
+            hdAccountIndex: Zip32AccountIndex(hd_account_index),
+            ufvk: ufvkTyped
         )
     }
 }

Sources/ZcashLightClientKit/Rust/ZcashRustBackendWelding.swift

@@ -303,7 +303,23 @@ protocol ZcashRustBackendWelding {
     ///
     /// - Throws rustCreatePCZTFromProposal as a common indicator of the operation failure
     func createPCZTFromProposal(accountUUID: AccountUUID, proposal: FfiProposal) async throws -> Pczt
-    
+
+    /// Redacts information from the given PCZT that is unnecessary for the Signer role.
+    ///
+    /// - Parameter pczt: The partially created transaction in its serialized format.
+    ///
+    /// - Returns The updated PCZT in its serialized format.
+    ///
+    /// - Throws  rustRedactPCZTForSigner as a common indicator of the operation failure
+    func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt
+
+    /// Checks whether the caller needs to have downloaded the Sapling parameters.
+    ///
+    /// - Parameter pczt: The partially created transaction in its serialized format.
+    ///
+    /// - Returns `true` if this PCZT requires Sapling proofs.
+    func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool
+
     /// Adds proofs to the given PCZT.
     ///
     /// - Parameter pczt: The partially created transaction in its serialized format.

Sources/ZcashLightClientKit/Synchronizer.swift

@@ -239,6 +239,22 @@ public protocol Synchronizer: AnyObject {
     /// - Throws rustCreatePCZTFromProposal as a common indicator of the operation failure
     func createPCZTFromProposal(accountUUID: AccountUUID, proposal: Proposal) async throws -> Pczt
 
+    /// Redacts information from the given PCZT that is unnecessary for the Signer role.
+    ///
+    /// - Parameter pczt: The partially created transaction in its serialized format.
+    ///
+    /// - Returns The updated PCZT in its serialized format.
+    ///
+    /// - Throws  rustRedactPCZTForSigner as a common indicator of the operation failure
+    func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt
+
+    /// Checks whether the caller needs to have downloaded the Sapling parameters.
+    ///
+    /// - Parameter pczt: The partially created transaction in its serialized format.
+    ///
+    /// - Returns `true` if this PCZT requires Sapling proofs.
+    func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool
+
     /// Adds proofs to the given PCZT.
     ///
     /// - Parameter pczt: The partially created transaction in its serialized format.

Sources/ZcashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift

@@ -155,6 +155,24 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
+    public func redactPCZTForSigner(
+        pczt: Pczt,
+        completion: @escaping (Result<Pczt, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.redactPCZTForSigner(pczt: pczt)
+        }
+    }
+
+    public func PCZTRequiresSaplingProofs(
+        pczt: Pczt,
+        completion: @escaping (Bool) -> Void
+    ) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.PCZTRequiresSaplingProofs(pczt: pczt)
+        }
+    }
+
     public func addProofsToPCZT(
         pczt: Pczt,
         completion: @escaping (Result<Pczt, Error>) -> Void

Sources/ZcashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift

@@ -134,6 +134,22 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
+    public func redactPCZTForSigner(
+        pczt: Pczt
+    ) -> SinglePublisher<Pczt, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.redactPCZTForSigner(pczt: pczt)
+        }
+    }
+
+    public func PCZTRequiresSaplingProofs(
+        pczt: Pczt
+    ) -> SinglePublisher<Bool, Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.PCZTRequiresSaplingProofs(pczt: pczt)
+        }
+    }
+
     public func addProofsToPCZT(
         pczt: Pczt
     ) -> SinglePublisher<Pczt, Error> {

Sources/ZcashLightClientKit/Synchronizer/SDKSynchronizer.swift

@@ -414,7 +414,19 @@ public class SDKSynchronizer: Synchronizer {
             proposal: proposal.inner
         )
     }
-    
+
+    public func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt {
+        try await initializer.rustBackend.redactPCZTForSigner(
+            pczt: pczt
+        )
+    }
+
+    public func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool {
+        await initializer.rustBackend.PCZTRequiresSaplingProofs(
+            pczt: pczt
+        )
+    }
+
     public func addProofsToPCZT(pczt: Pczt) async throws -> Pczt {
         try await initializer.rustBackend.addProofsToPCZT(
             pczt: pczt

Sources/ZcashLightClientKit/Tor/TorClient.swift

@@ -33,10 +33,27 @@ public class TorClient {
         runtime = runtimePtr
     }
 
+    private init(runtimePtr: OpaquePointer) {
+        runtime = runtimePtr
+    }
+
     deinit {
         zcashlc_free_tor_runtime(runtime)
     }
 
+    public func isolatedClient() async throws -> TorClient {
+        let isolatedPtr = zcashlc_tor_isolated_client(runtime)
+
+        guard let isolatedPtr else {
+            throw ZcashError.rustTorIsolatedClient(
+                lastErrorMessage(
+                    fallback:
+                        "`TorClient.isolatedClient` failed with unknown error"))
+        }
+
+        return TorClient(runtimePtr: isolatedPtr)
+    }
+
     public func getExchangeRateUSD() async throws -> FiatCurrencyResult {
         let rate = zcashlc_get_exchange_rate_usd(runtime)
 
@@ -46,12 +63,126 @@ public class TorClient {
 
         let newValue = FiatCurrencyResult(
             date: Date(),
-            rate: NSDecimalNumber(mantissa: rate.mantissa, exponent: rate.exponent, isNegative: rate.is_sign_negative),
+            rate: NSDecimalNumber(
+                mantissa: rate.mantissa, exponent: rate.exponent,
+                isNegative: rate.is_sign_negative),
             state: .success
         )
-        
+
         cachedFiatCurrencyResult = newValue
-        
+
         return newValue
     }
+
+    public func connectToLightwalletd(endpoint: String) async throws
+        -> TorLwdConn
+    {
+        guard !endpoint.containsCStringNullBytesBeforeStringEnding() else {
+            throw ZcashError.rustTorConnectToLightwalletd(
+                "endpoint string contains null bytes")
+        }
+
+        let lwdConnPtr = zcashlc_tor_connect_to_lightwalletd(
+            runtime, [CChar](endpoint.utf8CString))
+
+        guard let lwdConnPtr else {
+            throw ZcashError.rustTorConnectToLightwalletd(
+                lastErrorMessage(
+                    fallback:
+                        "`TorClient.connectToLightwalletd` failed with unknown error"
+                ))
+        }
+
+        return TorLwdConn(connPtr: lwdConnPtr)
+    }
+}
+
+public class TorLwdConn {
+    private let conn: OpaquePointer
+
+    fileprivate init(connPtr: OpaquePointer) {
+        conn = connPtr
+    }
+
+    deinit {
+        zcashlc_free_tor_lwd_conn(conn)
+    }
+
+    /// Submits a raw transaction over lightwalletd.
+    /// - Parameter spendTransaction: data representing the transaction to be sent
+    /// - Throws: `serviceSubmitFailed` when GRPC call fails.
+    func submit(spendTransaction: Data) async throws
+        -> LightWalletServiceResponse
+    {
+        let success = zcashlc_tor_lwd_conn_submit_transaction(
+            conn,
+            spendTransaction.bytes,
+            UInt(spendTransaction.count)
+        )
+
+        var response = SendResponse()
+        if !success {
+            let err = lastErrorMessage(
+                fallback: "`TorLwdConn.submit` failed with unknown error")
+            if err.hasPrefix("Failed to submit transaction (")
+                && err.contains(")")
+            {
+                let startOfCode = err.firstIndex(of: "(")!
+                let endOfCode = err.firstIndex(of: ")")!
+                let errorCode = Int32(
+                    err[err.index(startOfCode, offsetBy: 1)..<endOfCode])!
+                let errorMessage = String(
+                    err[err.index(endOfCode, offsetBy: 3)...])
+
+                response.errorCode = errorCode
+                response.errorMessage = errorMessage
+            } else {
+                throw ZcashError.rustTorLwdSubmit(err)
+            }
+        }
+        return response
+    }
+
+    /// Gets a transaction by id
+    /// - Parameter txId: data representing the transaction ID
+    /// - Throws: LightWalletServiceError
+    /// - Returns: LightWalletServiceResponse
+    /// - Throws: `serviceFetchTransactionFailed` when GRPC call fails.
+    func fetchTransaction(txId: Data) async throws -> (
+        tx: ZcashTransaction.Fetched?, status: TransactionStatus
+    ) {
+        guard txId.count == 32 else {
+            throw ZcashError.rustGetMemoInvalidTxIdLength
+        }
+
+        var height: UInt64 = 0
+
+        let txPtr = zcashlc_tor_lwd_conn_fetch_transaction(
+            conn, txId.bytes, &height)
+
+        guard let txPtr else {
+            throw ZcashError.rustTorLwdFetchTransaction(
+                lastErrorMessage(
+                    fallback:
+                        "`TorLwdConn.fetchTransaction` failed with unknown error")
+            )
+        }
+
+        defer { zcashlc_free_boxed_slice(txPtr) }
+
+        let isNotMined = height == 0 || height > UInt32.max
+
+        return (
+            tx:
+                ZcashTransaction.Fetched(
+                    rawID: txId,
+                    minedHeight: isNotMined ? nil : UInt32(height),
+                    raw: Data(
+                        bytes: txPtr.pointee.ptr,
+                        count: Int(txPtr.pointee.len)
+                    )
+                ),
+            status: isNotMined ? .notInMainChain : .mined(Int(height))
+        )
+    }
 }

Tests/NetworkTests/TorClientTests.swift

@@ -0,0 +1,40 @@
+//
+//  TorClientTests.swift
+//  ZcashLightClientKit
+//
+//  Created by Jack Grigg on 27/02/2025.
+//
+
+import GRPC
+import XCTest
+
+@testable import TestUtils
+@testable import ZcashLightClientKit
+
+class TorClientTests: ZcashTestCase {
+    let network: ZcashNetwork = ZcashNetworkBuilder.network(for: .testnet)
+
+    func testLwdCanFetchAndSubmitTx() async throws {
+        // Spin up a new Tor client.
+        let client = try await TorClient(torDir: testTempDirectory)
+
+        // Connect to a testnet lightwalletd server.
+        let lwdConn = try await client.connectToLightwalletd(
+            endpoint: LightWalletEndpointBuilder.publicTestnet.urlString)
+
+        // Fetch a known testnet transaction.
+        let txId =
+            "9e309d29a99f06e6dcc7aee91dca23c0efc2cf5083cc483463ddbee19c1fadf1"
+            .toTxIdString().hexadecimal!
+        let (tx, status) = try await lwdConn.fetchTransaction(txId: txId)
+        XCTAssertEqual(status, .mined(1_234_567))
+
+        // We should fail to resubmit the already-mined transaction.
+        let result = try await lwdConn.submit(spendTransaction: tx!.raw)
+        XCTAssertEqual(result.errorCode, -25)
+        XCTAssertEqual(
+            result.errorMessage,
+            "failed to validate tx: transaction::Hash(\"private\"), error: transaction is already in state"
+        )
+    }
+}

Tests/OfflineTests/Zip325Tests.swift

@@ -0,0 +1,81 @@
+//
+//  Zip325Tests.swift
+//  ZcashLightClientKit
+//
+//  Created by Jack Grigg on 25/02/2025.
+//
+
+import XCTest
+@testable import ZcashLightClientKit
+
+class Zip325Tests: XCTestCase {
+    let seedBytes: [UInt8] = [
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
+    ]
+    let privateUseSubject: [UInt8] = [UInt8]("Zip325TestVectors".utf8)
+
+    let ufvk = UnifiedFullViewingKey(
+        validatedEncoding: """
+        uview1cgrqnry478ckvpr0f580t6fsahp0a5mj2e9xl7hv2d2jd4ldzy449mwwk2l9yeuts85wjls6hjtghdsy5vhhvmjdw3jxl3cxhrg3vs296a3czazrycrr5cywjhwc5c3ztfyjdhm\
+        z0exvzzeyejamyp0cr9z8f9wj0953fzht0m4lenk94t70ruwgjxag2tvp63wn9ftzhtkh20gyre3w5s24f6wlgqxnjh40gd2lxe75sf3z8h5y2x0atpxcyf9t3em4h0evvsftluruqne6\
+        w4sm066sw0qe5y8qg423grple5fftxrqyy7xmqmatv7nzd7tcjadu8f7mqz4l83jsyxy4t8pkayytyk7nrp467ds85knekdkvnd7hqkfer8mnqd7pv
+        """
+    )
+
+    func testInherentKeyDerivation() async throws {
+        // From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/zip_0325.py
+        let tvs = [
+            "d88239020bcc64d08282cd3d242cc12be207eb7154b1065fbeaf262dc4cbc94f",
+            "3bf2fd2bfcead493ae3a1e2b6c5dedc3f4c4a6129ef23699ca8e2015da557728",
+            "a73ffccd70c8c7c7bc47ac555512e8ffdc41e02f32716372f46dbf5a4e207aa2",
+            "e237eb4cceb983cc8703996a63668bacb2208289e49dc863fa96feb402bf7b42",
+        ]
+
+        for account in 0..<4 {
+            let accountMetadataKey = try await AccountMetadataKey(from: seedBytes, accountIndex: Zip32AccountIndex(UInt32(account)), networkType: .mainnet)
+            let keys = try await accountMetadataKey.derivePrivateUseMetadataKey(ufvk: nil, privateUseSubject: privateUseSubject)
+
+            // Inherent metadata keys are unique per account.
+            XCTAssertEqual(keys.count, 1)
+            XCTAssertEqual(keys[0].hexEncodedString(), tvs[account])
+        }
+    }
+
+    func testImportedUFVKKeyDerivation() async throws {
+        // From https://github.com/zcash-hackworks/zcash-test-vectors/blob/master/zip_0325.py
+        let tvs = [
+            [
+                "02f6dfb0096dad5401a8fa7e371c1b4838341673cc7010a66b17ddb68a851e4f",
+                "f4cd290baf093e9454de5f5cb75ce049102951348f60c666f393c915f23d0310",
+                "dfd34cabdc9afc4ac8ed0b631b109e5ff80824b80c12ecb2892080222d970e43",
+            ],
+            [
+                "b24ebfefc04f4eb98ac7c5beecf7a3ab1474a97ac7b3c7d857a23afea547caaf",
+                "fa07cfc2c7ed10d173f7e28f4d601595facd41072e72f6e5936a1440c9cbc7df",
+                "b34929a3f05af8a5ab16ad94708f031c08217b8369f35d125e7fcdfec56ea1bb",
+            ],
+            [
+                "ebf59396fb27862406b1984309d4784eedf14cb28c969344eabec1c300160da5",
+                "dd39129515151a8e77d280d1e8513fd091eec6c9cce5ce0096fdfc60d8d3f204",
+                "32650eb08e10b17ae37f9d82680e4d83cad25150061a3910a82bc72e25cda568",
+            ],
+            [
+                "6a4124096c38b0132da7fb94c199df4156d804a3589e46f33395c1d0e358e9f0",
+                "d9ef369e616a31e8c40996cc625c352f2cf9815f5119a4edad6562165c8b727a",
+                "9d83e6d209792bd5796f2d0fe19ceb18bfdfec3d09ad0386ed27339a1e7f8501",
+            ],
+        ]
+
+        for account in 0..<1 {
+            let accountMetadataKey = try await AccountMetadataKey(from: seedBytes, accountIndex: Zip32AccountIndex(UInt32(account)), networkType: .mainnet)
+            let keys = try await accountMetadataKey.derivePrivateUseMetadataKey(ufvk: ufvk.stringEncoded, privateUseSubject: privateUseSubject)
+
+            // UFVK has Orchard, transparent, and unknown FVK items.
+            XCTAssertEqual(keys.count, 3)
+
+            for i in 0..<3 {
+                XCTAssertEqual(keys[i].hexEncodedString(), tvs[account][i])
+            }
+        }
+    }
+}

Tests/TestUtils/Sourcery/GeneratedMocks/AutoMockable.generated.swift

@@ -1,4 +1,4 @@
-// Generated using Sourcery 2.2.5 — https://github.com/krzysztofzablocki/Sourcery
+// Generated using Sourcery 2.2.6 — https://github.com/krzysztofzablocki/Sourcery
 // DO NOT EDIT
 import Combine
 @testable import ZcashLightClientKit
@@ -1596,6 +1596,50 @@ class SynchronizerMock: Synchronizer {
         }
     }
 
+    // MARK: - redactPCZTForSigner
+
+    var redactPCZTForSignerPcztThrowableError: Error?
+    var redactPCZTForSignerPcztCallsCount = 0
+    var redactPCZTForSignerPcztCalled: Bool {
+        return redactPCZTForSignerPcztCallsCount > 0
+    }
+    var redactPCZTForSignerPcztReceivedPczt: Pczt?
+    var redactPCZTForSignerPcztReturnValue: Pczt!
+    var redactPCZTForSignerPcztClosure: ((Pczt) async throws -> Pczt)?
+
+    func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt {
+        if let error = redactPCZTForSignerPcztThrowableError {
+            throw error
+        }
+        redactPCZTForSignerPcztCallsCount += 1
+        redactPCZTForSignerPcztReceivedPczt = pczt
+        if let closure = redactPCZTForSignerPcztClosure {
+            return try await closure(pczt)
+        } else {
+            return redactPCZTForSignerPcztReturnValue
+        }
+    }
+
+    // MARK: - PCZTRequiresSaplingProofs
+
+    var pcztRequiresSaplingProofsPcztCallsCount = 0
+    var pcztRequiresSaplingProofsPcztCalled: Bool {
+        return pcztRequiresSaplingProofsPcztCallsCount > 0
+    }
+    var pcztRequiresSaplingProofsPcztReceivedPczt: Pczt?
+    var pcztRequiresSaplingProofsPcztReturnValue: Bool!
+    var pcztRequiresSaplingProofsPcztClosure: ((Pczt) async -> Bool)?
+
+    func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool {
+        pcztRequiresSaplingProofsPcztCallsCount += 1
+        pcztRequiresSaplingProofsPcztReceivedPczt = pczt
+        if let closure = pcztRequiresSaplingProofsPcztClosure {
+            return await closure(pczt)
+        } else {
+            return pcztRequiresSaplingProofsPcztReturnValue
+        }
+    }
+
     // MARK: - addProofsToPCZT
 
     var addProofsToPCZTPcztThrowableError: Error?
@@ -3166,6 +3210,50 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
         }
     }
 
+    // MARK: - redactPCZTForSigner
+
+    var redactPCZTForSignerPcztThrowableError: Error?
+    var redactPCZTForSignerPcztCallsCount = 0
+    var redactPCZTForSignerPcztCalled: Bool {
+        return redactPCZTForSignerPcztCallsCount > 0
+    }
+    var redactPCZTForSignerPcztReceivedPczt: Pczt?
+    var redactPCZTForSignerPcztReturnValue: Pczt!
+    var redactPCZTForSignerPcztClosure: ((Pczt) async throws -> Pczt)?
+
+    func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt {
+        if let error = redactPCZTForSignerPcztThrowableError {
+            throw error
+        }
+        redactPCZTForSignerPcztCallsCount += 1
+        redactPCZTForSignerPcztReceivedPczt = pczt
+        if let closure = redactPCZTForSignerPcztClosure {
+            return try await closure(pczt)
+        } else {
+            return redactPCZTForSignerPcztReturnValue
+        }
+    }
+
+    // MARK: - PCZTRequiresSaplingProofs
+
+    var pcztRequiresSaplingProofsPcztCallsCount = 0
+    var pcztRequiresSaplingProofsPcztCalled: Bool {
+        return pcztRequiresSaplingProofsPcztCallsCount > 0
+    }
+    var pcztRequiresSaplingProofsPcztReceivedPczt: Pczt?
+    var pcztRequiresSaplingProofsPcztReturnValue: Bool!
+    var pcztRequiresSaplingProofsPcztClosure: ((Pczt) async -> Bool)?
+
+    func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool {
+        pcztRequiresSaplingProofsPcztCallsCount += 1
+        pcztRequiresSaplingProofsPcztReceivedPczt = pczt
+        if let closure = pcztRequiresSaplingProofsPcztClosure {
+            return await closure(pczt)
+        } else {
+            return pcztRequiresSaplingProofsPcztReturnValue
+        }
+    }
+
     // MARK: - addProofsToPCZT
 
     var addProofsToPCZTPcztThrowableError: Error?

Tests/TestUtils/Sourcery/generateMocks.sh

@@ -3,7 +3,7 @@
 scriptDir=${0:a:h}
 cd "${scriptDir}"
 
-sourcery_version=2.2.5
+sourcery_version=2.2.6
 
 if which sourcery >/dev/null; then
     if [[ $(sourcery --version) != $sourcery_version ]]; then

Tests/TestUtils/Tests+Utils.swift

@@ -50,7 +50,7 @@ enum LightWalletEndpointBuilder {
     }
     
     static var publicTestnet: LightWalletEndpoint {
-        LightWalletEndpoint(address: "testnet.lightwalletd.com", port: 9067, secure: true)
+        LightWalletEndpoint(address: "testnet.zec.rocks", port: 443, secure: true)
     }
     
     static var eccTestnet: LightWalletEndpoint {