feat(platform-wallet): registry-owned coordinator lifecycle with Rust-owned FFI callback contexts

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

@@ -7,11 +7,14 @@ package org.dashfoundation.dashsdk.ffi
  *
  * [nativeCreate] takes the SDK handle plus the two Kotlin bridge objects
  * (persistence + event), builds the native persistence / event vtables
- * with boxed `GlobalRef` contexts, hands them to
- * `platform_wallet_manager_create_with_persistence_capabilities`, and returns a boxed **bundle** pointer
- * as a `jlong`. The bundle owns the two context boxes for the manager's
- * lifetime; [nativeDestroy] shuts the manager down (quiescing every
- * callback-firing task) and only then frees them.
+ * with boxed `GlobalRef` contexts, hands them — **with ownership** (the
+ * vtables carry a `release_fn`) — to
+ * `platform_wallet_manager_create_with_persistence_capabilities`, and
+ * returns a boxed **bundle** pointer as a `jlong`. The native manager
+ * frees each context box exactly once, when its last worker reference
+ * drops; [nativeDestroy] shuts the manager down (bounded quiesce + join
+ * of every callback-firing task) and a worker that straggles past it
+ * keeps its bridge `GlobalRef` alive until that worker exits.
  *
  * The raw manager `Handle` used by the sync / wallet-accessor calls is
  * read from the bundle via [nativeManagerHandle].

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

@@ -147,9 +147,14 @@ class PlatformWalletPersistenceHandler(
 
     /**
      * Shut down the owned executor (no-op for an injected dispatcher).
-     * Callers must quiesce native callbacks first — the manager invokes
-     * this only after `nativeDestroy` has freed the callback contexts, so
-     * nothing can dispatch onto the executor afterwards.
+     * The manager invokes this after `nativeDestroy`'s bounded shutdown
+     * has quiesced the callback-firing tasks. A native worker that
+     * straggled past that shutdown holds its own strong reference to the
+     * bridge (Rust owns the callback context and frees it when the worker
+     * exits), so a late callback is memory-safe; if it dispatches onto
+     * the already-closed executor it is rejected and dropped, which is
+     * fine — every persistence hook is reconciliation-based and re-runs
+     * on the next launch.
      */
     override fun close() {
         ownedDispatcher?.close()

packages/kotlin-sdk/sdk/src/main/kotlin/org/dashfoundation/dashsdk/wallet/PlatformWalletManager.kt

@@ -154,10 +154,12 @@ internal fun initializePlatformWalletNativeManager(
  * ## Lifecycle
  *
  * [AutoCloseable]. [close] stops the sync loops, destroys the native
- * bundle (which runs the Rust `shutdown()` — quiescing every callback
- * before its context `GlobalRef`s are freed), then closes the resolver +
- * signer children. Order matters: the native manager must be torn down
- * before the children whose bridges its callbacks reference.
+ * bundle (which runs the Rust `shutdown()` — a bounded quiesce + join of
+ * every callback-firing task; the context `GlobalRef`s themselves are
+ * owned and freed by the native manager when its last worker reference
+ * drops), then closes the resolver + signer children. Order matters: the
+ * native manager must be torn down before the children whose bridges its
+ * callbacks reference.
  *
  * Blocking natives are wrapped `suspend` / [withContext] `(Dispatchers.IO)`
  * and errors pass through `mapNativeErrors` at the public boundary.

packages/rs-dash-async/Cargo.toml

@@ -13,6 +13,8 @@ tracing = "0.1.41"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1.40", features = ["rt", "rt-multi-thread", "time", "net"] }
+tokio-util = { version = "0.7.12" }
+futures = { version = "0.3.30" }
 
 [dev-dependencies]
-tokio = { version = "1.40", features = ["macros", "rt-multi-thread", "sync"] }
+tokio = { version = "1.40", features = ["macros", "rt-multi-thread", "sync", "time"] }

packages/rs-dash-async/src/lib.rs

@@ -2,7 +2,17 @@
 //!
 //! Provides [`block_on`] -- a function that bridges async futures into sync code,
 //! handling multiple tokio runtime flavors (no runtime, current-thread, multi-thread).
+//!
+//! Also provides `ThreadRegistry` — a shared lifecycle engine for background
+//! OS-thread workers (start, cancel, bounded quiesce + join, orphan reap).
 
 mod block_on;
+#[cfg(not(target_arch = "wasm32"))]
+mod registry;
 
 pub use block_on::{block_on, AsyncError};
+#[cfg(not(target_arch = "wasm32"))]
+pub use registry::{
+    ClearingGuard, RegistryKey, ShutdownReport, ThreadRegistry, WorkerConfig, WorkerStatus,
+    DEFAULT_JOIN_BUDGET, DEFAULT_REAP_BACKSTOP,
+};