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

package/ios/ZCashLightClientKit/Synchronizer.swift

@@ -36,7 +36,7 @@ public struct SynchronizerState: Equatable {
     /// SyncSessionIDs are provided to users
     public var syncSessionID: UUID
     /// account balance known to this synchronizer given the data that has processed locally
-    public var accountBalance: AccountBalance?
+    public var accountsBalances: [AccountUUID: AccountBalance]
     /// status of the whole sync process
     var internalSyncStatus: InternalSyncStatus
     public var syncStatus: SyncStatus
@@ -47,7 +47,7 @@ public struct SynchronizerState: Equatable {
     public static var zero: SynchronizerState {
         SynchronizerState(
             syncSessionID: .nullID,
-            accountBalance: .zero,
+            accountsBalances: [:],
             internalSyncStatus: .unprepared,
             latestBlockHeight: .zero
         )
@@ -55,12 +55,12 @@ public struct SynchronizerState: Equatable {
     
     init(
         syncSessionID: UUID,
-        accountBalance: AccountBalance?,
+        accountsBalances: [AccountUUID: AccountBalance],
         internalSyncStatus: InternalSyncStatus,
         latestBlockHeight: BlockHeight
     ) {
         self.syncSessionID = syncSessionID
-        self.accountBalance = accountBalance
+        self.accountsBalances = accountsBalances
         self.internalSyncStatus = internalSyncStatus
         self.latestBlockHeight = latestBlockHeight
         self.syncStatus = internalSyncStatus.mapToSyncStatus()
@@ -72,7 +72,7 @@ public enum SynchronizerEvent {
     case minedTransaction(ZcashTransaction.Overview)
 
     // Sent when the synchronizer finds a mined transaction
-    case foundTransactions(_ transactions: [ZcashTransaction.Overview], _ inRange: CompactBlockRange)
+    case foundTransactions(_ transactions: [ZcashTransaction.Overview], _ inRange: CompactBlockRange?)
     // Sent when the synchronizer fetched utxos from lightwalletd attempted to store them.
     case storedUTXOs(_ inserted: [UnspentTransactionOutputEntity], _ skipped: [UnspentTransactionOutputEntity])
     // Connection state to LightwalletEndpoint changed.
@@ -103,7 +103,7 @@ public protocol Synchronizer: AnyObject {
 
     /// This stream emits the latest known USD/ZEC exchange rate, paired with the time it was queried. See `FiatCurrencyResult`.
     var exchangeRateUSDStream: AnyPublisher<FiatCurrencyResult?, Never> { get }
-    
+
     /// Initialize the wallet. The ZIP-32 seed bytes can optionally be passed to perform
     /// database migrations. most of the times the seed won't be needed. If they do and are
     /// not provided this will fail with `InitializationResult.seedRequired`. It could
@@ -120,6 +120,8 @@ public protocol Synchronizer: AnyObject {
     ///   - for: [walletMode] Set `.newWallet` when preparing synchronizer for a brand new generated wallet,
     ///   `.restoreWallet` when wallet is about to be restored from a seed
     ///   and  `.existingWallet` for all other scenarios.
+    ///   - name: name of the account.
+    ///   - keySource: custom optional string for clients, used for example to help identify the type of the account.
     /// - Throws:
     ///     - `aliasAlreadyInUse` if the Alias used to create this instance is already used by other instance.
     ///     - `cantUpdateURLWithAlias` if the updating of paths in `Initilizer` according to alias fails. When this happens it means that
@@ -129,7 +131,9 @@ public protocol Synchronizer: AnyObject {
     func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?
     ) async throws -> Initializer.InitializationResult
 
     /// Starts this synchronizer within the given scope.
@@ -144,23 +148,29 @@ public protocol Synchronizer: AnyObject {
     func stop()
 
     /// Gets the sapling shielded address for the given account.
-    /// - Parameter accountIndex: the optional accountId whose address is of interest. By default, the first account is used.
+    /// - Parameter accountUUID: the  account whose address is of interest.
     /// - Returns the address or nil if account index is incorrect
-    func getSaplingAddress(accountIndex: Int) async throws -> SaplingAddress
+    func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress
 
-    /// Gets the unified address for the given account.
-    /// - Parameter accountIndex: the optional accountId whose address is of interest. By default, the first account is used.
+    /// Gets the default unified address for the given account.
+    /// - Parameter accountUUID: the account whose address is of interest.
     /// - Returns the address or nil if account index is incorrect
-    func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress
+    func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress
 
     /// Gets the transparent address for the given account.
-    /// - Parameter accountIndex: the optional accountId whose address is of interest. By default, the first account is used.
+    /// - Parameter accountUUID: the account whose address is of interest. By default, the first account is used.
+    /// - Returns the address or nil if account index is incorrect
+    func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress
+
+    /// Obtains a fresh unified address for the given account with the specified receiver types.
+    /// - Parameter accountUUID: the account whose address is of interest.
+    /// - Parameter receivers: the receiver types to include in the address.
     /// - Returns the address or nil if account index is incorrect
-    func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress
+    func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>) async throws -> UnifiedAddress
 
     /// Creates a proposal for transferring funds to the given recipient.
     ///
-    /// - Parameter accountIndex: the account from which to transfer funds.
+    /// - Parameter accountUUID: the account from which to transfer funds.
     /// - Parameter recipient: the recipient's address.
     /// - Parameter amount: the amount to send in Zatoshi.
     /// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
@@ -168,7 +178,7 @@ public protocol Synchronizer: AnyObject {
     /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
     func proposeTransfer(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         recipient: Recipient,
         amount: Zatoshi,
         memo: Memo?
@@ -176,7 +186,7 @@ public protocol Synchronizer: AnyObject {
 
     /// Creates a proposal for shielding any transparent funds received by the given account.
     ///
-    /// - Parameter accountIndex: the account for which to shield funds.
+    /// - Parameter accountUUID: the account for which to shield funds.
     /// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
     /// - Parameter memo: an optional memo to include as part of the proposal's transactions.
     /// - Parameter transparentReceiver: a specific transparent receiver within the account
@@ -190,7 +200,7 @@ public protocol Synchronizer: AnyObject {
     /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
     func proposeShielding(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         shieldingThreshold: Zatoshi,
         memo: Memo,
         transparentReceiver: TransparentAddress?
@@ -212,46 +222,64 @@ public protocol Synchronizer: AnyObject {
         spendingKey: UnifiedSpendingKey
     ) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>
 
-    /// Sends zatoshi.
-    /// - Parameter spendingKey: the `UnifiedSpendingKey` that allows spends to occur.
-    /// - Parameter zatoshi: the amount to send in Zatoshi.
-    /// - Parameter toAddress: the recipient's address.
-    /// - Parameter memo: an `Optional<Memo>`with the memo to include as part of the transaction. send `nil` when sending to transparent receivers otherwise the function will throw an error
-    ///
-    /// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
-    /// `SynchronizerErrors.notPrepared`.
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    func sendToAddress(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        toAddress: Recipient,
-        memo: Memo?
-    ) async throws -> ZcashTransaction.Overview
-
-    /// Attempts to propose fulfilling a [ZIP-321](https://zips.z.cash/zip-0321) payment URI using the given `accountIndex`
+    /// Attempts to propose fulfilling a [ZIP-321](https://zips.z.cash/zip-0321) payment URI by spending from the ZIP 32 account with the given index.
     ///  - Parameter uri: a valid ZIP-321 payment URI
-    ///  - Parameter accountIndex: the account index that allows spends to occur.
+    ///  - Parameter accountUUID: the account providing spend authority.
     ///
     /// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
     func proposefulfillingPaymentURI(
         _ uri: String,
-        accountIndex: Int
+        accountUUID: AccountUUID
     ) async throws -> Proposal
 
-    /// Shields transparent funds from the given private key into the best shielded pool of the account associated to the given `UnifiedSpendingKey`.
-    /// - Parameter spendingKey: the `UnifiedSpendingKey` that allows to spend transparent funds
-    /// - Parameter memo: the optional memo to include as part of the transaction.
-    /// - Parameter shieldingThreshold: the minimum transparent balance required before a transaction will be created.
+    /// Creates a partially-created (unsigned without proofs) transaction from the given proposal.
     ///
-    /// - Note: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
-    /// `SynchronizerErrors.notPrepared`.
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi
-    ) async throws -> ZcashTransaction.Overview
+    /// 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: 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.
+    ///
+    /// - 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 createTransactionFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>
 
     /// all the transactions that are on the blockchain
     var transactions: [ZcashTransaction.Overview] { get async }
@@ -261,7 +289,7 @@ public protocol Synchronizer: AnyObject {
 
     /// all transactions related to receiving funds
     var receivedTransactions: [ZcashTransaction.Overview] { get async }
-    
+
     /// A repository serving transactions in a paginated manner
     /// - Parameter kind: Transaction Kind expected from this PaginatedTransactionRepository
     func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository
@@ -286,7 +314,7 @@ public protocol Synchronizer: AnyObject {
 
     /// Attempt to get outputs involved in a given Transaction.
     /// - parameter transaction: A transaction overview
-    /// - returns the array of outputs involved in this transaction. Transparent outputs might not be tracked 
+    /// - returns the array of outputs involved in this transaction. Transparent outputs might not be tracked
     ///
     // sourcery: mockedName="getTransactionOutputsForTransaction"
     func getTransactionOutputs(for transaction: ZcashTransaction.Overview) async -> [ZcashTransaction.Output]
@@ -307,14 +335,34 @@ public protocol Synchronizer: AnyObject {
     /// `SynchronizerErrors.notPrepared`.
     func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs
 
-    /// Account balances from the given account index
-    /// - Parameter accountIndex: the index of the account
-    /// - Returns: `AccountBalance`, struct that holds sapling and unshielded balances or `nil` when no account is associated with `accountIndex`
-    func getAccountBalance(accountIndex: Int) async throws -> AccountBalance?
+    /// Accounts balances
+    /// - Returns: `[AccountUUID: AccountBalance]`, struct that holds Sapling and unshielded balances per account
+    func getAccountsBalances() async throws -> [AccountUUID: AccountBalance]
 
     /// Fetches the latest ZEC-USD exchange rate and updates `exchangeRateUSDSubject`.
     func refreshExchangeRateUSD()
 
+    /// Returns a list of the accounts in the wallet.
+    func listAccounts() async throws -> [Account]
+
+    /// Imports a new account with UnifiedFullViewingKey.
+    /// - Parameters:
+    ///   - ufvk: unified full viewing key
+    ///   - purpose: of the account, either `spending` or `viewOnly`
+    ///   - name: name of the account.
+    ///   - keySource: custom optional string for clients, used for example to help identify the type of the account.
+    // swiftlint:disable:next function_parameter_count
+    func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> AccountUUID
+
+    func fetchTxidsWithMemoContaining(searchTerm: String) async throws -> [Data]
+
     /// Rescans the known blocks with the current keys.
     ///
     /// `rewind(policy:)` can be called anytime. If the sync process is in progress then it is stopped first. In this case, it make some significant
@@ -354,9 +402,9 @@ public protocol Synchronizer: AnyObject {
     ///
     /// Returned publisher emits `initializerAliasAlreadyInUse` if the updating of paths in `Initilizer` according to alias fails. When
     /// this happens it means that some path passed to `Initializer` is invalid. The SDK can't recover from this and this instance won't do anything.
-    /// 
+    ///
     func wipe() -> AnyPublisher<Void, Error>
-    
+
     /// This API stops the synchronization and re-initalizes everything according to the new endpoint provided.
     /// It can be called anytime.
     /// - Throws: ZcashError when failures occur and related to `synchronizer.start(retry: Bool)`, it's the only throwing operation
@@ -367,30 +415,104 @@ public protocol Synchronizer: AnyObject {
     ///
     /// - parameter seed: byte array of the seed
     func isSeedRelevantToAnyDerivedAccount(seed: [UInt8]) async throws -> Bool
-    
+
     /// Takes the list of endpoints and runs it through a series of checks to evaluate its performance.
     /// - Parameters:
     ///    - endpoints: Array of endpoints to evaluate.
-    ///    - latencyThresholdMillis: The mean latency of `getInfo` and `getTheLatestHeight` calls must be below this threshold. The default is 300 ms.
     ///    - fetchThresholdSeconds: The time to download `nBlocksToFetch` blocks from the stream must be below this threshold. The default is 60 seconds.
     ///    - nBlocksToFetch: The number of blocks expected to be downloaded from the stream, with the time compared to `fetchThresholdSeconds`. The default is 100.
-    ///    - kServers: The expected number of endpoints in the output. The default is 3.
+    ///    - kServers: The required number of endpoints in the output. The default is 3.
     ///    - network: Mainnet or testnet. The default is mainnet.
     func evaluateBestOf(
         endpoints: [LightWalletEndpoint],
-        latencyThresholdMillis: Double,
         fetchThresholdSeconds: Double,
         nBlocksToFetch: UInt64,
         kServers: Int,
         network: NetworkType
     ) async -> [LightWalletEndpoint]
+
+    /// Takes a given date and finds out the closes checkpoint's height for it.
+    /// Each checkpoint has a timestamp stored so it can be used for the calculations.
+    func estimateBirthdayHeight(for date: Date) -> BlockHeight
+
+    /// Allows to setup the Tor opt-in/out runtime.
+    /// - Parameters:
+    ///    - enabled: When true, the SDK ensures `TorClient` is ready. This flag controls http and lwd service calls.
+    /// - Throws: ZcashError when failures of the `TorClient` occur
+    func tor(enabled: Bool) async throws
+
+    /// Allows to setup exchange rate over Tor.
+    /// - Parameters:
+    ///    - enabled: When true, the SDK ensures `TorClient` is ready. This flag controls whether exchange rate feature is possible to use or not.
+    /// - Throws: ZcashError when failures of the `TorClient` occur
+    func exchangeRateOverTor(enabled: Bool) async throws
+
+    /// Init of the SDK must always happen but initialization of `TorClient` can fail. This failure is designed to not block SDK initialization.
+    /// Instead, a result of the initialization is stored in the `SDKFLags`
+    /// - Returns: nil, the initialization hasn't been initiated, true/false = initialization succeeded/failed
+    func isTorSuccessfullyInitialized() async -> Bool?
+
+    /// Makes an HTTP request over Tor and delivers the `HTTPURLResponse`.
+    ///
+    /// This request is isolated (using separate circuits) from any other requests or
+    /// Tor usage, but may still be correlatable by the server through request timing
+    /// (if the caller does not mitigate timing attacks).
+    ///
+    /// The Swift's signature aligns with `URLSession.data(for request: URLRequest)`.
+    ///
+    /// - Parameters:
+    ///    - for: URLRequest
+    ///    - retryLimit: How many times the request will be retried in case of failure
+    func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8) async throws -> (data: Data, response: HTTPURLResponse)
+
+    /// Performs an `sql` query on a database and returns some output as a string
+    /// Use cautiously!
+    /// The connection to the database is created in a read-only mode. it's a hard requirement.
+    /// Details: `TransactionSQLDAO(dbProvider: SimpleConnectionProvider(path: urls.dataDbURL.path, readonly: true))`
+    func debugDatabase(sql: String) -> String
+
+    /// Get an ephemeral single use transparent address
+    /// - Parameter accountUUID: The account for which the single use transparent address is going to be created.
+    /// - Returns The struct with an ephemeral transparent address and gap limit info
+    ///
+    /// - Throws rustGetSingleUseTransparentAddress as a common indicator of the operation failure
+    func getSingleUseTransparentAddress(accountUUID: AccountUUID) async throws -> SingleUseTransparentAddress
+
+    /// Checks to find any single-use ephemeral addresses exposed in the past day that have not yet
+    /// received funds, excluding any whose next check time is in the future. This will then choose the
+    /// address that is most overdue for checking, retrieve any UTXOs for that address over Tor, and
+    /// add them to the wallet database. If no such UTXOs are found, the check will be rescheduled
+    /// following an expoential-backoff-with-jitter algorithm.
+    /// - Parameter accountUUID: The account for which the single use transparent addresses are going to be checked.
+    /// - Returns `.found(String)` an address found if UTXOs were added to the wallet, `.notFound` otherwise.
+    ///
+    /// - Throws rustCheckSingleUseTransparentAddresses as a common indicator of the operation failure
+    func checkSingleUseTransparentAddresses(accountUUID: AccountUUID) async throws -> TransparentAddressCheckResult
+
+    /// Finds all transactions associated with the given transparent address.
+    /// - Parameter address: The address for which the transactions will be checked.
+    /// - Returns `.found(String)` an address found if UTXOs were added to the wallet, `.notFound` otherwise.
+    ///
+    /// - Throws rustUpdateTransparentAddressTransactions as a common indicator of the operation failure
+    func updateTransparentAddressTransactions(address: String) async throws -> TransparentAddressCheckResult
+
+    /// Checks to find any UTXOs associated with the given transparent address. This check will cover the block range starting at the exposure height for that address,
+    /// if known, or otherwise at the birthday height of the specified account.
+    /// - Parameters:
+    ///    - address: The address for which the transactions will be checked.
+    ///    - accountUUID: The account for which the single use transparent addresses are going to be checked.
+    /// - Returns `.found(String)` an address found if UTXOs were added to the wallet, `.notFound` otherwise.
+    ///
+    /// - Throws rustFetchUTXOsByAddress as a common indicator of the operation failure
+    func fetchUTXOsBy(address: String, accountUUID: AccountUUID) async throws -> TransparentAddressCheckResult
 }
 
 public enum SyncStatus: Equatable {
     public static func == (lhs: SyncStatus, rhs: SyncStatus) -> Bool {
         switch (lhs, rhs) {
         case (.unprepared, .unprepared): return true
-        case let (.syncing(lhsProgress), .syncing(rhsProgress)): return lhsProgress == rhsProgress
+        case let (.syncing(lhsSyncProgress, lhsRecoveryPrgoress), .syncing(rhsSyncProgress, rhsRecoveryPrgoress)):
+            return lhsSyncProgress == rhsSyncProgress && lhsRecoveryPrgoress == rhsRecoveryPrgoress
         case (.upToDate, .upToDate): return true
         case (.error, .error): return true
         default: return false
@@ -402,7 +524,7 @@ public enum SyncStatus: Equatable {
     /// taking other maintenance steps that need to occur after an upgrade.
     case unprepared
 
-    case syncing(_ progress: Float)
+    case syncing(_ syncProgress: Float, _ areFundsSpendable: Bool)
 
     /// Indicates that this Synchronizer is fully up to date and ready for all wallet functions.
     /// When set, a UI element may want to turn green.
@@ -455,7 +577,7 @@ enum InternalSyncStatus: Equatable {
     case unprepared
 
     /// Indicates that this Synchronizer is actively processing new blocks (consists of fetch, scan and enhance operations)
-    case syncing(Float)
+    case syncing(Float, Bool)
     
     /// Indicates that this Synchronizer is fully up to date and ready for all wallet functions.
     /// When set, a UI element may want to turn green.
@@ -551,7 +673,8 @@ extension InternalSyncStatus {
     public static func == (lhs: InternalSyncStatus, rhs: InternalSyncStatus) -> Bool {
         switch (lhs, rhs) {
         case (.unprepared, .unprepared): return true
-        case let (.syncing(lhsProgress), .syncing(rhsProgress)): return lhsProgress == rhsProgress
+        case let (.syncing(lhsSyncProgress, lhsRecoveryPrgoress), .syncing(rhsSyncProgress, rhsRecoveryPrgoress)):
+            return lhsSyncProgress == rhsSyncProgress && lhsRecoveryPrgoress == rhsRecoveryPrgoress
         case (.synced, .synced): return true
         case (.stopped, .stopped): return true
         case (.disconnected, .disconnected): return true
@@ -562,8 +685,8 @@ extension InternalSyncStatus {
 }
 
 extension InternalSyncStatus {
-    init(_ blockProcessorProgress: Float) {
-        self = .syncing(blockProcessorProgress)
+    init(_ syncProgress: Float, _ areFundsSpendable: Bool) {
+        self = .syncing(syncProgress, areFundsSpendable)
     }
 }
 
@@ -572,8 +695,8 @@ extension InternalSyncStatus {
         switch self {
         case .unprepared:
             return .unprepared
-        case .syncing(let progress):
-            return .syncing(progress)
+        case let .syncing(syncProgress, areFundsSpendable):
+            return .syncing(syncProgress, areFundsSpendable)
         case .synced:
             return .upToDate
         case .stopped:

package/ios/ZCashLightClientKit/Tool/DerivationTool.swift

@@ -17,14 +17,18 @@ public protocol KeyValidation {
 }
 
 public protocol KeyDeriving {
-    /// Given the seed bytes tand the account index, return the UnifiedSpendingKey
+    /// Derives and returns a UnifiedAddress from a UnifiedFullViewingKey
+    /// - Parameter ufvk: UTF-8 encoded String containing a valid UFVK
+    /// - Returns: the corresponding default `UnifiedAddress`
+    func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress
+    
+    /// Given the seed bytes and ZIP 32 account index, return the corresponding UnifiedSpendingKey.
     /// - Parameter seed: `[Uint8]` seed bytes
-    /// - Parameter accountNumber: `Int` with the account number
+    /// - Parameter accountIndex: the ZIP 32 index of the account
     /// - Throws:
-    ///     - `derivationToolSpendingKeyInvalidAccount` if the `accountIndex` is invalid.
     ///     - some `ZcashError.rust*` error if the derivation fails.
     /// - Returns a `UnifiedSpendingKey`
-    func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Int) throws -> UnifiedSpendingKey
+    func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Zip32AccountIndex) throws -> UnifiedSpendingKey
 
     /// Given a spending key, return the associated viewing key.
     /// - Parameter spendingKey: the `UnifiedSpendingKey` from which to derive the `UnifiedFullViewingKey` from.
@@ -48,6 +52,30 @@ public protocol KeyDeriving {
     func receiverTypecodesFromUnifiedAddress(_ address: UnifiedAddress) throws -> [UnifiedAddress.ReceiverTypecodes]
 
     static func getAddressMetadata(_ addr: String) -> AddressMetadata?
+
+    /// Derives and returns a ZIP 32 Arbitrary Key from the given seed at the "wallet level", i.e.
+    /// directly from the seed with no ZIP 32 path applied.
+    ///
+    /// The resulting key will be the same across all networks (Zcash mainnet, Zcash testnet,
+    /// OtherCoin mainnet, and so on). You can think of it as a context-specific seed fingerprint
+    /// that can be used as (static) key material.
+    ///
+    /// - Parameter contextString: a globally-unique non-empty sequence of at most 252 bytes that identifies the desired context.
+    /// - Parameter seed: `[Uint8]` seed bytes
+    /// - Throws:
+    ///     - some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns a `[Uint8]`
+    static func deriveArbitraryWalletKey(contextString: [UInt8], seed: [UInt8]) throws -> [UInt8]
+
+    /// Derives and returns a ZIP 32 Arbitrary Key from the given seed at the account level.
+    ///
+    /// - Parameter contextString: a globally-unique non-empty sequence of at most 252 bytes that identifies the desired context.
+    /// - Parameter seed: `[Uint8]` seed bytes
+    /// - Parameter accountIndex: the ZIP 32 index of the account
+    /// - Throws:
+    ///     - some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns a `[Uint8]`
+    func deriveArbitraryAccountKey(contextString: [UInt8], seed: [UInt8], accountIndex: Zip32AccountIndex) throws -> [UInt8]
 }
 
 public class DerivationTool: KeyDeriving {
@@ -69,6 +97,10 @@ public class DerivationTool: KeyDeriving {
         ZcashKeyDerivationBackend.getAddressMetadata(addr)
     }
 
+    public func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress {
+        try backend.deriveUnifiedAddressFrom(ufvk: ufvk)
+    }
+    
     /// Given a spending key, return the associated viewing key.
     /// - Parameter spendingKey: the `UnifiedSpendingKey` from which to derive the `UnifiedFullViewingKey` from.
     /// - Returns: the viewing key that corresponds to the spending key.
@@ -78,18 +110,44 @@ public class DerivationTool: KeyDeriving {
 
     /// Given a seed and a number of accounts, return the associated spending keys.
     /// - Parameter seed: the seed from which to derive spending keys.
-    /// - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
-    /// supported so the default value of 1 is recommended.
+    /// - Parameter accountIndex: the ZIP 32 index of the account
     /// - Returns: the spending keys that correspond to the seed, formatted as Strings.
-    public func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Int) throws -> UnifiedSpendingKey {
-        guard accountIndex >= 0, let accountIndex = Int32(exactly: accountIndex) else { throw ZcashError.derivationToolSpendingKeyInvalidAccount }
-        return try backend.deriveUnifiedSpendingKey(from: seed, accountIndex: accountIndex)
+    public func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Zip32AccountIndex) throws -> UnifiedSpendingKey {
+        try backend.deriveUnifiedSpendingKey(from: seed, accountIndex: accountIndex)
     }
 
     public func receiverTypecodesFromUnifiedAddress(_ address: UnifiedAddress) throws -> [UnifiedAddress.ReceiverTypecodes] {
-        return try backend.receiverTypecodesOnUnifiedAddress(address.stringEncoded)
+        try backend.receiverTypecodesOnUnifiedAddress(address.stringEncoded)
             .map { UnifiedAddress.ReceiverTypecodes(typecode: $0) }
     }
+
+    /// Derives and returns a ZIP 32 Arbitrary Key from the given seed at the "wallet level", i.e.
+    /// directly from the seed with no ZIP 32 path applied.
+    ///
+    /// The resulting key will be the same across all networks (Zcash mainnet, Zcash testnet,
+    /// OtherCoin mainnet, and so on). You can think of it as a context-specific seed fingerprint
+    /// that can be used as (static) key material.
+    ///
+    /// - Parameter contextString: a globally-unique non-empty sequence of at most 252 bytes that identifies the desired context.
+    /// - Parameter seed: `[Uint8]` seed bytes
+    /// - Throws:
+    ///     - some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns a `[Uint8]`
+    public static func deriveArbitraryWalletKey(contextString: [UInt8], seed: [UInt8]) throws -> [UInt8] {
+        try ZcashKeyDerivationBackend.deriveArbitraryWalletKey(contextString: contextString, from: seed)
+    }
+
+    /// Derives and returns a ZIP 32 Arbitrary Key from the given seed at the account level.
+    ///
+    /// - Parameter contextString: a globally-unique non-empty sequence of at most 252 bytes that identifies the desired context.
+    /// - Parameter seed: `[Uint8]` seed bytes
+    /// - Parameter accountIndex: the ZIP 32 index of the account
+    /// - Throws:
+    ///     - some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns a `[Uint8]`
+    public func deriveArbitraryAccountKey(contextString: [UInt8], seed: [UInt8], accountIndex: Zip32AccountIndex) throws -> [UInt8] {
+        try backend.deriveArbitraryAccountKey(contextString: contextString, from: seed, accountIndex: accountIndex)
+    }
 }
 
 public struct AddressMetadata {
@@ -184,9 +242,8 @@ extension UnifiedFullViewingKey {
     /// already validated by another function. only for internal use. Unless you are
     /// constructing an address from a primitive function of the FFI, you probably
     /// shouldn't be using this.
-    init(validatedEncoding: String, account: UInt32) {
+    init(validatedEncoding: String) {
         self.encoding = validatedEncoding
-        self.account = account
     }
 }