dash-shielded-native 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# dash-shielded-native
+
+## 0.1.0 (2026-08-31)
+
+- Initial Node N-API + React Native UniFFI package for Dash Platform shielded addresses and transfers.

package/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 Airbitz, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This package wraps the Dash Platform wallet crates, which are MIT, and ships
+binaries compiled from them. The Rust dependencies they pull in remain under
+their own licenses.

package/README.md

@@ -0,0 +1,36 @@
+# dash-shielded-native
+
+Native Dash Platform shielded-pool wallet library for React Native and Node.js.
+
+One package serves both hosts, matching `monero-native` / `zcash-native` / `zano-native`:
+
+| Export | Backend |
+|--------|---------|
+| `dash-shielded-native` / `./rn` | UniFFI iOS + Android |
+| `dash-shielded-native/node` | N-API (`makeNodeDashShieldedModule`) |
+
+v1 covers keys, `dash1z` / `tdash1z` addresses, sync stubs, and `ShieldedTransfer` proposal/create. Create currently requires `rs-platform-wallet` DAPI bindings before a live testnet send.
+
+```ts
+import { makeNodeDashShieldedModule } from 'dash-shielded-native/node'
+
+const io = makeNodeDashShieldedModule({ documentDirectory })
+const keys = await io.Tools.deriveViewingKey(mnemonic, 'testnet')
+const synchronizer = await io.makeSynchronizer({
+  mnemonicSeed: mnemonic,
+  account: 0,
+  alias: 'wallet',
+  network: 'testnet',
+  dataDir: documentDirectory,
+  defaultHost: 'seed-1.testnet.networks.dash.org',
+  defaultPort: 1443
+})
+```
+
+Host build:
+
+```bash
+socket npm install
+socket npm run build-native-host
+socket npm run smoke-node
+```

package/android/build.gradle

@@ -0,0 +1,56 @@
+buildscript {
+  def kotlinVersion = rootProject.ext.has('kotlinVersion')
+    ? rootProject.ext.get('kotlinVersion')
+    : '2.1.10'
+
+  repositories {
+    mavenCentral()
+    google()
+  }
+  dependencies {
+    classpath 'com.android.tools.build:gradle:8.5.0'
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
+  }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  compileSdkVersion safeExtGet('compileSdkVersion', 35)
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 27)
+    targetSdkVersion safeExtGet('targetSdkVersion', 35)
+    ndk {
+      abiFilters 'arm64-v8a'
+    }
+  }
+  sourceSets {
+    main {
+      jniLibs.srcDirs = ['src/main/jniLibs']
+    }
+  }
+  lintOptions {
+    abortOnError false
+  }
+  namespace 'app.edge.rndashshielded'
+}
+
+repositories {
+  maven {
+    url('../node_modules/react-native/android')
+  }
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-native:+'
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
+  implementation 'net.java.dev.jna:jna:5.17.0@aar'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/app/edge/rndashshielded/RNDashShieldedModule.kt

@@ -0,0 +1,215 @@
+package app.edge.rndashshielded
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import uniffi.dash.Poll
+import java.io.File
+
+class RNDashShieldedModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    private val moduleScope: CoroutineScope = CoroutineScope(Dispatchers.IO)
+
+    override fun getName() = "RNDashShielded"
+
+    @Volatile private var documentDirReady = false
+
+    init {
+        System.setProperty("uniffi.component.dash.libraryOverride", "dashshielded")
+    }
+
+    private fun ensureDocumentDirectory() {
+        if (documentDirReady) return
+        synchronized(this) {
+            if (documentDirReady) return
+            val dir = File(reactContext.filesDir, "native/dashshielded")
+            dir.mkdirs()
+            uniffi.dash.setDocumentDirectory(dir.absolutePath)
+            documentDirReady = true
+        }
+    }
+
+    private inline fun Promise.wrap(block: () -> Any?) {
+        try {
+            ensureDocumentDirectory()
+            resolve(block())
+        } catch (t: Throwable) {
+            reject("Err", t)
+        }
+    }
+
+    private fun pollMap(snap: Poll): WritableMap {
+        val transactions = Arguments.createArray()
+        snap.transactions.forEach { tx ->
+            val map = Arguments.createMap()
+            map.putString("txid", tx.txid)
+            map.putInt("blockTimeInSeconds", tx.blockTimeInSeconds.toInt())
+            map.putInt("minedHeight", tx.minedHeight.toInt())
+            map.putString("value", tx.value)
+            tx.fee?.let { map.putString("fee", it) }
+            tx.toAddress?.let { map.putString("toAddress", it) }
+            map.putArray("memos", Arguments.fromList(tx.memos))
+            transactions.pushMap(map)
+        }
+
+        val out = Arguments.createMap()
+        out.putString("alias", snap.alias)
+        out.putString("status", snap.status)
+        out.putDouble("scanProgress", snap.scanProgress)
+        out.putInt("networkBlockHeight", snap.networkBlockHeight.toInt())
+        out.putString("availableCredits", snap.availableCredits)
+        out.putString("totalCredits", snap.totalCredits)
+        out.putArray("transactions", transactions)
+        return out
+    }
+
+    @ReactMethod
+    fun initialize(
+        seed: String,
+        account: Int,
+        alias: String,
+        networkName: String,
+        defaultHost: String,
+        defaultPort: Int,
+        promise: Promise,
+    ) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.initialize(
+                    seed,
+                    account.toUInt(),
+                    alias,
+                    networkName,
+                    defaultHost,
+                    defaultPort.toUInt(),
+                )
+                null
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stop(alias: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap { uniffi.dash.stop(alias) }
+        }
+    }
+
+    @ReactMethod
+    fun startSync(alias: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.startSync(alias)
+                null
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stopSync(alias: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.stopSync(alias)
+                null
+            }
+        }
+    }
+
+    @ReactMethod
+    fun deriveShieldedAddress(alias: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                val addresses = uniffi.dash.deriveShieldedAddress(alias)
+                val map = Arguments.createMap()
+                map.putString("shieldedAddress", addresses.shieldedAddress)
+                map
+            }
+        }
+    }
+
+    @ReactMethod
+    fun deriveShieldedAddressFromSeed(
+        seed: String,
+        network: String,
+        account: Int,
+        promise: Promise,
+    ) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.deriveShieldedAddressFromSeed(seed, network, account.toUInt())
+            }
+        }
+    }
+
+    @ReactMethod
+    fun isValidAddress(address: String, network: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap { uniffi.dash.isValidAddress(address, network) }
+        }
+    }
+
+    @ReactMethod
+    fun deriveViewingKey(seed: String, network: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap { uniffi.dash.deriveViewingKey(seed, network) }
+        }
+    }
+
+    @ReactMethod
+    fun warmUpProver(promise: Promise) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.warmUpProver()
+                null
+            }
+        }
+    }
+
+    @ReactMethod
+    fun isProverReady(promise: Promise) {
+        moduleScope.launch {
+            promise.wrap { uniffi.dash.isProverReady() }
+        }
+    }
+
+    @ReactMethod
+    fun poll(alias: String, promise: Promise) {
+        moduleScope.launch {
+            promise.wrap { pollMap(uniffi.dash.poll(alias)) }
+        }
+    }
+
+    @ReactMethod
+    fun proposeTransfer(
+        alias: String,
+        amountCredits: String,
+        toAddress: String,
+        memo: String?,
+        promise: Promise,
+    ) {
+        moduleScope.launch {
+            promise.wrap {
+                uniffi.dash.proposeTransfer(alias, amountCredits, toAddress, memo)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun createTransfer(
+        alias: String,
+        proposalId: String,
+        seed: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch {
+            promise.wrap { uniffi.dash.createTransfer(alias, proposalId, seed) }
+        }
+    }
+}

package/android/src/main/java/app/edge/rndashshielded/RNDashShieldedPackage.kt

@@ -0,0 +1,16 @@
+package app.edge.rndashshielded
+
+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 RNDashShieldedPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext) =
+        listOf<NativeModule>(
+            RNDashShieldedModule(reactContext),
+        )
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}