react-native-zcash 0.1.0 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # React Native Zcash
 
+## 0.2.2 (2022-06-10)
+
+- Upgrade SDKs to NU5 compatible versions
+  - Android: Upgrade zcash-android-sdk to v1.5.0-beta01
+  - iOS: Upgrade ZcashLightClientKit to v0.14.0-beta
+- iOS: Fix memory leak after stopping synchronizer
+- ANdroid: White space and import cleanups
+
+## 0.2.1 (2022-03-16)
+
+- Update the ZcashLightClientKit dependency
+- Remove unused build scripts
+
+## 0.2.0 (2022-01-10)
+
+- Add iOS support
+- Android: Cleanup unused methods
+
 ## 0.1.0 (2021-11-09)
 
 - Initial release

package/android/build.gradle

@@ -1,7 +1,7 @@
 buildscript {
     ext.versions = [
       'kotlin': '1.5.0',
-      'zcash': '1.3.0-beta18',
+      'zcash': '1.5.0-beta01',
       'room': '2.3.0'
     ]
     repositories {
@@ -33,7 +33,7 @@ def safeExtGet(prop, fallback) {
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
 def DEFAULT_BUILD_TOOLS_VERSION = "28.0.2"
-def DEFAULT_MIN_SDK_VERSION = 16
+def DEFAULT_MIN_SDK_VERSION = 19
 def DEFAULT_TARGET_SDK_VERSION = 27
 
 android {
@@ -80,4 +80,10 @@ dependencies {
     implementation "androidx.paging:paging-runtime-ktx:2.1.2"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9"
+
+    implementation ("androidx.appcompat:appcompat:1.3.1") {
+        version {
+            strictly '1.3.1'
+        }
+    }
 }

package/android/src/main/java/app/edge/rnzcash/RNZcashModule.kt

@@ -1,32 +1,29 @@
 package app.edge.rnzcash;
 
-import androidx.paging.PagedList
 import cash.z.ecc.android.sdk.Initializer
 import cash.z.ecc.android.sdk.SdkSynchronizer
 import cash.z.ecc.android.sdk.Synchronizer
-import cash.z.ecc.android.sdk.Synchronizer.Status.SYNCED
-import cash.z.ecc.android.sdk.block.CompactBlockProcessor
 import cash.z.ecc.android.sdk.db.entity.*
 import cash.z.ecc.android.sdk.ext.*
-import cash.z.ecc.android.sdk.transaction.*
+import cash.z.ecc.android.sdk.internal.transaction.PagedTransactionRepository
+import cash.z.ecc.android.sdk.internal.*
 import cash.z.ecc.android.sdk.type.*
 import cash.z.ecc.android.sdk.tool.DerivationTool
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import java.nio.charset.StandardCharsets
 import kotlin.coroutines.EmptyCoroutineContext
 
 class WalletSynchronizer constructor(val initializer: Initializer)  {
-    
-    val synchronizer: SdkSynchronizer = Synchronizer(
+
+    val synchronizer: SdkSynchronizer = Synchronizer.newBlocking(
         initializer
     ) as SdkSynchronizer
-    val repository = PagedTransactionRepository(initializer.context, 10, initializer.rustBackend, initializer.birthday, initializer.viewingKeys)
+    val repository = runBlocking { PagedTransactionRepository.new(initializer.context, 10, initializer.rustBackend, initializer.birthday, initializer.viewingKeys) }
     var isStarted = false
 }
 
@@ -50,42 +47,44 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     @ReactMethod
     fun initialize(extfvk: String, extpub: String, birthdayHeight: Int, alias: String, networkName: String = "mainnet", defaultHost: String = "mainnet.lightwalletd.com", defaultPort: Int = 9067, promise: Promise) =
         promise.wrap {
-            Twig.plant(TroubleshootingTwig())
-            var vk = UnifiedViewingKey(extfvk, extpub)
-            if (synchronizerMap[alias] == null) {
-                val initializer = Initializer(reactApplicationContext) { config ->
-                    config.importedWalletBirthday(birthdayHeight)
-                    config.setViewingKeys(vk)
-                    config.setNetwork(networks[networkName] ?: ZcashNetwork.Mainnet, defaultHost, defaultPort)
-                    config.alias = alias
-                }
-                synchronizerMap[alias] = WalletSynchronizer(initializer)
-                val wallet = getWallet(alias)
+          Twig.plant(TroubleshootingTwig())
+          var vk = UnifiedViewingKey(extfvk, extpub)
+          if (synchronizerMap[alias] == null) {
+            runBlocking {
+              Initializer.new(reactApplicationContext) {
+                it.importedWalletBirthday(birthdayHeight)
+                it.setViewingKeys(vk)
+                it.setNetwork(networks[networkName]
+                  ?: ZcashNetwork.Mainnet, defaultHost, defaultPort)
+                it.alias = alias
+              }
+            }.let { initializer ->
+              synchronizerMap[alias] = WalletSynchronizer(initializer)
             }
-            val wallet = getWallet(alias)
-            wallet.synchronizer.hashCode().toString()
-            
+          }
+          val wallet = getWallet(alias)
+          wallet.synchronizer.hashCode().toString()
         }
 
     @ReactMethod
     fun start(alias: String, promise: Promise) = promise.wrap {
         val wallet = getWallet(alias)
         if (!wallet.isStarted) {
-            wallet.synchronizer.prepare()
+            runBlocking {
+              wallet.synchronizer.prepare()
+            }
             wallet.synchronizer.start(moduleScope)
             val scope = wallet.synchronizer.coroutineScope
             wallet.synchronizer.processorInfo.collectWith(scope, { update ->
                 sendEvent("UpdateEvent") { args ->
                     args.putString("alias", alias)
-                    args.putBoolean("isDownloading", update.isDownloading)
-                    args.putBoolean("isScanning", update.isScanning)
                     args.putInt("lastDownloadedHeight", update.lastDownloadedHeight)
                     args.putInt("lastScannedHeight", update.lastScannedHeight)
                     args.putInt("scanProgress", update.scanProgress)
                     args.putInt("networkBlockHeight", update.networkBlockHeight)
                 }
             })
-            wallet.synchronizer.status.collectWith(scope, { status -> 
+            wallet.synchronizer.status.collectWith(scope, { status ->
                 sendEvent("StatusEvent") { args ->
                     args.putString("alias", alias)
                     args.putString("name", status.toString())
@@ -106,7 +105,6 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
                     args.putInt("transactionCount", txList.count())
                 }
             })
-            wallet.repository.prepare()
             wallet.isStarted = true
         }
         "success"
@@ -152,15 +150,9 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun getBlockCount(
-        promise: Promise
-    ) = promise.wrap {
-    }
-
     @ReactMethod
     fun deriveViewingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) {
-        var keys = DerivationTool.deriveUnifiedViewingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0]
+        var keys = runBlocking { DerivationTool.deriveUnifiedViewingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0] }
         val map = Arguments.createMap()
         map.putString("extfvk", keys.extfvk)
         map.putString("extpub", keys.extpub)
@@ -169,7 +161,7 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun deriveSpendingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) = promise.wrap {
-        DerivationTool.deriveSpendingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0]
+        runBlocking { DerivationTool.deriveSpendingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0] }
     }
 
     //
@@ -183,24 +175,6 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         wallet.synchronizer.latestHeight
     }
 
-    @ReactMethod
-    fun getLatestScannedHeight(promise: Promise) = promise.wrap {
-        // TODO: implement this after switching to StateFlow objects
-        throw NotImplementedError()
-    }
-
-    @ReactMethod
-    fun getProgress(promise: Promise) = promise.wrap {
-        // TODO: implement this after switching to StateFlow objects
-        throw NotImplementedError()
-    }
-
-    @ReactMethod
-    fun getStatus(promise: Promise) = promise.wrap {
-        // TODO: implement this after switching to StateFlow objects
-        throw NotImplementedError()
-    }
-
     @ReactMethod
     fun getShieldedBalance(alias: String, promise: Promise) = promise.wrap {
         val wallet = getWallet(alias)
@@ -247,15 +221,12 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
                         if (tx.errorCode != null) map.putString("errorCode", tx.errorCode.toString())
                         promise.resolve(false)
                     }
-                    sendEvent("PendingTransactionUpdated") { args ->
-                        args.putPendingTransaction(tx)
-                    }
                 }
             } catch (t: Throwable) {
                 promise.reject("Err", t)
             }
         }
-        
+
     }
 
     //
@@ -264,82 +235,56 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun deriveShieldedAddress(viewingKey: String, network: String = "mainnet", promise: Promise) = promise.wrap {
-        DerivationTool.deriveShieldedAddress(viewingKey, networks.getOrDefault(network, ZcashNetwork.Mainnet))
+        runBlocking { DerivationTool.deriveShieldedAddress(viewingKey, networks.getOrDefault(network, ZcashNetwork.Mainnet)) }
     }
 
     @ReactMethod
-    fun deriveTransparentAddress(seed: String, network: String = "mainnet", promise: Promise) = promise.wrap {
-        DerivationTool.deriveTransparentAddress(seed.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))
-    }
-
-    @ReactMethod
-    fun isValidShieldedAddress(address: String, promise: Promise) {
+    fun isValidShieldedAddress(address: String, network: String, promise: Promise) {
         moduleScope.launch {
             promise.wrap {
-                val wallet = getAnyWallet()
-                wallet.synchronizer.isValidShieldedAddr(address)
+                var isValid = false
+                val wallets = synchronizerMap.asIterable()
+            for (wallet in wallets) {
+                if (wallet.value.synchronizer.network.networkName == network) {
+                  isValid = wallet.value.synchronizer.isValidShieldedAddr(address)
+                  break
+                }
+              }
+              isValid
             }
         }
     }
 
     @ReactMethod
-    fun isValidTransparentAddress(address: String, promise: Promise) {    
+    fun isValidTransparentAddress(address: String, network: String, promise: Promise) {
         moduleScope.launch {
             promise.wrap {
-                val wallet = getAnyWallet()
-                wallet.synchronizer.isValidTransparentAddr(address)
-            } 
-        }
-    }
-
-    override fun onCatalystInstanceDestroy() {
-        super.onCatalystInstanceDestroy()
-        try {
-            // cancelling the parent scope will also stop the synchronizer, through structured concurrency
-            // so calling synchronizer.stop() here is possible but redundant
-            moduleScope.cancel()
-        } catch (t: Throwable) {
-            // ignore
-        }
-    }
-
-
-    //
-    // Test functions (remove these, later)
-    //
-
-    @ReactMethod
-    fun readyToSend(alias: String, promise: Promise) = promise.wrap {
-        val wallet = getWallet(alias)
-        // for testing purposes, one is enough--we just want to make sure we're not downloading
-        wallet.synchronizer.status.filter { it == SYNCED }.onFirstWith(wallet.synchronizer.coroutineScope) {
-            true
+              var isValid = false
+              val wallets = synchronizerMap.asIterable()
+              for (wallet in wallets) {
+                if (wallet.value.synchronizer.network.networkName == network) {
+                  isValid = wallet.value.synchronizer.isValidTransparentAddr(address)
+                  break
+                }
+              }
+              isValid
+            }
         }
     }
 
-
     //
     // Utilities
     //
 
     /**
      * Retrieve wallet object from synchronizer map
-     */    
+     */
     private fun getWallet(alias: String): WalletSynchronizer {
         val wallet = synchronizerMap.get(alias)
         if (wallet == null) throw Exception("Wallet not found")
         return wallet
     }
-    
-    
-    /**
-     * Retrieve any wallet object for tasks that need simple synchronizer 
-     * functions like address validation
-     */
-    private fun getAnyWallet(): WalletSynchronizer {
-        val wallet = synchronizerMap.firstNotNullOf { it.takeIf { it != null } }
-        return wallet.value
-    }
+
 
     /**
      * Wrap the given block of logic in a promise, rejecting for any error.
@@ -352,21 +297,6 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
-    /**
-     * Serialize a pending tranaction to a map as an event
-     */
-    private fun WritableMap.putPendingTransaction(tx: PendingTransaction) {
-        sendEvent("PendingTransactionUpdated") { args ->
-            tx.let { info ->
-                if (tx.accountIndex != null ) putInt("accountIndex", tx.accountIndex)
-                if (tx.expiryHeight != null ) putInt("expiryHeight", tx.expiryHeight)
-                if (tx.submitAttempts != null ) putInt("submitAttempts", tx.submitAttempts)
-                if (tx.errorMessage != null ) putString("errorMessage", tx.errorMessage)
-                if (tx.createTime != null ) putString("PendingTransactionUpdated", tx.createTime.toString())
-            }
-        }
-    }
-
     private fun sendEvent(eventName: String, putArgs: (WritableMap) -> Unit) {
         val args = Arguments.createMap()
         putArgs(args)
@@ -384,4 +314,12 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
             "Unable to parse memo."
         }
     }
+
+    inline fun ByteArray.toHexReversed(): String {
+      val sb = StringBuilder(size * 2)
+      var i = size - 1
+      while (i >= 0)
+        sb.append(String.format("%02x", this[i--]))
+      return sb.toString()
+    }
 }

package/ios/RNZcash-Bridging-Header.h

@@ -0,0 +1,6 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>

package/ios/RNZcash.m

@@ -1,45 +1,91 @@
-// Formatted using clang-format with default settings.
-
-#import "RNZcash.h"
-
-@implementation RNZcash
-
-RCT_EXPORT_MODULE()
-
-// - (id)init {
-//   self = [super init];
-//   return self;
-// }
-
-+ (BOOL)requiresMainQueueSetup {
-  return NO;
-}
-
-RCT_REMAP_METHOD(getNumTransactions, getNumTransactions:(float) N
-                 resolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject)
-{
-//     NSUInteger const onehundred = 100;
-//     NSNumber *val = [NSNumber numberWithInteger:(N+42)];
-    NSNumber *myNum = [NSNumber numberWithFloat:(N+123)];
-    resolve(myNum);
-}
-
-RCT_REMAP_METHOD(deriveViewKey, deriveViewKey:(NSString *) seedBytesHex
-                 resolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject)
-{
-NSString *out = [seedBytesHex stringByAppendingString:@"-viewKey"];
-    resolve(out);
-}
-
-
-RCT_REMAP_METHOD(getShieldedBalance,
-                 resolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject)
-{
-NSDictionary *dict = @{@"availableBalance":@"123",@"totalBalance": @"1234"};
-    resolve(dict);
-}
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+
+@interface RCT_EXTERN_MODULE(RNZcash, RCTEventEmitter<RCTBridgeModule>)
+
+// Synchronizer
+RCT_EXTERN_METHOD(initialize:(NSString *)extfvk
+:(NSString *)extpub
+:(NSInteger *)birthdayHeight
+:(NSString *)alias
+:(NSString *)networkName
+:(NSString *)defaultHost
+:(NSInteger *)defaultPort
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(start:(NSString *)alias
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(stop:(NSString *)alias
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(spendToAddress:(NSString *)alias
+:(NSString *)zatoshi
+:(NSString *)toAddress
+:(NSString *)memo
+:(NSInteger *)fromAccountIndex
+:(NSString *)spendingKey
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(getTransactions:(NSString *)alias
+:(NSInteger *)first
+:(NSInteger *)last
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(getShieldedBalance:(NSString *)alias
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(rescan:(NSString *)alias
+:(NSInteger *)height
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+// Derivation tool
+RCT_EXTERN_METHOD(deriveViewingKey:(NSString *)seed
+:(NSString *)network
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(deriveSpendingKey:(NSString *)seed
+:(NSString *)network
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(deriveShieldedAddress:(NSString *)viewingKey
+:(NSString *)network
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(isValidTransparentAddress:(NSString *)address
+:(NSString *)network
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(isValidShieldedAddress:(NSString *)address
+:(NSString *)network
+resolver:(RCTPromiseResolveBlock)resolve
+rejecter:(RCTPromiseRejectBlock)reject
+)
+
+// Events
+RCT_EXTERN_METHOD(supportedEvents)
 
 @end