Merge branch 'v1.0-dev' into ci/skip-claude-review-without-auth

Author: lklimek

src/app.rs

@@ -1356,6 +1356,11 @@ impl App for AppState {
     }
 
     fn on_exit(&mut self, _gl: Option<&eframe::glow::Context>) {
+        // On macOS, order windows out before winit tears down the event
+        // handler. This lets AppKit properly clean up display-related KVO
+        // observers (TouchBar, etc.) while views are still alive.
+        crate::platform::order_out_all_windows();
+
         // If shutdown_receiver is Some, the async shutdown was already initiated
         // in update(). Skip the blocking fallback to avoid double-shutdown.
         // The blocking path only runs when the window was force-closed without

src/backend_task/contested_names/vote_on_dpns_name.rs

@@ -9,14 +9,29 @@ use dash_sdk::dpp::data_contract::document_type::accessors::DocumentTypeV0Getter
 use dash_sdk::dpp::identity::accessors::IdentityGettersV0;
 use dash_sdk::dpp::platform_value::Value;
 use dash_sdk::dpp::platform_value::string_encoding::Encoding;
+use dash_sdk::dpp::util::strings::convert_to_homograph_safe_chars;
 use dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice;
 use dash_sdk::dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll;
 use dash_sdk::dpp::voting::votes::Vote;
 use dash_sdk::dpp::voting::votes::resource_vote::ResourceVote;
 use dash_sdk::dpp::voting::votes::resource_vote::v0::ResourceVoteV0;
+use dash_sdk::drive::query::vote_polls_by_document_type_query::VotePollsByDocumentTypeQuery;
+use dash_sdk::platform::FetchMany;
 use dash_sdk::platform::transition::vote::PutVote;
+use dash_sdk::query_types::ContestedResource;
 use std::sync::Arc;
 
+/// Build `[Value::from("dash"), Value::Text(normalized_label.to_owned())]` for a DPNS vote poll.
+///
+/// Caller must pre-normalize the label via `convert_to_homograph_safe_chars`
+/// (`alice` → `a11ce`); Platform indexes polls under the normalized form.
+fn dpns_vote_poll_index_values(normalized_label: &str) -> Vec<Value> {
+    vec![
+        Value::from("dash"),
+        Value::Text(normalized_label.to_owned()),
+    ]
+}
+
 impl AppContext {
     pub(super) async fn vote_on_dpns_name(
         self: &Arc<Self>,
@@ -42,15 +57,44 @@ impl AppContext {
             });
         };
 
-        let index_values = [Value::from("dash"), Value::Text(name.to_owned())];
+        let normalized_label = convert_to_homograph_safe_chars(name);
+        let index_values = dpns_vote_poll_index_values(&normalized_label);
 
         let vote_poll = ContestedDocumentResourceVotePoll {
             index_name: contested_index.name.clone(),
-            index_values: index_values.to_vec(),
+            index_values,
             document_type_name: document_type.name().to_string(),
             contract_id: data_contract.id(),
         };
 
+        // Pre-flight: confirm Platform has an open poll for this label before
+        // broadcasting — fails fast with VotePollNotFound if it doesn't.
+        let existence_query = VotePollsByDocumentTypeQuery {
+            contract_id: data_contract.id(),
+            document_type_name: document_type.name().to_string(),
+            index_name: contested_index.name.clone(),
+            start_index_values: vec![Value::from("dash")],
+            end_index_values: vec![],
+            // Start exactly at our normalized label (inclusive) — a single
+            // row is enough to confirm the poll exists.
+            start_at_value: Some((Value::Text(normalized_label.clone()), true)),
+            limit: Some(1),
+            order_ascending: true,
+        };
+
+        let resources = ContestedResource::fetch_many(sdk, existence_query)
+            .await
+            .map_err(TaskError::from)?;
+        let poll_exists = resources
+            .0
+            .iter()
+            .any(|r| r.0.as_str() == Some(normalized_label.as_str()));
+        if !poll_exists {
+            return Err(TaskError::VotePollNotFound {
+                name: name.to_owned(),
+            });
+        }
+
         let mut vote_results = vec![];
 
         for qualified_identity in voters.iter() {
@@ -84,3 +128,45 @@ impl AppContext {
         Ok(BackendTaskSuccessResult::DPNSVoteResults(vote_results))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn index_values_uses_the_given_normalized_label() {
+        // Given: a pre-normalized DPNS label (homographs already substituted).
+        let normalized = "a11ce";
+
+        // When: constructing the vote poll index values.
+        let values = dpns_vote_poll_index_values(normalized);
+
+        // Then: first element is the `"dash"` parent, second is the label as-given.
+        assert_eq!(values.len(), 2);
+        assert_eq!(values[0], Value::from("dash"));
+        assert_eq!(values[1], Value::Text("a11ce".to_owned()));
+    }
+
+    #[test]
+    fn index_values_do_not_renormalize_the_label() {
+        // Given: a label that still contains homograph characters.
+        let not_yet_normalized = "alice";
+
+        // When: passing it directly to the helper (violating the contract).
+        let values = dpns_vote_poll_index_values(not_yet_normalized);
+
+        // Then: the helper does NOT renormalize — the raw label is returned as-is.
+        // (Caller is responsible for normalizing before calling.)
+        assert_eq!(values[1], Value::Text("alice".to_owned()));
+    }
+
+    #[test]
+    fn convert_to_homograph_safe_chars_maps_alice_to_a11ce() {
+        // Given: the canonical DPNS homograph substitutions (i/l → 1, o → 0).
+        // When: normalizing a label with i/l/o.
+        let normalized = convert_to_homograph_safe_chars("alice");
+
+        // Then: the result matches the constant used by the vote poll tests.
+        assert_eq!(normalized, "a11ce");
+    }
+}

src/backend_task/error.rs

@@ -842,6 +842,16 @@ pub enum TaskError {
     )]
     NoVotingIdentity { identity_id: String },
 
+    /// No open vote poll was found on Platform for the given DPNS name.
+    ///
+    /// Surfaced by the pre-flight existence check in `vote_on_dpns_name`,
+    /// before any state transition is broadcast. Short-circuits a ~70 s
+    /// retry chain that would otherwise expire with an opaque timeout.
+    #[error(
+        "The contested name \"{name}\" is not currently open for voting. It may have been resolved or may not exist. Refresh the contested names list and try again."
+    )]
+    VotePollNotFound { name: String },
+
     /// The identity does not have an authentication key required to sign documents.
     #[error(
         "This identity does not have a key for signing documents. Please add an authentication key."

src/platform/macos.rs

@@ -2,6 +2,43 @@ use objc2::MainThreadMarker;
 use objc2::msg_send;
 use objc2::runtime::{AnyClass, AnyObject};
 
+/// Orders all application windows out (hides them) so that AppKit can
+/// properly tear down display-related observations — in particular
+/// `_NSTouchBarFinderObservation` KVO observers — while the windows and
+/// their views are still alive.
+///
+/// Without this, winit's event handler teardown triggers a display cycle
+/// flush that finds KVO observers on inconsistent objects, causing a
+/// SIGILL crash via `_crashOnException:`.
+///
+/// Must be called from `on_exit()` before returning control to the
+/// eframe/winit shutdown path.
+pub fn order_out_all_windows(_mtm: MainThreadMarker) {
+    unsafe {
+        let Some(cls) = AnyClass::get(c"NSApplication") else {
+            return;
+        };
+        let app: *mut AnyObject = msg_send![cls, sharedApplication];
+        if app.is_null() {
+            return;
+        }
+
+        let windows: *mut AnyObject = msg_send![app, windows];
+        if windows.is_null() {
+            return;
+        }
+
+        let count: usize = msg_send![windows, count];
+        for i in 0..count {
+            let window: *mut AnyObject = msg_send![windows, objectAtIndex: i];
+            if !window.is_null() {
+                let _: () = msg_send![window, orderOut: std::ptr::null::<AnyObject>()];
+            }
+        }
+        tracing::debug!("Ordered out {count} windows for clean shutdown");
+    }
+}
+
 /// Queries `accessibilityChildren` on the key window's content view to force
 /// macOS to call the AccessKit adapter's subclassed method, which transitions
 /// the adapter from `Inactive` to `Active`. Without this, tools like Peekaboo

src/platform/mod.rs

@@ -29,3 +29,16 @@ pub fn force_accessibility_activation() -> bool {
         true
     }
 }
+
+/// Orders all windows out before shutdown so macOS can clean up
+/// display-related observations. No-op on non-macOS platforms.
+pub fn order_out_all_windows() {
+    #[cfg(target_os = "macos")]
+    {
+        let Some(mtm) = objc2::MainThreadMarker::new() else {
+            tracing::error!("order_out_all_windows called from non-main thread");
+            return;
+        };
+        macos::order_out_all_windows(mtm);
+    }
+}