react-native-zcash 0.9.13 → 0.10.0

package/ios/ZCashLightClientKit/Checkpoint/CheckpointSource.swift

@@ -31,4 +31,8 @@ protocol CheckpointSource {
     /// - Note: When the user knows the exact height of the first received funds for a wallet,
     /// the effective birthday of that wallet is `transaction.height - 1`.
     func birthday(for height: BlockHeight) -> Checkpoint
+    
+    /// 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
 }

package/ios/ZCashLightClientKit/ClosureSynchronizer.swift

@@ -22,23 +22,27 @@ public protocol ClosureSynchronizer {
     var stateStream: AnyPublisher<SynchronizerState, Never> { get }
     var eventStream: AnyPublisher<SynchronizerEvent, Never> { get }
 
+    // swiftlint:disable:next function_parameter_count
     func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
         for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?,
         completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
     )
 
     func start(retry: Bool, completion: @escaping (Error?) -> Void)
     func stop()
 
-    func getSaplingAddress(accountIndex: Int, completion: @escaping (Result<SaplingAddress, Error>) -> Void)
-    func getUnifiedAddress(accountIndex: Int, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
-    func getTransparentAddress(accountIndex: Int, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
+    func getSaplingAddress(accountUUID: AccountUUID, completion: @escaping (Result<SaplingAddress, Error>) -> Void)
+    func getUnifiedAddress(accountUUID: AccountUUID, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
+    func getTransparentAddress(accountUUID: AccountUUID, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
+    func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
 
     /// 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.
@@ -46,7 +50,7 @@ public protocol ClosureSynchronizer {
     /// 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?,
@@ -55,7 +59,7 @@ public protocol ClosureSynchronizer {
 
     /// 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 from 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
@@ -69,7 +73,7 @@ public protocol ClosureSynchronizer {
     /// 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?,
@@ -93,23 +97,46 @@ public protocol ClosureSynchronizer {
         completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
     )
 
-    @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?,
-        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    func createPCZTFromProposal(
+        accountUUID: AccountUUID,
+        proposal: Proposal,
+        completion: @escaping (Result<Pczt, Error>) -> Void
     )
 
-    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
-    func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi,
-        completion: @escaping (Result<ZcashTransaction.Overview, 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
+    )
+    
+    func createTransactionFromPCZT(
+        pcztWithProofs: Pczt,
+        pcztWithSigs: Pczt,
+        completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
+    )
+
+    func listAccounts(completion: @escaping (Result<[Account], Error>) -> Void)
+
+    // swiftlint:disable:next function_parameter_count
+    func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?,
+        completion: @escaping (Result<AccountUUID, Error>) -> Void
+    ) async throws
+
     func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
     func sentTranscations(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
     func receivedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
@@ -127,10 +154,14 @@ public protocol ClosureSynchronizer {
 
     func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void)
 
-    func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void)
+    func getAccountsBalances(_ completion: @escaping (Result<[AccountUUID: AccountBalance], Error>) -> Void)
 
     func refreshExchangeRateUSD()
 
+    func estimateBirthdayHeight(for date: Date, completion: @escaping (BlockHeight) -> Void)
+
+    func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8, completion: @escaping (Result<(data: Data, response: HTTPURLResponse), Error>) -> Void)
+    
     /*
      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/CombineSynchronizer.swift

@@ -25,19 +25,22 @@ public protocol CombineSynchronizer {
     func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?
     ) -> SinglePublisher<Initializer.InitializationResult, Error>
 
     func start(retry: Bool) -> CompletablePublisher<Error>
     func stop()
 
-    func getSaplingAddress(accountIndex: Int) -> SinglePublisher<SaplingAddress, Error>
-    func getUnifiedAddress(accountIndex: Int) -> SinglePublisher<UnifiedAddress, Error>
-    func getTransparentAddress(accountIndex: Int) -> SinglePublisher<TransparentAddress, Error>
+    func getSaplingAddress(accountUUID: AccountUUID) -> SinglePublisher<SaplingAddress, Error>
+    func getUnifiedAddress(accountUUID: AccountUUID) -> SinglePublisher<UnifiedAddress, Error>
+    func getTransparentAddress(accountUUID: AccountUUID) -> SinglePublisher<TransparentAddress, Error>
+    func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>) -> SinglePublisher<UnifiedAddress, Error>
 
     /// 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.
@@ -45,7 +48,7 @@ public protocol CombineSynchronizer {
     /// 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?
@@ -53,7 +56,7 @@ public protocol CombineSynchronizer {
 
     /// 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 from 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
@@ -67,7 +70,7 @@ public protocol CombineSynchronizer {
     /// 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?
@@ -89,30 +92,45 @@ public protocol CombineSynchronizer {
         spendingKey: UnifiedSpendingKey
     ) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>
 
-    @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?
-    ) -> SinglePublisher<ZcashTransaction.Overview, Error>
-    
-    @available(
-        *,
-        deprecated,
-        message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients. use `proposeShielding:` instead"
-    )
-    func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi
-    ) -> SinglePublisher<ZcashTransaction.Overview, Error>
+    func createPCZTFromProposal(
+        accountUUID: AccountUUID,
+        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>
 
+    func createTransactionFromPCZT(
+        pcztWithProofs: Pczt,
+        pcztWithSigs: Pczt
+    ) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>
+    
     func proposefulfillingPaymentURI(
         _ uri: String,
-        accountIndex: Int
+        accountUUID: AccountUUID
     ) -> SinglePublisher<Proposal, Error>
 
+    func listAccounts() -> SinglePublisher<[Account], Error>
+
+    // swiftlint:disable:next function_parameter_count
+    func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> SinglePublisher<AccountUUID, Error>
+
     var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
@@ -131,6 +149,10 @@ public protocol CombineSynchronizer {
 
     func refreshExchangeRateUSD()
 
+    func estimateBirthdayHeight(for date: Date) -> SinglePublisher<BlockHeight, Error>
+
+    func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8) -> SinglePublisher<(data: Data, response: HTTPURLResponse), Error>
+    
     func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error>
     func wipe() -> CompletablePublisher<Error>
 }

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -11,7 +11,7 @@ public protocol ZcashNetwork {
     var constants: NetworkConstants.Type { get }
 }
 
-public enum NetworkType {
+public enum NetworkType: Equatable, Codable, Hashable {
     case mainnet
     case testnet
     
@@ -136,7 +136,7 @@ public enum ZcashSDK {
     /// The Url that is used by default in zcashd.
     /// We'll want to make this externally configurable, rather than baking it into the SDK but
     /// this will do for now, since we're using a cloudfront URL that already redirects.
-    public static let cloudParameterURL = "https://z.cash/downloads/"
+    public static let cloudParameterURL = "https://download.z.cash/downloads/"
 
     /// File name for the sapling spend params
     public static let spendParamFilename = "sapling-spend.params"
@@ -219,3 +219,9 @@ public enum ZcashSDKTestnetConstants: NetworkConstants {
     
     public static let defaultDbNamePrefix = "ZcashSdk_testnet_"
 }
+
+/// Used when importing an account `importAccount(..., purpose: AccountPurpose)`
+public enum AccountPurpose: UInt32, Equatable {
+    case spending = 0
+    case viewOnly
+}

package/ios/ZCashLightClientKit/DAO/BlockDao.swift

@@ -0,0 +1,65 @@
+//  BlockDao.swift
+//  ZcashLightClientKit
+//
+//  Created by Lukas Korba on 2025-01-25.
+//
+
+import Foundation
+import SQLite
+
+protocol BlockDao {
+    func block(at height: BlockHeight) throws -> Block?
+}
+
+struct Block: Codable {
+    enum CodingKeys: String, CodingKey {
+        case height
+        case time
+    }
+
+    enum TableStructure {
+        static let height = SQLite.Expression<Int>(Block.CodingKeys.height.rawValue)
+        static let time = SQLite.Expression<Int>(Block.CodingKeys.time.rawValue)
+    }
+
+    let height: BlockHeight
+    let time: Int
+    
+    static let table = Table("blocks")
+}
+
+class BlockSQLDAO: BlockDao {
+    let dbProvider: ConnectionProvider
+    let table: Table
+    let height = SQLite.Expression<Int>("height")
+
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+        self.table = Table("Blocks")
+    }
+
+    /// - Throws:
+    ///     - `blockDAOCantDecode` if block data loaded from DB can't be decoded to `Block` object.
+    ///     - `blockDAOBlock` if sqlite query to load block metadata failed.
+    func block(at height: BlockHeight) throws -> Block? {
+        do {
+            return try dbProvider
+                .connection()
+                .prepare(Block.table.filter(Block.TableStructure.height == height).limit(1))
+                .map {
+                    do {
+                        return try $0.decode()
+                    } catch {
+                        throw ZcashError.blockDAOCantDecode(error)
+                    }
+                }
+                .first
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.blockDAOBlock(error)
+            }
+        }
+    }
+}

package/ios/ZCashLightClientKit/DAO/TransactionDao.swift

@@ -8,20 +8,53 @@
 import Foundation
 import SQLite
 
+extension Connection {
+    func debugQuery(_ sql: String) -> String {
+        do {
+            let rows = try self.prepare(sql)
+            var result = ""
+            
+            for row in rows {
+                let stringRow = row.map { value -> String in
+                    if let value {
+                        return "\(value)"
+                    }
+                    return "NULL"
+                }
+                .joined(separator: " | ")
+                
+                result = "\(result)\n\(stringRow)"
+            }
+            
+            return result.isEmpty ? "No results" : result
+        } catch {
+            return "Error: \(error)"
+        }
+    }
+}
+
 class TransactionSQLDAO: TransactionRepository {
     enum NotesTableStructure {
         static let transactionID = SQLite.Expression<Int>("tx")
         static let memo = SQLite.Expression<Blob>("memo")
     }
 
+    enum UserMetadata {
+        static let txid = SQLite.Expression<Blob>("txid")
+        static let memoCount = SQLite.Expression<Int>("memo_count")
+        static let memo = SQLite.Expression<String>("memo")
+    }
+
     let dbProvider: ConnectionProvider
     
+    private let blockDao: BlockSQLDAO
     private let transactionsView = View("v_transactions")
     private let txOutputsView = View("v_tx_outputs")
     private let traceClosure: ((String) -> Void)?
     
     init(dbProvider: ConnectionProvider, traceClosure: ((String) -> Void)? = nil) {
         self.dbProvider = dbProvider
+        self.blockDao = BlockSQLDAO(dbProvider: dbProvider)
         self.traceClosure = traceClosure
     }
 
@@ -38,7 +71,49 @@ class TransactionSQLDAO: TransactionRepository {
     func isInitialized() async throws -> Bool {
         true
     }
+
+    func resolveMissingBlockTimes(for transactions: [ZcashTransaction.Overview]) async throws -> [ZcashTransaction.Overview] {
+        var transactionsCopy = transactions
+        
+        for i in 0..<transactions.count {
+            let transaction = transactions[i]
+            
+            guard transaction.blockTime == nil else {
+                continue
+            }
+            
+            if let expiryHeight = transaction.expiryHeight {
+                if let block = try await blockForHeight(expiryHeight) {
+                    transactionsCopy[i].blockTime = TimeInterval(block.time)
+                }
+            }
+        }
+        
+        return transactionsCopy
+    }
     
+    @DBActor
+    func fetchTxidsWithMemoContaining(searchTerm: String) async throws -> [Data] {
+        let query = transactionsView
+            .join(txOutputsView, on: transactionsView[UserMetadata.txid] == txOutputsView[UserMetadata.txid])
+            .filter(transactionsView[UserMetadata.memoCount] > 0)
+            .filter(txOutputsView[UserMetadata.memo].like("%\(searchTerm)%"))
+
+        var txids: [Data] = []
+        for row in try connection().prepare(query) {
+            let txidBlob = try row.get(txOutputsView[UserMetadata.txid])
+            let txid = Data(blob: txidBlob)
+            txids.append(txid)
+        }
+        
+        return txids
+    }
+    
+    @DBActor
+    func blockForHeight(_ height: BlockHeight) async throws -> Block? {
+        try blockDao.block(at: height)
+    }
+
     @DBActor
     func countAll() async throws -> Int {
         do {
@@ -71,7 +146,9 @@ class TransactionSQLDAO: TransactionRepository {
             .filterQueryFor(kind: kind)
             .limit(limit, offset: offset)
 
-        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
+        let transactions: [ZcashTransaction.Overview] = try await execute(query) { try ZcashTransaction.Overview(row: $0) }
+
+        return try await resolveMissingBlockTimes(for: transactions)
     }
 
     func find(in range: CompactBlockRange, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
@@ -197,6 +274,14 @@ class TransactionSQLDAO: TransactionRepository {
             }
         }
     }
+    
+    func debugDatabase(sql: String) -> String {
+        guard let connection = try? connection() else {
+            return "Connection failed"
+        }
+        
+        return connection.debugQuery(sql)
+    }
 }
 
 private extension View {

package/ios/ZCashLightClientKit/Entity/AccountEntity.swift

@@ -9,24 +9,24 @@ import Foundation
 import SQLite
 
 protocol AccountEntity {
-    var account: Int { get }
+    var accountIndex: Zip32AccountIndex { get }
     var ufvk: String { get }
 }
 
 struct DbAccount: AccountEntity, Encodable, Decodable {
-    let account: Int
+    let accountIndex: Zip32AccountIndex
     let ufvk: String
 }
 
 extension DbAccount: Hashable {
     func hash(into hasher: inout Hasher) {
-        hasher.combine(account)
+        hasher.combine(accountIndex.index)
         hasher.combine(ufvk)
     }
     
     static func == (lhs: Self, rhs: Self) -> Bool {
         guard
-            lhs.account == rhs.account,
+            lhs.accountIndex == rhs.accountIndex,
             lhs.ufvk == rhs.ufvk
         else { return false }
         

package/ios/ZCashLightClientKit/Entity/Pczt.swift

@@ -0,0 +1,10 @@
+//
+//  Pczt.swift
+//  ZcashLightClientKit
+//
+//  Created by Lukáš Korba on 13.12.2024.
+//
+
+import Foundation
+
+public typealias Pczt = Data

package/ios/ZCashLightClientKit/Entity/SentNoteEntity.swift

@@ -11,9 +11,9 @@ protocol SentNoteEntity {
     var id: Int { get }
     var transactionId: Int { get }
     var outputIndex: Int { get }
-    var fromAccount: Int { get }
+    var fromAccount: AccountId { get }
     var toAddress: String? { get }
-    var toAccount: Int? { get }
+    var toAccount: AccountId? { get }
     var value: Int { get }
     var memo: Data? { get }
 }