dash-shielded-native 0.0.1

package/rust/Cargo.toml

@@ -0,0 +1,63 @@
+[package]
+name = "edge-dash-shielded"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+name = "dashshielded"
+crate-type = ["cdylib", "staticlib"]
+
+[features]
+default = ["napi-backend"]
+napi-backend = ["dep:napi", "dep:napi-derive", "dep:napi-build"]
+uniffi-backend = ["dep:uniffi", "dep:thiserror"]
+
+[dependencies]
+dash-sdk = { git = "https://github.com/dashpay/platform.git", tag = "v4.1.1", default-features = false, features = ["wallet"] }
+dashcore = { git = "https://github.com/dashpay/rust-dashcore", rev = "70d4bf8e36057c58e02d56769a6e9760f701dd06" }
+key-wallet = { git = "https://github.com/dashpay/rust-dashcore", rev = "70d4bf8e36057c58e02d56769a6e9760f701dd06" }
+platform-wallet-storage = { git = "https://github.com/dashpay/platform.git", tag = "v4.1.1", features = ["sqlite"] }
+dash-spv = { git = "https://github.com/dashpay/rust-dashcore", rev = "70d4bf8e36057c58e02d56769a6e9760f701dd06" }
+dash-network-seeds = { git = "https://github.com/dashpay/rust-dashcore", rev = "70d4bf8e36057c58e02d56769a6e9760f701dd06" }
+rs-sdk-trusted-context-provider = { git = "https://github.com/dashpay/platform.git", tag = "v4.1.1" }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
+platform-wallet = { git = "https://github.com/dashpay/platform.git", tag = "v4.1.1", features = ["shielded"] }
+bech32 = "0.11"
+bip0039 = { version = "0.12", features = ["rand"] }
+hex = "0.4"
+json = "0.12"
+napi = { version = "2.16", default-features = false, features = [
+    "napi8",
+    "async",
+    "tokio_rt",
+], optional = true }
+napi-derive = { version = "2.16", optional = true }
+once_cell = "1"
+orchard = { git = "https://github.com/dashpay/orchard.git", tag = "dashified-0.14.1", default-features = false }
+thiserror = { version = "2", optional = true }
+tokio = { version = "1", features = ["rt-multi-thread", "sync"] }
+uniffi = { version = "0.29", optional = true, features = ["cli"] }
+zip32 = "0.2"
+
+[build-dependencies]
+napi-build = { version = "2.1", optional = true }
+uniffi = { version = "0.29", optional = true, features = ["build"] }
+
+[[bin]]
+name = "uniffi-bindgen"
+path = "uniffi-bindgen.rs"
+required-features = ["uniffi-backend"]
+
+# The iOS app links every native module into one binary, and ARM64 direct
+# branches only reach ±128 MB. With the full Dash Platform SDK compiled in,
+# the default release profile pushed __TEXT past that limit and the link
+# failed with `B/BL out of range` from monero's pre-linked blob, which the
+# linker cannot split to insert branch islands. Optimize for size.
+[profile.release]
+opt-level = "z"
+lto = "fat"
+codegen-units = 1
+strip = true
+# Deliberately NOT `panic = "abort"`: both backends turn a Rust panic into a
+# host-side error, and aborting would take the whole app down instead.

package/rust/build.rs

@@ -0,0 +1,7 @@
+fn main() {
+    #[cfg(feature = "napi-backend")]
+    napi_build::setup();
+
+    #[cfg(feature = "uniffi-backend")]
+    uniffi::generate_scaffolding("src/dash.udl").unwrap();
+}

package/rust/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.97.1"
+components = [ "clippy", "rustfmt" ]

package/rust/src/dash.udl

@@ -0,0 +1,90 @@
+[Error]
+interface DashError {
+  Internal(string message);
+};
+
+dictionary Addresses {
+  string shielded_address;
+};
+
+dictionary Transaction {
+  string txid;
+  i64 block_time_in_seconds;
+  i64 mined_height;
+  string value;
+  string? fee;
+  string? to_address;
+  sequence<string> memos;
+};
+
+dictionary Poll {
+  string alias;
+  string status;
+  f64 scan_progress;
+  u32 network_block_height;
+  string available_credits;
+  string total_credits;
+  sequence<Transaction> transactions;
+};
+
+namespace dash {
+  [Throws=DashError]
+  void set_document_directory(string path);
+
+  [Throws=DashError]
+  void initialize(
+    string mnemonic_seed,
+    u32 account,
+    string alias,
+    string network_name,
+    string default_host,
+    u32 default_port
+  );
+
+  [Throws=DashError]
+  string stop(string alias);
+
+  [Throws=DashError]
+  void start_sync(string alias);
+
+  [Throws=DashError]
+  void stop_sync(string alias);
+
+  [Throws=DashError]
+  Addresses derive_shielded_address(string alias);
+
+  boolean is_valid_address(string address, string network);
+
+  [Throws=DashError]
+  string derive_viewing_key(string mnemonic_seed, string network);
+
+  [Throws=DashError]
+  void warm_up_prover();
+
+  boolean is_prover_ready();
+
+  [Throws=DashError]
+  Poll poll(string alias);
+
+  [Throws=DashError]
+  string propose_transfer(
+    string alias,
+    string amount_credits,
+    string to_address,
+    string? memo
+  );
+
+  [Throws=DashError]
+  string create_transfer(
+    string alias,
+    string proposal_id,
+    string mnemonic_seed
+  );
+
+  [Throws=DashError]
+  string derive_shielded_address_from_seed(
+    string mnemonic_seed,
+    string network,
+    u32 account
+  );
+};

package/rust/src/lib.rs

@@ -0,0 +1,16 @@
+mod wallet;
+
+#[cfg(feature = "napi-backend")]
+mod napi_api;
+
+#[cfg(feature = "uniffi-backend")]
+mod uniffi_api;
+
+#[cfg(feature = "uniffi-backend")]
+pub use uniffi_api::*;
+
+#[cfg(feature = "uniffi-backend")]
+pub use wallet::{Addresses, Poll, Transaction};
+
+#[cfg(feature = "uniffi-backend")]
+uniffi::include_scaffolding!("dash");

package/rust/src/napi_api.rs

@@ -0,0 +1,164 @@
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+use crate::wallet;
+
+fn err(msg: impl ToString) -> Error {
+    Error::from_reason(msg.to_string())
+}
+
+fn map<T>(value: wallet::WalletResult<T>) -> Result<T> {
+    value.map_err(err)
+}
+
+#[napi(object)]
+pub struct JsAddresses {
+    pub shielded_address: String,
+}
+
+#[napi(object)]
+pub struct JsTransaction {
+    pub txid: String,
+    pub block_time_in_seconds: i64,
+    pub mined_height: i64,
+    pub value: String,
+    pub fee: Option<String>,
+    pub to_address: Option<String>,
+    pub memos: Vec<String>,
+}
+
+#[napi(object)]
+pub struct JsPoll {
+    pub alias: String,
+    pub status: String,
+    pub scan_progress: f64,
+    pub network_block_height: u32,
+    pub available_credits: String,
+    pub total_credits: String,
+    pub transactions: Vec<JsTransaction>,
+}
+
+impl From<wallet::Addresses> for JsAddresses {
+    fn from(value: wallet::Addresses) -> Self {
+        Self {
+            shielded_address: value.shielded_address,
+        }
+    }
+}
+
+impl From<wallet::Transaction> for JsTransaction {
+    fn from(value: wallet::Transaction) -> Self {
+        Self {
+            txid: value.txid,
+            block_time_in_seconds: value.block_time_in_seconds,
+            mined_height: value.mined_height,
+            value: value.value,
+            fee: value.fee,
+            to_address: value.to_address,
+            memos: value.memos,
+        }
+    }
+}
+
+impl From<wallet::Poll> for JsPoll {
+    fn from(value: wallet::Poll) -> Self {
+        Self {
+            alias: value.alias,
+            status: value.status,
+            scan_progress: value.scan_progress,
+            network_block_height: value.network_block_height,
+            available_credits: value.available_credits,
+            total_credits: value.total_credits,
+            transactions: value.transactions.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+#[napi]
+pub fn set_document_directory(path: String) -> Result<()> {
+    map(wallet::set_document_directory(path))
+}
+
+#[napi]
+pub async fn initialize(
+    mnemonic_seed: String,
+    account: u32,
+    alias: String,
+    network_name: String,
+    default_host: String,
+    default_port: u32,
+) -> Result<()> {
+    map(wallet::initialize(
+        mnemonic_seed,
+        account,
+        alias,
+        network_name,
+        default_host,
+        default_port,
+    )
+    .await)
+}
+
+#[napi]
+pub async fn stop(alias: String) -> Result<String> {
+    map(wallet::stop(alias).await)
+}
+
+#[napi]
+pub async fn start_sync(alias: String) -> Result<()> {
+    map(wallet::start_sync(alias).await)
+}
+
+#[napi]
+pub async fn stop_sync(alias: String) -> Result<()> {
+    map(wallet::stop_sync(alias).await)
+}
+
+#[napi]
+pub async fn derive_shielded_address(alias: String) -> Result<JsAddresses> {
+    map(wallet::derive_shielded_address(alias).await).map(Into::into)
+}
+
+#[napi]
+pub fn is_valid_address(address: String, network: String) -> bool {
+    wallet::is_valid_address(address, network)
+}
+
+#[napi]
+pub fn derive_viewing_key(mnemonic_seed: String, network: String) -> Result<String> {
+    map(wallet::derive_viewing_key(mnemonic_seed, network))
+}
+
+#[napi]
+pub async fn warm_up_prover() -> Result<()> {
+    map(wallet::warm_up_prover().await)
+}
+
+#[napi]
+pub fn is_prover_ready() -> bool {
+    wallet::is_prover_ready()
+}
+
+#[napi]
+pub async fn poll(alias: String) -> Result<JsPoll> {
+    map(wallet::poll(alias).await).map(Into::into)
+}
+
+#[napi]
+pub async fn propose_transfer(
+    alias: String,
+    amount_credits: String,
+    to_address: String,
+    memo: Option<String>,
+) -> Result<String> {
+    map(wallet::propose_transfer(alias, amount_credits, to_address, memo).await)
+}
+
+#[napi]
+pub async fn create_transfer(
+    alias: String,
+    proposal_id: String,
+    mnemonic_seed: String,
+) -> Result<String> {
+    map(wallet::create_transfer(alias, proposal_id, mnemonic_seed).await)
+}

package/rust/src/uniffi_api.rs

@@ -0,0 +1,116 @@
+use once_cell::sync::Lazy;
+use tokio::runtime::Runtime;
+
+use crate::wallet;
+
+static RT: Lazy<Runtime> = Lazy::new(|| Runtime::new().expect("tokio runtime"));
+
+#[derive(Debug, thiserror::Error)]
+pub enum DashError {
+    #[error("{message}")]
+    Internal { message: String },
+}
+
+fn map<T>(value: wallet::WalletResult<T>) -> Result<T, DashError> {
+    value.map_err(|message| DashError::Internal { message })
+}
+
+fn block_on<F: std::future::Future>(future: F) -> F::Output {
+    RT.block_on(future)
+}
+
+pub fn set_document_directory(path: String) -> Result<(), DashError> {
+    map(wallet::set_document_directory(path))
+}
+
+pub fn initialize(
+    mnemonic_seed: String,
+    account: u32,
+    alias: String,
+    network_name: String,
+    default_host: String,
+    default_port: u32,
+) -> Result<(), DashError> {
+    map(block_on(wallet::initialize(
+        mnemonic_seed,
+        account,
+        alias,
+        network_name,
+        default_host,
+        default_port,
+    )))
+}
+
+pub fn stop(alias: String) -> Result<String, DashError> {
+    map(block_on(wallet::stop(alias)))
+}
+
+pub fn start_sync(alias: String) -> Result<(), DashError> {
+    map(block_on(wallet::start_sync(alias)))
+}
+
+pub fn stop_sync(alias: String) -> Result<(), DashError> {
+    map(block_on(wallet::stop_sync(alias)))
+}
+
+pub fn derive_shielded_address(alias: String) -> Result<wallet::Addresses, DashError> {
+    map(block_on(wallet::derive_shielded_address(alias)))
+}
+
+pub fn is_valid_address(address: String, network: String) -> bool {
+    wallet::is_valid_address(address, network)
+}
+
+pub fn derive_viewing_key(mnemonic_seed: String, network: String) -> Result<String, DashError> {
+    map(wallet::derive_viewing_key(mnemonic_seed, network))
+}
+
+pub fn warm_up_prover() -> Result<(), DashError> {
+    map(block_on(wallet::warm_up_prover()))
+}
+
+pub fn is_prover_ready() -> bool {
+    wallet::is_prover_ready()
+}
+
+pub fn poll(alias: String) -> Result<wallet::Poll, DashError> {
+    map(block_on(wallet::poll(alias)))
+}
+
+pub fn propose_transfer(
+    alias: String,
+    amount_credits: String,
+    to_address: String,
+    memo: Option<String>,
+) -> Result<String, DashError> {
+    map(block_on(wallet::propose_transfer(
+        alias,
+        amount_credits,
+        to_address,
+        memo,
+    )))
+}
+
+pub fn create_transfer(
+    alias: String,
+    proposal_id: String,
+    mnemonic_seed: String,
+) -> Result<String, DashError> {
+    map(block_on(wallet::create_transfer(
+        alias,
+        proposal_id,
+        mnemonic_seed,
+    )))
+}
+
+pub fn derive_shielded_address_from_seed(
+    mnemonic_seed: String,
+    network: String,
+    account: u32,
+) -> Result<String, DashError> {
+    let alias = format!("tools-addr-{network}-{account}");
+    initialize(mnemonic_seed, account, alias.clone(), network, String::new(), 0)?;
+    let addresses = derive_shielded_address(alias.clone())?;
+    let _ = stop(alias);
+    Ok(addresses.shielded_address)
+}