refactor(sdk): run the KeyWallet helpers on platform-wallet-ffi

`TransactionDecoder.decode`, `Mnemonic.generate`, `Mnemonic.validate`, `KeyDerivation.getIdentityAuthenticationPath` and `Address.validate` keep their Swift signatures and now call `platform-wallet-ffi`. The Kotlin JNI `decodeTransaction` and `generateMnemonic` bridges do the same and map failures through `take_pwffi_error`, so `rs-unified-sdk-jni` no longer depends on `key-wallet-ffi`.

`platform_wallet_mnemonic_word_list` takes its language as a plain integer too, and the Swift callers pass `MnemonicLanguage.rawValue`. The JNI bridge passes Kotlin's ordinal through unchanged, so an unknown ordinal is an error instead of English, and Kotlin's `Language` gains Japanese, Korean, Portuguese and Spanish.

New Swift API lets apps stop rebuilding a `KeyWallet` wallet from the phrase: `Mnemonic.walletId(for:network:)`, `Mnemonic.firstReceiveAddress(for:network:)`, and `ManagedPlatformWallet.findBIP44AddressPath(address:)` and `bip44AddressPrivateKey(address:storage:)` for the BIP-44 account scan. The last shares `coreAddressPrivateKey`'s resolver handling. Every helper that passes a string to C rejects an embedded NUL. Parity tests pin the wallet id and the first receive address against the `KeyWallet` code they replace, for English and French phrases.

`Mnemonic.generate`, `TransactionDecoder.decode` and `getIdentityAuthenticationPath` now throw `PlatformWalletError`. The other `KeyWallet` classes and `rs-unified-sdk-ffi`'s `key-wallet-ffi` dependency are unchanged.

Author: xdustinface

Cargo.lock

@@ -2,7 +2,7 @@
 # Build libdash_sdk_jni.so for Android — the analog of ../swift-sdk/build_ios.sh.
 #
 # Produces one cdylib per ABI containing the JNI exports of rs-unified-sdk-jni plus
-# the C ABI of rs-sdk-ffi / platform-wallet-ffi / key-wallet-ffi (linked in
+# the C ABI of rs-sdk-ffi / platform-wallet-ffi (linked in
 # as rlibs), and drops them into sdk/src/main/jniLibs/<abi>/ where AGP
 # packages them.
 #

packages/kotlin-sdk/build_android.sh

@@ -16,8 +16,8 @@ internal object MnemonicNative {
     external fun destroyResolver(handle: Long)
 
     /**
-     * Generate a BIP-39 mnemonic (key-wallet-ffi). wordCount ∈ {12,15,18,21,24};
-     * language is the FFILanguage ordinal (0 = English).
+     * Generate a BIP-39 mnemonic (platform-wallet-ffi). wordCount ∈ {12,15,18,21,24};
+     * language is the FFIMnemonicLanguage ordinal (0 = English).
      * @throws DashSDKException on failure
      */
     external fun generateMnemonic(wordCount: Int, language: Int): String

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/ffi/MnemonicNative.kt

@@ -7,8 +7,8 @@ package org.dashfoundation.dashsdk.ffi
 internal object TxDecodeNative {
 
     /**
-     * Consensus-decode raw transaction bytes (key-wallet-ffi
-     * `transaction_decode`) into the packed big-endian BLOB documented in
+     * Consensus-decode raw transaction bytes (platform-wallet-ffi
+     * `platform_wallet_transaction_decode`) into the packed big-endian BLOB documented in
      * `tx_decode.rs` / parsed by
      * [org.dashfoundation.dashsdk.keywallet.TransactionDecoder.parseBlob].
      * [networkOrd] is [org.dashfoundation.dashsdk.Network.ffiValue].

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/ffi/TxDecodeNative.kt

@@ -6,19 +6,23 @@ import org.dashfoundation.dashsdk.ffi.MnemonicNative
 
 /**
  * BIP-39 mnemonic operations — port of `SwiftDashSDK/KeyWallet/Mnemonic.swift`.
- * Generation runs entirely in Rust (key-wallet-ffi); the phrase transits
+ * Generation runs entirely in Rust (platform-wallet-ffi); the phrase transits
  * Kotlin only to be shown for backup and stored encrypted.
  */
 object Mnemonic {
 
-    /** Mirror of the iOS `MnemonicLanguage` enum (FFILanguage ordinals). */
+    /** Mirror of the iOS `MnemonicLanguage` enum (FFIMnemonicLanguage ordinals). */
     enum class Language(val ffiValue: Int) {
         ENGLISH(0),
         CHINESE_SIMPLIFIED(1),
         CHINESE_TRADITIONAL(2),
         CZECH(3),
         FRENCH(4),
         ITALIAN(5),
+        JAPANESE(6),
+        KOREAN(7),
+        PORTUGUESE(8),
+        SPANISH(9),
     }
 
     /**

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/keywallet/Mnemonic.kt

@@ -10,7 +10,7 @@ import org.dashfoundation.dashsdk.ffi.TxDecodeNative
  * A consensus-decoded Dash transaction: per-output `(address, value,
  * script)` plus per-input previous outpoints with a best-effort P2PKH
  * sender address — port of `SwiftDashSDK/KeyWallet/TransactionDecoder.swift`
- * (platform PR #3981) over key-wallet-ffi's `transaction_decode`.
+ * (platform PR #3981) over platform-wallet-ffi's `platform_wallet_transaction_decode`.
  *
  * Wallet persistence stores every transaction's raw bytes
  * (`TransactionEntity.transactionData`) but only materializes TXO rows for
@@ -88,8 +88,8 @@ class DecodedTransaction(
 }
 
 /**
- * Pure utility — decodes raw transaction bytes via key-wallet-ffi's
- * `transaction_decode`. No wallet handle or state involved.
+ * Pure utility — decodes raw transaction bytes via platform-wallet-ffi's
+ * `platform_wallet_transaction_decode`. No wallet handle or state involved.
  */
 object TransactionDecoder {
 
@@ -99,7 +99,7 @@ object TransactionDecoder {
      * @param txData serialized transaction bytes (e.g. a persisted
      *   `TransactionEntity.transactionData`).
      * @param network network used to render addresses (base58 version bytes).
-     * @throws org.dashfoundation.dashsdk.errors.DashSdkError.InvalidParameter
+     * @throws org.dashfoundation.dashsdk.errors.DashSdkError.PlatformWallet
      *   for malformed or empty bytes (including trailing garbage).
      */
     fun decode(txData: ByteArray, network: Network): DecodedTransaction {

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/keywallet/TransactionDecoder.kt

@@ -134,8 +134,8 @@ class PlatformWalletPersistenceHandler(
     /**
      * Where the sweep pass gets a stored loser's input outpoints (the
      * outpoint-keyed hold, see `applySweptTransactions`). The production
-     * default decodes the stored consensus bytes through key-wallet-ffi's
-     * `transaction_decode`; tests inject a fake keyed by txid, since the
+     * default decodes the stored consensus bytes through platform-wallet-ffi's
+     * `platform_wallet_transaction_decode`; tests inject a fake keyed by txid, since the
      * native library is not loadable under Robolectric.
      */
     private val storedTransactionInputs: StoredTransactionInputs =
@@ -4265,8 +4265,8 @@ fun interface StoredTransactionInputs {
 }
 
 /**
- * Production [StoredTransactionInputs]: key-wallet-ffi's
- * `transaction_decode` through [org.dashfoundation.dashsdk.keywallet.TransactionDecoder].
+ * Production [StoredTransactionInputs]: platform-wallet-ffi's
+ * `platform_wallet_transaction_decode` through [org.dashfoundation.dashsdk.keywallet.TransactionDecoder].
  * The decoder is a stateless marshaler — it takes no wallet-manager lock —
  * so calling it from inside a persistence callback (which runs while Rust
  * holds that lock) cannot deadlock; the "no native calls under

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/persistence/PlatformWalletPersistenceHandler.kt

@@ -64,7 +64,7 @@ class PlatformWalletPersistenceHandlerTest {
     /**
      * What the sweep pass "decodes" from a stored record's bytes, keyed by
      * txid. Every fixture records transactions with dummy bytes
-     * (`ByteArray(10) { 5 }`) that key-wallet-ffi could never decode, and
+     * (`ByteArray(10) { 5 }`) that the native decoder could never decode, and
      * the native decoder is not loadable under Robolectric anyway, so
      * [recordTransaction] registers each record's `inputOutpoints` here and
      * [storedInputs] hands them back. A txid never registered throws, as

packages/kotlin-sdk/sdk/src/test/kotlin/org/dashfoundation/dashsdk/persistence/PlatformWalletPersistenceHandlerTest.kt

@@ -94,17 +94,22 @@ impl From<FFIMnemonicLanguage> for key_wallet::Language {
 /// caller owns `*out_string` and must free it via
 /// [`crate::xpub_render::platform_wallet_free_string`].
 ///
+/// `language` is an [`FFIMnemonicLanguage`] value, taken as a plain integer so
+/// an unknown value fails with `ErrorInvalidParameter` instead of being
+/// undefined behaviour.
+///
 /// # Safety
 /// `out_string` must point to writable memory for one `*mut c_char`.
 #[no_mangle]
 pub unsafe extern "C" fn platform_wallet_mnemonic_word_list(
-    language: FFIMnemonicLanguage,
+    language: u32,
     out_string: *mut *mut c_char,
 ) -> PlatformWalletFFIResult {
     check_ptr!(out_string);
     *out_string = std::ptr::null_mut();
 
-    let language: key_wallet::Language = language.into();
+    let language: key_wallet::Language =
+        unwrap_result_or_return!(FFIMnemonicLanguage::try_from(language)).into();
     let joined = language.word_list().join("\n");
     let c = unwrap_result_or_return!(CString::new(joined));
     *out_string = c.into_raw();
@@ -245,7 +250,8 @@ mod tests {
         // word_list: English -> 2048 \n-joined words including "abandon"/"zoo".
         let mut wl: *mut c_char = std::ptr::null_mut();
         unsafe {
-            let r = platform_wallet_mnemonic_word_list(FFIMnemonicLanguage::English, &mut wl);
+            let r =
+                platform_wallet_mnemonic_word_list(FFIMnemonicLanguage::English as u32, &mut wl);
             assert_eq!(r.code, PlatformWalletFFIResultCode::Success);
             assert!(!wl.is_null());
             let s = CStr::from_ptr(wl).to_str().unwrap().to_owned();
@@ -260,7 +266,10 @@ mod tests {
         // confirms the enum conversion actually selects the wordlist.
         let mut wl_ja: *mut c_char = std::ptr::null_mut();
         unsafe {
-            let r = platform_wallet_mnemonic_word_list(FFIMnemonicLanguage::Japanese, &mut wl_ja);
+            let r = platform_wallet_mnemonic_word_list(
+                FFIMnemonicLanguage::Japanese as u32,
+                &mut wl_ja,
+            );
             assert_eq!(r.code, PlatformWalletFFIResultCode::Success);
             let s = CStr::from_ptr(wl_ja).to_str().unwrap().to_owned();
             assert_eq!(s.split('\n').count(), 2048);
@@ -271,7 +280,7 @@ mod tests {
         // word_list NULL out-pointer -> error
         unsafe {
             let r = platform_wallet_mnemonic_word_list(
-                FFIMnemonicLanguage::English,
+                FFIMnemonicLanguage::English as u32,
                 std::ptr::null_mut(),
             );
             assert_eq!(r.code, PlatformWalletFFIResultCode::ErrorNullPointer);
@@ -380,6 +389,10 @@ mod tests {
             let r = platform_wallet_mnemonic_generate(12, 10, &mut bad);
             assert_eq!(r.code, PlatformWalletFFIResultCode::ErrorInvalidParameter);
             assert!(bad.is_null());
+            let mut list: *mut c_char = NonNull::dangling().as_ptr();
+            let r = platform_wallet_mnemonic_word_list(10, &mut list);
+            assert_eq!(r.code, PlatformWalletFFIResultCode::ErrorInvalidParameter);
+            assert!(list.is_null());
         }
 
         // validate: any supported language, but not a bad checksum or gibberish

packages/rs-platform-wallet-ffi/src/mnemonic_words.rs

@@ -4,7 +4,7 @@ edition = "2021"
 version.workspace = true
 rust-version.workspace = true
 license = "MIT"
-description = "JNI bindings for the Dash Platform SDK — Android/Kotlin shim over rs-sdk-ffi, platform-wallet-ffi and key-wallet-ffi"
+description = "JNI bindings for the Dash Platform SDK — Android/Kotlin shim over rs-sdk-ffi and platform-wallet-ffi"
 
 [lib]
 # Kotlin loads this as System.loadLibrary("dash_sdk_jni").
@@ -15,7 +15,6 @@ crate-type = ["cdylib"]
 jni = "0.21"
 rs-sdk-ffi = { path = "../rs-sdk-ffi" }
 platform-wallet-ffi = { path = "../rs-platform-wallet-ffi" }
-key-wallet-ffi = { workspace = true }
 dash-network = { workspace = true, features = ["ffi"] }
 log = "0.4"
 zeroize = "1"