react-native-zcash 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # React Native Zcash
 
+## 0.3.5 (2023-08-03)
+
+- fixed: Update our default Kotlin version to be compatible with React Native v0.72.
+- changed: Remove our iOS dependency on ZCashLightClientKit by copying the Swift sources directly into this NPM package. This removes the need for users to touch checkpoints on either platform.
+
 ## 0.3.4 (2023-07-27)
 
 - added: Add checkpoints to repo with script to update and copy them from Android to iOS build directories

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Electric Coin Company Prototypes and Experiments
+Copyright (c) 2022 Airbitz, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,64 +1,64 @@
-# React Native Zcash
+# react-native-zcash
 
-[![Build Status](https://travis-ci.org/EdgeApp/react-native-zcash.svg?branch=master)](https://travis-ci.org/EdgeApp/react-native-zcash)
-[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+This library packages the ZCashLightClientKit for use on React Native.
 
-`yarn add react-native-zcash` to install.
+## Usage
 
-## iOS
+First, add this library to your React Native app using NPM or Yarn, and run `pod install` as necessary to integrate it with your app's native code.
 
-To use this library on iOS add these lines to your Podspec file, to work around certain compatiblity issues between the ZCash SDK and React Native:
+If you encounter errors during `pod install`, you may need to add the following code to the `target` section of your Podfile:
 
 ```ruby
+# Zcash transitive dependencies:
+pod 'CGRPCZlib', :modular_headers => true
 pod 'CNIOAtomics', :modular_headers => true
 pod 'CNIOBoringSSL', :modular_headers => true
 pod 'CNIOBoringSSLShims', :modular_headers => true
-pod 'CNIOLinux', :modular_headers => true
 pod 'CNIODarwin', :modular_headers => true
 pod 'CNIOHTTPParser', :modular_headers => true
+pod 'CNIOLinux', :modular_headers => true
 pod 'CNIOWindows', :modular_headers => true
-pod 'CGRPCZlib', :modular_headers => true
-pod 'ZcashLightClientKit', :git => 'https://github.com/zcash/ZcashLightClientKit.git', :commit => '74f3ae20f26748e162c051e5fa343c71febc4294'
 ```
 
-Finally, you can use CocoaPods to integrate the library with your project:
+On the Android side, you may need to configure an explicit Kotlin version, so all your native dependencies will be compatible with one another. Simply define `kotlinVersion` in your `android/build.gradle` file:
 
-```bash
-cd ios
-pod install
+```groovy
+buildscript {
+  ext {
+    kotlinVersion = '1.8.22'
+  }
+}
 ```
 
-## Android
-
-### Change Gradle version
-
-`react-native-zcash` is not yet compatible with gradle 8 which is the default for RN71. Replace
-
-    distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-all.zip
-
-with
-
-    distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-all.zip
-
-in your `gradle-wrapper.properties` file
-
-
-### Define Kotlin version
-
-In the `android/build.gradle` add the line
-
-    kotlinVersion = '1.6.10'
-
-to the section
+### API overview
+
+- `KeyTool`
+  - `deriveViewingKey`
+  - `deriveSpendingKey`
+  - `getBirthdayHeight`
+- `AddressTool`
+  - `deriveShieldedAddress`
+  - `isValidShieldedAddress`
+  - `isValidTransparentAddress`
+- `makeSynchronizer`
+  - `start`
+  - `stop`
+  - `rescan`
+  - `getLatestNetworkHeight`
+  - `getShieldedBalance`
+  - `getTransactions`
+  - `sendToAddress`
+
+## Developing
+
+This library relies on a large amount of native code from other repos. To integrate this code, you must run the following script before publishing this library to NPM:
+
+```sh
+npm run update-sources
+```
 
-    buildscript {
-      ext {
-        ...
-        kotlinVersion = '1.6.10'
-        ...
-      }
-    }
+This script will download ZCashLightClientKit and zcash-light-client-ffi, modify them for React Native, and integrate them with our wrapper code.
 
-## API overview
+The `update-sources` script is also the place to make edits when upgrading any of the third-party dependencies.
 
-TODO
+We also have an `update-checkpoints` command that will connect to a node and generate fresh checkpoints based on the chain state.

package/android/build.gradle

@@ -1,7 +1,7 @@
 buildscript {
   def kotlinVersion = rootProject.ext.has('kotlinVersion')
     ? rootProject.ext.get('kotlinVersion')
-    : '1.5.20'
+    : '1.8.22'
 
   repositories {
     mavenCentral()

package/ios/RNZcash.m

@@ -1,7 +1,6 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
-
 @interface RCT_EXTERN_MODULE(RNZcash, RCTEventEmitter<RCTBridgeModule>)
 
 // Synchronizer

package/ios/RNZcash.swift

@@ -1,5 +1,4 @@
 import Foundation
-import ZcashLightClientKit
 import os
 
 var SynchronizerMap = [String: WalletSynchronizer]()
@@ -125,7 +124,7 @@ class RNZcash : RCTEventEmitter {
                 wallet.subscribe()
             } catch {
                 reject("StartError", "Synchronizer failed to start", error)
-            } 
+            }
             resolve(nil)
         } else {
             reject("StartError", "Wallet does not exist", genericError)
@@ -253,12 +252,12 @@ class RNZcash : RCTEventEmitter {
                 wallet.fullySynced = false
             } catch {
                 reject("RescanError", "Failed to rescan wallet", error)
-            } 
+            }
             resolve(nil)
         } else {
             reject("RescanError", "Wallet does not exist", genericError)
         }
-    }    
+    }
 
     // Derivation Tool
     private func getDerivationToolForNetwork(_ network: String) -> DerivationTool {
@@ -396,7 +395,7 @@ class WalletSynchronizer : NSObject {
             emit("StatusEvent", data)
         }
     }
-    
+
     @objc public func updateProcessorState(notification: NSNotification) {
         let prevLastDownloadedHeight = self.processorState.lastDownloadedHeight
         let prevScanProgress = self.processorState.scanProgress
@@ -512,7 +511,7 @@ func outputParamsURLHelper(_ alias: String) throws -> URL {
 
 
 // Logger
-class RNZcashLogger: ZcashLightClientKit.Logger {
+class RNZcashLogger: Logger {
     enum LogLevel: Int {
         case debug
         case error
@@ -520,33 +519,33 @@ class RNZcashLogger: ZcashLightClientKit.Logger {
         case event
         case info
     }
-    
+
     enum LoggerType {
         case osLog
         case printerLog
     }
-    
+
     var level: LogLevel
     var loggerType: LoggerType
-    
+
     init(logLevel: LogLevel, type: LoggerType = .osLog) {
         self.level = logLevel
         self.loggerType = type
     }
-    
+
     private static let subsystem = Bundle.main.bundleIdentifier!
     static let oslog = OSLog(subsystem: subsystem, category: "logs")
-    
+
     func debug(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         guard level.rawValue == LogLevel.debug.rawValue else { return }
         log(level: "DEBUG 🐞", message: message, file: file, function: function, line: line)
     }
-    
+
     func error(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         guard level.rawValue <= LogLevel.error.rawValue else { return }
         log(level: "ERROR 💥", message: message, file: file, function: function, line: line)
     }
-    
+
     func warn(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         guard level.rawValue <= LogLevel.warning.rawValue else { return }
         log(level: "WARNING ⚠️", message: message, file: file, function: function, line: line)
@@ -556,12 +555,12 @@ class RNZcashLogger: ZcashLightClientKit.Logger {
         guard level.rawValue <= LogLevel.event.rawValue else { return }
         log(level: "EVENT ⏱", message: message, file: file, function: function, line: line)
     }
-    
+
     func info(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         guard level.rawValue <= LogLevel.info.rawValue else { return }
         log(level: "INFO ℹ️", message: message, file: file, function: function, line: line)
     }
-    
+
     private func log(level: String, message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         let fileName = (String(describing: file) as NSString).lastPathComponent
         switch loggerType {

package/ios/ZCashLightClientKit/Block/DatabaseStorage/CompactBlockStorage.swift

@@ -0,0 +1,123 @@
+//
+//  CompactBlockStorage.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+protocol ConnectionProvider {
+    func connection() throws -> Connection
+}
+
+class CompactBlockStorage: CompactBlockDAO {
+    var dbProvider: ConnectionProvider
+    
+    init(connectionProvider: ConnectionProvider) {
+        dbProvider = connectionProvider
+    }
+    
+    private func compactBlocksTable() -> Table {
+        Table("compactblocks")
+    }
+    private func heightColumn() -> Expression<Int64> {
+        Expression<Int64>("height")
+    }
+    private func dataColumn() -> Expression<Blob> {
+        Expression<Blob>("data")
+    }
+    func createTable() throws {
+        do {
+            let compactBlocks = compactBlocksTable()
+            let height = heightColumn()
+            let data = dataColumn()
+            
+            let db = try dbProvider.connection()
+         
+            try db.run(compactBlocks.create(ifNotExists: true) { table in
+                table.column(height, primaryKey: true)
+                table.column(data)
+            }
+            )
+            
+            try db.run(compactBlocks.createIndex(height, ifNotExists: true))
+        } catch {
+            throw StorageError.couldNotCreate
+        }
+    }
+    
+    func insert(_ block: ZcashCompactBlock) throws {
+        try dbProvider.connection().run(compactBlocksTable().insert(block))
+    }
+    
+    func insert(_ blocks: [ZcashCompactBlock]) throws {
+        let compactBlocks = compactBlocksTable()
+        let db = try dbProvider.connection()
+        try db.transaction(.immediate) {
+            for block in blocks {
+                try db.run(compactBlocks.insert(block))
+            }
+        }
+    }
+    
+    func latestBlockHeight() throws -> BlockHeight {
+        guard let maxHeight = try dbProvider.connection().scalar(compactBlocksTable().select(heightColumn().max)) else {
+            return BlockHeight.empty()
+        }
+        
+        guard let blockHeight = BlockHeight(exactly: maxHeight) else {
+            throw StorageError.operationFailed
+        }
+        
+        return blockHeight
+    }
+    
+    func rewind(to height: BlockHeight) throws {
+        try dbProvider.connection().run(compactBlocksTable().filter(heightColumn() >= Int64(height)).delete())
+    }
+}
+
+extension CompactBlockStorage: CompactBlockRepository {
+    func latestHeight() throws -> BlockHeight {
+        try latestBlockHeight()
+    }
+    
+    func latestHeight(result: @escaping (Swift.Result<BlockHeight, Error>) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                result(.success(try self.latestBlockHeight()))
+            } catch {
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func write(blocks: [ZcashCompactBlock]) throws {
+        try insert(blocks)
+    }
+    
+    func write(blocks: [ZcashCompactBlock], completion: ((Error?) -> Void)?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try self.insert(blocks)
+                completion?(nil)
+            } catch {
+                completion?(error)
+            }
+        }
+    }
+    
+    func rewind(to height: BlockHeight, completion: ((Error?) -> Void)?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try self.rewind(to: height)
+                completion?(nil)
+            } catch {
+                completion?(error)
+            }
+        }
+    }
+}

package/ios/ZCashLightClientKit/Block/DatabaseStorage/DatabaseMigrationManager.swift

@@ -0,0 +1,222 @@
+//
+//  DatabaseMigrationManager.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 3/31/21.
+//
+
+import Foundation
+import SQLite
+
+class MigrationManager {
+    enum DataDbMigrations: Int32 {
+        case none = 0
+        case version1 = 1
+    }
+    
+    enum CacheDbMigration: Int32 {
+        case none = 0
+    }
+    
+    enum PendingDbMigration: Int32 {
+        case none = 0
+    }
+
+    static let latestDataDbMigrationVersion: Int32 = DataDbMigrations.version1.rawValue
+    static let latestCacheDbMigrationVersion: Int32 = CacheDbMigration.none.rawValue
+    static let latestPendingDbMigrationVersion: Int32 = PendingDbMigration.none.rawValue
+    
+    var cacheDb: ConnectionProvider
+    var dataDb: ConnectionProvider
+    var pendingDb: ConnectionProvider
+    var network: NetworkType
+
+    init(
+        cacheDbConnection: ConnectionProvider,
+        dataDbConnection: ConnectionProvider,
+        pendingDbConnection: ConnectionProvider,
+        networkType: NetworkType
+    ) {
+        self.cacheDb = cacheDbConnection
+        self.dataDb = dataDbConnection
+        self.pendingDb = pendingDbConnection
+        self.network = networkType
+    }
+
+    func performMigration(uvks: [UnifiedViewingKey]) throws {
+        try migrateDataDb(uvks: uvks)
+        try migrateCacheDb()
+        try migratePendingDb()
+    }
+
+    func performVersion1Migration(viewingKeys: [UnifiedViewingKey]) throws {
+        LoggerProxy.debug("Starting migration version 1 from viewing Keys")
+        let db = try self.dataDb.connection()
+       
+        let placeholder = "deriveMe"
+        let migrationStatement =
+            """
+                BEGIN TRANSACTION;
+                PRAGMA foreign_keys = OFF;
+                DROP TABLE utxos;
+                CREATE TABLE IF NOT EXISTS utxos(
+                    id_utxo INTEGER PRIMARY KEY,
+                    address TEXT NOT NULL,
+                    prevout_txid BLOB NOT NULL,
+                    prevout_idx INTEGER NOT NULL,
+                    script BLOB NOT NULL,
+                    value_zat INTEGER NOT NULL,
+                    height INTEGER NOT NULL,
+                    spent_in_tx INTEGER,
+                    FOREIGN KEY (spent_in_tx) REFERENCES transactions(id_tx),
+                    CONSTRAINT tx_outpoint UNIQUE (prevout_txid, prevout_idx)
+                );
+
+                CREATE TABLE IF NOT EXISTS accounts_new (
+                    account INTEGER PRIMARY KEY,
+                    extfvk TEXT NOT NULL,
+                    address TEXT NOT NULL,
+                    transparent_address TEXT NOT NULL
+                );
+
+                INSERT INTO accounts_new SELECT account, extfvk, address, '\(placeholder)' FROM accounts;
+                DROP TABLE accounts;
+
+                ALTER TABLE accounts_new RENAME TO accounts;
+
+                PRAGMA user_version = 1;
+                PRAGMA foreign_keys = ON;
+                COMMIT TRANSACTION;
+            """
+        LoggerProxy.debug("db.execute(\"\(migrationStatement)\")")
+        try db.execute(migrationStatement)
+            
+        LoggerProxy.debug("db.run() succeeded")
+        
+        // derive transparent (shielding) addresses
+        let accountsDao = AccountSQDAO(dbProvider: self.dataDb)
+        
+        let accounts = try accountsDao.getAll()
+        
+        guard !accounts.isEmpty else {
+            LoggerProxy.debug("no existing accounts found while performing this migration")
+            return
+        }
+        
+        guard accounts.count == viewingKeys.count else {
+            let message = """
+                Number of accounts found and viewing keys provided don't match.
+                Found \(accounts.count) account(s) and there were \(viewingKeys.count) Viewing key(s) provided.
+                """
+            LoggerProxy.debug(message)
+            throw StorageError.migrationFailedWithMessage(message: message)
+        }
+
+        let derivationTool = DerivationTool(networkType: self.network)
+        
+        for tuple in zip(accounts, viewingKeys) {
+            let tAddr = try derivationTool.deriveTransparentAddressFromPublicKey(tuple.1.extpub)
+            var account = tuple.0
+            account.transparentAddress = tAddr
+            try accountsDao.update(account)
+        }
+        
+        // sanity check
+        guard try accountsDao.getAll().first(where: { $0.transparentAddress == placeholder }) == nil else {
+            LoggerProxy.error("Accounts Migration performed but the transparent addresses were not derived")
+            throw StorageError.migrationFailed(underlyingError: KeyDerivationErrors.unableToDerive)
+        }
+    }
+
+    func performVersion1Migration(_ seedBytes: [UInt8]) throws {
+        LoggerProxy.debug("Starting migration version 1")
+        
+        // derive transparent (shielding) addresses
+        let accountsDao = AccountSQDAO(dbProvider: self.dataDb)
+        
+        let accounts = try accountsDao.getAll()
+        
+        guard !accounts.isEmpty else {
+            LoggerProxy.debug("no existing accounts found while performing this migration")
+            return
+        }
+        
+        let derivationTool = DerivationTool(networkType: self.network)
+        
+        let uvks = try derivationTool.deriveUnifiedViewingKeysFromSeed(seedBytes, numberOfAccounts: accounts.count)
+        
+        try performVersion1Migration(viewingKeys: uvks)
+    }
+}
+
+private extension MigrationManager {
+    func migratePendingDb() throws {
+        let currentPendingDbVersion = try pendingDb.connection().getUserVersion()
+
+        LoggerProxy.debug(
+            "Attempting to perform migration for pending Db - currentVersion: \(currentPendingDbVersion)." +
+            "Latest version is: \(Self.latestPendingDbMigrationVersion)"
+        )
+
+        if currentPendingDbVersion < Self.latestPendingDbMigrationVersion {
+            // perform no migration just adjust the version number
+            try self.cacheDb.connection().setUserVersion(PendingDbMigration.none.rawValue)
+        } else {
+            LoggerProxy.debug("PendingDb Db - no migration needed")
+        }
+    }
+
+    func migrateCacheDb() throws {
+        let currentCacheDbVersion = try cacheDb.connection().getUserVersion()
+
+        LoggerProxy.debug(
+            "Attempting to perform migration for cache Db - currentVersion: \(currentCacheDbVersion)." +
+            "Latest version is: \(Self.latestCacheDbMigrationVersion)"
+        )
+
+        if currentCacheDbVersion < Self.latestCacheDbMigrationVersion {
+            // perform no migration just adjust the version number
+            try self.cacheDb.connection().setUserVersion(CacheDbMigration.none.rawValue)
+        } else {
+            LoggerProxy.debug("Cache Db - no migration needed")
+        }
+    }
+
+    func migrateDataDb(uvks: [UnifiedViewingKey]) throws {
+        let currentDataDbVersion = try dataDb.connection().getUserVersion()
+        LoggerProxy.debug(
+            "Attempting to perform migration for data Db - currentVersion: \(currentDataDbVersion)." +
+            "Latest version is: \(Self.latestDataDbMigrationVersion)"
+        )
+
+        if currentDataDbVersion < Self.latestDataDbMigrationVersion {
+            for dbVersion in (currentDataDbVersion + 1) ... Self.latestDataDbMigrationVersion {
+                guard let version = DataDbMigrations.init(rawValue: dbVersion) else {
+                    LoggerProxy.error("failed to determine migration version")
+                    throw StorageError.invalidMigrationVersion(version: dbVersion)
+                }
+                switch version {
+                case .version1:
+                    try performVersion1Migration(viewingKeys: uvks)
+                case .none:
+                    break
+                }
+            }
+        } else {
+            LoggerProxy.debug("Data Db - no migration needed")
+        }
+    }
+}
+
+extension Connection {
+    func getUserVersion() throws -> Int32 {
+        guard let version = try scalar("PRAGMA user_version") as? Int64 else {
+            return 0
+        }
+        return Int32(version)
+    }
+    
+    func setUserVersion(_ version: Int32) throws {
+        try run("PRAGMA user_version = \(version)")
+    }
+}

package/ios/ZCashLightClientKit/Block/DatabaseStorage/StorageError.swift

@@ -0,0 +1,22 @@
+//
+//  Storage.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum StorageError: Error {
+    case couldNotCreate
+    case openFailed
+    case closeFailed
+    case operationFailed
+    case updateFailed
+    case malformedEntity(fields: [String]?)
+    case transactionFailed(underlyingError: Error)
+    case invalidMigrationVersion(version: Int32)
+    case migrationFailed(underlyingError: Error)
+    case migrationFailedWithMessage(message: String)
+}