react-native-zcash 0.9.13 → 0.10.0

package/ios/ZCashLightClientKit/Rust/ZcashRustBackendWelding.swift

@@ -8,6 +8,8 @@
 
 import Foundation
 
+typealias LCZip32Index = Int32
+
 enum ZcashRustBackendWeldingConstants {
     static let validChain: Int32 = -1
 }
@@ -34,7 +36,28 @@ public enum RewindResult {
 
 protocol ZcashRustBackendWelding {
     /// Returns a list of the accounts in the wallet.
-    func listAccounts() async throws -> [Int32]
+    func listAccounts() async throws -> [Account]
+
+    /// Adds a new account to the wallet by importing the UFVK that will be used to detect incoming
+    /// payments.
+    ///
+    /// Derivation metadata may optionally be included. To indicate that no derivation metadata is
+    /// available, `seedFingerprint` and `zip32AccountIndex` should be set to `nil`. Derivation
+    /// metadata will not be stored unless both the seed fingerprint and the HD account index are
+    /// provided.
+    ///
+    /// - Returns: the globally unique identifier for the account.
+    // swiftlint:disable:next function_parameter_count
+    func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        treeState: TreeState,
+        recoverUntil: UInt32?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> AccountUUID
 
     /// Adds the next available account-level spend authority, given the current set of [ZIP 316]
     /// account identifiers known, to the wallet database.
@@ -55,7 +78,13 @@ protocol ZcashRustBackendWelding {
     /// - parameter recoverUntil: the fully-scanned height up to which the account will be treated as "being recovered"
     /// - Returns: The `UnifiedSpendingKey` structs for the number of accounts created
     /// - Throws: `rustCreateAccount`.
-    func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey
+    func createAccount(
+        seed: [UInt8],
+        treeState: TreeState,
+        recoverUntil: UInt32?,
+        name: String,
+        keySource: String?
+    ) async throws -> UnifiedSpendingKey
 
     /// Checks whether the given seed is relevant to any of the derived accounts in the wallet.
     ///
@@ -65,22 +94,24 @@ protocol ZcashRustBackendWelding {
     /// Scans a transaction for any information that can be decrypted by the accounts in the wallet, and saves it to the wallet.
     /// - parameter tx:     the transaction to decrypt
     /// - parameter minedHeight: height on which this transaction was mined. this is used to fetch the consensus branch ID.
+    /// - Returns: The transaction's ID.
     /// - Throws: `rustDecryptAndStoreTransaction`.
-    func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: UInt32?) async throws
+    func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: UInt32?) async throws -> Data
 
     /// Returns the most-recently-generated unified payment address for the specified account.
     /// - parameter account: index of the given account
     /// - Throws:
     ///     - `rustGetCurrentAddress` if rust layer returns error.
     ///     - `rustGetCurrentAddressInvalidAddress` if generated unified address isn't valid.
-    func getCurrentAddress(account: Int32) async throws -> UnifiedAddress
+    func getCurrentAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress
 
     /// Returns a newly-generated unified payment address for the specified account, with the next available diversifier.
     /// - parameter account: index of the given account
+    /// - parameter receiverFlags: bitflags specifying which receivers to include in the address.
     /// - Throws:
     ///     - `rustGetNextAvailableAddress` if rust layer returns error.
     ///     - `rustGetNextAvailableAddressInvalidAddress` if generated unified address isn't valid.
-    func getNextAvailableAddress(account: Int32) async throws -> UnifiedAddress
+    func getNextAvailableAddress(accountUUID: AccountUUID, receiverFlags: UInt32) async throws -> UnifiedAddress
 
     /// Get memo from note.
     /// - parameter txId: ID of transaction containing the note
@@ -93,7 +124,7 @@ protocol ZcashRustBackendWelding {
     /// - Throws:
     ///     - `rustGetTransparentBalanceNegativeAccount` if `account` is < 0.
     ///     - `rustGetTransparentBalance` if rust layer returns error.
-    func getTransparentBalance(account: Int32) async throws -> Int64
+    func getTransparentBalance(accountUUID: AccountUUID) async throws -> Int64
 
     /// Initializes the data db. This will performs any migrations needed on the sqlite file
     /// provided. Some migrations might need that callers provide the seed bytes.
@@ -110,14 +141,14 @@ protocol ZcashRustBackendWelding {
     /// - Throws:
     ///     - `rustListTransparentReceivers` if rust layer returns error.
     ///     - `rustListTransparentReceiversInvalidAddress` if transarent received generated by rust is invalid.
-    func listTransparentReceivers(account: Int32) async throws -> [TransparentAddress]
+    func listTransparentReceivers(accountUUID: AccountUUID) async throws -> [TransparentAddress]
 
     /// Get the verified cached transparent balance for the given account
     /// - parameter account: account index to query the balance for.
     /// - Throws:
     ///     - `rustGetVerifiedTransparentBalanceNegativeAccount` if `account` is < 0.
     ///     - `rustGetVerifiedTransparentBalance` if rust layer returns error.
-    func getVerifiedTransparentBalance(account: Int32) async throws -> Int64
+    func getVerifiedTransparentBalance(accountUUID: AccountUUID) async throws -> Int64
 
     /// Resets the state of the database to only contain block and transaction information up to the given height. clears up all derived data as well
     /// - parameter height: height to rewind to.
@@ -215,7 +246,7 @@ protocol ZcashRustBackendWelding {
     /// - Parameter memo: the `MemoBytes` for this transaction. pass `nil` when sending to transparent receivers
     /// - Throws: `rustCreateToAddress`.
     func proposeTransfer(
-        account: Int32,
+        accountUUID: AccountUUID,
         to address: String,
         value: Int64,
         memo: MemoBytes?
@@ -227,13 +258,10 @@ protocol ZcashRustBackendWelding {
     ///
     /// - parameter uri: the URI String that the proposal will be made from.
     /// - parameter account: index of the given account
-    /// - Parameter to: recipient address
-    /// - Parameter value: transaction amount in Zatoshi
-    /// - Parameter memo: the `MemoBytes` for this transaction. pass `nil` when sending to transparent receivers
     /// - Throws: `rustCreateToAddress`.
     func proposeTransferFromURI(
         _ uri: String,
-        account: Int32
+        accountUUID: AccountUUID
     ) async throws -> FfiProposal
 
     /// Constructs a transaction proposal to shield all found UTXOs in data db for the given account,
@@ -251,7 +279,7 @@ protocol ZcashRustBackendWelding {
     ///             to shield.
     /// - Throws: `rustShieldFunds` if rust layer returns error.
     func proposeShielding(
-        account: Int32,
+        accountUUID: AccountUUID,
         memo: MemoBytes?,
         shieldingThreshold: Zatoshi,
         transparentReceiver: String?
@@ -266,6 +294,54 @@ protocol ZcashRustBackendWelding {
         usk: UnifiedSpendingKey
     ) async throws -> [Data]
 
+    /// Creates a partially-created (unsigned without proofs) transaction from the given proposal.
+    ///
+    /// Do not call this multiple times in parallel, or you will generate PCZT instances that, if
+    /// finalized, would double-spend the same notes.
+    ///
+    /// - Parameter accountUUID: The account for which the proposal was created.
+    /// - Parameter proposal: The proposal for which to create the transaction.
+    /// - Returns The partially created transaction in [Pczt] format.
+    ///
+    /// - 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.
+    ///
+    /// - Returns The updated PCZT in its serialized format.
+    ///
+    /// - Throws  rustAddProofsToPCZT as a common indicator of the operation failure
+    func addProofsToPCZT(pczt: Pczt) async throws -> Pczt
+
+    /// Takes a PCZT that has been separately proven and signed, finalizes it, and stores
+    /// it in the wallet. Internally, this logic also submits and checks the newly stored and encoded transaction.
+    ///
+    /// - Parameter pcztWithProofs
+    /// - Parameter pcztWithSigs
+    ///
+    /// - Returns The submission result of the completed transaction.
+    ///
+    /// - Throws  PcztException.ExtractAndStoreTxFromPcztException as a common indicator of the operation failure
+    func extractAndStoreTxFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> Data
+
     /// Gets the consensus branch id for the given height
     /// - Parameter height: the height you what to know the branch id for
     /// - Throws: `rustNoConsensusBranchId` if rust layer returns error.
@@ -305,4 +381,11 @@ protocol ZcashRustBackendWelding {
     /// scanning; as a consequence, the wallet must actively query to determine whether such
     /// transactions have been mined.
     func setTransactionStatus(txId: Data, status: TransactionStatus) async throws
+
+    /// Fix witnesses - addressing note commitment tree bug.
+    /// This function is supposed to be called occasionaly. It's handled by the SDK Synchronizer and called only once per version.
+    func fixWitnesses() async
+
+    /// Get an ephemeral single use transparent address
+    func getSingleUseTransparentAddress(accountUUID: AccountUUID) async throws -> SingleUseTransparentAddress
 }

package/ios/ZCashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift

@@ -31,14 +31,23 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
     public var stateStream: AnyPublisher<SynchronizerState, Never> { synchronizer.stateStream }
     public var eventStream: AnyPublisher<SynchronizerEvent, Never> { synchronizer.eventStream }
 
+    // swiftlint:disable:next function_parameter_count
     public func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
         for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?,
         completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
+            return try await self.synchronizer.prepare(
+                with: seed,
+                walletBirthday: walletBirthday,
+                for: walletMode,
+                name: name,
+                keySource: keySource
+            )
         }
     }
 
@@ -52,38 +61,72 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         synchronizer.stop()
     }
 
-    public func getSaplingAddress(accountIndex: Int, completion: @escaping (Result<SaplingAddress, Error>) -> Void) {
+    public func getSaplingAddress(accountUUID: AccountUUID, completion: @escaping (Result<SaplingAddress, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getSaplingAddress(accountUUID: accountUUID)
+        }
+    }
+
+    public func getUnifiedAddress(accountUUID: AccountUUID, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getUnifiedAddress(accountUUID: accountUUID)
         }
     }
 
-    public func getUnifiedAddress(accountIndex: Int, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
+    public func getTransparentAddress(accountUUID: AccountUUID, completion: @escaping (Result<TransparentAddress, Error>) -> Void) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getTransparentAddress(accountUUID: accountUUID)
         }
     }
 
-    public func getTransparentAddress(accountIndex: Int, completion: @escaping (Result<TransparentAddress, Error>) -> Void) {
+    public func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getCustomUnifiedAddress(accountUUID: accountUUID, receivers: receivers)
+        }
+    }
+
+    public func listAccounts(completion: @escaping (Result<[Account], Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.listAccounts()
+        }
+    }
+
+    // swiftlint:disable:next function_parameter_count
+    public func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?,
+        completion: @escaping (Result<AccountUUID, Error>) -> Void
+    ) async throws {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.importAccount(
+                ufvk: ufvk,
+                seedFingerprint: seedFingerprint,
+                zip32AccountIndex: zip32AccountIndex,
+                purpose: purpose,
+                name: name,
+                keySource: keySource
+            )
         }
     }
 
     public func proposeTransfer(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         recipient: Recipient,
         amount: Zatoshi,
         memo: Memo?,
         completion: @escaping (Result<Proposal, Error>) -> Void
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
+            try await self.synchronizer.proposeTransfer(accountUUID: accountUUID, recipient: recipient, amount: amount, memo: memo)
         }
     }
 
     public func proposeShielding(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         shieldingThreshold: Zatoshi,
         memo: Memo,
         transparentReceiver: TransparentAddress? = nil,
@@ -91,7 +134,7 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
             try await self.synchronizer.proposeShielding(
-                accountIndex: accountIndex,
+                accountUUID: accountUUID,
                 shieldingThreshold: shieldingThreshold,
                 memo: memo,
                 transparentReceiver: transparentReceiver
@@ -109,28 +152,50 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    public func sendToAddress(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        toAddress: Recipient,
-        memo: Memo?,
-        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    public func createPCZTFromProposal(
+        accountUUID: AccountUUID,
+        proposal: Proposal,
+        completion: @escaping (Result<Pczt, Error>) -> Void
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
+            try await self.synchronizer.createPCZTFromProposal(accountUUID: accountUUID, proposal: proposal)
         }
     }
 
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    public func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi,
-        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    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
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
+            try await self.synchronizer.addProofsToPCZT(pczt: pczt)
+        }
+    }
+
+    public func createTransactionFromPCZT(
+        pcztWithProofs: Pczt,
+        pcztWithSigs: Pczt,
+        completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.createTransactionFromPCZT(pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
         }
     }
 
@@ -188,9 +253,9 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
-    public func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void) {
+    public func getAccountsBalances(_ completion: @escaping (Result<[AccountUUID: AccountBalance], Error>) -> Void) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
+            try await self.synchronizer.getAccountsBalances()
         }
     }
 
@@ -198,6 +263,17 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         synchronizer.refreshExchangeRateUSD()
     }
 
+    public func estimateBirthdayHeight(for date: Date, completion: @escaping (BlockHeight) -> Void) {
+        let height = synchronizer.estimateBirthdayHeight(for: date)
+        completion(height)
+    }
+
+    public func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8, completion: @escaping (Result<(data: Data, response: HTTPURLResponse), Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.httpRequestOverTor(for: request, retryLimit: retryLimit)
+        }
+    }
+    
     /*
      It can be missleading that these two methods are returning Publisher even this protocol is closure based. Reason is that Synchronizer doesn't
      provide different implementations for these two methods. So Combine it is even here.

package/ios/ZCashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift

@@ -34,10 +34,18 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
     public func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?
     ) -> SinglePublisher<Initializer.InitializationResult, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
+            return try await self.synchronizer.prepare(
+                with: seed,
+                walletBirthday: walletBirthday,
+                for: walletMode,
+                name: name,
+                keySource: keySource
+            )
         }
     }
 
@@ -51,56 +59,62 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         synchronizer.stop()
     }
 
-    public func getSaplingAddress(accountIndex: Int) -> SinglePublisher<SaplingAddress, Error> {
+    public func getSaplingAddress(accountUUID: AccountUUID) -> SinglePublisher<SaplingAddress, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getSaplingAddress(accountUUID: accountUUID)
+        }
+    }
+
+    public func getUnifiedAddress(accountUUID: AccountUUID) -> SinglePublisher<UnifiedAddress, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getUnifiedAddress(accountUUID: accountUUID)
         }
     }
 
-    public func getUnifiedAddress(accountIndex: Int) -> SinglePublisher<UnifiedAddress, Error> {
+    public func getTransparentAddress(accountUUID: AccountUUID) -> SinglePublisher<TransparentAddress, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getTransparentAddress(accountUUID: accountUUID)
         }
     }
 
-    public func getTransparentAddress(accountIndex: Int) -> SinglePublisher<TransparentAddress, Error> {
+    public func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>) -> SinglePublisher<UnifiedAddress, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
+            try await self.synchronizer.getCustomUnifiedAddress(accountUUID: accountUUID, receivers: receivers)
         }
     }
 
     public func proposeTransfer(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         recipient: Recipient,
         amount: Zatoshi,
         memo: Memo?
     ) -> SinglePublisher<Proposal, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
+            try await self.synchronizer.proposeTransfer(accountUUID: accountUUID, recipient: recipient, amount: amount, memo: memo)
         }
     }
 
     public func proposefulfillingPaymentURI(
         _ uri: String,
-        accountIndex: Int
+        accountUUID: AccountUUID
     ) -> SinglePublisher<Proposal, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
             try await self.synchronizer.proposefulfillingPaymentURI(
                 uri,
-                accountIndex: accountIndex
+                accountUUID: accountUUID
             )
         }
     }
 
     public func proposeShielding(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         shieldingThreshold: Zatoshi,
         memo: Memo,
         transparentReceiver: TransparentAddress? = nil
     ) -> SinglePublisher<Proposal?, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
             try await self.synchronizer.proposeShielding(
-                accountIndex: accountIndex,
+                accountUUID: accountUUID,
                 shieldingThreshold: shieldingThreshold,
                 memo: memo,
                 transparentReceiver: transparentReceiver
@@ -117,26 +131,72 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    public func sendToAddress(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        toAddress: Recipient,
-        memo: Memo?
-    ) -> SinglePublisher<ZcashTransaction.Overview, Error> {
+    public func createPCZTFromProposal(
+        accountUUID: AccountUUID,
+        proposal: Proposal
+    ) -> SinglePublisher<Pczt, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
+            try await self.synchronizer.createPCZTFromProposal(accountUUID: accountUUID, proposal: proposal)
         }
     }
 
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    public func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi
-    ) -> SinglePublisher<ZcashTransaction.Overview, Error> {
+    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> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
+            try await self.synchronizer.addProofsToPCZT(pczt: pczt)
+        }
+    }
+
+    public func createTransactionFromPCZT(
+        pcztWithProofs: Pczt,
+        pcztWithSigs: Pczt
+    ) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.createTransactionFromPCZT(pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
+        }
+    }
+
+    public func listAccounts() -> SinglePublisher<[Account], Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.listAccounts()
+        }
+    }
+
+    // swiftlint:disable:next function_parameter_count
+    public func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> SinglePublisher<AccountUUID, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.importAccount(
+                ufvk: ufvk,
+                seedFingerprint: seedFingerprint,
+                zip32AccountIndex: zip32AccountIndex,
+                purpose: purpose,
+                name: name,
+                keySource: keySource
+            )
         }
     }
 
@@ -190,9 +250,9 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
-    public func getAccountBalance(accountIndex: Int) -> SinglePublisher<AccountBalance?, Error> {
+    public func getAccountsBalances() -> SinglePublisher<[AccountUUID: AccountBalance], Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
+            try await self.synchronizer.getAccountsBalances()
         }
     }
 
@@ -200,6 +260,20 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         synchronizer.refreshExchangeRateUSD()
     }
 
+    public func estimateBirthdayHeight(for date: Date) -> SinglePublisher<BlockHeight, Error> {
+        let height = synchronizer.estimateBirthdayHeight(for: date)
+        let subject = PassthroughSubject<BlockHeight, Error>()
+        subject.send(height)
+        subject.send(completion: .finished)
+        return subject.eraseToAnyPublisher()
+    }
+
+    public func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8) -> SinglePublisher<(data: Data, response: HTTPURLResponse), Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.httpRequestOverTor(for: request, retryLimit: retryLimit)
+        }
+    }
+    
     public func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error> { synchronizer.rewind(policy) }
     public func wipe() -> CompletablePublisher<Error> { synchronizer.wipe() }
 }