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

* 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>

* docs(contested-names): slim comments and restyle unit tests as given/when/then

Address review feedback on #835: the `dpns_vote_poll_index_values` doc
comment and the pre-flight check inline comment were over-explanatory;
trimmed each to 2-3 lines with concrete examples. The two unit tests
now use inline Given/When/Then comments instead of a free-form doc
comment — easier to scan and matches project test-style preference.

No logic changes; assertions unchanged.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(contested-names): remove time-bound retry-chain reference from pre-flight comment

The ~70 s retry chain text is platform-version-bound and will age badly
once Platform's MasternodeVote picks up `validates_full_state_on_check_tx()`
(b44ccff5, v3.1.0-dev.1+) — CheckTx will start rejecting missing polls
and the client-visible cost drops. The pre-flight's durable value is
fail-fast with an actionable error regardless of server-side timing.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor(contested-names): pass pre-normalized label to dpns_vote_poll_index_values

Bot reviewers on #835 (copilot-pull-request-reviewer, coderabbitai)
flagged that convert_to_homograph_safe_chars ran twice per vote:
once by the caller to build normalized_label for the pre-flight query,
and once inside the helper. Harmless today, but if either call site
ever picks up a different normalization the pre-flight and the vote
poll would key off different strings — silently reproducing the very
bug this PR fixes.

Helper now takes a pre-normalized &str and returns it verbatim. The
caller's normalized_label is passed through once, used for both the
pre-flight query and the vote poll's index_values. A dedicated test
pins convert_to_homograph_safe_chars("alice") == "a11ce" so the
normalization contract itself stays covered after the move.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

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