src/wallet: yeet

Cargo.toml

@@ -117,7 +117,7 @@ wasmer = {version = "4.2.5", optional = true}
 wasmer-compiler-singlepass = {version = "4.2.5", optional = true}
 wasmer-middlewares = {version = "4.2.5", optional = true}
 
-# Wallet management
+# SQLite stuff
 rusqlite = {version = "0.30.0", features = ["sqlcipher"], optional = true}
 libsqlite3-sys = {version = "0.27.0", features = ["sqlcipher"], optional = true}
 
@@ -184,7 +184,6 @@ validator = [
     "system",
     "tx",
     "util",
-    "wallet",
     "wasm-runtime",
     "zk",
     "zkas",
@@ -284,11 +283,6 @@ util = [
     "darkfi-serial",
 ]
 
-wallet = [
-    "rusqlite",
-    "smol",
-]
-
 wasm-runtime = [
     "wasmer",
     "wasmer-compiler-singlepass",

src/contract/test-harness/src/lib.rs

@@ -26,7 +26,6 @@ use darkfi::{
         time::{TimeKeeper, Timestamp},
     },
     validator::{Validator, ValidatorConfig, ValidatorPtr},
-    wallet::{WalletDb, WalletPtr},
     zk::{empty_witnesses, ProvingKey, ZkCircuit},
     zkas::ZkBinary,
     Result,
@@ -134,7 +133,6 @@ pub struct Wallet {
     pub consensus_unstaked_merkle_tree: MerkleTree,
     pub dao_merkle_tree: MerkleTree,
     pub dao_proposals_tree: MerkleTree,
-    pub wallet: WalletPtr,
     pub unspent_money_coins: Vec<OwnCoin>,
     pub spent_money_coins: Vec<OwnCoin>,
     pub dao_leafs: HashMap<DaoBulla, bridgetree::Position>,
@@ -150,7 +148,6 @@ impl Wallet {
         vks: &Vks,
         verify_fees: bool,
     ) -> Result<Self> {
-        let wallet = WalletDb::new(None, None)?;
         let sled_db = sled::Config::new().temporary(true).open()?;
 
         // Use pregenerated vks and get pregenerated pks
@@ -198,7 +195,6 @@ impl Wallet {
             consensus_unstaked_merkle_tree,
             dao_merkle_tree,
             dao_proposals_tree,
-            wallet,
             unspent_money_coins,
             spent_money_coins,
             dao_leafs: HashMap::new(),

src/error.rs

@@ -432,18 +432,6 @@ pub enum Error {
     #[error("zkas bincode not found in sled database")]
     ZkasBincodeNotFound,
 
-    // =============
-    // Wallet errors
-    // =============
-    #[error("Wallet password is empty")]
-    WalletEmptyPassword,
-
-    #[error("Merkle tree already exists in wallet")]
-    WalletTreeExists,
-
-    #[error("Wallet insufficient balance")]
-    WalletInsufficientBalance,
-
     // ===================
     // wasm runtime errors
     // ===================

src/lib.rs

@@ -53,9 +53,6 @@ pub mod tx;
 #[cfg(feature = "util")]
 pub mod util;
 
-#[cfg(feature = "wallet")]
-pub mod wallet;
-
 #[cfg(feature = "wasm-runtime")]
 pub mod runtime;
 

src/wallet/mod.rs

@@ -1,21 +0,0 @@
-/* This file is part of DarkFi (https://dark.fi)
- *
- * Copyright (C) 2020-2024 Dyne.org foundation
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-/// Main wallet primitives, extendable by traits.
-pub mod walletdb;
-pub use walletdb::{WalletDb, WalletPtr};

src/wallet/walletdb.rs

@@ -1,212 +0,0 @@
-/* This file is part of DarkFi (https://dark.fi)
- *
- * Copyright (C) 2020-2024 Dyne.org foundation
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-use std::{any::Any, path::PathBuf, sync::Arc};
-
-use log::{debug, info};
-use rusqlite::Connection;
-use smol::lock::Mutex;
-
-use crate::Result;
-
-pub type WalletPtr = Arc<WalletDb>;
-
-/// Types we want to allow to query from the SQL wallet
-pub enum QueryType {
-    /// Integer gets decoded into `u64`
-    Integer = 0x00,
-    /// Blob gets decoded into `Vec<u8>`
-    Blob = 0x01,
-    /// OptionInteger gets decoded into `Option<u64>`
-    OptionInteger = 0x02,
-    /// OptionBlob gets decoded into `Option<Vec<u8>>`
-    OptionBlob = 0x03,
-    /// Text gets decoded into `String`
-    Text = 0x04,
-    /// Last type, increment this when you add new types.
-    Last = 0x05,
-}
-
-impl From<u8> for QueryType {
-    fn from(x: u8) -> Self {
-        match x {
-            0x00 => Self::Integer,
-            0x01 => Self::Blob,
-            0x02 => Self::OptionInteger,
-            0x03 => Self::OptionBlob,
-            0x04 => Self::Text,
-            _ => unimplemented!(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum SqlType {
-    Integer(i64),
-    Text(String),
-    Blob(Vec<u8>),
-    Null,
-}
-
-impl SqlType {
-    pub fn inner<T: 'static>(&self) -> Option<&T> {
-        match self {
-            SqlType::Integer(v) => (v as &dyn Any).downcast_ref::<T>(),
-            SqlType::Text(v) => (v as &dyn Any).downcast_ref::<T>(),
-            SqlType::Blob(v) => (v as &dyn Any).downcast_ref::<T>(),
-            SqlType::Null => None,
-        }
-    }
-}
-
-/// Structure representing base wallet operations.
-/// Additional operations can be implemented by trait extensions.
-pub struct WalletDb {
-    pub conn: Mutex<Connection>,
-}
-
-impl WalletDb {
-    /// Create a new wallet. If `path` is `None`, create it in memory.
-    pub fn new(path: Option<PathBuf>, password: Option<&str>) -> Result<WalletPtr> {
-        let conn = match path.clone() {
-            Some(p) => Connection::open(p)?,
-            None => Connection::open_in_memory()?,
-        };
-
-        if let Some(password) = password {
-            conn.pragma_update(None, "key", password)?;
-        }
-        conn.pragma_update(None, "foreign_keys", "ON")?;
-
-        info!(target: "wallet::walletdb", "[WalletDb] Opened Sqlite connection at \"{:?}\"", path);
-        Ok(Arc::new(Self { conn: Mutex::new(conn) }))
-    }
-
-    /// This function executes a given SQL query, but isn't able to return anything.
-    /// Therefore it's best to use it for initializing a table or similar things.
-    pub async fn exec_sql(&self, query: &str) -> Result<()> {
-        info!(target: "wallet::walletdb", "[WalletDb] Executing SQL query");
-        debug!(target: "wallet::walletdb", "[WalletDb] Query:\n{}", query);
-        let _ = self.conn.lock().await.execute(query, ())?;
-        Ok(())
-    }
-
-    pub async fn query_single(
-        &self,
-        table: &str,
-        col_names: Vec<&str>,
-        where_queries: Option<Vec<(&str, SqlType)>>,
-    ) -> Result<Vec<SqlType>> {
-        let mut query = format!("SELECT {} FROM {}", col_names.join(", "), table);
-
-        if let Some(wq) = where_queries.as_ref() {
-            let where_str: Vec<String> = wq.iter().map(|(k, _)| format!("{} = ?", k)).collect();
-            query.push_str(&format!(" WHERE {}", where_str.join(" AND ")));
-        }
-
-        let params: Vec<rusqlite::types::ToSqlOutput> = where_queries.map_or(Vec::new(), |wq| {
-            wq.into_iter()
-                .map(|(_, v)| match v {
-                    SqlType::Integer(i) => rusqlite::types::ToSqlOutput::from(i),
-                    SqlType::Text(t) => rusqlite::types::ToSqlOutput::from(t),
-                    SqlType::Blob(b) => rusqlite::types::ToSqlOutput::from(b),
-                    SqlType::Null => rusqlite::types::ToSqlOutput::from(rusqlite::types::Null),
-                })
-                .collect::<Vec<_>>()
-        });
-
-        let wallet_conn = self.conn.lock().await;
-        let mut stmt = wallet_conn.prepare(&query)?;
-        let params_as_slice: Vec<&dyn rusqlite::ToSql> =
-            params.iter().map(|x| x as &dyn rusqlite::ToSql).collect();
-        let mut rows = stmt.query(params_as_slice.as_slice())?;
-
-        let row = match rows.next()? {
-            Some(row_result) => row_result,
-            None => return Ok(vec![]),
-        };
-
-        let mut result = vec![];
-        for (idx, _) in col_names.iter().enumerate() {
-            let value: SqlType = match row.get_ref(idx)?.data_type() {
-                rusqlite::types::Type::Integer => SqlType::Integer(row.get(idx)?),
-                rusqlite::types::Type::Text => SqlType::Text(row.get(idx)?),
-                rusqlite::types::Type::Blob => SqlType::Blob(row.get(idx)?),
-                rusqlite::types::Type::Null => SqlType::Null,
-                _ => unimplemented!(),
-            };
-
-            result.push(value);
-        }
-
-        Ok(result)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_mem_wallet() {
-        smol::block_on(async {
-            let wallet = WalletDb::new(None, Some("foobar")).unwrap();
-            wallet.exec_sql("CREATE TABLE mista ( numba INTEGER );").await.unwrap();
-            wallet.exec_sql("INSERT INTO mista ( numba ) VALUES ( 42 );").await.unwrap();
-
-            let conn = wallet.conn.lock().await;
-            let mut stmt = conn.prepare("SELECT numba FROM mista").unwrap();
-            let numba: u64 = stmt.query_row((), |row| Ok(row.get("numba").unwrap())).unwrap();
-            stmt.finalize().unwrap();
-            assert!(numba == 42);
-        });
-    }
-
-    #[test]
-    fn test_query_single() {
-        smol::block_on(async {
-            let wallet = WalletDb::new(None, None).unwrap();
-            wallet
-                .exec_sql("CREATE TABLE mista ( why INTEGER, are TEXT, you INTEGER, gae BLOB );")
-                .await
-                .unwrap();
-
-            let why = 42;
-            let are = "are".to_string();
-            let you = 69;
-            let gae = vec![42u8; 32];
-
-            let query_str = "INSERT INTO mista ( why, are, you, gae ) VALUES (?1, ?2, ?3, ?4);";
-
-            let wallet_conn = wallet.conn.lock().await;
-            let mut stmt = wallet_conn.prepare(query_str).unwrap();
-            stmt.execute(rusqlite::params![why, are, you, gae]).unwrap();
-            stmt.finalize().unwrap();
-            drop(wallet_conn);
-
-            let ret =
-                wallet.query_single("mista", vec!["why", "are", "you", "gae"], None).await.unwrap();
-            assert!(ret.len() == 4);
-
-            assert!(ret[0].inner::<i64>().unwrap() == &why);
-            assert!(ret[1].inner::<String>().unwrap() == &are);
-            assert!(ret[2].inner::<i64>().unwrap() == &you);
-            assert!(ret[3].inner::<Vec<u8>>().unwrap() == &gae);
-        });
-    }
-}