Remove cashier data from rocks

src/bin/cashierd.rs

@@ -18,17 +18,9 @@ use easy_parallel::Parallel;
 async fn start(executor: Arc<Executor<'_>>, config: Arc<&CashierdConfig>) -> Result<()> {
     let accept_addr: SocketAddr = config.accept_url.parse()?;
 
-    let database_path = config.database_path.clone();
-
-    let database_path = join_config_path(&PathBuf::from(database_path))?;
-
-    let rocks = Rocks::new(&database_path)?;
-
-    let rocks_cashierstore_column = RocksColumn::<columns::CashierKeys>::new(rocks);
-
     let wallet = Arc::new(CashierDb::new("cashier.db", config.password.clone())?);
 
-    let cashier = CashierService::new(accept_addr, rocks_cashierstore_column, wallet)?;
+    let cashier = CashierService::new(accept_addr, wallet)?;
 
     cashier.start(executor.clone()).await?;
     Ok(())

src/bin/darkfid.rs

@@ -157,7 +157,6 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
     let rocks2 = rocks.clone();
     let slabstore = RocksColumn::<columns::Slabs>::new(rocks2.clone());
     let rocks3 = rocks2.clone();
-    let cashier_column = RocksColumn::<columns::CashierKeys>::new(rocks3);
 
     // Auto create trusted ceremony parameters if they don't exist
     if !Path::new("mint.params").exists() {
@@ -211,7 +210,7 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
     debug!(target: "fn::start client", "start() Client started");
     client.start().await?;
 
-    let adapter = RpcAdapter::new(wallet.clone(), config.connect_url.clone(), cashier_column)?;
+    let adapter = RpcAdapter::new(wallet.clone(), config.connect_url.clone())?;
     // start the rpc server
     jsonserver::start(ex.clone(), config.clone(), adapter).await?;
 

src/blockchain/cashier_keypair.rs

@@ -1,44 +0,0 @@
-use crate::serial::{Decodable, Encodable};
-use crate::Result;
-
-#[derive(Clone, Debug)]
-pub struct CashierKeypair {
-    zk_public: jubjub::SubgroupPoint,
-    payload: Vec<u8>,
-}
-
-impl CashierKeypair {
-    pub fn new(zk_public: jubjub::SubgroupPoint, payload: Vec<u8>) -> Self {
-        CashierKeypair { zk_public, payload }
-    }
-
-    pub fn set_index(&mut self, index: jubjub::SubgroupPoint) {
-        self.zk_public = index;
-    }
-
-    pub fn get_index(&self) -> jubjub::SubgroupPoint {
-        self.zk_public
-    }
-
-    pub fn get_payload(&self) -> Vec<u8> {
-        self.payload.clone()
-    }
-}
-
-impl Encodable for CashierKeypair {
-    fn encode<S: std::io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.zk_public.encode(&mut s)?;
-        len += self.payload.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for CashierKeypair {
-    fn decode<D: std::io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            zk_public: Decodable::decode(&mut d)?,
-            payload: Decodable::decode(&mut d)?,
-        })
-    }
-}

src/blockchain/cashierstore.rs

@@ -1,54 +0,0 @@
-use std::sync::Arc;
-
-use crate::serial::{deserialize, serialize};
-use crate::Result;
-
-use super::cashier_keypair::CashierKeypair;
-use super::rocks::{columns, IteratorMode, RocksColumn};
-
-pub struct CashierStore {
-    rocks: RocksColumn<columns::CashierKeys>,
-}
-
-impl CashierStore {
-    pub fn new(rocks: RocksColumn<columns::CashierKeys>) -> Result<Arc<Self>> {
-        Ok(Arc::new(CashierStore { rocks }))
-    }
-
-    pub fn get(&self, key: jubjub::SubgroupPoint) -> Result<Option<Vec<u8>>> {
-        let value = self.rocks.get(key)?;
-        Ok(value)
-    }
-
-    pub fn put(&self, keypair: CashierKeypair) -> Result<Option<jubjub::SubgroupPoint>> {
-        let index = keypair.get_index();
-
-        match self.get(index) {
-            Ok(_v) => Ok(None),
-            Err(_e) => {
-                self.rocks.put(index.clone(), keypair)?;
-                Ok(Some(index))
-            }
-        }
-    }
-
-    pub fn get_value_deserialized(&self, key: Vec<u8>) -> Result<Option<CashierKeypair>> {
-        self.rocks.get_value_deserialized::<CashierKeypair>(key)
-    }
-    // Fix this
-    // pub fn get_last_index(&self) -> Result<jubjub::SubgroupPoint> {
-    //     let last_index = self.rocks.iterator(IteratorMode::End)?.next();
-    //     match last_index {
-    //         Some((index, _)) => Ok(deserialize(&index)?),
-    //         None => Ok()
-    //     }
-    // }
-
-    pub fn get_last_index_as_bytes(&self) -> Result<Vec<u8>> {
-        let last_index = self.rocks.iterator(IteratorMode::End)?.next();
-        match last_index {
-            Some((index, _)) => Ok(index.to_vec()),
-            None => Ok(serialize::<u64>(&0)),
-        }
-    }
-}

src/blockchain/mod.rs

@@ -1,11 +1,7 @@
-pub mod cashier_keypair;
-pub mod cashierstore;
 pub mod rocks;
 pub mod slab;
 pub mod slabstore;
 
-pub use cashier_keypair::CashierKeypair;
-pub use cashierstore::CashierStore;
 pub use rocks::{Rocks, RocksColumn};
 pub use slab::Slab;
 pub use slabstore::SlabStore;

src/blockchain/rocks.rs

@@ -20,7 +20,6 @@ pub mod columns {
     pub struct Slabs;
     pub struct Nullifiers;
     pub struct MerkleRoots;
-    pub struct CashierKeys;
 }
 
 impl Column for columns::Slabs {
@@ -34,9 +33,7 @@ impl Column for columns::Nullifiers {
 impl Column for columns::MerkleRoots {
     const NAME: &'static str = "merkleroots";
 }
-impl Column for columns::CashierKeys {
-    const NAME: &'static str = "cashierkeys";
-}
+
 pub struct Rocks {
     db: DB,
 }
@@ -55,9 +52,7 @@ impl Rocks {
         let nullifiers_cf = ColumnFamilyDescriptor::new(columns::Nullifiers::NAME, cf_opts.clone());
         // merkleroots column family
         let merkleroots_cf =
-            ColumnFamilyDescriptor::new(columns::MerkleRoots::NAME, cf_opts.clone());
-        // cashierkeypair column family
-        let cashierkeys_cf = ColumnFamilyDescriptor::new(columns::CashierKeys::NAME, cf_opts);
+            ColumnFamilyDescriptor::new(columns::MerkleRoots::NAME, cf_opts);
 
         // column families
         let cfs = vec![
@@ -65,7 +60,6 @@ impl Rocks {
             slab_cf,
             nullifiers_cf,
             merkleroots_cf,
-            cashierkeys_cf,
         ];
 
         // database options

src/rpc/adapter.rs

@@ -1,4 +1,4 @@
-use crate::blockchain::{rocks::columns, CashierStore, RocksColumn};
+use crate::blockchain::{rocks::columns, RocksColumn};
 use crate::service::cashier::CashierClient;
 use crate::wallet::WalletDb;
 use crate::{Error, Result};
@@ -20,11 +20,10 @@ impl RpcAdapter {
     pub fn new(
         wallet: Arc<WalletDb>,
         connect_url: String,
-        rocks: RocksColumn<columns::CashierKeys>,
     ) -> Result<Self> {
         debug!(target: "ADAPTER", "new() [CREATING NEW WALLET]");
         let connect_addr: SocketAddr = connect_url.parse().unwrap();
-        let mut client = CashierClient::new(connect_addr, rocks)?;
+        let mut client = CashierClient::new(connect_addr)?;
         Ok(Self {
             wallet,
             client,

src/service/cashier.rs

@@ -8,7 +8,7 @@ use bitcoin::network::constants::Network;
 
 use bitcoin::hash_types::PubkeyHash;
 use super::reqrep::{PeerId, RepProtocol, Reply, ReqProtocol, Request};
-use crate::blockchain::{rocks::columns, RocksColumn, CashierKeypair, CashierStore};
+
 use crate::{serial::deserialize, serial::serialize, Error, Result};
 
 use crate::wallet::{CashierDb, CashierDbPtr};
@@ -84,21 +84,17 @@ impl BitcoinKeys {
 
 pub struct CashierService {
     addr: SocketAddr,
-    cashierstore: Arc<CashierStore>,
     wallet: Arc<CashierDb>,
 }
 
 impl CashierService {
     pub fn new(
         addr: SocketAddr,
-        rocks: RocksColumn<columns::CashierKeys>,
         wallet: Arc<CashierDb>,
     )-> Result<Arc<CashierService>> {
-        let cashierstore = CashierStore::new(rocks)?;
-        //let wallet = CashierDb::new();
+
         Ok(Arc::new(CashierService {
             addr,
-            cashierstore,
             wallet,
         }))
     }
@@ -130,11 +126,11 @@ impl CashierService {
         loop {
             match recv_queue.recv().await {
                 Ok(msg) => {
-                    let cashierstore = self.cashierstore.clone();
+                    let cashier_wallet = self.wallet.clone();
                     let _ = executor
                         .spawn(Self::handle_request(
                             msg,
-                            cashierstore,
+                            cashier_wallet,
                             send_queue.clone(),
                         ))
                         .detach();
@@ -148,7 +144,7 @@ impl CashierService {
     }
     async fn handle_request(
         msg: (PeerId, Request),
-        cashierstore: Arc<CashierStore>,
+        cashier_wallet: Arc<CashierDb>,
         send_queue: async_channel::Sender<(PeerId, Reply)>,
     ) -> Result<()> {
         let request = msg.1;
@@ -163,8 +159,8 @@ impl CashierService {
 
                 let btc_pub = btc_keys.get_pubkey();
 
-                // add to cashierstore?
-                //let error = cashierstore.put(deserialize(&zkpub)?)?;
+                // add to cashier_wallet
+                //
 
                 let mut reply = Reply::from(&request, CashierError::NoError as u32, vec![]);
 
@@ -189,18 +185,14 @@ impl CashierService {
 
 pub struct CashierClient {
     protocol: ReqProtocol,
-    cashierstore: Arc<CashierStore>,
 }
 
 impl CashierClient {
-    pub fn new(addr: SocketAddr, rocks: RocksColumn<columns::CashierKeys>) -> Result<Self> {
+    pub fn new(addr: SocketAddr) -> Result<Self> {
         let protocol = ReqProtocol::new(addr, String::from("CASHIER CLIENT"));
 
-        let cashierstore = CashierStore::new(rocks)?;
-
         Ok(CashierClient {
-            protocol,
-            cashierstore,
+            protocol
         })
     }
 
@@ -230,9 +222,6 @@ impl CashierClient {
         Ok(None)
     }
 
-    pub fn get_cashierstore(&self) -> Arc<CashierStore> {
-        self.cashierstore.clone()
-    }
 
 }