react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift

@@ -0,0 +1,180 @@
+//
+//  ClosureSDKSynchronizer.swift
+//  
+//
+//  Created by Michal Fousek on 20.03.2023.
+//
+
+import Combine
+import Foundation
+
+/// This is a super thin layer that implements the `ClosureSynchronizer` protocol and translates the async API defined in `Synchronizer` to
+/// closure-based API. And it doesn't do anything else. It doesn't keep any state.  It's here so each client can choose the API that suits its case
+/// the best. And usage of this can be combined with usage of `CombineSDKSynchronizer`. So devs can really choose the best SDK API for each part of the
+/// client app.
+///
+/// If you are looking for documentation for a specific method or property look for it in the `Synchronizer` protocol.
+public struct ClosureSDKSynchronizer {
+    private let synchronizer: Synchronizer
+
+    public init(synchronizer: Synchronizer) {
+        self.synchronizer = synchronizer
+    }
+}
+
+extension ClosureSDKSynchronizer: ClosureSynchronizer {
+    public var alias: ZcashSynchronizerAlias { synchronizer.alias }
+
+    public var latestState: SynchronizerState { synchronizer.latestState }
+    public var connectionState: ConnectionState { synchronizer.connectionState }
+
+    public var stateStream: AnyPublisher<SynchronizerState, Never> { synchronizer.stateStream }
+    public var eventStream: AnyPublisher<SynchronizerEvent, Never> { synchronizer.eventStream }
+
+    public func prepare(
+        with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight,
+        completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            return try await self.synchronizer.prepare(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
+        }
+    }
+
+    public func start(retry: Bool, completion: @escaping (Error?) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.start(retry: retry)
+        }
+    }
+
+    public func stop() {
+        synchronizer.stop()
+    }
+
+    public func getSaplingAddress(accountIndex: Int, completion: @escaping (Result<SaplingAddress, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func getUnifiedAddress(accountIndex: Int, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func getTransparentAddress(accountIndex: Int, completion: @escaping (Result<TransparentAddress, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func sendToAddress(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        toAddress: Recipient,
+        memo: Memo?,
+        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
+        }
+    }
+
+    public func shieldFunds(
+        spendingKey: UnifiedSpendingKey,
+        memo: Memo,
+        shieldingThreshold: Zatoshi,
+        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
+        }
+    }
+
+    public func pendingTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.pendingTransactions
+        }
+    }
+
+    public func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.transactions
+        }
+    }
+
+    public func sentTranscations(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.sentTransactions
+        }
+    }
+
+    public func receivedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.receivedTransactions
+        }
+    }
+    
+    public func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository { synchronizer.paginatedTransactions(of: kind) }
+
+    public func getMemos(for transaction: ZcashTransaction.Overview, completion: @escaping (Result<[Memo], Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getMemos(for: transaction)
+        }
+    }
+
+    public func getRecipients(for transaction: ZcashTransaction.Overview, completion: @escaping ([TransactionRecipient]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.getRecipients(for: transaction)
+        }
+    }
+
+    public func allConfirmedTransactions(
+        from transaction: ZcashTransaction.Overview,
+        limit: Int,
+        completion: @escaping (Result<[ZcashTransaction.Overview], Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.allTransactions(from: transaction, limit: limit)
+        }
+    }
+
+    public func latestHeight(completion: @escaping (Result<BlockHeight, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.latestHeight()
+        }
+    }
+
+    public func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.refreshUTXOs(address: address, from: height)
+        }
+    }
+
+    public func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
+        }
+    }
+
+    public func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getShieldedBalance(accountIndex: accountIndex)
+        }
+    }
+
+    public func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
+        }
+    }
+
+    /*
+     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.
+     */
+    public func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error> { synchronizer.rewind(policy) }
+    public func wipe() -> CompletablePublisher<Error> { synchronizer.wipe() }
+}

package/ios/ZCashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift

@@ -0,0 +1,175 @@
+//
+//  CombineSDKSynchronizer.swift
+//  
+//
+//  Created by Michal Fousek on 16.03.2023.
+//
+
+import Combine
+import Foundation
+
+/// This is a super thin layer that implements the `CombineSynchronizer` protocol and translates the async API defined in `Synchronizer` to
+/// Combine-based API. And it doesn't do anything else. It doesn't keep any state. It's here so each client can choose the API that suits its case the
+/// best. And usage of this can be combined with usage of `ClosureSDKSynchronizer`. So devs can really choose the best SDK API for each part of the
+/// client app.
+///
+/// If you are looking for documentation for a specific method or property look for it in the `Synchronizer` protocol.
+public struct CombineSDKSynchronizer {
+    private let synchronizer: Synchronizer
+
+    public init(synchronizer: Synchronizer) {
+        self.synchronizer = synchronizer
+    }
+}
+
+extension CombineSDKSynchronizer: CombineSynchronizer {
+    public var alias: ZcashSynchronizerAlias { synchronizer.alias }
+
+    public var latestState: SynchronizerState { synchronizer.latestState }
+    public var connectionState: ConnectionState { synchronizer.connectionState }
+
+    public var stateStream: AnyPublisher<SynchronizerState, Never> { synchronizer.stateStream }
+    public var eventStream: AnyPublisher<SynchronizerEvent, Never> { synchronizer.eventStream }
+
+    public func prepare(
+        with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
+    ) -> SinglePublisher<Initializer.InitializationResult, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            return try await self.synchronizer.prepare(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
+        }
+    }
+
+    public func start(retry: Bool) -> CompletablePublisher<Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.start(retry: retry)
+        }
+    }
+
+    public func stop() {
+        synchronizer.stop()
+    }
+
+    public func getSaplingAddress(accountIndex: Int) -> SinglePublisher<SaplingAddress, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func getUnifiedAddress(accountIndex: Int) -> SinglePublisher<UnifiedAddress, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func getTransparentAddress(accountIndex: Int) -> SinglePublisher<TransparentAddress, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
+        }
+    }
+
+    public func sendToAddress(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        toAddress: Recipient,
+        memo: Memo?
+    ) -> SinglePublisher<ZcashTransaction.Overview, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
+        }
+    }
+
+    public func shieldFunds(
+        spendingKey: UnifiedSpendingKey,
+        memo: Memo,
+        shieldingThreshold: Zatoshi
+    ) -> SinglePublisher<ZcashTransaction.Overview, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
+        }
+    }
+
+    public var pendingTransactions: AnyPublisher<[ZcashTransaction.Overview], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.pendingTransactions
+        }
+    }
+
+    public var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.transactions
+        }
+    }
+
+    public var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.sentTransactions
+        }
+    }
+
+    public var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.receivedTransactions
+        }
+    }
+    
+    public func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository { synchronizer.paginatedTransactions(of: kind) }
+
+    public func getMemos(for transaction: ZcashTransaction.Overview) -> SinglePublisher<[Memo], Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getMemos(for: transaction)
+        }
+    }
+
+    public func getRecipients(for transaction: ZcashTransaction.Overview) -> SinglePublisher<[TransactionRecipient], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.getRecipients(for: transaction)
+        }
+    }
+
+    public func allPendingTransactions() -> AnyPublisher<[ZcashTransaction.Overview], Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.allPendingTransactions()
+        }
+    }
+
+    public func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) -> SinglePublisher<[ZcashTransaction.Overview], Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.allTransactions(from: transaction, limit: limit)
+        }
+    }
+
+    public func latestHeight() -> SinglePublisher<BlockHeight, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.latestHeight()
+        }
+    }
+
+    public func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) -> SinglePublisher<RefreshedUTXOs, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.refreshUTXOs(address: address, from: height)
+        }
+    }
+
+    public func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
+        }
+    }
+
+    public func getShieldedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await synchronizer.getShieldedBalance(accountIndex: accountIndex)
+        }
+    }
+
+    public func getShieldedVerifiedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
+        }
+    }
+
+    public func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error> { synchronizer.rewind(policy) }
+    public func wipe() -> CompletablePublisher<Error> { synchronizer.wipe() }
+}

package/ios/ZCashLightClientKit/Synchronizer/Dependencies.swift

@@ -0,0 +1,207 @@
+//
+//  Dependencies.swift
+//  
+//
+//  Created by Michal Fousek on 01.05.2023.
+//
+
+import Foundation
+
+enum Dependencies {
+    static func setup(
+        in container: DIContainer,
+        urls: Initializer.URLs,
+        alias: ZcashSynchronizerAlias,
+        networkType: NetworkType,
+        endpoint: LightWalletEndpoint,
+        loggingPolicy: Initializer.LoggingPolicy = .default(.debug)
+    ) {
+        container.register(type: Logger.self, isSingleton: true) { _ in
+            let logger: Logger
+            switch loggingPolicy {
+            case let .default(logLevel):
+                logger = OSLogger(logLevel: logLevel, alias: alias)
+            case let .custom(customLogger):
+                logger = customLogger
+            case .noLogging:
+                logger = NullLogger()
+            }
+
+            return logger
+        }
+
+        container.register(type: ZcashRustBackendWelding.self, isSingleton: true) { _ in
+            return ZcashRustBackend(
+                dbData: urls.dataDbURL,
+                fsBlockDbRoot: urls.fsBlockDbRoot,
+                spendParamsPath: urls.spendParamsURL,
+                outputParamsPath: urls.outputParamsURL,
+                networkType: networkType
+            )
+        }
+
+        container.register(type: LightWalletService.self, isSingleton: true) { _ in
+            return LightWalletGRPCService(endpoint: endpoint)
+        }
+
+        container.register(type: TransactionRepository.self, isSingleton: true) { _ in
+            TransactionSQLDAO(dbProvider: SimpleConnectionProvider(path: urls.dataDbURL.path, readonly: true))
+        }
+
+        container.register(type: CompactBlockRepository.self, isSingleton: true) { di in
+            let logger = di.resolve(Logger.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+
+            return FSCompactBlockRepository(
+                fsBlockDbRoot: urls.fsBlockDbRoot,
+                metadataStore: .live(
+                    fsBlockDbRoot: urls.fsBlockDbRoot,
+                    rustBackend: rustBackend,
+                    logger: logger
+                ),
+                blockDescriptor: .live,
+                contentProvider: DirectoryListingProviders.defaultSorted,
+                logger: logger
+            )
+        }
+
+        container.register(type: BlockDownloaderService.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let storage = di.resolve(CompactBlockRepository.self)
+
+            return BlockDownloaderServiceImpl(service: service, storage: storage)
+        }
+
+        container.register(type: SDKMetrics.self, isSingleton: true) { _ in
+            SDKMetrics()
+        }
+
+        container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
+
+            return LatestBlocksDataProviderImpl(service: service, transactionRepository: transactionRepository)
+        }
+
+        container.register(type: SyncSessionIDGenerator.self, isSingleton: false) { _ in
+            UniqueSyncSessionIDGenerator()
+        }
+
+        container.register(type: InternalSyncProgress.self, isSingleton: true) { di in
+            let logger = di.resolve(Logger.self)
+            return InternalSyncProgress(alias: alias, storage: UserDefaults.standard, logger: logger)
+        }
+    }
+    
+    static func setupCompactBlockProcessor(
+        in container: DIContainer,
+        config: CompactBlockProcessor.Configuration,
+        accountRepository: AccountRepository
+    ) {
+        container.register(type: BlockDownloader.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let blockDownloaderService = di.resolve(BlockDownloaderService.self)
+            let storage = di.resolve(CompactBlockRepository.self)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+
+            return BlockDownloaderImpl(
+                service: service,
+                downloaderService: blockDownloaderService,
+                storage: storage,
+                internalSyncProgress: internalSyncProgress,
+                metrics: metrics,
+                logger: logger
+            )
+        }
+        
+        container.register(type: BlockValidator.self, isSingleton: true) { di in
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+
+            return BlockValidatorImpl(
+                rustBackend: rustBackend,
+                metrics: metrics,
+                logger: logger
+            )
+        }
+
+        container.register(type: BlockScanner.self, isSingleton: true) { di in
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+            let latestBlocksDataProvider = di.resolve(LatestBlocksDataProvider.self)
+
+            let blockScannerConfig = BlockScannerConfig(
+                networkType: config.network.networkType,
+                scanningBatchSize: config.scanningBatchSize
+            )
+
+            return BlockScannerImpl(
+                config: blockScannerConfig,
+                rustBackend: rustBackend,
+                transactionRepository: transactionRepository,
+                metrics: metrics,
+                logger: logger,
+                latestBlocksDataProvider: latestBlocksDataProvider
+            )
+        }
+        
+        container.register(type: BlockEnhancer.self, isSingleton: true) { di in
+            let blockDownloaderService = di.resolve(BlockDownloaderService.self)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+
+            return BlockEnhancerImpl(
+                blockDownloaderService: blockDownloaderService,
+                internalSyncProgress: internalSyncProgress,
+                rustBackend: rustBackend,
+                transactionRepository: transactionRepository,
+                metrics: metrics,
+                logger: logger
+            )
+        }
+        
+        container.register(type: UTXOFetcher.self, isSingleton: true) { di in
+            let blockDownloaderService = di.resolve(BlockDownloaderService.self)
+            let utxoFetcherConfig = UTXOFetcherConfig(walletBirthdayProvider: config.walletBirthdayProvider)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+            
+            return UTXOFetcherImpl(
+                accountRepository: accountRepository,
+                blockDownloaderService: blockDownloaderService,
+                config: utxoFetcherConfig,
+                internalSyncProgress: internalSyncProgress,
+                rustBackend: rustBackend,
+                metrics: metrics,
+                logger: logger
+            )
+        }
+        
+        container.register(type: SaplingParametersHandler.self, isSingleton: true) { di in
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let logger = di.resolve(Logger.self)
+
+            let saplingParametersHandlerConfig = SaplingParametersHandlerConfig(
+                outputParamsURL: config.outputParamsURL,
+                spendParamsURL: config.spendParamsURL,
+                saplingParamsSourceURL: config.saplingParamsSourceURL
+            )
+            
+            return SaplingParametersHandlerImpl(
+                config: saplingParametersHandlerConfig,
+                rustBackend: rustBackend,
+                logger: logger
+            )
+        }
+    }
+}