react-native-zcash 0.0.2 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # React Native Zcash
 
+## 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
+
 ## 0.0.2
 
 - Add stubs for deriveViewKey and getShieldedBalance

package/android/build.gradle

@@ -1,19 +1,34 @@
 buildscript {
+    ext.versions = [
+      'kotlin': '1.5.0',
+      'zcash': '1.3.0-beta18',
+      'room': '2.3.0'
+    ]
     repositories {
+        mavenLocal()
         google()
+        mavenCentral()
         jcenter()
+        maven {
+            url 'https://jitpack.io'
+        }
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.1'
+        classpath 'com.android.tools.build:gradle:4.0.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
     }
 }
 
 apply plugin: 'com.android.library'
-apply plugin: 'maven'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
 
 def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
@@ -24,7 +39,13 @@ def DEFAULT_TARGET_SDK_VERSION = 27
 android {
   compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
   buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
-
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_1_8
+  }
   defaultConfig {
     minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
     targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
@@ -37,9 +58,26 @@ android {
 }
 
 repositories {
-    mavenCentral()
+  mavenLocal()
+  google()
+  jcenter()
+    // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+  maven {
+    url("../node_modules/react-native/android")
+  }
 }
 
 dependencies {
+    // React-Native
     implementation 'com.facebook.react:react-native:+'
+
+    // Zcash
+    implementation  "cash.z.ecc.android:zcash-android-sdk:${versions.zcash}"
+
+    // Process Room annotations
+    kapt "androidx.room:room-compiler:${versions.room}"
+
+    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"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.reactlibrary">
+          package="app.edge.rnzcash">
 
 </manifest>

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

@@ -0,0 +1,317 @@
+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.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 java.nio.charset.StandardCharsets
+import kotlin.coroutines.EmptyCoroutineContext
+
+class WalletSynchronizer constructor(val initializer: Initializer)  {
+    
+    val synchronizer: SdkSynchronizer = Synchronizer(
+        initializer
+    ) as SdkSynchronizer
+    val repository = PagedTransactionRepository(initializer.context, 10, initializer.rustBackend, initializer.birthday, initializer.viewingKeys)
+    var isStarted = false
+}
+
+class RNZcashModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    /**
+     * Scope for anything that out-lives the synchronizer, meaning anything that can be used before
+     * the synchronizer starts or after it stops. Everything else falls within the scope of the
+     * synchronizer and should use `synchronizer.coroutineScope` whenever a scope is needed.
+     *
+     * In a real production app, we'd use the scope of the parent activity
+     */
+    var moduleScope: CoroutineScope = CoroutineScope(EmptyCoroutineContext)
+    var synchronizerMap = mutableMapOf<String, WalletSynchronizer>()
+
+    val networks = mapOf("mainnet" to ZcashNetwork.Mainnet, "testnet" to ZcashNetwork.Testnet)
+
+    override fun getName() = "RNZcash"
+
+    @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)
+            }
+            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()
+            wallet.synchronizer.start(moduleScope)
+            val scope = wallet.synchronizer.coroutineScope
+            wallet.synchronizer.processorInfo.collectWith(scope, { update ->
+                sendEvent("UpdateEvent") { args ->
+                    args.putString("alias", alias)
+                    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 -> 
+                sendEvent("StatusEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putString("name", status.toString())
+                }
+            })
+            wallet.synchronizer.saplingBalances.collectWith(scope, { walletBalance ->
+                sendEvent("BalanceEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putString("availableZatoshi", walletBalance.availableZatoshi.toString())
+                    args.putString("totalZatoshi", walletBalance.totalZatoshi.toString())
+                }
+            })
+            // add 'distinctUntilChanged' to filter by events that represent changes in txs, rather than each poll
+            wallet.synchronizer.clearedTransactions.distinctUntilChanged().collectWith(scope, { txList ->
+                sendEvent("TransactionEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putBoolean("hasChanged", true)
+                    args.putInt("transactionCount", txList.count())
+                }
+            })
+            wallet.repository.prepare()
+            wallet.isStarted = true
+        }
+        "success"
+    }
+
+    @ReactMethod
+    fun stop(alias: String, promise: Promise) = promise.wrap {
+        val wallet = getWallet(alias)
+        wallet.synchronizer.stop()
+        synchronizerMap.remove(alias)
+        "success"
+    }
+
+    @ReactMethod
+    fun getTransactions(alias: String, first: Int, last: Int, promise: Promise) {
+        val wallet = getWallet(alias)
+        moduleScope.launch {
+            promise.wrap {
+                val result = wallet.repository.findNewTransactions(first..last)
+                val nativeArray = Arguments.createArray()
+
+                for (i in 0..result.size - 1) {
+                    val map = Arguments.createMap()
+                    map.putString("value", result[i].value.toString())
+                    map.putInt("minedHeight", result[i].minedHeight)
+                    map.putInt("blockTimeInSeconds", result[i].blockTimeInSeconds.toInt())
+                    map.putString("rawTransactionId", result[i].rawTransactionId.toHexReversed())
+                    if (result[i].memo != null) map.putString("memo", result[i].memo?.decodeToString()?.trim('\u0000', '\uFFFD'))
+                    if (result[i].toAddress != null) map.putString("toAddress", result[i].toAddress)
+                    nativeArray.pushMap(map)
+                }
+
+                nativeArray
+            }
+        }
+    }
+
+    @ReactMethod
+    fun rescan(alias: String, height: Int, promise: Promise) {
+        val wallet = getWallet(alias)
+        moduleScope.launch {
+            wallet.synchronizer.rewindToNearestHeight(height)
+        }
+    }
+
+    @ReactMethod
+    fun deriveViewingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) {
+        var keys = DerivationTool.deriveUnifiedViewingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0]
+        val map = Arguments.createMap()
+        map.putString("extfvk", keys.extfvk)
+        map.putString("extpub", keys.extpub)
+        promise.resolve(map)
+    }
+
+    @ReactMethod
+    fun deriveSpendingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) = promise.wrap {
+        DerivationTool.deriveSpendingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0]
+    }
+
+    //
+    // Properties
+    //
+
+
+    @ReactMethod
+    fun getLatestNetworkHeight(alias: String, promise: Promise) = promise.wrap {
+        val wallet = getWallet(alias)
+        wallet.synchronizer.latestHeight
+    }
+
+    @ReactMethod
+    fun getShieldedBalance(alias: String, promise: Promise) = promise.wrap {
+        val wallet = getWallet(alias)
+        val map = Arguments.createMap()
+        map.putString("totalZatoshi", wallet.synchronizer.saplingBalances.value.totalZatoshi.toString(10))
+        map.putString("availableZatoshi", wallet.synchronizer.saplingBalances.value.availableZatoshi.toString(10))
+        map
+    }
+
+    @ReactMethod
+    fun spendToAddress(
+        alias: String,
+        zatoshi: String,
+        toAddress: String,
+        memo: String,
+        fromAccountIndex: Int,
+        spendingKey: String,
+        promise: Promise
+    ) {
+        val wallet = getWallet(alias)
+        wallet.synchronizer.coroutineScope.launch {
+            try {
+                wallet.synchronizer.sendToAddress(
+                    spendingKey,
+                    zatoshi.toLong(),
+                    toAddress,
+                    memo,
+                    fromAccountIndex
+                ).collectWith(wallet.synchronizer.coroutineScope) {tx ->
+                    // this block is called repeatedly for each update to the pending transaction, including all 10 confirmations
+                    // the promise either shouldn't be used (and rely on events instead) or it can be resolved once the transaction is submitted to the network or mined
+                    if (tx.isSubmitSuccess()) { // alternatively use it.isMined() but be careful about making a promise that never resolves!
+                        val map = Arguments.createMap()
+                        map.putString("txId", tx.rawTransactionId?.toHexReversed())
+                        map.putString("raw", tx.raw?.toHexReversed())
+                        promise.resolve(map)
+                    } else if (tx.isFailure()) {
+                        val map = Arguments.createMap()
+                        map.putInt("expiryHeight", tx.expiryHeight)
+                        map.putString("cancelled", tx.cancelled.toString())
+                        map.putString("encodeAttempts", tx.encodeAttempts.toString())
+                        map.putString("submitAttempts", tx.submitAttempts.toString())
+                        if (tx.errorMessage != null) map.putString("errorMessage", tx.errorMessage)
+                        if (tx.errorCode != null) map.putString("errorCode", tx.errorCode.toString())
+                        promise.resolve(false)
+                    }
+                }
+            } catch (t: Throwable) {
+                promise.reject("Err", t)
+            }
+        }
+        
+    }
+
+    //
+    // AddressTool
+    //
+
+    @ReactMethod
+    fun deriveShieldedAddress(viewingKey: String, network: String = "mainnet", promise: Promise) = promise.wrap {
+        DerivationTool.deriveShieldedAddress(viewingKey, networks.getOrDefault(network, ZcashNetwork.Mainnet))
+    }
+
+    @ReactMethod
+    fun isValidShieldedAddress(address: String, network: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                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, network: String, promise: Promise) {    
+        moduleScope.launch {
+            promise.wrap {
+              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
+    }
+    
+
+    /**
+     * Wrap the given block of logic in a promise, rejecting for any error.
+     */
+    private inline fun <T> Promise.wrap(block: () -> T) {
+        try {
+            resolve(block())
+        } catch (t: Throwable) {
+            reject("Err", t)
+        }
+    }
+
+    private fun sendEvent(eventName: String, putArgs: (WritableMap) -> Unit) {
+        val args = Arguments.createMap()
+        putArgs(args)
+        reactApplicationContext
+            .getJSModule(RCTDeviceEventEmitter::class.java)
+            .emit(eventName, args)
+    }
+
+    // TODO: move this to the SDK
+    inline fun ByteArray?.toUtf8Memo(): String {
+        return if (this == null || this[0] >= 0xF5) "" else try {
+            // trim empty and "replacement characters" for codes that can't be represented in unicode
+            String(this, StandardCharsets.UTF_8).trim('\u0000', '\uFFFD')
+        } catch (t: Throwable) {
+            "Unable to parse memo."
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+package app.edge.rnzcash;
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.Collections.emptyList
+
+
+class RNZcashPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext) =
+        listOf<NativeModule>(
+            RNZcashModule(reactContext)
+        )
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

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