react-native-zcash 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # React Native Zcash
 
+## 0.6.1 (2023-10-11)
+
+- added: Add `shieldFunds` support
+- changed: Package now exports types
+- deprecated: Balance event fields `availableZatoshi` and `totalZatoshi`
+
+Android
+
+- changed: Various syntax cleanups
+- fixed: Transactions event now returns confirmed and pending (<10 confirmations) transactions
+
+## 0.6.0 (2023-10-10)
+
+- added: Balances and transactions are no longer queryable and are now emitted as updates are found
+- changed: Upgrade zcash-android-sdk to v2.0.1
+- changed: Upgrade ZcashLightClientKit to v2.0.1
+- changed: Return `raw` and `fee` with transactions
+- removed: `getBalance` and `getTransactions`
+
+Android:
+
+- changed: Various syntax cleanups
+
+iOS:
+
+- fixed: Restart synchronizer on rescan
+- fixed: Txid parsing
+
 ## 0.5.0 (2023-09-20)
 
 - changed: `deriveUnifiedAddress` will now return all three address types

package/README.md

@@ -41,12 +41,16 @@ buildscript {
   - `stop`
   - `rescan`
   - `getLatestNetworkHeight`
-  - `getBalance`
-  - `getTransactions`
   - `sendToAddress`
+  - `shieldFunds`
   - `deriveUnifiedAddress`
 
-`Tools` contains methods that don't require a running synchronizer (with one exception, `isValidAddress` on Android which does requires any synchronizer connected to the requested network).
+`Tools` contains methods that don't require a running synchronizer (with one exception, `isValidAddress` on Android which does requires any synchronizer connected to the requested network). In addition to the methods above, the following events can be subscribed to:
+
+- `BalanceEvent`- available and total transparent and shielded balances
+- `StatusEvent` - current synchronizer activity (`STOPPED`, `DISCONNECTED`, `SYNCING`, and `SYNCED`)
+- `TransactionEvent`- confirmed transactions
+- `UpdateEvent` - syncing progress and network height
 
 ## Developing
 

package/android/build.gradle

@@ -30,6 +30,7 @@ android {
   lintOptions {
     abortOnError false
   }
+  namespace 'app.edge.rnzcash'
 }
 
 repositories {
@@ -48,8 +49,8 @@ dependencies {
 
   implementation 'androidx.appcompat:appcompat:1.4.1'
   implementation 'androidx.paging:paging-runtime-ktx:2.1.2'
-  implementation 'cash.z.ecc.android:zcash-android-sdk:1.20.0-beta01'
-  implementation 'cash.z.ecc.android:zcash-android-sdk-incubator:1.20.0-beta01'
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
+  implementation 'cash.z.ecc.android:zcash-android-sdk:2.0.1'
+  implementation 'cash.z.ecc.android:zcash-android-sdk-incubator:2.0.1'
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
 }

package/android/src/main/assets/co.electriccoin.zcash/checkpoint/mainnet/2240000.json

@@ -0,0 +1,8 @@
+{
+  "network": "main",
+  "height": "2240000",
+  "hash": "000000000069a67c9ef4829f0b5742cbd27fdf2ae5cdec365c91c3b04d309647",
+  "time": 1695696312,
+  "saplingTree": "012d11971e09b4bbc63e78277847849e4843736aeff18a135a19ae200fe1970766012421255c867e37da2db4a3f9fbaa18084aca9816a621e2f8b3103787782c81291a018507b35ac4792682f3189c01f91f8479815c654eea791e6ab8e67f1822bcd1480163dcf884428127f8cd206316abb345d30bd4d3eeeca49145276cf7565787c83c0120900a176f78b83e32730da21f559ae18a98797d1a032c00438b6f192ac5f34a017d758ec17f8ff744218b78468d0d88259bfe1b4139eaa78b3c9268e2fdf54b1801bab9674e72ec2c946ec5ab3da729e6190d4c49bdac30b69ceee0e28d82ac464600017cd0f0d9198e1a3d140f4f40efddc64fb40d7443ba65deda6b3aa3c9a4322b0c0001f0cf9a379500ee4e71bced9683ff1e2b8483379faea159d63637febbfe5a1f1b0128a132203057c9e99c4090ff766658573ba170affa85b9237ccb5927b5ae1336012657f8a0a10c175b231460849cc1fbcff1e8bf7e668e0319f4ed13be1d3e0f5f01b19192921006a181a583899542df7bb68359c482e658142e42241d8a6c3e511e019a757058b6e952ffa49663a800cdef1d06b7a7ffd7c56e55355f2ad9f89b00140194bd4a72af1bf73b690a8129b9db24a508f7052d570f1d48657c72a0d4dc421b00000182ac7ebe2f7e9d8084a38aa8be56b1bd86292babf05f98882a6959cf9d318c110001d8ccea507421a590ed38116b834189cdc22421b4764179fa4e364803dfa66d56018cf6f5034a55fed59d1d832620916a43c756d2379e50ef9440fc4c3e7a29aa2300011619f99023a69bb647eab2d2aa1a73c3673c74bb033c3c4930eacda19e6fd93b0000000160272b134ca494b602137d89e528c751c06d3ef4a87a45f33af343c15060cc1e",
+  "orchardTree": "010a2edceb81a84b9fa465de87a9c3701c8a5f109dfac1bd9f7ac82eff5f291405015c75544f79cc861f1b401a8ee726adf63736f51d636609504ba99cd51ac513291f000170b0286597e58d725cd67e5845575bd4a5c6c9d91eb9d956c1b5662589ebb80100000199f76442c47c3e319a90c8e2f71ed243cf1e0115d3b962413e310f2cc4edd51c000112bcfce07875062a5ad577e2c97d67d7f6a000dc65aef03a0e520e21f12a8f1c01c114ee14f4296876cfb428aaccffa1091b13db6ffff5c1a2027c58b102b5530d00017abfa6e9773177d75a8006efe4868cbcafaf292d48e852ee06f519c5bf6667200162f63c4527bf1c0d7e4728649cbfd93cfe3d79d0834e0f5f548870d6df43671200000001dd3e61f3e1d497d923486bd000737ea0ffac885fa481316727d0d8f7fc2138100001cf3bf92f69798e68555548afcce1648add1fb2548d64fa9a1ec22a3e26e7890101e637281deb58dff0c44ba13149b784a95da1b493005efd057e6f4ac20ef5d81d000001cc2dcaa338b312112db04b435a706d63244dd435238f0aa1e9e1598d35470810012dcc4273c8a0ed2337ecf7879380a07e7d427c7f9d82e538002bd1442978402c01daf63debf5b40df902dae98dadc029f281474d190cddecef1b10653248a234150001e2bca6a8d987d668defba89dc082196a922634ed88e065c669e526bb8815ee1b000000000000"
+}

package/android/src/main/assets/co.electriccoin.zcash/checkpoint/mainnet/2250000.json

@@ -0,0 +1,8 @@
+{
+  "network": "main",
+  "height": "2250000",
+  "hash": "00000000012b3fe412a00b795a282135c30abd4b46d2bf2e7d0168e5c947ebf5",
+  "time": 1696451387,
+  "saplingTree": "01bf2a311d6302f905762ff13823d1dcff0fb9e68674059a7121f2f19b9c27882101575df84d954625511d141479c09bd602af93ed7cfca6e45cd9ac483beaf72d611a000001ee73c0c892f582faeb7690f1629ef9024b4ca8cff0bcd2226a43f896be3b275f000001cf2bbcec921924a0afd09235555b0a346d76081b45255d57ce2d691fd5c4175501f55cea93a7061448481c950ed26cfbabf9ace934177e39c2b78570385f413c35000001f45efd0bd694a391cd6d3773ae3e75c9251c68a8281469db451521bb3359004c00013f453edf224bb61a9c0b3d703fc97c5082dabde0bd78429f0798dbe8b6046f0c00018cdd71abb1799bfd51405067ea43033bf0a5253d3536b4b241e866a257b7916c01e055cec06072c1c4c7381264864f21db313d32511ef89fc09a6a60e41e0d0c2a000182ac7ebe2f7e9d8084a38aa8be56b1bd86292babf05f98882a6959cf9d318c110001d8ccea507421a590ed38116b834189cdc22421b4764179fa4e364803dfa66d56018cf6f5034a55fed59d1d832620916a43c756d2379e50ef9440fc4c3e7a29aa2300011619f99023a69bb647eab2d2aa1a73c3673c74bb033c3c4930eacda19e6fd93b0000000160272b134ca494b602137d89e528c751c06d3ef4a87a45f33af343c15060cc1e",
+  "orchardTree": "0108d0c8b7890fdfb38c4ba60d9c66da45cc2fb23e6698a0a0eaeb4508c5b37d39001f01c1782f10a594f13095cae37809ac3c2dd43e8029d62ef1282039429ab758ad2700010b5a16f6a11fc79b21f36c55261931cef68d6b00d4210ce90cc447e5ba656724014ffd7c660201b4c82c01b832a3153a8295197fa8945a12a79ca5d9a1aafcac1800015e0ad0bc0cd859186f456f1be54e8c6992f4cc61507b23e59d7fa3df8ec8d62b01e2aed22800fa2e21ce1ed9b89e84ef7161c6cc25f6653964bf5c4e134a030e2f0166e704cc940f0e24abfa2dfe74e94f6f1545a94c1f5114ba90c32a29cb2ec50701a0889c7b1f704d82004c6cfd6d91fe3115db60b121464b5237b49240d421cd3e015a85dd41ba7341c7d10885ea2add0b09c72b22f2fc398f0c8ba11123f27e9713000125529c4352762dea55de0005e0efadaadd1a6b55084f0ca7beac54f78c2af304000001dd3e61f3e1d497d923486bd000737ea0ffac885fa481316727d0d8f7fc2138100001cf3bf92f69798e68555548afcce1648add1fb2548d64fa9a1ec22a3e26e7890101e637281deb58dff0c44ba13149b784a95da1b493005efd057e6f4ac20ef5d81d000001cc2dcaa338b312112db04b435a706d63244dd435238f0aa1e9e1598d35470810012dcc4273c8a0ed2337ecf7879380a07e7d427c7f9d82e538002bd1442978402c01daf63debf5b40df902dae98dadc029f281474d190cddecef1b10653248a234150001e2bca6a8d987d668defba89dc082196a922634ed88e065c669e526bb8815ee1b000000000000"
+}

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

@@ -2,6 +2,7 @@ package app.edge.rnzcash
 
 import cash.z.ecc.android.sdk.SdkSynchronizer
 import cash.z.ecc.android.sdk.Synchronizer
+import cash.z.ecc.android.sdk.WalletInitMode
 import cash.z.ecc.android.sdk.exception.LightWalletException
 import cash.z.ecc.android.sdk.ext.*
 import cash.z.ecc.android.sdk.internal.*
@@ -14,166 +15,197 @@ import co.electriccoin.lightwallet.client.model.Response
 import co.electriccoin.lightwallet.client.new
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import kotlinx.coroutines.async
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
-import kotlin.coroutines.EmptyCoroutineContext
 
 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, SdkSynchronizer>()
+    private var moduleScope: CoroutineScope = CoroutineScope(Dispatchers.IO)
+    private var synchronizerMap = mutableMapOf<String, SdkSynchronizer>()
 
-    val networks = mapOf("mainnet" to ZcashNetwork.Mainnet, "testnet" to ZcashNetwork.Testnet)
+    private val networks = mapOf("mainnet" to ZcashNetwork.Mainnet, "testnet" to ZcashNetwork.Testnet)
 
     override fun getName() = "RNZcash"
 
     @ReactMethod
-    fun initialize(seed: String, birthdayHeight: Int, alias: String, networkName: String = "mainnet", defaultHost: String = "mainnet.lightwalletd.com", defaultPort: Int = 9067, promise: Promise) =
-        moduleScope.launch {
-            promise.wrap {
-                var network = networks.getOrDefault(networkName, ZcashNetwork.Mainnet)
-                var endpoint = LightWalletEndpoint(defaultHost, defaultPort, true)
-                var seedPhrase = SeedPhrase.new(seed)
-                if (!synchronizerMap.containsKey(alias)) {
-                    synchronizerMap.set(alias, Synchronizer.new(reactApplicationContext, network, alias, endpoint, seedPhrase.toByteArray(), BlockHeight.new(network, birthdayHeight.toLong())) as SdkSynchronizer)
+    fun initialize(
+        seed: String,
+        birthdayHeight: Int,
+        alias: String,
+        networkName: String = "mainnet",
+        defaultHost: String = "mainnet.lightwalletd.com",
+        defaultPort: Int = 9067,
+        newWallet: Boolean,
+        promise: Promise,
+    ) = moduleScope.launch {
+        promise.wrap {
+            val network = networks.getOrDefault(networkName, ZcashNetwork.Mainnet)
+            val endpoint = LightWalletEndpoint(defaultHost, defaultPort, true)
+            val seedPhrase = SeedPhrase.new(seed)
+            val initMode = if (newWallet) WalletInitMode.NewWallet else WalletInitMode.ExistingWallet
+            if (!synchronizerMap.containsKey(alias)) {
+                synchronizerMap[alias] =
+                    Synchronizer.new(
+                        reactApplicationContext, network, alias, endpoint, seedPhrase.toByteArray(),
+                        BlockHeight.new(network, birthdayHeight.toLong()), initMode,
+                    ) as SdkSynchronizer
+            }
+            val wallet = getWallet(alias)
+            val scope = wallet.coroutineScope
+            combine(wallet.progress, wallet.networkHeight) { progress, networkHeight ->
+                return@combine mapOf("progress" to progress, "networkHeight" to networkHeight)
+            }.collectWith(scope) { map ->
+                val progress = map["progress"] as PercentDecimal
+                var networkBlockHeight = map["networkHeight"] as BlockHeight?
+                if (networkBlockHeight == null) networkBlockHeight = BlockHeight.new(wallet.network, birthdayHeight.toLong())
+
+                sendEvent("UpdateEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putInt(
+                        "scanProgress",
+                        progress.toPercentage(),
+                    )
+                    args.putInt("networkBlockHeight", networkBlockHeight.value.toInt())
                 }
-                val wallet = getWallet(alias)
-                val scope = wallet.coroutineScope
-                wallet.processorInfo.collectWith(scope, { update ->
-                    scope.launch {
-                        var lastDownloadedHeight = this.async { wallet.processor.downloader.getLastDownloadedHeight() }.await()
-                        if (lastDownloadedHeight == null) lastDownloadedHeight = BlockHeight.new(wallet.network, birthdayHeight.toLong())
-
-                        var lastScannedHeight = update.lastSyncedHeight
-                        if (lastScannedHeight == null) lastScannedHeight = BlockHeight.new(wallet.network, birthdayHeight.toLong())
-
-                        var networkBlockHeight = update.networkBlockHeight
-                        if (networkBlockHeight == null) networkBlockHeight = BlockHeight.new(wallet.network, birthdayHeight.toLong())
-
-                        sendEvent("UpdateEvent") { args ->
-                            args.putString("alias", alias)
-                            args.putInt("lastDownloadedHeight", lastDownloadedHeight.value.toInt())
-                            args.putInt("lastScannedHeight", lastScannedHeight.value.toInt())
-                            args.putInt("scanProgress", wallet.processor.progress.value.toPercentage())
-                            args.putInt("networkBlockHeight", networkBlockHeight.value.toInt())
+            }
+            wallet.status.collectWith(scope) { status ->
+                sendEvent("StatusEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putString("name", status.toString())
+                }
+            }
+            wallet.transactions.collectWith(scope) { txList ->
+                scope.launch {
+                    val nativeArray = Arguments.createArray()
+                    txList.filter { tx -> tx.transactionState != TransactionState.Expired }.map { tx ->
+                        launch {
+                            val parsedTx = parseTx(wallet, tx)
+                            nativeArray.pushMap(parsedTx)
                         }
-                    }
-                })
-                wallet.status.collectWith(scope, { status ->
-                    sendEvent("StatusEvent") { args ->
+                    }.forEach { it.join() }
+
+                    sendEvent("TransactionEvent") { args ->
                         args.putString("alias", alias)
-                        args.putString("name", status.toString())
+                        args.putArray(
+                            "transactions",
+                            nativeArray,
+                        )
                     }
-                })
-                return@wrap null
+                }
             }
+            combine(
+                wallet.transparentBalances,
+                wallet.saplingBalances,
+            ) { transparentBalances, saplingBalances ->
+                return@combine mapOf(
+                    "transparentBalances" to transparentBalances,
+                    "saplingBalances" to saplingBalances,
+                )
+            }.collectWith(scope) { map ->
+                val transparentBalances = map["transparentBalances"]
+                val saplingBalances = map["saplingBalances"]
+
+                val transparentAvailableZatoshi = transparentBalances?.available ?: Zatoshi(0L)
+                val transparentTotalZatoshi = transparentBalances?.total ?: Zatoshi(0L)
+
+                val saplingAvailableZatoshi = saplingBalances?.available ?: Zatoshi(0L)
+                val saplingTotalZatoshi = saplingBalances?.total ?: Zatoshi(0L)
+
+                sendEvent("BalanceEvent") { args ->
+                    args.putString("alias", alias)
+                    args.putString("transparentAvailableZatoshi", transparentAvailableZatoshi.value.toString())
+                    args.putString("transparentTotalZatoshi", transparentTotalZatoshi.value.toString())
+                    args.putString("saplingAvailableZatoshi", saplingAvailableZatoshi.value.toString())
+                    args.putString("saplingTotalZatoshi", saplingTotalZatoshi.value.toString())
+                }
+            }
+            return@wrap null
         }
+    }
 
     @ReactMethod
-    fun stop(alias: String, promise: Promise) {
+    fun stop(
+        alias: String,
+        promise: Promise,
+    ) {
         val wallet = getWallet(alias)
         wallet.close()
         synchronizerMap.remove(alias)
         promise.resolve(null)
     }
 
-    fun inRange(tx: TransactionOverview, first: Int, last: Int): Boolean {
-        if (tx.minedHeight != null && tx.minedHeight!!.value >= first.toLong() && tx.minedHeight!!.value <= last.toLong()) {
-            return true
-        }
-        return false
-    }
-
-    suspend fun collectTxs(wallet: SdkSynchronizer, limit: Int): List<TransactionOverview> {
-        val allTxs = mutableListOf<TransactionOverview>()
-        val job = wallet.coroutineScope.launch {
-            wallet.transactions.collect { txList ->
-                txList.forEach { tx ->
-                    allTxs.add(tx)
+    private suspend fun parseTx(
+        wallet: SdkSynchronizer,
+        tx: TransactionOverview,
+    ): WritableMap {
+        val map = Arguments.createMap()
+        val job =
+            wallet.coroutineScope.launch {
+                map.putString("value", tx.netValue.value.toString())
+                if (tx.feePaid != null) {
+                    map.putString("fee", tx.feePaid!!.value.toString())
                 }
-                if (allTxs.size == limit) {
-                    cancel()
+                map.putInt("minedHeight", tx.minedHeight?.value?.toInt() ?: 0)
+                map.putInt("blockTimeInSeconds", tx.blockTimeEpochSeconds?.toInt() ?: 0)
+                map.putString("rawTransactionId", tx.rawId.byteArray.toHexReversed())
+                if (tx.raw != null) {
+                    map.putString("raw", tx.raw!!.byteArray.toHex())
                 }
-            }
-        }
-        job.join()
-
-        return allTxs
-    }
-
-    suspend fun parseTx(wallet: SdkSynchronizer, tx: TransactionOverview): WritableMap {
-        val map = Arguments.createMap()
-        val job = wallet.coroutineScope.launch {
-            map.putString("value", tx.netValue.value.toString())
-            map.putInt("minedHeight", tx.minedHeight!!.value.toInt())
-            map.putInt("blockTimeInSeconds", tx.blockTimeEpochSeconds.toInt())
-            map.putString("rawTransactionId", tx.rawId.byteArray.toHexReversed())
-            if (tx.isSentTransaction) {
-                val recipient = wallet.getRecipients(tx).first()
-                if (recipient is TransactionRecipient.Address) {
-                    map.putString("toAddress", recipient.addressValue)
+                if (tx.isSentTransaction) {
+                    try {
+                        val recipient = wallet.getRecipients(tx).first()
+                        if (recipient is TransactionRecipient.Address) {
+                            map.putString("toAddress", recipient.addressValue)
+                        }
+                    } catch (t: Throwable) {
+                        // Error is OK. SDK limitation means we cannot find recipient for shielding transactions
+                    }
+                }
+                if (tx.memoCount > 0) {
+                    val memos = wallet.getMemos(tx).take(tx.memoCount).toList()
+                    map.putArray("memos", Arguments.fromList(memos))
+                } else {
+                    map.putArray("memos", Arguments.createArray())
                 }
             }
-            if (tx.memoCount > 0) {
-                val memos = wallet.getMemos(tx).take(tx.memoCount).toList()
-                map.putArray("memos", Arguments.fromList(memos))
-            } else {
-                map.putArray("memos", Arguments.createArray())
-            }
-        }
         job.join()
         return map
     }
 
     @ReactMethod
-    fun getTransactions(alias: String, first: Int, last: Int, promise: Promise) {
-        val wallet = getWallet(alias)
-
-        wallet.coroutineScope.launch {
-            val numTxs = async { wallet.getTransactionCount() }.await()
-            val nativeArray = Arguments.createArray()
-            if (numTxs == 0) {
-                promise.resolve(nativeArray)
-                return@launch
-            }
-
-            val allTxs = async { collectTxs(wallet, numTxs) }.await()
-            val filteredTxs = allTxs.filter { tx -> inRange(tx, first, last) }
-
-            filteredTxs.map { tx -> launch {
-                val parsedTx = parseTx(wallet, tx)
-                nativeArray.pushMap(parsedTx)
-            } }.forEach { it.join() }
-
-            promise.resolve(nativeArray)
-        }
-    }
-
-    @ReactMethod
-    fun rescan(alias: String, promise: Promise) {
+    fun rescan(
+        alias: String,
+        promise: Promise,
+    ) {
         val wallet = getWallet(alias)
         wallet.coroutineScope.launch {
-            wallet.coroutineScope.async { wallet.rewindToNearestHeight(wallet.latestBirthdayHeight, true) }.await()
+            wallet.rewindToNearestHeight(wallet.latestBirthdayHeight)
             promise.resolve(null)
         }
     }
 
     @ReactMethod
-    fun deriveViewingKey(seed: String, network: String = "mainnet", promise: Promise) {
-        var seedPhrase = SeedPhrase.new(seed)
+    fun deriveViewingKey(
+        seed: String,
+        network: String = "mainnet",
+        promise: Promise,
+    ) {
+        val seedPhrase = SeedPhrase.new(seed)
         moduleScope.launch {
-            var keys = moduleScope.async { DerivationTool.getInstance().deriveUnifiedFullViewingKeys(seedPhrase.toByteArray(), networks.getOrDefault(network, ZcashNetwork.Mainnet), DerivationTool.DEFAULT_NUMBER_OF_ACCOUNTS)[0] }.await()
+            val keys =
+                DerivationTool.getInstance().deriveUnifiedFullViewingKeys(
+                    seedPhrase.toByteArray(),
+                    networks.getOrDefault(network, ZcashNetwork.Mainnet),
+                    DerivationTool.DEFAULT_NUMBER_OF_ACCOUNTS,
+                )[0]
             promise.resolve(keys.encoding)
         }
     }
@@ -183,17 +215,24 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     //
 
     @ReactMethod
-    fun getLatestNetworkHeight(alias: String, promise: Promise) = promise.wrap {
+    fun getLatestNetworkHeight(
+        alias: String,
+        promise: Promise,
+    ) = promise.wrap {
         val wallet = getWallet(alias)
         return@wrap wallet.latestHeight
     }
 
     @ReactMethod
-    fun getBirthdayHeight(host: String, port: Int, promise: Promise) {
+    fun getBirthdayHeight(
+        host: String,
+        port: Int,
+        promise: Promise,
+    ) {
         moduleScope.launch {
             promise.wrap {
-                var endpoint = LightWalletEndpoint(host, port, true)
-                var lightwalletService = LightWalletClient.new(reactApplicationContext, endpoint)
+                val endpoint = LightWalletEndpoint(host, port, true)
+                val lightwalletService = LightWalletClient.new(reactApplicationContext, endpoint)
                 return@wrap when (val response = lightwalletService.getLatestBlockHeight()) {
                     is Response.Success -> {
                         response.result.value.toInt()
@@ -211,32 +250,6 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun getBalance(alias: String, promise: Promise) {
-        val wallet = getWallet(alias)
-        var availableZatoshi = Zatoshi(0L)
-        var totalZatoshi = Zatoshi(0L)
-
-        wallet.coroutineScope.launch {
-            wallet.coroutineScope.async { wallet.refreshAllBalances() }.await()
-
-            val transparentBalances = wallet.transparentBalances.value
-            availableZatoshi = availableZatoshi.plus(transparentBalances?.available ?: Zatoshi(0L))
-            totalZatoshi = totalZatoshi.plus(transparentBalances?.total ?: Zatoshi(0L))
-            val saplingBalances = wallet.saplingBalances.value
-            availableZatoshi = availableZatoshi.plus(saplingBalances?.available ?: Zatoshi(0L))
-            totalZatoshi = totalZatoshi.plus(saplingBalances?.total ?: Zatoshi(0L))
-            val orchardBalances = wallet.orchardBalances.value
-            availableZatoshi = availableZatoshi.plus(orchardBalances?.available ?: Zatoshi(0L))
-            totalZatoshi = totalZatoshi.plus(orchardBalances?.total ?: Zatoshi(0L))
-
-            val map = Arguments.createMap()
-            map.putString("totalZatoshi", totalZatoshi.value.toString())
-            map.putString("availableZatoshi", availableZatoshi.value.toString())
-            promise.resolve(map)
-        }
-    }
-
     @ReactMethod
     fun sendToAddress(
         alias: String,
@@ -248,18 +261,17 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     ) {
         val wallet = getWallet(alias)
         wallet.coroutineScope.launch {
-            var seedPhrase = SeedPhrase.new(seed)
-            val usk = wallet.coroutineScope.async { DerivationTool.getInstance().deriveUnifiedSpendingKey(seedPhrase.toByteArray(), wallet.network, Account.DEFAULT) }.await()
+            val seedPhrase = SeedPhrase.new(seed)
+            val usk = DerivationTool.getInstance().deriveUnifiedSpendingKey(seedPhrase.toByteArray(), wallet.network, Account.DEFAULT)
             try {
-                val internalId = wallet.sendToAddress(
-                    usk,
-                    Zatoshi(zatoshi.toLong()),
-                    toAddress,
-                    memo,
-                )
-                val tx = wallet.coroutineScope.async { wallet.transactions.flatMapConcat { list -> flowOf(*list.toTypedArray()) } }.await().firstOrNull { item -> item.id == internalId }
-                if (tx == null) throw Exception("transaction failed")
-
+                val internalId =
+                    wallet.sendToAddress(
+                        usk,
+                        Zatoshi(zatoshi.toLong()),
+                        toAddress,
+                        memo,
+                    )
+                val tx = wallet.coroutineScope.async { wallet.transactions.first().first() }.await()
                 val map = Arguments.createMap()
                 map.putString("txId", tx.rawId.byteArray.toHexReversed())
                 if (tx.raw != null) map.putString("raw", tx.raw?.byteArray?.toHex())
@@ -270,28 +282,67 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun shieldFunds(
+        alias: String,
+        seed: String,
+        memo: String,
+        threshold: String,
+        promise: Promise,
+    ) {
+        val wallet = getWallet(alias)
+        wallet.coroutineScope.launch {
+            val seedPhrase = SeedPhrase.new(seed)
+            val usk = DerivationTool.getInstance().deriveUnifiedSpendingKey(seedPhrase.toByteArray(), wallet.network, Account.DEFAULT)
+            try {
+                val internalId =
+                    wallet.shieldFunds(
+                        usk,
+                        memo,
+                    )
+                val tx = wallet.coroutineScope.async { wallet.transactions.first().first() }.await()
+                val parsedTx = parseTx(wallet, tx)
+
+                // Hack: Memos aren't ready to be queried right after broadcast
+                val memos = Arguments.createArray()
+                memos.pushString(memo)
+                parsedTx.putArray("memos", memos)
+                promise.resolve(parsedTx)
+            } catch (t: Throwable) {
+                promise.reject("Err", t)
+            }
+        }
+    }
+
     //
     // AddressTool
     //
 
     @ReactMethod
-    fun deriveUnifiedAddress(alias: String, promise: Promise) {
+    fun deriveUnifiedAddress(
+        alias: String,
+        promise: Promise,
+    ) {
         val wallet = getWallet(alias)
         wallet.coroutineScope.launch {
-                var unifiedAddress = wallet.coroutineScope.async { wallet.getUnifiedAddress(Account(0)) }.await()
-                val saplingAddress = wallet.coroutineScope.async { wallet.getSaplingAddress(Account(0)) }.await()
-                val transparentAddress = wallet.coroutineScope.async { wallet.getTransparentAddress(Account(0)) }.await()
+            val unifiedAddress = wallet.getUnifiedAddress(Account(0))
+            val saplingAddress = wallet.getSaplingAddress(Account(0))
+            val transparentAddress = wallet.getTransparentAddress(Account(0))
 
-                val map = Arguments.createMap()
-                map.putString("unifiedAddress", unifiedAddress)
-                map.putString("saplingAddress", saplingAddress)
-                map.putString("transparentAddress", transparentAddress)
-                promise.resolve(map)
+            val map = Arguments.createMap()
+            map.putString("unifiedAddress", unifiedAddress)
+            map.putString("saplingAddress", saplingAddress)
+            map.putString("transparentAddress", transparentAddress)
+            promise.resolve(map)
         }
     }
 
     @ReactMethod
-    fun isValidAddress(address: String, network: String, promise: Promise) {
+    fun isValidAddress(
+        address: String,
+        network: String,
+        promise: Promise,
+    ) {
         moduleScope.launch {
             promise.wrap {
                 var isValid = false
@@ -315,9 +366,7 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
      * Retrieve wallet object from synchronizer map
      */
     private fun getWallet(alias: String): SdkSynchronizer {
-        val wallet = synchronizerMap.get(alias)
-        if (wallet == null) throw Exception("Wallet not found")
-        return wallet
+        return synchronizerMap[alias] ?: throw Exception("Wallet not found")
     }
 
     /**
@@ -331,7 +380,10 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
-    private fun sendEvent(eventName: String, putArgs: (WritableMap) -> Unit) {
+    private fun sendEvent(
+        eventName: String,
+        putArgs: (WritableMap) -> Unit,
+    ) {
         val args = Arguments.createMap()
         putArgs(args)
         reactApplicationContext
@@ -339,7 +391,7 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
             .emit(eventName, args)
     }
 
-    inline fun ByteArray.toHexReversed(): String {
+    private fun ByteArray.toHexReversed(): String {
         val sb = StringBuilder(size * 2)
         var i = size - 1
         while (i >= 0)

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

@@ -12,6 +12,5 @@ class RNZcashPackage : ReactPackage {
             RNZcashModule(reactContext),
         )
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
-        emptyList()
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
 }

package/ios/RNZcash.m

@@ -10,6 +10,7 @@ RCT_EXTERN_METHOD(initialize:(NSString *)seed
 :(NSString *)networkName
 :(NSString *)defaultHost
 :(NSInteger *)defaultPort
+:(BOOL *)newWallet
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
@@ -44,14 +45,10 @@ 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(getBalance:(NSString *)alias
+RCT_EXTERN_METHOD(shieldFunds:(NSString *)alias
+:(NSString *)seed
+:(NSString *)memo
+:(NSString *)threshold
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )