react-native-zcash 0.4.2 → 0.6.0

package/src/react-native.ts

@@ -5,16 +5,14 @@ import {
 } from 'react-native'
 
 import {
-  BlockRange,
-  ConfirmedTransaction,
+  Addresses,
   InitializerConfig,
   Network,
   SpendFailure,
   SpendInfo,
   SpendSuccess,
   SynchronizerCallbacks,
-  UnifiedViewingKey,
-  WalletBalance
+  UnifiedViewingKey
 } from './types'
 
 const { RNZcash } = NativeModules
@@ -68,11 +66,12 @@ export class Synchronizer {
       initializerConfig.alias,
       initializerConfig.networkName,
       initializerConfig.defaultHost,
-      initializerConfig.defaultPort
+      initializerConfig.defaultPort,
+      initializerConfig.newWallet
     )
   }
 
-  async deriveUnifiedAddress(): Promise<string> {
+  async deriveUnifiedAddress(): Promise<Addresses> {
     const result = await RNZcash.deriveUnifiedAddress(this.alias)
     return result
   }
@@ -82,20 +81,6 @@ export class Synchronizer {
     return result
   }
 
-  async getBalance(): Promise<WalletBalance> {
-    const result = await RNZcash.getBalance(this.alias)
-    return result
-  }
-
-  async getTransactions(range: BlockRange): Promise<ConfirmedTransaction[]> {
-    const result = await RNZcash.getTransactions(
-      this.alias,
-      range.first,
-      range.last
-    )
-    return result
-  }
-
   rescan(): void {
     RNZcash.rescan(this.alias)
   }
@@ -115,8 +100,15 @@ export class Synchronizer {
 
   // Events
 
-  subscribe({ onStatusChanged, onUpdate }: SynchronizerCallbacks): void {
+  subscribe({
+    onBalanceChanged,
+    onStatusChanged,
+    onTransactionsChanged,
+    onUpdate
+  }: SynchronizerCallbacks): void {
+    this.setListener('BalanceEvent', onBalanceChanged)
     this.setListener('StatusEvent', onStatusChanged)
+    this.setListener('TransactionEvent', onTransactionsChanged)
     this.setListener('UpdateEvent', onUpdate)
   }
 

package/src/types.ts

@@ -1,10 +1,5 @@
 export type Network = 'mainnet' | 'testnet'
 
-export interface WalletBalance {
-  availableZatoshi: string
-  totalZatoshi: string
-}
-
 export interface InitializerConfig {
   networkName: Network
   defaultHost: string
@@ -12,6 +7,7 @@ export interface InitializerConfig {
   mnemonicSeed: string
   alias: string
   birthdayHeight: number
+  newWallet: boolean
 }
 
 export interface SpendInfo {
@@ -31,40 +27,39 @@ export interface SpendFailure {
   errorCode?: string
 }
 
-export interface SynchronizerStatus {
-  alias: string
-  name:
-    | 'STOPPED' /** Indicates that [stop] has been called on this Synchronizer and it will no longer be used. */
-    | 'DISCONNECTED' /** Indicates that this Synchronizer is disconnected from its lightwalletd server. When set, a UI element may want to turn red. */
-    | 'DOWNLOADING' /** Indicates that this Synchronizer is actively downloading new blocks from the server. */
-    | 'VALIDATING' /** Indicates that this Synchronizer is actively validating new blocks that were downloaded from the server. Blocks need to be verified before they are scanned. This confirms that each block is chain-sequential, thereby detecting missing blocks and reorgs. */
-    | 'SCANNING' /** Indicates that this Synchronizer is actively decrypting new blocks that were downloaded from the server. */
-    | 'ENHANCING' /** Indicates that this Synchronizer is actively enhancing newly scanned blocks with additional transaction details, fetched from the server. */
-    | 'SYNCED' /** 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. In this state, the balance can be trusted. */
-}
-
 export interface UnifiedViewingKey {
   extfvk: string
   extpub: string
 }
 
+export interface BalanceEvent {
+  availableZatoshi: string
+  totalZatoshi: string
+}
+
 export interface StatusEvent {
   alias: string
-  name: SynchronizerStatus
+  name:
+    | 'STOPPED' /** Indicates that [stop] has been called on this Synchronizer and it will no longer be used. */
+    | 'DISCONNECTED' /** Indicates that this Synchronizer is disconnected from its lightwalletd server. When set, a UI element may want to turn red. */
+    | 'SYNCING' /** Indicates that this Synchronizer is actively downloading and scanning new blocks */
+    | 'SYNCED' /** 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. In this state, the balance can be trusted. */
+}
+
+export interface TransactionEvent {
+  transactions: ConfirmedTransaction[]
 }
 
 export interface UpdateEvent {
   alias: string
-  isDownloading: boolean
-  isScanning: boolean
-  lastDownloadedHeight: number
-  lastScannedHeight: number
   scanProgress: number // 0 - 100
   networkBlockHeight: number
 }
 
 export interface SynchronizerCallbacks {
-  onStatusChanged(status: SynchronizerStatus): void
+  onBalanceChanged(balance: BalanceEvent): void
+  onStatusChanged(status: StatusEvent): void
+  onTransactionsChanged(transactions: TransactionEvent): void
   onUpdate(event: UpdateEvent): void
 }
 
@@ -75,9 +70,17 @@ export interface BlockRange {
 
 export interface ConfirmedTransaction {
   rawTransactionId: string
+  raw?: string
   blockTimeInSeconds: number
   minedHeight: number
   value: string
+  fee?: string
   toAddress?: string
   memos: string[]
 }
+
+export interface Addresses {
+  unifiedAddress: string
+  saplingAddress: string
+  transparentAddress: string
+}

package/ios/ZCashLightClientKit/Block/Utils/InternalSyncProgress.swift

@@ -1,200 +0,0 @@
-//
-//  InternalSyncProgress.swift
-//  
-//
-//  Created by Michal Fousek on 23.11.2022.
-//
-
-import Foundation
-
-struct SyncRanges: Equatable {
-    let latestBlockHeight: BlockHeight
-    /// The sync process can be interrupted in any phase. It may happen that it's interrupted while downloading blocks. In that case in next sync
-    /// process already downloaded blocks needs to be scanned before the sync process starts to download new blocks. And the range of blocks that are
-    /// already downloaded but not scanned is stored in this variable.
-    let downloadedButUnscannedRange: CompactBlockRange?
-    /// Range of blocks that are not yet downloaded and not yet scanned.
-    let downloadAndScanRange: CompactBlockRange?
-    /// Range of blocks that are not enhanced yet.
-    let enhanceRange: CompactBlockRange?
-    /// Range of blocks for which no UTXOs are fetched yet.
-    let fetchUTXORange: CompactBlockRange?
-
-    let latestScannedHeight: BlockHeight?
-
-    let latestDownloadedBlockHeight: BlockHeight?
-}
-
-protocol InternalSyncProgressStorage {
-    func bool(forKey defaultName: String) -> Bool
-    func integer(forKey defaultName: String) -> Int
-    func set(_ value: Int, forKey defaultName: String)
-    func set(_ value: Bool, forKey defaultName: String)
-    @discardableResult
-    func synchronize() -> Bool
-}
-
-extension UserDefaults: InternalSyncProgressStorage { }
-
-actor InternalSyncProgress {
-    enum Key: String, CaseIterable {
-        case latestDownloadedBlockHeight
-        case latestEnhancedHeight
-        case latestUTXOFetchedHeight
-
-        func with(_ alias: ZcashSynchronizerAlias) -> String {
-            switch alias {
-            case .`default`:
-                return self.rawValue
-            case let .custom(rawAlias):
-                return "\(self.rawValue)_\(rawAlias)"
-            }
-        }
-    }
-
-    private let alias: ZcashSynchronizerAlias
-    private let storage: InternalSyncProgressStorage
-    let logger: Logger
-
-    var latestDownloadedBlockHeight: BlockHeight { load(.latestDownloadedBlockHeight) }
-    var latestEnhancedHeight: BlockHeight { load(.latestEnhancedHeight) }
-    var latestUTXOFetchedHeight: BlockHeight { load(.latestUTXOFetchedHeight) }
-
-    init(alias: ZcashSynchronizerAlias, storage: InternalSyncProgressStorage, logger: Logger) {
-        self.alias = alias
-        self.storage = storage
-        self.logger = logger
-    }
-
-    func load(_ key: Key) -> BlockHeight {
-        storage.integer(forKey: key.with(alias))
-    }
-
-    func set(_ value: BlockHeight, _ key: Key) {
-        storage.set(value, forKey: key.with(alias))
-        storage.synchronize()
-    }
-
-    func rewind(to: BlockHeight) {
-        Key.allCases.forEach { key in
-            let finalRewindHeight = min(load(key), to)
-            self.set(finalRewindHeight, key)
-        }
-    }
-
-    /// `InternalSyncProgress` is from now on used to track which block were already downloaded. Previous versions of the SDK were using cache DB to
-    /// track this. Because of this we have to migrate height of latest downloaded block from cache DB to here.
-    ///
-    /// - Parameter latestDownloadedBlockHeight: Height of latest downloaded block from cache DB.
-    func migrateIfNeeded(latestDownloadedBlockHeightFromCacheDB latestDownloadedBlockHeight: BlockHeight) {
-        let key = "InternalSyncProgressMigrated"
-        if !storage.bool(forKey: key) {
-            set(latestDownloadedBlockHeight, .latestDownloadedBlockHeight)
-        }
-        storage.set(true, forKey: key)
-        storage.synchronize()
-    }
-
-    /// Computes the next state for the sync process. Thanks to this it's possible to interrupt the sync process at any phase and then it can be safely
-    /// resumed.
-    ///
-    /// The sync process has 4 phases (download, scan, enhance, fetch UTXO). `InternalSyncProgress` tracks independently which blocks were already
-    /// processed in each phase. To compute the next state these 4 numbers are compared with `latestBlockHeight`.
-    ///
-    /// - If any of these numbers are larger than `latestBlockHeight` then `wait` is used as the next state. We have locally higher block heights than
-    ///   are currently available at LightWalletd.
-    /// - If any of these numbers are lower than `latestBlockHeight` then `processNewBlocks` is used as the next state. The sync process should run.
-    /// - Otherwise `finishProcessing` is used as the next state. It means that local data are synced with what is available at LightWalletd.
-    ///
-    /// - Parameters:
-    ///   - latestBlockHeight: Latest height fetched from LightWalletd API.
-    ///   - latestScannedHeight: Latest height of latest block scanned.
-    ///   - walletBirthday: Wallet birthday.
-    /// - Returns: Computed state.
-    func computeNextState(
-        latestBlockHeight: BlockHeight,
-        latestScannedHeight: BlockHeight,
-        walletBirthday: BlockHeight
-    ) -> CompactBlockProcessor.NextState {
-        logger.debug("""
-            Init numbers:
-            latestBlockHeight:       \(latestBlockHeight)
-            latestDownloadedHeight:  \(latestDownloadedBlockHeight)
-            latestScannedHeight:     \(latestScannedHeight)
-            latestEnhancedHeight:    \(latestEnhancedHeight)
-            latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
-            """)
-
-        if  latestDownloadedBlockHeight > latestBlockHeight ||
-            latestScannedHeight > latestBlockHeight ||
-            latestEnhancedHeight > latestBlockHeight ||
-            latestUTXOFetchedHeight > latestBlockHeight {
-            return .wait(latestHeight: latestBlockHeight, latestDownloadHeight: latestDownloadedBlockHeight)
-        } else if latestDownloadedBlockHeight < latestBlockHeight ||
-            latestScannedHeight < latestBlockHeight ||
-            latestEnhancedHeight < latestEnhancedHeight ||
-            latestUTXOFetchedHeight < latestBlockHeight {
-            let ranges = computeSyncRanges(
-                birthday: walletBirthday,
-                latestBlockHeight: latestBlockHeight,
-                latestScannedHeight: latestScannedHeight
-            )
-            return .processNewBlocks(ranges: ranges)
-        } else {
-            return .finishProcessing(height: latestBlockHeight)
-        }
-    }
-
-    func computeSyncRanges(
-        birthday: BlockHeight,
-        latestBlockHeight: BlockHeight,
-        latestScannedHeight: BlockHeight
-    ) -> SyncRanges {
-        // If there is more downloaded then scanned blocks we have to range for these blocks. The sync process will then start with scanning these
-        // blocks instead of downloading new ones.
-        let downloadedButUnscannedRange: CompactBlockRange?
-        if latestScannedHeight < latestDownloadedBlockHeight {
-            downloadedButUnscannedRange = latestScannedHeight + 1...latestDownloadedBlockHeight
-        } else {
-            downloadedButUnscannedRange = nil
-        }
-
-        if latestScannedHeight > latestDownloadedBlockHeight {
-            logger.warn("""
-            InternalSyncProgress found inconsistent state.
-                latestBlockHeight:       \(latestBlockHeight)
-            --> latestDownloadedHeight:  \(latestDownloadedBlockHeight)
-                latestScannedHeight:     \(latestScannedHeight)
-                latestEnhancedHeight:    \(latestEnhancedHeight)
-                latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
-
-            latest downloaded height
-            """)
-        }
-
-        // compute the range that must be downloaded and scanned based on
-        // birthday, `latestDownloadedBlockHeight`, `latestScannedHeight` and
-        // latest block height fetched from the chain.
-        let downloadAndScanRange = computeRange(
-            latestHeight: max(latestDownloadedBlockHeight, latestScannedHeight),
-            birthday: birthday,
-            latestBlockHeight: latestBlockHeight
-        )
-
-        return SyncRanges(
-            latestBlockHeight: latestBlockHeight,
-            downloadedButUnscannedRange: downloadedButUnscannedRange,
-            downloadAndScanRange: downloadAndScanRange,
-            enhanceRange: computeRange(latestHeight: latestEnhancedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
-            fetchUTXORange: computeRange(latestHeight: latestUTXOFetchedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
-            latestScannedHeight: latestScannedHeight,
-            latestDownloadedBlockHeight: latestDownloadedBlockHeight
-        )
-    }
-
-    private func computeRange(latestHeight: BlockHeight, birthday: BlockHeight, latestBlockHeight: BlockHeight) -> CompactBlockRange? {
-        guard latestHeight < latestBlockHeight else { return nil }
-        let lowerBound = latestHeight <= birthday ? birthday : latestHeight + 1
-        return lowerBound...latestBlockHeight
-    }
-}

package/ios/ZCashLightClientKit/Block/Validate/BlockValidator.swift

@@ -1,51 +0,0 @@
-//
-//  CompactBlockValidationInformation.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 10/30/19.
-//  Copyright © 2019 Electric Coin Company. All rights reserved.
-//
-
-import Foundation
-
-protocol BlockValidator {
-    /// Validate all the downloaded blocks that haven't been yet validated.
-    func validate() async throws
-}
-
-struct BlockValidatorImpl {
-    let rustBackend: ZcashRustBackendWelding
-    let metrics: SDKMetrics
-    let logger: Logger
-}
-
-extension BlockValidatorImpl: BlockValidator {
-    /// - Throws:
-    ///  - `rustValidateCombinedChainValidationFailed` if there was an error during validation unrelated to chain validity.
-    ///  - `rustValidateCombinedChainInvalidChain(upperBound)` if the combined chain is invalid. `upperBound` is the height of the highest invalid
-    ///    block(on the assumption that the highest block in the cache database is correct).
-    func validate() async throws {
-        try Task.checkCancellation()
-
-        let startTime = Date()
-        do {
-            try await rustBackend.validateCombinedChain(limit: 0)
-            pushProgressReport(startTime: startTime, finishTime: Date())
-            logger.debug("validateChainFinished")
-        } catch {
-            logger.debug("Validate chain failed with \(error)")
-            pushProgressReport(startTime: startTime, finishTime: Date())
-            throw error
-        }
-    }
-
-    private func pushProgressReport(startTime: Date, finishTime: Date) {
-        metrics.pushProgressReport(
-            progress: BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0),
-            start: startTime,
-            end: finishTime,
-            batchSize: 0,
-            operation: .validateBlocks
-        )
-    }
-}

package/ios/ZCashLightClientKit/DAO/BlockDao.swift

@@ -1,112 +0,0 @@
-//
-//  BlockDao.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 10/16/19.
-//  Copyright © 2019 Electric Coin Company. All rights reserved.
-//
-
-import Foundation
-import SQLite
-
-protocol BlockDao {
-    func latestBlockHeight() throws -> BlockHeight
-    func latestBlock() throws -> Block?
-    func block(at height: BlockHeight) throws -> Block?
-}
-
-struct Block: Codable {
-    enum CodingKeys: String, CodingKey {
-        case height
-        case hash
-        case time
-        case saplingTree = "sapling_tree"
-    }
-
-    enum TableStructure {
-        static let height = Expression<Int>(Block.CodingKeys.height.rawValue)
-        static let hash = Expression<Blob>(Block.CodingKeys.hash.rawValue)
-        static let time = Expression<Int>(Block.CodingKeys.time.rawValue)
-        static let saplingTree = Expression<Blob>(Block.CodingKeys.saplingTree.rawValue)
-    }
-
-    let height: BlockHeight
-    let hash: Data
-    let time: Int
-    let saplingTree: Data
-    
-    static let table = Table("blocks")
-}
-
-class BlockSQLDAO: BlockDao {
-    let dbProvider: ConnectionProvider
-    let table: Table
-    let height = 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)
-            }
-        }
-    }
-
-    /// - Throws: `blockDAOLatestBlockHeight` if sqlite to fetch height fails.
-    func latestBlockHeight() throws -> BlockHeight {
-        do {
-            return try dbProvider.connection().scalar(table.select(height.max)) ?? BlockHeight.empty()
-        } catch {
-            throw ZcashError.blockDAOLatestBlockHeight(error)
-        }
-    }
-    
-    func latestBlock() throws -> Block? {
-        do {
-            return try dbProvider
-                .connection()
-                .prepare(Block.table.order(height.desc).limit(1))
-                .map {
-                    do {
-                        return try $0.decode()
-                    } catch {
-                        throw ZcashError.blockDAOLatestBlockCantDecode(error)
-                    }
-                }
-                .first
-        } catch {
-            if let error = error as? ZcashError {
-                throw error
-            } else {
-                throw ZcashError.blockDAOLatestBlock(error)
-            }
-        }
-    }
-}
-
-extension BlockSQLDAO: BlockRepository {
-    func lastScannedBlockHeight() -> BlockHeight {
-        (try? self.latestBlockHeight()) ?? BlockHeight.empty()
-    }
-}

package/ios/ZCashLightClientKit/Entity/BlockProgress.swift

@@ -1,24 +0,0 @@
-//
-//  BlockProgress.swift
-//  
-//
-//  Created by Michal Fousek on 03.02.2023.
-//
-
-import Foundation
-
-public struct BlockProgress: Equatable {
-    public let startHeight: BlockHeight
-    public let targetHeight: BlockHeight
-    public let progressHeight: BlockHeight
-
-    public var progress: Float {
-        let overall = self.targetHeight - self.startHeight
-
-        return overall > 0 ? Float((self.progressHeight - self.startHeight)) / Float(overall) : 0
-    }
-}
-
-public extension BlockProgress {
-    static let nullProgress = BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)
-}