feat: get all owned dpns names

src/context.rs

@@ -3,7 +3,7 @@ use crate::context_provider::Provider;
 use crate::database::Database;
 use crate::model::contested_name::ContestedName;
 use crate::model::qualified_contract::QualifiedContract;
-use crate::model::qualified_identity::QualifiedIdentity;
+use crate::model::qualified_identity::{DPNSNameInfo, QualifiedIdentity};
 use crate::model::wallet::Wallet;
 use crate::sdk_wrapper::initialize_sdk;
 use crate::ui::RootScreenType;
@@ -13,7 +13,7 @@ use dash_sdk::dpp::identity::accessors::IdentityGettersV0;
 use dash_sdk::dpp::identity::Identity;
 use dash_sdk::dpp::system_data_contracts::{load_system_data_contract, SystemDataContract};
 use dash_sdk::dpp::version::PlatformVersion;
-use dash_sdk::platform::DataContract;
+use dash_sdk::platform::{DataContract, Identifier};
 use dash_sdk::Sdk;
 use rusqlite::Result;
 use std::sync::atomic::AtomicBool;
@@ -137,32 +137,27 @@ impl AppContext {
         self.db.get_ongoing_contested_names(self)
     }
 
-    pub fn owned_contested_names(&self) -> Result<Vec<ContestedName>> {
-        let all_contested_names = self.all_contested_names().unwrap_or_else(|e| {
-            tracing::error!("Failed to load contested names: {:?}", e);
-            Vec::new() // Use default value if loading fails
-        });
-        let local_qualified_identities =
-            self.load_local_qualified_identities().unwrap_or_else(|e| {
-                tracing::error!("Failed to load local qualified identities: {:?}", e);
-                Vec::new() // Use default value if loading fails
-            });
-
-        let owned_contested_names = all_contested_names
-            .into_iter()
-            .filter(|contested_name| {
-                contested_name
-                    .awarded_to
-                    .as_ref()
-                    .map_or(false, |awarded_to| {
-                        local_qualified_identities
-                            .iter()
-                            .any(|identity| identity.identity.id() == awarded_to)
-                    })
+    /// Fetches the local identities from the database and then maps them to their DPNS names.
+    pub fn local_dpns_names(&self) -> Result<Vec<(Identifier, DPNSNameInfo)>> {
+        let qualified_identities = self.db.get_local_qualified_identities(self)?;
+
+        // Map each identity's DPNS names to (Identifier, DPNSNameInfo) tuples
+        let dpns_names = qualified_identities
+            .iter()
+            .flat_map(|qualified_identity| {
+                qualified_identity.dpns_names.iter().map(|dpns_name_info| {
+                    (
+                        qualified_identity.identity.id(),
+                        DPNSNameInfo {
+                            name: dpns_name_info.name.clone(),
+                            acquired_at: dpns_name_info.acquired_at,
+                        },
+                    )
+                })
             })
-            .collect();
+            .collect::<Vec<(Identifier, DPNSNameInfo)>>();
 
-        Ok(owned_contested_names)
+        Ok(dpns_names)
     }
 
     /// Updates the `start_root_screen` in the settings table

src/model/qualified_identity.rs

@@ -64,6 +64,12 @@ impl From<Purpose> for EncryptedPrivateKeyTarget {
     }
 }
 
+#[derive(Debug, Encode, Decode, Clone, PartialEq)]
+pub struct DPNSNameInfo {
+    pub name: String,
+    pub acquired_at: u64,
+}
+
 #[derive(Debug, Encode, Decode, Clone, PartialEq)]
 pub struct QualifiedIdentity {
     pub identity: Identity,
@@ -74,6 +80,7 @@ pub struct QualifiedIdentity {
     pub alias: Option<String>,
     pub encrypted_private_keys:
         BTreeMap<(EncryptedPrivateKeyTarget, KeyID), (IdentityPublicKey, [u8; 32])>,
+    pub dpns_names: Vec<DPNSNameInfo>,
 }
 
 impl Signer for QualifiedIdentity {
@@ -271,6 +278,7 @@ impl From<Identity> for QualifiedIdentity {
             identity_type: IdentityType::User,
             alias: None,
             encrypted_private_keys: Default::default(),
+            dpns_names: vec![],
         }
     }
 }

src/platform/identity/load_identity.rs

@@ -2,15 +2,18 @@ use crate::context::AppContext;
 use crate::model::qualified_identity::EncryptedPrivateKeyTarget::{
     self, PrivateKeyOnMainIdentity, PrivateKeyOnVoterIdentity,
 };
-use crate::model::qualified_identity::{IdentityType, QualifiedIdentity};
+use crate::model::qualified_identity::{DPNSNameInfo, IdentityType, QualifiedIdentity};
 use crate::platform::identity::{verify_key_input, IdentityInputToLoad};
 use dash_sdk::dashcore_rpc::dashcore::key::Secp256k1;
 use dash_sdk::dashcore_rpc::dashcore::PrivateKey;
+use dash_sdk::dpp::document::DocumentV0Getters;
 use dash_sdk::dpp::identifier::MasternodeIdentifiers;
 use dash_sdk::dpp::identity::accessors::IdentityGettersV0;
 use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
 use dash_sdk::dpp::platform_value::string_encoding::Encoding;
-use dash_sdk::platform::{Fetch, Identifier, Identity};
+use dash_sdk::dpp::platform_value::Value;
+use dash_sdk::drive::query::{WhereClause, WhereOperator};
+use dash_sdk::platform::{Document, DocumentQuery, Fetch, FetchMany, Identifier, Identity};
 use dash_sdk::Sdk;
 use std::collections::BTreeMap;
 
@@ -138,6 +141,50 @@ impl AppContext {
             }
         }
 
+        // Fetch DPNS names using SDK
+        let dpns_names_document_query = DocumentQuery {
+            data_contract: self.dpns_contract.clone(),
+            document_type_name: "domain".to_string(),
+            where_clauses: vec![WhereClause {
+                field: "records.identity".to_string(),
+                operator: WhereOperator::Equal,
+                value: Value::Identifier(identity_id.into()),
+            }],
+            order_by_clauses: vec![],
+            limit: 100,
+            start: None,
+        };
+
+        let maybe_owned_dpns_names = Document::fetch_many(&self.sdk, dpns_names_document_query)
+            .await
+            .map(|document_map| {
+                document_map
+                    .values()
+                    .filter_map(|maybe_doc| {
+                        maybe_doc.as_ref().and_then(|doc| {
+                            let name = doc
+                                .get("normalizedLabel")
+                                .map(|label| label.to_str().unwrap_or_default());
+                            let acquired_at = doc
+                                .created_at()
+                                .into_iter()
+                                .chain(doc.transferred_at())
+                                .max();
+
+                            match (name, acquired_at) {
+                                (Some(name), Some(acquired_at)) => Some(DPNSNameInfo {
+                                    name: name.to_string(),
+                                    acquired_at,
+                                }),
+                                _ => None,
+                            }
+                        })
+                    })
+                    .collect::<Vec<DPNSNameInfo>>()
+                    .into()
+            })
+            .map_err(|e| format!("Error fetching DPNS names: {}", e))?;
+
         let qualified_identity = QualifiedIdentity {
             identity,
             associated_voter_identity,
@@ -150,6 +197,7 @@ impl AppContext {
                 Some(alias_input)
             },
             encrypted_private_keys,
+            dpns_names: maybe_owned_dpns_names,
         };
 
         // Insert qualified identity into the database

src/platform/identity/register_identity.rs

@@ -157,6 +157,7 @@ impl AppContext {
             identity_type: IdentityType::User,
             alias: None,
             encrypted_private_keys: keys.to_encrypted_private_keys(),
+            dpns_names: vec![],
         };
 
         let updated_identity = identity