test(platform-wallet): e2e framework + full test suite — triage pins, Found-*/PA-* guards, fail-closed persist, Stage-2 merge

packages/rs-platform-wallet/Cargo.toml

@@ -59,6 +59,39 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 # the non-test build keeps the leaner default-feature SDK above.
 dash-sdk = { path = "../rs-sdk", default-features = false, features = ["dashpay-contract", "dpns-contract", "mocks"] }
 
+# E2E test framework — see `tests/e2e/` for the integration harness
+# that exercises the wallet → SDK → broadcast pipeline against a
+# live testnet bank wallet. Pinned to the canonical published crate
+# names; cargo normalizes dash/underscore in keys but the published
+# name is the source of truth (e.g. `tokio-shared-rt`).
+tokio-shared-rt = "0.1"
+tempfile = "3"
+dotenvy = "0.15"
+bip39 = "2"
+fs2 = "0.4"
+serde = { version = "1", features = ["derive"] }
+simple-signer = { path = "../simple-signer", features = ["derive"] }
+parking_lot = "0.12"
+# `dash-async::block_on` is the runtime-flavor-agnostic bridge used by
+# `framework/context_provider.rs` to call `SpvRuntime`'s async API
+# from the synchronous `ContextProvider` trait. Handles all three
+# tokio runtime scenarios (no runtime, current-thread, multi-thread)
+# without the `block_in_place` panic that `tokio::task::block_in_place`
+# triggers on a current-thread runtime.
+dash-async = { path = "../rs-dash-async" }
+# `rt` feature gives us `CancellationToken` for the panic-hook +
+# graceful-shutdown wiring described in the e2e plan.
+tokio-util = { version = "0.7", features = ["rt"] }
+# `TrustedHttpContextProvider` is the e2e harness's current default
+# context provider. It backs `Sdk::set_context_provider` with the
+# operator-trusted Quorum HTTP endpoint built into the crate (per
+# network) so testnet / mainnet runs work without spinning up an
+# SPV client. The SPV-backed provider lives in `framework/spv.rs`
+# and `framework/context_provider.rs` and is currently disabled
+# (see harness.rs) — re-enable when SPV cold-start is stable
+# (Task #15).
+rs-sdk-trusted-context-provider = { path = "../rs-sdk-trusted-context-provider" }
+
 
 [features]
 default = ["bls", "eddsa"]

packages/rs-platform-wallet/src/changeset/changeset.rs

@@ -582,6 +582,36 @@ pub struct PlatformAddressChangeSet {
     /// Last block height with recent address changes (compaction marker).
     /// `None` means "no change".
     pub last_known_recent_block: Option<u64>,
+    /// Lower-bound static fee estimate for the transfer that produced
+    /// this changeset, in credits. `0` for changesets not produced by
+    /// `transfer()` (e.g. sync-only changesets). See
+    /// [`Self::estimated_min_fee`].
+    pub fee: Credits,
+}
+
+impl PlatformAddressChangeSet {
+    /// Lower-bound static fee estimate for the transfer that produced
+    /// this changeset, in credits.
+    ///
+    /// Returns `0` for changesets that didn't originate from a
+    /// `transfer()` call — e.g. sync-only changesets, or changesets
+    /// constructed via `Default::default()`. The value is the raw
+    /// `AddressFundsTransferTransition::estimate_min_fee(input_count,
+    /// output_count, version)` result captured at submit time — it is
+    /// **NOT** the actual on-chain fee and is **NOT** adjusted by the
+    /// `fee_strategy`.
+    ///
+    /// `estimate_min_fee` only models the static
+    /// `state_transition_min_fees` floor; chain-time fees include
+    /// storage + processing costs that scale with the operation set
+    /// (~6.5M static vs ~14.94M observed real for 1in/1out at the time
+    /// of writing). Tests asserting on the actual chain-time debit
+    /// must read the post-broadcast balance delta directly, not this
+    /// value. See platform issue #3040 for the open ticket on
+    /// upgrading `estimate_min_fee` to a chain-time-accurate estimate.
+    pub fn estimated_min_fee(&self) -> Credits {
+        self.fee
+    }
 }
 
 impl Merge for PlatformAddressChangeSet {
@@ -606,13 +636,20 @@ impl Merge for PlatformAddressChangeSet {
                     .map_or(r, |existing| existing.max(r)),
             );
         }
+        // Fee: append-sum via `saturating_add`. Sync-only merges
+        // (`fee == 0`) are a no-op so a transfer's recorded fee
+        // survives untouched; merging two transfer changesets sums
+        // the per-operation fees so the merged total reflects the
+        // "total fee paid across operations in this batch" intent.
+        self.fee = self.fee.saturating_add(other.fee);
     }
 
     fn is_empty(&self) -> bool {
         self.addresses.is_empty()
             && self.sync_height.is_none()
             && self.sync_timestamp.is_none()
             && self.last_known_recent_block.is_none()
+            && self.fee == 0
     }
 }
 

packages/rs-platform-wallet/src/wallet/identity/state/manager/accessors.rs

@@ -104,6 +104,20 @@ impl IdentityManager {
                 .sum::<usize>()
     }
 
+    /// Snapshot of every managed identity's `Identifier` across both
+    /// buckets. Order is unspecified — callers that need a stable
+    /// order should sort the returned `Vec`.
+    pub fn identity_ids(&self) -> Vec<Identifier> {
+        let mut out: Vec<Identifier> = Vec::with_capacity(self.identity_count());
+        out.extend(self.out_of_wallet_identities.keys().copied());
+        for inner in self.wallet_identities.values() {
+            for managed in inner.values() {
+                out.push(managed.identity.id());
+            }
+        }
+        out
+    }
+
     /// `true` iff both buckets are empty.
     pub fn is_empty(&self) -> bool {
         self.out_of_wallet_identities.is_empty() && self.wallet_identities.is_empty()

packages/rs-platform-wallet/src/wallet/platform_addresses/provider.rs

@@ -421,6 +421,18 @@ impl PlatformPaymentAddressProvider {
         self.last_known_recent_block = result.last_known_recent_block;
     }
 
+    /// Current `last_known_recent_block` watermark.
+    ///
+    /// Read-only mirror of the field used by the trait
+    /// implementation; exposed `pub` so wallet-level helpers
+    /// (notably [`super::wallet::PlatformAddressWallet::sync_watermark`])
+    /// can return the value to callers without going through the
+    /// `AddressProvider` trait. Monotonic non-decreasing across
+    /// `sync_finished` calls.
+    pub fn last_known_recent_block(&self) -> u64 {
+        self.last_known_recent_block
+    }
+
     /// Restore incremental-sync watermark from persisted state.
     pub(crate) fn set_stored_sync_state(
         &mut self,