feat: log proof log errors to db

Cargo.toml

@@ -18,7 +18,7 @@ strum = { version = "0.26.1", features = ["derive"] }
 bs58 = "0.5.0"
 base64 = "0.22.1"
 copypasta = "0.10.1"
-dash-sdk = { git = "https://github.com/dashpay/platform", rev = "994f7627080e4ab490f1dbf0f09c0fb37d0fbbb0" }
+dash-sdk = { git = "https://github.com/dashpay/platform", branch = "test/testWithoutSpan2" }
 thiserror = "1"
 serde = "1.0.197"
 serde_json = "1.0.120"

src/backend_task/contested_names/query_dpns_contested_resources.rs

@@ -1,5 +1,6 @@
 use crate::app::TaskResult;
 use crate::context::AppContext;
+use crate::model::proof_log_item::{ProofLogItem, RequestType};
 use dash_sdk::dpp::data_contract::accessors::v0::DataContractV0Getters;
 use dash_sdk::dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
 use dash_sdk::drive::query::vote_polls_by_document_type_query::VotePollsByDocumentTypeQuery;
@@ -33,11 +34,44 @@ impl AppContext {
             order_ascending: true,
         };
 
-        let contested_resources =
-            ContestedResource::fetch_many(&sdk, query)
+        let (contested_resources, metadata, proof) =
+            ContestedResource::fetch_many_with_metadata_and_proof(&sdk, query.clone(), None)
                 .await
                 .map_err(|e| {
                     tracing::error!("error fetching contested resources: {}", e);
+                    if let dash_sdk::Error::Proof(dash_sdk::ProofVerifierError::GroveDBError {
+                        proof_bytes,
+                        height,
+                        time_ms,
+                        error,
+                    }) = &e
+                    {
+                        // Encode the query using bincode
+                        let encoded_query =
+                            match bincode::encode_to_vec(&query, bincode::config::standard())
+                                .map_err(|encode_err| {
+                                    tracing::error!("error encoding query: {}", encode_err);
+                                    format!("error encoding query: {}", encode_err)
+                                }) {
+                                Ok(encoded_query) => encoded_query,
+                                Err(e) => return e,
+                            };
+
+                        if let Err(e) = self
+                            .db
+                            .insert_proof_log_item(ProofLogItem {
+                                request_type: RequestType::GetContestedResources,
+                                request_bytes: encoded_query,
+                                height: *height,
+                                time_ms: *time_ms,
+                                proof_bytes: proof_bytes.clone(),
+                                error: Some(error.clone()),
+                            })
+                            .map_err(|e| e.to_string())
+                        {
+                            return e;
+                        }
+                    }
                     format!("error fetching contested resources: {}", e)
                 })?;
 

src/database/initialization.rs

@@ -5,7 +5,7 @@ use std::fs;
 use std::path::Path;
 
 pub const DEFAULT_DB_VERSION: u16 = 1;
-pub const MIN_SUPPORTED_DB_VERSION: u16 = 1;
+pub const CURRENT_DB_VERSION: u16 = 2;
 pub const DEFAULT_NETWORK: &str = "dash";
 
 impl Database {
@@ -16,17 +16,44 @@ impl Database {
             self.set_default_version()?;
         } else {
             // Perform version check and back up and recreate the database if outdated.
-            if self.is_outdated()? {
-                self.backup_and_recreate_db(db_file_path)?;
-                self.create_tables()?;
-                self.set_default_version()?;
-                println!("Database reinitialized with default settings.");
+            if let Some(current_version) = self.is_outdated()? {
+                self.backup_db(db_file_path)?;
+                if let Err(e) = self.try_perform_migration(current_version, CURRENT_DB_VERSION) {
+                    // The migration failed
+                    println!("Migration failed: {:?}", e);
+                    self.recreate_db(db_file_path)?;
+                    self.create_tables()?;
+                    self.set_default_version()?;
+                    println!("Database reinitialized with default settings.");
+                }
             }
         }
 
         Ok(())
     }
 
+    fn apply_version_changes(&self, version: u16) -> rusqlite::Result<()> {
+        match version {
+            2 => {
+                self.initialize_proof_log_table()?;
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+    fn try_perform_migration(
+        &self,
+        original_version: u16,
+        to_version: u16,
+    ) -> rusqlite::Result<()> {
+        for version in (original_version + 1)..=to_version {
+            self.apply_version_changes(version)?;
+            self.update_database_version(version)?;
+        }
+        Ok(())
+    }
+
     /// Checks if the `settings` table is empty or missing, indicating a first-time setup.
     fn is_first_time_setup(&self) -> rusqlite::Result<bool> {
         let conn = self.conn.lock().unwrap();
@@ -50,7 +77,7 @@ impl Database {
     }
 
     /// Checks if the current database version is below the minimum supported version.
-    fn is_outdated(&self) -> rusqlite::Result<bool> {
+    fn is_outdated(&self) -> rusqlite::Result<Option<u16>> {
         let conn = self.conn.lock().unwrap();
         let version: u16 = conn
             .query_row(
@@ -59,11 +86,15 @@ impl Database {
                 |row| row.get(0),
             )
             .unwrap_or(0); // Default to version 0 if there's no version set
-        Ok(version < MIN_SUPPORTED_DB_VERSION)
+        if version < CURRENT_DB_VERSION {
+            Ok(Some(version))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Backs up the existing database with a unique timestamped filename, recreates `data.db`, and refreshes the connection.
-    fn backup_and_recreate_db(&self, db_file_path: &Path) -> rusqlite::Result<()> {
+    fn backup_db(&self, db_file_path: &Path) -> rusqlite::Result<()> {
         if db_file_path.exists() {
             // Create a "backups" folder in the same directory as `data.db` if not exists
             let backups_dir = db_file_path
@@ -82,11 +113,25 @@ impl Database {
             let backup_path = backups_dir.join(backup_filename);
 
             // Rename `data.db` to the unique backup file
-            fs::rename(db_file_path, &backup_path)
+            fs::copy(db_file_path, &backup_path)
                 .map_err(|e| rusqlite::Error::ToSqlConversionFailure(e.into()))?;
             println!("Old database backed up to {:?}", backup_path);
         }
+        Ok(())
+    }
 
+    /// Backs up the existing database with a unique timestamped filename, recreates `data.db`, and refreshes the connection.
+    fn recreate_db(&self, db_file_path: &Path) -> rusqlite::Result<()> {
+        // Remove the existing database file if it exists
+        if db_file_path.exists() {
+            fs::remove_file(db_file_path).map_err(|e| {
+                rusqlite::Error::FromSqlConversionFailure(
+                    0,
+                    rusqlite::types::Type::Text,
+                    Box::new(e),
+                )
+            })?;
+        }
         // Create a new empty `data.db` file and set up the initial schema
         let new_conn = Connection::open(db_file_path)?;
 
@@ -291,6 +336,8 @@ impl Database {
             [],
         )?;
 
+        self.initialize_proof_log_table()?;
+
         Ok(())
     }
 

src/database/mod.rs

@@ -3,6 +3,7 @@ mod contested_names;
 mod contracts;
 mod identities;
 mod initialization;
+mod proof_log;
 mod settings;
 mod utxo;
 mod wallet;

src/database/proof_log.rs

@@ -0,0 +1,125 @@
+use crate::database::Database;
+use crate::model::proof_log_item::{ProofLogItem, RequestType};
+use rusqlite::params;
+use std::ops::Range;
+
+impl Database {
+    pub fn initialize_proof_log_table(&self) -> rusqlite::Result<()> {
+        // Create the proof log tree
+        self.execute(
+            "CREATE TABLE IF NOT EXISTS proof_log (
+                        proof_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        request_type INTEGER NOT NULL,
+                        request_bytes BLOB NOT NULL,
+                        height INTEGER NOT NULL,
+                        time_ms INTEGER NOT NULL,
+                        proof_bytes BLOB NOT NULL,
+                        error TEXT
+                    )",
+            [],
+        )?;
+
+        // Create an index on request_type and time for combined queries
+        self.execute(
+    "CREATE INDEX IF NOT EXISTS idx_proof_log_request_type_time ON proof_log (request_type, time_ms)",
+    [],
+    )?;
+
+        // Create an index on time for queries ordered by time
+        self.execute(
+            "CREATE INDEX IF NOT EXISTS idx_proof_log_time ON proof_log (time_ms)",
+            [],
+        )?;
+
+        // Index for error, request_type, and time
+        self.execute(
+    "CREATE INDEX IF NOT EXISTS idx_proof_log_error_request_type_time ON proof_log (error, request_type, time_ms)",
+    [],
+    )?;
+
+        // Index for error and time
+        self.execute(
+            "CREATE INDEX IF NOT EXISTS idx_proof_log_error_time ON proof_log (error, time_ms)",
+            [],
+        )?;
+        Ok(())
+    }
+
+    /// Inserts a new ProofLogItem into the proof_log table
+    pub fn insert_proof_log_item(&self, item: ProofLogItem) -> rusqlite::Result<()> {
+        let conn = self.conn.lock().unwrap();
+
+        // Convert RequestType to u8
+        let request_type_int: u8 = item.request_type.into();
+
+        conn.execute(
+            "INSERT INTO proof_log (request_type, request_bytes, height, time_ms, proof_bytes, error)
+             VALUES (?, ?, ?, ?, ?, ?)",
+            params![
+                request_type_int,
+                item.request_bytes,
+                item.height,
+                item.time_ms,
+                item.proof_bytes,
+                item.error,
+            ],
+        )?;
+
+        Ok(())
+    }
+
+    /// Retrieves ProofLogItems with options for filtering and pagination
+    pub fn get_proof_log_items(
+        &self,
+        only_get_errored: bool,
+        range: Range<u64>,
+    ) -> rusqlite::Result<Vec<ProofLogItem>> {
+        let conn = self.conn.lock().unwrap();
+
+        // Build the query based on the only_get_errored flag
+        let mut query = String::from(
+            "SELECT request_type, request_bytes, height, time_ms, proof_bytes, error FROM proof_log",
+        );
+
+        if only_get_errored {
+            query.push_str(" WHERE error IS NOT NULL");
+        }
+
+        query.push_str(" ORDER BY time_ms DESC LIMIT ? OFFSET ?");
+
+        let mut stmt = conn.prepare(&query)?;
+
+        let proof_log_iter =
+            stmt.query_map(params![range.end - range.start, range.start], |row| {
+                let request_type_int: u8 = row.get(0)?;
+                let request_bytes: Vec<u8> = row.get(1)?;
+                let height: u64 = row.get(2)?;
+                let time_ms: u64 = row.get(3)?;
+                let proof_bytes: Vec<u8> = row.get(4)?;
+                let error: Option<String> = row.get(5)?;
+
+                // Convert u8 to RequestType
+                let request_type = RequestType::try_from(request_type_int).map_err(|_| {
+                    rusqlite::Error::FromSqlConversionFailure(
+                        request_type_int as usize,
+                        rusqlite::types::Type::Integer,
+                        Box::new(std::fmt::Error),
+                    )
+                })?;
+
+                Ok(ProofLogItem {
+                    request_type,
+                    request_bytes,
+                    height,
+                    time_ms,
+                    proof_bytes,
+                    error,
+                })
+            })?;
+
+        // Collect the results into a vector
+        let items: rusqlite::Result<Vec<ProofLogItem>> = proof_log_iter.collect();
+
+        items
+    }
+}

src/database/settings.rs

@@ -43,6 +43,20 @@ impl Database {
 
         Ok(())
     }
+
+    /// Updates the database version in the settings table.
+    pub fn update_database_version(&self, new_version: u16) -> Result<()> {
+        // Ensure the database version is updated
+        self.execute(
+            "UPDATE settings
+             SET database_version = ?
+             WHERE id = 1",
+            params![new_version],
+        )?;
+
+        Ok(())
+    }
+
     /// Retrieves the settings from the database.
     pub fn get_settings(&self) -> Result<Option<(Network, RootScreenType, Option<PasswordInfo>)>> {
         // Query the settings row

src/model/mod.rs

@@ -1,5 +1,6 @@
 pub mod contested_name;
 pub mod password_info;
+pub mod proof_log_item;
 pub mod qualified_contract;
 pub mod qualified_identity;
 pub mod wallet;