feat(trading-proto-upgrade): wasm DB, kickstart, refund states, v2 RPCs

.gitignore

@@ -39,6 +39,8 @@ scripts/mm2/seed/unparsed.txt
 /MM_VERSION
 /MM_VERSION.tmp
 /target
+/targettest
+/clippytarget
 
 # Subcrate artefacts
 /mm2src/*/target

mm2src/coins/lp_coins.rs

@@ -1310,13 +1310,13 @@ pub trait ToBytes {
 /// Defines associated types specific to each coin (Pubkey, Address, etc.)
 pub trait CoinAssocTypes {
     type Pubkey: ToBytes + Send + Sync;
-    type PubkeyParseError: Send + std::fmt::Display;
+    type PubkeyParseError: fmt::Debug + Send + fmt::Display;
     type Tx: Transaction + Send + Sync;
-    type TxParseError: Send + std::fmt::Display;
+    type TxParseError: fmt::Debug + Send + fmt::Display;
     type Preimage: ToBytes + Send + Sync;
-    type PreimageParseError: Send + std::fmt::Display;
+    type PreimageParseError: fmt::Debug + Send + fmt::Display;
     type Sig: ToBytes + Send + Sync;
-    type SigParseError: Send + std::fmt::Display;
+    type SigParseError: fmt::Debug + Send + fmt::Display;
 
     fn parse_pubkey(&self, pubkey: &[u8]) -> Result<Self::Pubkey, Self::PubkeyParseError>;
 

mm2src/common/bool_as_int.rs

@@ -0,0 +1,90 @@
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+/// A wrapper struct representing a boolean value as an integer (0 or 1).
+#[derive(Debug, Default, Eq, Ord, PartialEq, PartialOrd)]
+pub struct BoolAsInt(bool);
+
+impl BoolAsInt {
+    /// Creates a new `BoolAsInt` instance from a boolean value.
+    pub fn new(value: bool) -> Self { BoolAsInt(value) }
+
+    /// Retrieves the inner boolean value.
+    pub fn as_bool(&self) -> bool { self.0 }
+}
+
+impl From<bool> for BoolAsInt {
+    fn from(value: bool) -> Self { BoolAsInt(value) }
+}
+
+impl Serialize for BoolAsInt {
+    /// Serializes the `BoolAsInt` into a single-byte integer (0 or 1).
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u8(self.0 as u8)
+    }
+}
+
+impl<'de> Deserialize<'de> for BoolAsInt {
+    /// Deserializes a single-byte integer (0 or 1) into a `BoolAsInt`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the value is not 0 or 1.
+    fn deserialize<D>(deserializer: D) -> Result<BoolAsInt, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = u8::deserialize(deserializer)?;
+
+        match value {
+            0 => Ok(BoolAsInt(false)),
+            1 => Ok(BoolAsInt(true)),
+            _ => Err(de::Error::custom("Value must be 0 or 1")),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Tests the serialization of `BoolAsInt`.
+    #[test]
+    fn test_serialization() {
+        let bool_value = BoolAsInt::new(true);
+        let serialized = serde_json::to_string(&bool_value).unwrap();
+        assert_eq!(serialized, "1");
+    }
+
+    /// Tests the deserialization of `BoolAsInt` for a value of 0.
+    #[test]
+    fn test_deserialization() {
+        let deserialized: BoolAsInt = serde_json::from_str("0").unwrap();
+        assert_eq!(deserialized, BoolAsInt::new(false));
+    }
+
+    /// Tests the round trip of serialization and deserialization for `BoolAsInt`.
+    #[test]
+    fn test_round_trip() {
+        let bool_value = BoolAsInt::new(true);
+        let serialized = serde_json::to_string(&bool_value).unwrap();
+        let deserialized: BoolAsInt = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, bool_value);
+    }
+
+    /// Tests the deserialization error case when the value is not 0 or 1.
+    #[test]
+    fn test_deserialization_error() {
+        let result: Result<BoolAsInt, _> = serde_json::from_str("2");
+        assert!(result.is_err());
+    }
+
+    /// Tests the `as_bool` method to retrieve the inner boolean value.
+    #[test]
+    fn test_as_bool() {
+        let bool_value = BoolAsInt::new(true);
+        assert!(bool_value.as_bool());
+    }
+}

mm2src/common/common.rs

@@ -123,6 +123,7 @@ pub mod write_safe;
 #[macro_use]
 pub mod log;
 
+pub mod bool_as_int;
 pub mod crash_reports;
 pub mod custom_futures;
 pub mod custom_iter;

mm2src/crypto/src/privkey.rs

@@ -48,6 +48,8 @@ impl From<KeysError> for PrivKeyError {
     fn from(e: KeysError) -> Self { PrivKeyError::InvalidPrivKey(e.to_string()) }
 }
 
+impl std::error::Error for PrivKeyError {}
+
 fn private_from_seed(seed: &str) -> PrivKeyResult<Private> {
     match seed.parse() {
         Ok(private) => return Ok(private),
@@ -133,7 +135,7 @@ impl PartialEq for SerializableSecp256k1Keypair {
 impl Eq for SerializableSecp256k1Keypair {}
 
 impl SerializableSecp256k1Keypair {
-    fn new(key: [u8; 32]) -> PrivKeyResult<Self> {
+    pub fn new(key: [u8; 32]) -> PrivKeyResult<Self> {
         Ok(SerializableSecp256k1Keypair {
             inner: key_pair_from_secret(&key)?,
         })
@@ -143,7 +145,7 @@ impl SerializableSecp256k1Keypair {
 
     pub fn public_slice(&self) -> &[u8] { self.inner.public_slice() }
 
-    fn priv_key(&self) -> [u8; 32] { self.inner.private().secret.take() }
+    pub fn priv_key(&self) -> [u8; 32] { self.inner.private().secret.take() }
 
     pub fn random() -> Self {
         SerializableSecp256k1Keypair {

mm2src/mm2_db/src/indexed_db/drivers/upgrader.rs

@@ -18,6 +18,17 @@ pub enum OnUpgradeError {
     ErrorOpeningTable { table: String, description: String },
     #[display(fmt = "Error occurred due to creating the '{}' index: {}", index, description)]
     ErrorCreatingIndex { index: String, description: String },
+    #[display(
+        fmt = "Upgrade attempt to an unsupported version: {}, old: {}, new: {}",
+        unsupported_version,
+        old_version,
+        new_version
+    )]
+    UnsupportedVersion {
+        unsupported_version: u32,
+        old_version: u32,
+        new_version: u32,
+    },
 }
 
 pub struct DbUpgrader {

mm2src/mm2_main/src/database.rs

@@ -12,7 +12,7 @@ use db_common::sqlite::run_optimization_pragmas;
 use db_common::sqlite::rusqlite::{params_from_iter, Result as SqlResult};
 use mm2_core::mm_ctx::MmArc;
 
-use my_swaps::fill_my_swaps_from_json_statements;
+use my_swaps::{fill_my_swaps_from_json_statements, set_is_finished_for_legacy_swaps_statements};
 use stats_swaps::create_and_fill_stats_swaps_from_json_statements;
 
 const SELECT_MIGRATION: &str = "SELECT * FROM migration ORDER BY current_migration DESC LIMIT 1;";
@@ -22,7 +22,7 @@ fn get_current_migration(ctx: &MmArc) -> SqlResult<i64> {
     conn.query_row(SELECT_MIGRATION, [], |row| row.get(0))
 }
 
-pub async fn init_and_migrate_db(ctx: &MmArc) -> SqlResult<()> {
+pub async fn init_and_migrate_sql_db(ctx: &MmArc) -> SqlResult<()> {
     info!("Checking the current SQLite migration");
     match get_current_migration(ctx) {
         Ok(current_migration) => {
@@ -105,6 +105,10 @@ fn migration_9() -> Vec<(&'static str, Vec<String>)> {
     db_common::sqlite::execute_batch(my_swaps::TRADING_PROTO_UPGRADE_MIGRATION)
 }
 
+async fn migration_10(ctx: &MmArc) -> Vec<(&'static str, Vec<String>)> {
+    set_is_finished_for_legacy_swaps_statements(ctx).await
+}
+
 async fn statements_for_migration(ctx: &MmArc, current_migration: i64) -> Option<Vec<(&'static str, Vec<String>)>> {
     match current_migration {
         1 => Some(migration_1(ctx).await),
@@ -116,6 +120,7 @@ async fn statements_for_migration(ctx: &MmArc, current_migration: i64) -> Option
         7 => Some(migration_7()),
         8 => Some(migration_8()),
         9 => Some(migration_9()),
+        10 => Some(migration_10(ctx).await),
         _ => None,
     }
 }