fix(contested-names): normalize DPNS label in vote poll construction + pre-flight existence check

`vote_on_dpns_name` was constructing `ContestedDocumentResourceVotePoll`
with the raw DPNS label passed in by the caller. Platform indexes the
poll under the **normalized** label produced by
`convert_to_homograph_safe_chars` (`i`→`1`, `l`→`1`, `o`→`0`,
`to_lowercase`). Any label containing those characters — i.e. the common
case — produced a `(dash, <raw>)` lookup against an index keyed on
`(dash, <normalized>)`, triggering `VotePollNotFoundError` at
`PrepareProposal`. Client-side this surfaced as a ~70 s opaque
"An unexpected error occurred" timeout from the vote retry chain.

Confirmed against drive-abci logs at heights 319048, 319073, and 318950.

Changes:
* Normalize the label via `convert_to_homograph_safe_chars` before
  building `index_values`. Extracted as `dpns_vote_poll_index_values`,
  a pure helper with unit coverage.
* Add a pre-flight existence check that queries Platform for the vote
  poll before broadcasting any state transitions. Missing polls now
  return immediately instead of burning ~70 s on retries.
* New `TaskError::VotePollNotFound { name }` variant with a
  user-facing message (Everyday User persona, "what happened + what
  to do"): "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."
* Unit tests pin the normalization contract (`alice` → `a11ce`,
  `bar22` → `bar22`) so regressions in the helper fail in CI.

Other call-sites surveyed:
* `query_dpns_vote_contenders.rs` builds the same poll but is only
  called with labels already fetched from Platform (normalized), so
  is left unchanged per scope.
* `query_ending_times.rs` only **reads** `index_values` from polls
  returned by Platform — no construction, no normalization needed.

In the DET UI, `VoteOnDPNSNames` is dispatched with
`contested_name.normalized_contested_name`, so the user-facing path
happens to already supply a normalized string — but the backend must
be defensive regardless of caller (CLI, scheduled vote replay,
tests), hence the fix at the boundary.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lklimek

src/backend_task/contested_names/vote_on_dpns_name.rs

@@ -9,14 +9,35 @@ 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 the DPNS contested-index values for a vote poll.
+///
+/// Platform stores the vote poll under the homograph-safe **normalized** label,
+/// not the raw user input (e.g. `"alice"` → `"a11ce"`, with `i`→`1`, `l`→`1`,
+/// `o`→`0`, and `to_lowercase`). Any caller that constructs a vote poll with
+/// the raw label hits `VotePollNotFoundError` at `PrepareProposal`, which
+/// surfaces as an opaque ~70 s timeout.
+///
+/// Pure helper — no `AppContext`/`Sdk` dependency, trivially unit-testable.
+/// Returns `[Value::from("dash"), Value::Text(normalized_label)]`.
+fn dpns_vote_poll_index_values(name: &str) -> Vec<Value> {
+    vec![
+        Value::from("dash"),
+        Value::Text(convert_to_homograph_safe_chars(name)),
+    ]
+}
+
 impl AppContext {
     pub(super) async fn vote_on_dpns_name(
         self: &Arc<Self>,
@@ -42,15 +63,47 @@ 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(name);
 
         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 existence check. Confirm Platform actually has an open
+        // vote poll for `(dash, normalized_label)` before broadcasting any
+        // signed vote state transitions. This short-circuits the ~70 s
+        // retry chain triggered by `VotePollNotFoundError` at
+        // `PrepareProposal` when the poll is missing or already resolved.
+        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 +137,27 @@ impl AppContext {
         Ok(BackendTaskSuccessResult::DPNSVoteResults(vote_results))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Homograph substitutions must apply — Platform indexes the poll under
+    /// the normalized label, so a raw label produces a `VotePollNotFound`
+    /// mismatch at `PrepareProposal` time.
+    #[test]
+    fn index_values_normalizes_homograph_chars() {
+        let values = dpns_vote_poll_index_values("alice");
+        assert_eq!(values.len(), 2);
+        assert_eq!(values[0], Value::from("dash"));
+        assert_eq!(values[1], Value::Text("a11ce".to_owned()));
+    }
+
+    /// Labels that contain no homograph characters must round-trip unchanged —
+    /// except for `to_lowercase`, which is part of the normalization pipeline.
+    #[test]
+    fn index_values_preserve_non_homograph_label() {
+        let values = dpns_vote_poll_index_values("bar22");
+        assert_eq!(values[1], Value::Text("bar22".to_owned()));
+    }
+}

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."