Upgrade to v0.7

More goodies

Revert cargo.toml

Fix cargo toml

Cargo.toml

@@ -303,7 +303,7 @@ serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
 sphinx-packet = "0.1.1"
-sqlx = "0.6.3"
+sqlx = "0.7.4"
 strum = "0.26"
 subtle-encoding = "0.5"
 syn = "1"

common/client-core/gateways-storage/build.rs

@@ -8,6 +8,8 @@ async fn main() {
         use sqlx::{Connection, SqliteConnection};
         use std::env;
 
+        println!("cargo:rustc-env=SQLX_OFFLINE=false");
+
         let out_dir = env::var("OUT_DIR").unwrap();
         let database_path = format!("{out_dir}/gateways-storage-example.sqlite");
 

common/client-core/gateways-storage/src/backend/fs_backend/manager.rs

@@ -29,11 +29,10 @@ impl StorageManager {
             })?;
         }
 
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
-            .create_if_missing(true);
-
-        opts.disable_statement_logging();
+            .create_if_missing(true)
+            .disable_statement_logging();
 
         let connection_pool = sqlx::SqlitePool::connect_with(opts)
             .await
@@ -82,7 +81,7 @@ impl StorageManager {
         sqlx::query!("SELECT EXISTS (SELECT 1 FROM registered_gateway WHERE gateway_id_bs58 = ?) AS 'exists'", gateway_id)
             .fetch_one(&self.connection_pool)
             .await
-            .map(|result| result.exists == 1)
+            .map(|result| result.exists == Some(1))
     }
 
     pub(crate) async fn maybe_get_registered_gateway(

common/client-core/surb-storage/src/backend/fs_backend/manager.rs

@@ -1,9 +1,12 @@
 // Copyright 2022 - Nym Technologies SA <[email protected]>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::backend::fs_backend::error::StorageError;
-use crate::backend::fs_backend::models::{
-    ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag, StoredSurbSender,
+use crate::backend::fs_backend::{
+    error::StorageError,
+    models::{
+        ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag,
+        StoredSurbSender,
+    },
 };
 use log::{error, info};
 use sqlx::ConnectOptions;
@@ -27,11 +30,10 @@ impl StorageManager {
             })?;
         }
 
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
-            .create_if_missing(fresh);
-
-        opts.disable_statement_logging();
+            .create_if_missing(fresh)
+            .disable_statement_logging();
 
         let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
             Ok(pool) => pool,

common/credential-storage/build.rs

@@ -8,6 +8,8 @@ use std::env;
 
 #[tokio::main]
 async fn main() {
+    println!("cargo:rustc-env=SQLX_OFFLINE=false");
+
     let out_dir = env::var("OUT_DIR").unwrap();
     let database_path = format!("{out_dir}/coconut-credential-example.sqlite");
 

common/credential-storage/src/persistent_storage/mod.rs

@@ -3,27 +3,35 @@
 
 mod legacy_helpers;
 
-use crate::backends::sqlite::{
-    get_next_unspent_ticketbook, increase_used_ticketbook_tickets, SqliteEcashTicketbookManager,
+use crate::{
+    backends::sqlite::{
+        get_next_unspent_ticketbook, increase_used_ticketbook_tickets, SqliteEcashTicketbookManager,
+    },
+    error::StorageError,
+    models::{BasicTicketbookInformation, RetrievedPendingTicketbook, RetrievedTicketbook},
+    persistent_storage::legacy_helpers::{
+        deserialise_v1_coin_index_signatures, deserialise_v1_expiration_date_signatures,
+        deserialise_v1_master_verification_key,
+    },
+    storage::Storage,
 };
-use crate::error::StorageError;
-use crate::models::{BasicTicketbookInformation, RetrievedPendingTicketbook, RetrievedTicketbook};
-use crate::persistent_storage::legacy_helpers::{
-    deserialise_v1_coin_index_signatures, deserialise_v1_expiration_date_signatures,
-    deserialise_v1_master_verification_key,
-};
-use crate::storage::Storage;
 use async_trait::async_trait;
 use log::{debug, error};
-use nym_compact_ecash::scheme::coin_indices_signatures::AnnotatedCoinIndexSignature;
-use nym_compact_ecash::scheme::expiration_date_signatures::AnnotatedExpirationDateSignature;
-use nym_compact_ecash::VerificationKeyAuth;
-use nym_credentials::ecash::bandwidth::serialiser::keys::EpochVerificationKey;
-use nym_credentials::ecash::bandwidth::serialiser::signatures::{
-    AggregatedCoinIndicesSignatures, AggregatedExpirationDateSignatures,
+use nym_compact_ecash::{
+    scheme::{
+        coin_indices_signatures::AnnotatedCoinIndexSignature,
+        expiration_date_signatures::AnnotatedExpirationDateSignature,
+    },
+    VerificationKeyAuth,
+};
+use nym_credentials::{
+    ecash::bandwidth::serialiser::{
+        keys::EpochVerificationKey,
+        signatures::{AggregatedCoinIndicesSignatures, AggregatedExpirationDateSignatures},
+        VersionedSerialise,
+    },
+    IssuanceTicketBook, IssuedTicketBook,
 };
-use nym_credentials::ecash::bandwidth::serialiser::VersionedSerialise;
-use nym_credentials::{IssuanceTicketBook, IssuedTicketBook};
 use nym_ecash_time::{ecash_today, Date, EcashTime};
 use sqlx::ConnectOptions;
 use std::path::Path;
@@ -47,11 +55,10 @@ impl PersistentStorage {
             database_path.as_ref().as_os_str()
         );
 
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
-            .create_if_missing(true);
-
-        opts.disable_statement_logging();
+            .create_if_missing(true)
+            .disable_statement_logging();
 
         let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
             Ok(db) => db,
@@ -177,7 +184,7 @@ impl Storage for PersistentStorage {
         let mut tx = self.storage_manager.begin_storage_tx().await?;
 
         // we don't want ticketbooks with expiration in the past
-        let Some(raw) = get_next_unspent_ticketbook(&mut tx, deadline, tickets).await? else {
+        let Some(raw) = get_next_unspent_ticketbook(&mut *tx, deadline, tickets).await? else {
             // make sure to finish our tx
             tx.commit().await?;
             return Ok(None);
@@ -191,7 +198,7 @@ impl Storage for PersistentStorage {
                     ))
                 })?;
 
-        increase_used_ticketbook_tickets(&mut tx, raw.id, tickets).await?;
+        increase_used_ticketbook_tickets(&mut *tx, raw.id, tickets).await?;
         tx.commit().await?;
 
         // set the number of spent tickets on the crypto object

common/gateway-storage/build.rs

@@ -6,6 +6,8 @@ use std::env;
 
 #[tokio::main]
 async fn main() {
+    println!("cargo:rustc-env=SQLX_OFFLINE=false");
+
     let out_dir = env::var("OUT_DIR").unwrap();
     let database_path = format!("{}/gateway-example.sqlite", out_dir);
 

common/gateway-storage/src/bandwidth.rs

@@ -111,14 +111,14 @@ impl BandwidthManager {
             amount,
             client_id
         )
-        .execute(&mut tx)
+        .execute(&mut *tx)
         .await?;
 
         let remaining = sqlx::query!(
             "SELECT available FROM available_bandwidth WHERE client_id = ?",
             client_id
         )
-        .fetch_one(&mut tx)
+        .fetch_one(&mut *tx)
         .await?
         .available;
 
@@ -160,14 +160,14 @@ impl BandwidthManager {
             amount,
             client_id
         )
-        .execute(&mut tx)
+        .execute(&mut *tx)
         .await?;
 
         let remaining = sqlx::query!(
             "SELECT available FROM available_bandwidth WHERE client_id = ?",
             client_id
         )
-        .fetch_one(&mut tx)
+        .fetch_one(&mut *tx)
         .await?
         .available;
 

common/gateway-storage/src/lib.rs

@@ -286,14 +286,13 @@ impl PersistentStorage {
 
         // TODO: we can inject here more stuff based on our gateway global config
         // struct. Maybe different pool size or timeout intervals?
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
-            .create_if_missing(true);
+            .create_if_missing(true)
+            .disable_statement_logging();
 
         // TODO: do we want auto_vacuum ?
 
-        opts.disable_statement_logging();
-
         let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
             Ok(db) => db,
             Err(err) => {

common/gateway-storage/src/tickets.rs

@@ -92,7 +92,7 @@ impl TicketStorageManager {
         )
         .fetch_one(&self.connection_pool)
         .await
-        .map(|result| result.exists == 1)
+        .map(|result| result.exists == Some(1))
     }
 
     pub(crate) async fn remove_binary_ticket_data(

common/nyxd-scraper/src/storage/mod.rs

@@ -1,20 +1,24 @@
 // Copyright 2023 - Nym Technologies SA <[email protected]>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::block_processor::types::{FullBlockInformation, ParsedTransactionResponse};
-use crate::error::ScraperError;
-use crate::storage::manager::{
-    insert_block, insert_message, insert_precommit, insert_transaction, insert_validator,
-    prune_blocks, prune_messages, prune_pre_commits, prune_transactions, update_last_processed,
-    update_last_pruned, StorageManager,
+use crate::{
+    block_processor::types::{FullBlockInformation, ParsedTransactionResponse},
+    error::ScraperError,
+    storage::{
+        manager::{
+            insert_block, insert_message, insert_precommit, insert_transaction, insert_validator,
+            prune_blocks, prune_messages, prune_pre_commits, prune_transactions,
+            update_last_processed, update_last_pruned, StorageManager,
+        },
+        models::{CommitSignature, Validator},
+    },
+};
+use sqlx::{types::time::OffsetDateTime, ConnectOptions, Sqlite, Transaction};
+use std::{fmt::Debug, path::Path};
+use tendermint::{
+    block::{Commit, CommitSig},
+    Block,
 };
-use crate::storage::models::{CommitSignature, Validator};
-use sqlx::types::time::OffsetDateTime;
-use sqlx::{ConnectOptions, Sqlite, Transaction};
-use std::fmt::Debug;
-use std::path::Path;
-use tendermint::block::{Commit, CommitSig};
-use tendermint::Block;
 use tendermint_rpc::endpoint::validators;
 use tokio::time::Instant;
 use tracing::{debug, error, info, instrument, trace, warn};
@@ -46,14 +50,13 @@ pub(crate) fn log_db_operation_time(op_name: &str, start_time: Instant) {
 impl ScraperStorage {
     #[instrument]
     pub async fn init<P: AsRef<Path> + Debug>(database_path: P) -> Result<Self, ScraperError> {
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
-            .create_if_missing(true);
+            .create_if_missing(true)
+            .disable_statement_logging();
 
         // TODO: do we want auto_vacuum ?
 
-        opts.disable_statement_logging();
-
         let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
             Ok(db) => db,
             Err(err) => {
@@ -90,11 +93,11 @@ impl ScraperStorage {
 
         let mut tx = self.begin_processing_tx().await?;
 
-        prune_messages(oldest_to_keep.into(), &mut tx).await?;
-        prune_transactions(oldest_to_keep.into(), &mut tx).await?;
-        prune_pre_commits(oldest_to_keep.into(), &mut tx).await?;
-        prune_blocks(oldest_to_keep.into(), &mut tx).await?;
-        update_last_pruned(current_height.into(), &mut tx).await?;
+        prune_messages(oldest_to_keep.into(), &mut *tx).await?;
+        prune_transactions(oldest_to_keep.into(), &mut *tx).await?;
+        prune_pre_commits(oldest_to_keep.into(), &mut *tx).await?;
+        prune_blocks(oldest_to_keep.into(), &mut *tx).await?;
+        update_last_pruned(current_height.into(), &mut *tx).await?;
 
         let commit_start = Instant::now();
         tx.commit()
@@ -234,7 +237,7 @@ pub async fn persist_block(
     // persist messages (inside the transactions)
     persist_messages(&block.transactions, tx).await?;
 
-    update_last_processed(block.block.header.height.into(), tx).await?;
+    update_last_processed(block.block.header.height.into(), tx.as_mut()).await?;
 
     Ok(())
 }
@@ -251,7 +254,7 @@ async fn persist_validators(
         insert_validator(
             consensus_address.to_string(),
             consensus_pubkey.to_string(),
-            &mut *tx,
+            tx.as_mut(),
         )
         .await?;
     }
@@ -274,7 +277,7 @@ async fn persist_block_data(
         total_gas,
         proposer_address,
         block.header.time.into(),
-        tx,
+        tx.as_mut(),
     )
     .await?;
     Ok(())
@@ -320,7 +323,7 @@ async fn persist_commits(
             (*timestamp).into(),
             validator.power.into(),
             validator.proposer_priority.value(),
-            &mut *tx,
+            tx.as_mut(),
         )
         .await?;
     }
@@ -345,7 +348,7 @@ async fn persist_txs(
             chain_tx.tx_result.gas_wanted,
             chain_tx.tx_result.gas_used,
             chain_tx.tx_result.log.clone(),
-            &mut *tx,
+            tx.as_mut(),
         )
         .await?;
     }
@@ -366,7 +369,7 @@ async fn persist_messages(
                 index as i64,
                 msg.type_url.clone(),
                 chain_tx.height.into(),
-                &mut *tx,
+                tx.as_mut(),
             )
             .await?
         }