feat(platform-wallet-storage): embeddable SQLite persistence backend with seedless rehydration

.cargo/audit.toml

@@ -1,3 +1,26 @@
 [advisories]
-# TODO Remove it from here
-ignore = [ "RUSTSEC-2020-0071"] # advisory IDs to ignore e.g. ["RUSTSEC-2019-0001", ...]
+# Advisory IDs to ignore, e.g. ["RUSTSEC-2019-0001", ...]. Each entry
+# must point at a live advisory in the resolved graph and carry a dated
+# rationale; an entry matching nothing trains reviewers to skim the list.
+#
+# rustsec/audit-check runs from the repo root (.github/workflows/security-audit-rust.yml)
+# and only reads THIS file — a crate-local .cargo/audit.toml is never consulted by CI.
+ignore = [
+    # RUSTSEC-2025-0141 — bincode is unmaintained (informational advisory,
+    # not an exploitable CVE; published 2025-12-16, no patched release).
+    # Acknowledged 2026-06-08.
+    #
+    # Why this is acceptable for now:
+    #   - The advisory reports maintenance status, not a known exploit.
+    #   - Variable-length wallet decode boundaries are budgeted: storage
+    #     enforces MAX_VALUE_LEN / BLOB_SIZE_LIMIT_BYTES, per-secret write
+    #     caps, and MAX_VAULT_SIZE_BYTES; FFI asset-lock recovery rejects
+    #     proofs over 16 MiB and applies the same bincode decode budget.
+    #   - Malformed or oversized persisted data fails with a typed error.
+    #
+    # Residual risk: a future bincode defect would go unpatched upstream.
+    # Remediation plan: migrate the BLOB codec to a maintained equivalent
+    # (postcard / bitcode candidates) once the wire format is frozen at
+    # release; revisit this ignore at that time.
+    "RUSTSEC-2025-0141",
+]

Cargo.toml

@@ -113,6 +113,13 @@ opt-level = 3
 opt-level = 3
 [profile.dev.package.grovedb-commitment-tree]
 opt-level = 3
+# Same reasoning for Argon2id: a debug-built KDF is memory-hard by design, so
+# an unoptimized one costs seconds per derivation and dominates any test that
+# unlocks a `platform-wallet-storage` vault. `platform-wallet-storage` is the
+# only workspace member that compiles argon2, so this override touches nothing
+# else here despite the workspace-global syntax.
+[profile.dev.package.argon2]
+opt-level = 3
 
 [profile.test.package.halo2_proofs]
 opt-level = 3
@@ -126,6 +133,8 @@ opt-level = 3
 opt-level = 3
 [profile.test.package.grovedb-commitment-tree]
 opt-level = 3
+[profile.test.package.argon2]
+opt-level = 3
 
 [workspace.package]
 

packages/rs-platform-wallet-ffi/src/asset_lock/sync.rs

@@ -8,6 +8,20 @@ use std::ffi::CString;
 use std::os::raw::c_char;
 use std::time::Duration;
 
+const MAX_ASSET_LOCK_PROOF_SIZE_BYTES: usize = 16 * 1024 * 1024;
+
+fn validate_asset_lock_proof_size(proof_len: usize) -> Result<(), PlatformWalletFFIResult> {
+    if proof_len > MAX_ASSET_LOCK_PROOF_SIZE_BYTES {
+        return Err(PlatformWalletFFIResult::err(
+            PlatformWalletFFIResultCode::ErrorInvalidParameter,
+            format!(
+                "asset lock proof length {proof_len} exceeds the {MAX_ASSET_LOCK_PROOF_SIZE_BYTES}-byte limit"
+            ),
+        ));
+    }
+    Ok(())
+}
+
 /// Build an `OutPoint` from a 32-byte raw txid pointer and a vout.
 ///
 /// **FFI invariant:** the `txid` parameter is typed `*const [u8; 32]`,
@@ -188,10 +202,13 @@ pub unsafe extern "C" fn asset_lock_manager_recover(
 
     // Parse optional proof
     let proof = if !proof_bytes.is_null() && proof_len > 0 {
+        // A proof contains one Core transaction and, at most, one InstantLock;
+        // 16 MiB is generous while matching the persisted-blob ceiling.
+        unwrap_result_or_return!(validate_asset_lock_proof_size(proof_len));
         let data = std::slice::from_raw_parts(proof_bytes, proof_len);
         let (p, _) = unwrap_result_or_return!(dpp::bincode::decode_from_slice(
             data,
-            dpp::bincode::config::standard()
+            dpp::bincode::config::standard().with_limit::<MAX_ASSET_LOCK_PROOF_SIZE_BYTES>()
         ));
         Some(p)
     } else {
@@ -212,3 +229,21 @@ pub unsafe extern "C" fn asset_lock_manager_recover(
     unwrap_option_or_return!(option);
     PlatformWalletFFIResult::ok()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_reject_oversized_asset_lock_proof_before_decode() {
+        assert!(validate_asset_lock_proof_size(MAX_ASSET_LOCK_PROOF_SIZE_BYTES).is_ok());
+
+        let result = validate_asset_lock_proof_size(MAX_ASSET_LOCK_PROOF_SIZE_BYTES + 1)
+            .expect_err("oversized proof must fail");
+
+        assert_eq!(
+            result.code,
+            PlatformWalletFFIResultCode::ErrorInvalidParameter
+        );
+    }
+}

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

@@ -369,6 +369,16 @@ pub enum PlatformWalletFFIResultCode {
     /// shortfall, not a shielded-note shortfall.
     ErrorShieldedInsufficientBalance = 41,
 
+    // -----------------------------------------------------------------
+    // Embedded-persister failures (42-43). A fresh contiguous block above
+    // every current claim, per the registry note above: 28 and 30 are
+    // nominally free but reusing a vacated slot restarts the churn.
+    // -----------------------------------------------------------------
+    /// A persister operation failed transiently; callers may retry.
+    ErrorPersisterTransient = 42,
+    /// A persister operation failed permanently; callers must not retry.
+    ErrorPersisterFatal = 43,
+
     /// The named thing does not exist.
     ///
     /// Originally (and still mostly) the code for every `Option` returned as an
@@ -390,6 +400,31 @@ pub enum PlatformWalletFFIResultCode {
     ErrorUnknown = 99,
 }
 
+fn persistence_result_code(
+    error: &platform_wallet::changeset::PersistenceError,
+) -> PlatformWalletFFIResultCode {
+    if error.is_transient() {
+        PlatformWalletFFIResultCode::ErrorPersisterTransient
+    } else {
+        PlatformWalletFFIResultCode::ErrorPersisterFatal
+    }
+}
+
+fn platform_wallet_persister_result_code(
+    mut error: &PlatformWalletError,
+) -> PlatformWalletFFIResultCode {
+    loop {
+        match error {
+            PlatformWalletError::PersisterLoad(error)
+            | PlatformWalletError::PersisterStore(error) => {
+                return persistence_result_code(error);
+            }
+            PlatformWalletError::PersisterRestore(inner) => error = inner,
+            _ => return PlatformWalletFFIResultCode::ErrorPersisterFatal,
+        }
+    }
+}
+
 /// Must be freed with ['platform_wallet_ffi_result_free']
 #[repr(C)]
 #[derive(Debug)]
@@ -621,6 +656,11 @@ impl From<PlatformWalletError> for PlatformWalletFFIResult {
             PlatformWalletError::AssetLockFundingMismatch { .. } => {
                 PlatformWalletFFIResultCode::ErrorAssetLockFundingMismatch
             }
+            PlatformWalletError::PersisterLoad(..)
+            | PlatformWalletError::PersisterStore(..)
+            | PlatformWalletError::PersisterRestore(..) => {
+                platform_wallet_persister_result_code(&error)
+            }
             // A quiesce/drain barrier that did not complete within budget
             // (clear/reset paths). The host must fail closed: keep its
             // callback context alive and skip any paired persistence wipe.
@@ -888,10 +928,8 @@ impl From<dpp::platform_value::Error> for PlatformWalletFFIResult {
 
 impl From<platform_wallet::changeset::PersistenceError> for PlatformWalletFFIResult {
     fn from(e: platform_wallet::changeset::PersistenceError) -> Self {
-        Self::err(
-            PlatformWalletFFIResultCode::ErrorWalletOperation,
-            format!("persistence error: {e}"),
-        )
+        let code = persistence_result_code(&e);
+        Self::err(code, format!("persistence error: {e}"))
     }
 }
 
@@ -916,6 +954,19 @@ impl From<anyhow::Error> for PlatformWalletFFIResult {
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn result_code_discriminants_remain_stable() {
+        assert_eq!(
+            PlatformWalletFFIResultCode::ErrorPersisterTransient as i32,
+            42
+        );
+        assert_eq!(PlatformWalletFFIResultCode::ErrorPersisterFatal as i32, 43);
+        assert_eq!(
+            PlatformWalletFFIResultCode::ErrorTransactionBroadcastRejected as i32,
+            26
+        );
+    }
     use key_wallet::account::StandardAccountType;
     use key_wallet::wallet::managed_wallet_info::transaction_building::AccountTypePreference;
 
@@ -955,6 +1006,71 @@ mod tests {
         assert!(!r.message.is_null());
     }
 
+    fn persistence_error(
+        kind: platform_wallet::changeset::PersistenceErrorKind,
+    ) -> platform_wallet::changeset::PersistenceError {
+        platform_wallet::changeset::PersistenceError::backend_with_kind(kind, "test failure")
+    }
+
+    #[test]
+    fn should_map_persistence_errors_by_retry_classification() {
+        use platform_wallet::changeset::{PersistenceError, PersistenceErrorKind};
+
+        let transient: PlatformWalletFFIResult =
+            persistence_error(PersistenceErrorKind::Transient).into();
+        assert_eq!(
+            transient.code,
+            PlatformWalletFFIResultCode::ErrorPersisterTransient
+        );
+
+        for error in [
+            persistence_error(PersistenceErrorKind::Fatal),
+            persistence_error(PersistenceErrorKind::Constraint),
+            PersistenceError::LockPoisoned,
+        ] {
+            let result: PlatformWalletFFIResult = error.into();
+            assert_eq!(
+                result.code,
+                PlatformWalletFFIResultCode::ErrorPersisterFatal
+            );
+        }
+    }
+
+    #[test]
+    fn should_map_platform_wallet_persister_errors_by_retry_classification() {
+        use platform_wallet::changeset::PersistenceErrorKind;
+
+        let cases = [
+            (
+                PlatformWalletError::PersisterLoad(persistence_error(
+                    PersistenceErrorKind::Transient,
+                )),
+                PlatformWalletFFIResultCode::ErrorPersisterTransient,
+            ),
+            (
+                PlatformWalletError::PersisterStore(persistence_error(PersistenceErrorKind::Fatal)),
+                PlatformWalletFFIResultCode::ErrorPersisterFatal,
+            ),
+            (
+                PlatformWalletError::PersisterRestore(Box::new(
+                    PlatformWalletError::PersisterStore(persistence_error(
+                        PersistenceErrorKind::Transient,
+                    )),
+                )),
+                PlatformWalletFFIResultCode::ErrorPersisterTransient,
+            ),
+            (
+                PlatformWalletError::PersisterRestore(Box::new(PlatformWalletError::WalletLocked)),
+                PlatformWalletFFIResultCode::ErrorPersisterFatal,
+            ),
+        ];
+
+        for (error, expected) in cases {
+            let result: PlatformWalletFFIResult = error.into();
+            assert_eq!(result.code, expected);
+        }
+    }
+
     /// The three "can't-select-inputs" wallet variants (`NoSpendableInputs`,
     /// `OnlyOutputAddressesFunded`, `OnlyDustInputs`) all map to the dedicated
     /// `ErrorNoSelectableInputs` FFI code rather than flattening to