react-native-zcash 0.3.5 → 0.4.1

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

@@ -0,0 +1,8 @@
+{
+  "network": "main",
+  "height": "2210000",
+  "hash": "0000000001355c3493575fd882ce1efe7fea8d4e979e1f9c8665af8db296823a",
+  "time": 1693435343,
+  "saplingTree": "0161b72f49f0b0dd8a3e2bcb85262884a5969085f6e611f60ca73940e29238e733001a014c3601f3ebd57bc6d270c684390e3d980fc7570a0cca06f4bc3c97e24d93be5a00000000000000000188e1f654b2317621d8ec0d8aabab051752056bc85ce601ee7b2efc85a9076e2001b70de51176166ae4f6110e2726339e5659d043df716ec5426ee4fb3e3e47ef2801739355d442687c9b1cdbe89bdf1c83bb0e05df09123c6dc8ac46264332372a5b01a6efac374c5ef75e7c7c742150f6ffd7852c9d0641570c8f7dad318aa7162741012d24bb5e99f9ee9d19e144c12ff81507116946215cd7a6f28764662c8a5caa4a0001ba391f92d9f6f13ffa0a9be8f09e113dd528f28d64e3fa82a9841c3871f5711e000001d8ccea507421a590ed38116b834189cdc22421b4764179fa4e364803dfa66d56018cf6f5034a55fed59d1d832620916a43c756d2379e50ef9440fc4c3e7a29aa2300011619f99023a69bb647eab2d2aa1a73c3673c74bb033c3c4930eacda19e6fd93b0000000160272b134ca494b602137d89e528c751c06d3ef4a87a45f33af343c15060cc1e",
+  "orchardTree": "01275579cb64febfc92000492e10f910065c9571d6b94f6434d7b7e6c913779c3f001f01f5253a74bc6d283fbe31e6b2dafa5d4db91fe81abcec50de59c872065502cc0b0000018ac3e61ce99ecf9e3c1bced344b606dd7ae24f02b1448628ad91b163d3982e28000001fe353c0f219693c370cbe61398f479030c4cb70e0234e4f7b30e8d5072f4af3e00012a75037ed0051a079beadf00c146c505a7761f53f46ae9814e34bb4e954b0224000000011c624f6c2160a85fc2821643724e4ecb61ac64738e0fb36a51933a83e8618c260162cb5b712202981670217893d510e9464364f9e7e3084b43f0450d1f91a85e00000001cf3bf92f69798e68555548afcce1648add1fb2548d64fa9a1ec22a3e26e7890101e637281deb58dff0c44ba13149b784a95da1b493005efd057e6f4ac20ef5d81d000001cc2dcaa338b312112db04b435a706d63244dd435238f0aa1e9e1598d35470810012dcc4273c8a0ed2337ecf7879380a07e7d427c7f9d82e538002bd1442978402c01daf63debf5b40df902dae98dadc029f281474d190cddecef1b10653248a234150001e2bca6a8d987d668defba89dc082196a922634ed88e065c669e526bb8815ee1b000000000000"
+}

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

@@ -0,0 +1,8 @@
+{
+  "network": "main",
+  "height": "2220000",
+  "hash": "000000000172b493b91a2bf8da492818f469abaf367f0a34c6088d7384bf438d",
+  "time": 1694189265,
+  "saplingTree": "01e1fdb4fbf39470312e2ee698bbadaae6a6f600630704ce828f624092d419eb2b01bb2e754503afcbeba2f5f351cde44316015799935827d50086a09347b9aa72281a019cc2cee08afd6df6cbc2d89a3a7f5381c466fc8718a52e6db6e6fa44063db24000000000017e8553f04eb329f93a9882e2656a7d9772a7d12098932e9fc10b094844d4675701de3681f6095e049db159b1b3f7058a80bf8178e7dcc36de3e3eb11a2abc3584001fc25e0cec13e3f59891b069f75fd51f2caa60f501e23b3afdf6209faf71edf1b00000001d177df23a29c4acfa477b94c55bf3baa5b4f43dc65bf94ed65cf3ac7b2d753300001055bb26ddf3a7a7efa91af3ba8c040cf4f373d366b3bb01a778cc54fc31ab32a01cf666e6ab15724fcad98c1eaf7d0b555e9cfa4132c4152a5946256421eda496101ba391f92d9f6f13ffa0a9be8f09e113dd528f28d64e3fa82a9841c3871f5711e000001d8ccea507421a590ed38116b834189cdc22421b4764179fa4e364803dfa66d56018cf6f5034a55fed59d1d832620916a43c756d2379e50ef9440fc4c3e7a29aa2300011619f99023a69bb647eab2d2aa1a73c3673c74bb033c3c4930eacda19e6fd93b0000000160272b134ca494b602137d89e528c751c06d3ef4a87a45f33af343c15060cc1e",
+  "orchardTree": "01e9654f2f2065ea7222b509f367053c8c60335abd1fef4d4a8cc8f1b6e4c2a133011093acb8712c698913d117410839280fe234942db8fec4830c6544b3d97da0361f0000015cfab442f440115599554959ca560451d1da80cfa1fac8031be6c091c9eb79110001bf4c6e2c88cb1b29df8cbe2ab268c40e3d2a2d26155a3ebfc3a9d450954c6d050001b8c991defe192f04816e611cbeff67ba630aba4e68cb9a01d8a15861d6d5460001463c8512a48687e5827657cefbc11b0495302ca787760ef02346bdb91922c10801a23a492db19a8b6962c4f58d478dcc81a3b22f59914a8dbaced764f53e923e3700000177fe87edaf3267ef297756a3b204b4920001f2db983b35a9a122e79b4a90bb2c011c624f6c2160a85fc2821643724e4ecb61ac64738e0fb36a51933a83e8618c260162cb5b712202981670217893d510e9464364f9e7e3084b43f0450d1f91a85e00000001cf3bf92f69798e68555548afcce1648add1fb2548d64fa9a1ec22a3e26e7890101e637281deb58dff0c44ba13149b784a95da1b493005efd057e6f4ac20ef5d81d000001cc2dcaa338b312112db04b435a706d63244dd435238f0aa1e9e1598d35470810012dcc4273c8a0ed2337ecf7879380a07e7d427c7f9d82e538002bd1442978402c01daf63debf5b40df902dae98dadc029f281474d190cddecef1b10653248a234150001e2bca6a8d987d668defba89dc082196a922634ed88e065c669e526bb8815ee1b000000000000"
+}

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

@@ -1,33 +1,26 @@
-package app.edge.rnzcash;
+package app.edge.rnzcash
 
-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.db.entity.*
+import cash.z.ecc.android.sdk.exception.LightWalletException
 import cash.z.ecc.android.sdk.ext.*
-import cash.z.ecc.android.sdk.internal.service.LightWalletGrpcService
-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.model.*
 import cash.z.ecc.android.sdk.tool.DerivationTool
+import cash.z.ecc.android.sdk.type.*
+import co.electriccoin.lightwallet.client.LightWalletClient
+import co.electriccoin.lightwallet.client.model.LightWalletEndpoint
+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.CoroutineScope
-import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.*
 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.newBlocking(
-        initializer
-    ) as SdkSynchronizer
-    val repository = runBlocking { PagedTransactionRepository.new(initializer.context, 10, initializer.rustBackend, initializer.birthday, initializer.viewingKeys) }
-    var isStarted = false
-}
-
 class RNZcashModule(private val reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
@@ -39,199 +32,223 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
      * In a real production app, we'd use the scope of the parent activity
      */
     var moduleScope: CoroutineScope = CoroutineScope(EmptyCoroutineContext)
-    var synchronizerMap = mutableMapOf<String, WalletSynchronizer>()
+    var synchronizerMap = mutableMapOf<String, SdkSynchronizer>()
 
     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) {
-            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)
+    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)
+                }
+                val wallet = getWallet(alias)
+                val scope = wallet.coroutineScope
+                wallet.processorInfo.collectWith(scope, { update ->
+                    var lastDownloadedHeight = runBlocking { wallet.processor.downloader.getLastDownloadedHeight() }
+                    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())
+                    }
+                })
+                return@wrap null
             }
-          }
-          val wallet = getWallet(alias)
-          wallet.synchronizer.hashCode().toString()
         }
 
     @ReactMethod
-    fun start(alias: String, promise: Promise) = promise.wrap {
+    fun stop(alias: String, promise: Promise) {
         val wallet = getWallet(alias)
-        if (!wallet.isStarted) {
+        moduleScope.launch {
             runBlocking {
-              wallet.synchronizer.prepare()
+                wallet.close()
+                synchronizerMap.remove(alias)
+                promise.resolve(null)
             }
-            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.isStarted = true
         }
-        "success"
     }
 
-    @ReactMethod
-    fun stop(alias: String, promise: Promise) = promise.wrap {
-        val wallet = getWallet(alias)
-        wallet.synchronizer.stop()
-        synchronizerMap.remove(alias)
-        "success"
+    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
     }
 
     @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)
+
+        fun parseTx(tx: TransactionOverview): WritableMap {
+            val map = Arguments.createMap()
+            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 = runBlocking { wallet.getRecipients(tx).first() }
+                if (recipient is TransactionRecipient.Address) {
+                    map.putString("toAddress", recipient.addressValue)
                 }
+            }
+            if (tx.memoCount > 0) {
+                val memos = runBlocking { wallet.getMemos(tx).take(tx.memoCount).toList() }
+                map.putArray("memos", Arguments.fromList(memos))
+            }
+            return map
+        }
 
-                nativeArray
+        moduleScope.launch {
+            val numTxs = wallet.getTransactionCount()
+            var txCount = 0
+            val nativeArray = Arguments.createArray()
+            if (numTxs == 0) {
+                promise.resolve(nativeArray)
+                return@launch
+            }
+            runBlocking {
+                wallet.transactions.onEach {
+                    it.forEach { tx ->
+                        run {
+                            txCount++
+                            if (inRange(tx, first, last)) nativeArray.pushMap(parseTx(tx))
+                        }
+                        if (numTxs == txCount) {
+                            cancel()
+                            promise.resolve(nativeArray)
+                        }
+                    }
+                }.collect()
             }
         }
     }
 
     @ReactMethod
-    fun rescan(alias: String, height: Int, promise: Promise) {
+    fun rescan(alias: String, promise: Promise) {
         val wallet = getWallet(alias)
         moduleScope.launch {
-            wallet.synchronizer.rewindToNearestHeight(height)
+            runBlocking {
+                wallet.rewindToNearestHeight(wallet.latestBirthdayHeight, true)
+                promise.resolve(null)
+            }
         }
     }
 
     @ReactMethod
-    fun deriveViewingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) {
-        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)
-        promise.resolve(map)
-    }
-
-    @ReactMethod
-    fun deriveSpendingKey(seedBytesHex: String, network: String = "mainnet", promise: Promise) = promise.wrap {
-        runBlocking { DerivationTool.deriveSpendingKeys(seedBytesHex.fromHex(), networks.getOrDefault(network, ZcashNetwork.Mainnet))[0] }
+    fun deriveViewingKey(seed: String, network: String = "mainnet", promise: Promise) {
+        var seedPhrase = SeedPhrase.new(seed)
+        var keys = runBlocking { DerivationTool.getInstance().deriveUnifiedFullViewingKeys(seedPhrase.toByteArray(), networks.getOrDefault(network, ZcashNetwork.Mainnet), DerivationTool.DEFAULT_NUMBER_OF_ACCOUNTS)[0] }
+        promise.resolve(keys.encoding)
     }
 
     //
     // Properties
     //
 
-
     @ReactMethod
     fun getLatestNetworkHeight(alias: String, promise: Promise) = promise.wrap {
         val wallet = getWallet(alias)
-        wallet.synchronizer.latestHeight
+        return@wrap wallet.latestHeight
     }
 
     @ReactMethod
-    fun getBirthdayHeight(host: String, port: Int, promise: Promise) = promise.wrap {
-        var lightwalletService = LightWalletGrpcService(reactApplicationContext, host, port)
-        val height = lightwalletService?.getLatestBlockHeight()
-        lightwalletService?.shutdown()
-        height
+    fun getBirthdayHeight(host: String, port: Int, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                var endpoint = LightWalletEndpoint(host, port, true)
+                var lightwalletService = LightWalletClient.new(reactApplicationContext, endpoint)
+                return@wrap when (val response = lightwalletService.getLatestBlockHeight()) {
+                    is Response.Success -> {
+                        response.result.value.toInt()
+                    }
+
+                    is Response.Failure -> {
+                        throw LightWalletException.DownloadBlockException(
+                            response.code,
+                            response.description,
+                            response.toThrowable(),
+                        )
+                    }
+                }
+            }
+        }
     }
 
     @ReactMethod
-    fun getShieldedBalance(alias: String, promise: Promise) = promise.wrap {
+    fun getBalance(alias: String, promise: Promise) = promise.wrap {
         val wallet = getWallet(alias)
+        var availableZatoshi = Zatoshi(0L)
+        var totalZatoshi = Zatoshi(0L)
+
+        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", wallet.synchronizer.saplingBalances.value.totalZatoshi.toString(10))
-        map.putString("availableZatoshi", wallet.synchronizer.saplingBalances.value.availableZatoshi.toString(10))
-        map
+        map.putString("totalZatoshi", totalZatoshi.value.toString())
+        map.putString("availableZatoshi", availableZatoshi.value.toString())
+        return@wrap map
     }
 
     @ReactMethod
-    fun spendToAddress(
+    fun sendToAddress(
         alias: String,
         zatoshi: String,
         toAddress: String,
-        memo: String,
-        fromAccountIndex: Int,
-        spendingKey: String,
-        promise: Promise
+        memo: String = "",
+        seed: String,
+        promise: Promise,
     ) {
         val wallet = getWallet(alias)
-        wallet.synchronizer.coroutineScope.launch {
+        wallet.coroutineScope.launch {
+            var seedPhrase = SeedPhrase.new(seed)
+            val usk = runBlocking { DerivationTool.getInstance().deriveUnifiedSpendingKey(seedPhrase.toByteArray(), wallet.network, Account.DEFAULT) }
             try {
-                wallet.synchronizer.sendToAddress(
-                    spendingKey,
-                    zatoshi.toLong(),
+                val internalId = wallet.sendToAddress(
+                    usk,
+                    Zatoshi(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()
-                        if (tx.errorMessage != null) map.putString("errorMessage", tx.errorMessage)
-                        if (tx.errorCode != null) map.putString("errorCode", tx.errorCode.toString())
-                        promise.resolve(map)
-                    }
-                }
+                )
+                val tx = runBlocking { wallet.transactions.flatMapConcat { list -> flowOf(*list.toTypedArray()) } }.firstOrNull { item -> item.id == internalId }
+                if (tx == null) throw Exception("transaction failed")
+
+                val map = Arguments.createMap()
+                map.putString("txId", tx.rawId.byteArray.toHexReversed())
+                if (tx.raw != null) map.putString("raw", tx.raw?.byteArray?.toHex())
+                promise.resolve(map)
             } catch (t: Throwable) {
                 promise.reject("Err", t)
             }
         }
-
     }
 
     //
@@ -239,40 +256,29 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     //
 
     @ReactMethod
-    fun deriveShieldedAddress(viewingKey: String, network: String = "mainnet", promise: Promise) = promise.wrap {
-        runBlocking { DerivationTool.deriveShieldedAddress(viewingKey, networks.getOrDefault(network, ZcashNetwork.Mainnet)) }
-    }
-
-    @ReactMethod
-    fun isValidShieldedAddress(address: String, network: String, promise: Promise) {
+    fun deriveUnifiedAddress(alias: String, promise: Promise) = promise.wrap {
+        val wallet = getWallet(alias)
         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
+            runBlocking {
+                var unifiedAddress = wallet.getUnifiedAddress(Account(0))
+                promise.resolve(unifiedAddress)
             }
         }
     }
 
     @ReactMethod
-    fun isValidTransparentAddress(address: String, network: String, promise: Promise) {
+    fun isValidAddress(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
+                var isValid = false
+                val wallets = synchronizerMap.asIterable()
+                for (wallet in wallets) {
+                    if (wallet.value.network.networkName == network) {
+                        isValid = wallet.value.isValidAddress(address)
+                        break
+                    }
                 }
-              }
-              isValid
+                return@wrap isValid
             }
         }
     }
@@ -284,13 +290,12 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     /**
      * Retrieve wallet object from synchronizer map
      */
-    private fun getWallet(alias: String): WalletSynchronizer {
+    private fun getWallet(alias: String): SdkSynchronizer {
         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.
      */
@@ -311,10 +316,10 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
     }
 
     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()
+        val sb = StringBuilder(size * 2)
+        var i = size - 1
+        while (i >= 0)
+            sb.append(String.format("%02x", this[i--]))
+        return sb.toString()
     }
 }

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

@@ -1,4 +1,4 @@
-package app.edge.rnzcash;
+package app.edge.rnzcash
 
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
@@ -6,11 +6,10 @@ 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)
+            RNZcashModule(reactContext),
         )
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =

package/ios/RNZcash.m

@@ -4,8 +4,7 @@
 @interface RCT_EXTERN_MODULE(RNZcash, RCTEventEmitter<RCTBridgeModule>)
 
 // Synchronizer
-RCT_EXTERN_METHOD(initialize:(NSString *)extfvk
-:(NSString *)extpub
+RCT_EXTERN_METHOD(initialize:(NSString *)seed
 :(NSInteger *)birthdayHeight
 :(NSString *)alias
 :(NSString *)networkName
@@ -36,11 +35,10 @@ resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(spendToAddress:(NSString *)alias
+RCT_EXTERN_METHOD(sendToAddress:(NSString *)alias
 :(NSString *)zatoshi
 :(NSString *)toAddress
 :(NSString *)memo
-:(NSInteger *)fromAccountIndex
 :(NSString *)spendingKey
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
@@ -53,13 +51,12 @@ resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(getShieldedBalance:(NSString *)alias
+RCT_EXTERN_METHOD(getBalance:(NSString *)alias
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
 
 RCT_EXTERN_METHOD(rescan:(NSString *)alias
-:(NSInteger *)height
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
@@ -71,25 +68,12 @@ 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
+RCT_EXTERN_METHOD(deriveUnifiedAddress:(NSString *)alias
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(isValidShieldedAddress:(NSString *)address
+RCT_EXTERN_METHOD(isValidAddress:(NSString *)address
 :(NSString *)network
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject