Add GatewayClient to cashier for posting tx to blockchain

src/bin/cashierd.rs

@@ -1,15 +1,17 @@
 use std::net::SocketAddr;
-use std::sync::Arc;
+use async_std::sync::Mutex;
 
 use std::{path::Path, path::PathBuf};
 //use toml;
 
 use drk::cli::{CashierdCli, CashierdConfig, Config};
 use drk::service::CashierService;
+use drk::service::GatewayClient;
 use drk::wallet::CashierDb;
-
+use drk::blockchain::{rocks::columns, Rocks, RocksColumn};
 use drk::util::join_config_path;
-use drk::Result;
+use drk::{Error, Result};
+use log::*;
 
 use async_executor::Executor;
 use easy_parallel::Parallel;
@@ -17,9 +19,23 @@ use easy_parallel::Parallel;
 async fn start(executor: Arc<Executor<'_>>, config: Arc<&CashierdConfig>) -> Result<()> {
     let accept_addr: SocketAddr = config.accept_url.parse()?;
 
+    let gateway_addr: SocketAddr = config.gateway_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 slabstore = RocksColumn::<columns::Slabs>::new(rocks.clone());
+
     let wallet = Arc::new(CashierDb::new("cashier.db", config.password.clone())?);
 
-    let cashier = CashierService::new(accept_addr, wallet)?;
+    debug!(target: "Client", "Creating gateway client");
+    let mut gateway = GatewayClient::new(gateway_addr, slabstore)?;
+
+    debug!(target: "fn::start gateway client", "start() Gateway Client started");
+    gateway.start().await?;
+
+    // Probably not ideal to create an Arc here
+    let cashier = CashierService::new(accept_addr, wallet, gateway)?;
 
     cashier.start(executor.clone()).await?;
     Ok(())
@@ -73,7 +89,7 @@ fn main() -> Result<()> {
             smol::future::block_on(async move {
                 start(ex2, config_ptr).await?;
                 drop(signal);
-                Ok::<(), drk::Error>(())
+                Ok::<(), Error>(())
             })
         });
 

src/bin/darkfid.rs

@@ -273,7 +273,7 @@ async fn start(executor: Arc<Executor<'_>>, config: Arc<&DarkfidConfig>) -> Resu
     debug!(target: "Client", "Creating client");
     let mut client = GatewayClient::new(connect_addr, slabstore)?;
 
-    // create gateway client
+    // create cashier client
     debug!(target: "Cashier Client", "Creating cashier client");
     let mut cashier_client = CashierClient::new(cashier_addr)?;
 

src/cli/cli_config.rs

@@ -192,6 +192,10 @@ pub struct CashierdConfig {
     #[serde(rename = "database_path")]
     pub database_path: String,
 
+    #[serde(default)]
+    #[serde(rename = "connect_url")]
+    pub gateway_url: String,
+
     #[serde(default)]
     #[serde(rename = "log_path")]
     pub log_path: String,
@@ -204,6 +208,7 @@ pub struct CashierdConfig {
 impl Default for CashierdConfig {
     fn default() -> Self {
         let accept_url = String::from("127.0.0.1:7777");
+        let gateway_url = String::from("127.0.0.1:3333");
         let database_path = String::from("cashierd.db");
 
         let mut lp = PathBuf::new();
@@ -215,6 +220,7 @@ impl Default for CashierdConfig {
         Self {
             accept_url,
             database_path,
+            gateway_url,
             log_path,
             password,
         }

src/service/btc.rs

@@ -64,7 +64,7 @@ impl BitcoinKeys {
             pub_address,
         })
     }
-    pub fn start_scheduler(&self, executor: Arc<Executor<'_>>) -> Result<()> {
+    pub fn start_scheduler(&self, _executor: Arc<Executor<'_>>) -> Result<()> {
         //&self.scheduler.every(10.minutes()).run();
 
         Ok(())

src/service/cashier.rs

@@ -2,8 +2,11 @@ use super::reqrep::{PeerId, RepProtocol, Reply, ReqProtocol, Request};
 
 use super::btc::{BitcoinKeys, PubAddress};
 
+use super::GatewayClient;
+use crate::blockchain::{ Slab };
+
 use crate::{Error, Result};
-use crate::serial::{Decodable, Encodable, deserialize, serialize};
+use crate::serial::{Encodable, serialize};
 use crate::wallet::CashierDbPtr;
 use crate::tx;
 use crate::crypto::load_params;
@@ -31,6 +34,7 @@ enum CashierCommand {
 pub struct CashierService {
     addr: SocketAddr,
     wallet: CashierDbPtr,
+    gateway: GatewayClient,
     mint_params: groth16::Parameters<Bls12>,
     mint_pvk: groth16::PreparedVerifyingKey<Bls12>,
     spend_params: groth16::Parameters<Bls12>,
@@ -38,7 +42,12 @@ pub struct CashierService {
 }
 
 impl CashierService {
-    pub fn new(addr: SocketAddr, wallet: CashierDbPtr) -> Result<Arc<CashierService>> {
+    pub fn new(
+        addr: SocketAddr,
+        wallet: CashierDbPtr,
+        gateway: GatewayClient,
+    ) -> Result<Arc<CashierService>> {
+
         // Load trusted setup parameters
         let (mint_params, mint_pvk) = load_params("mint.params")?;
         let (spend_params, spend_pvk) = load_params("spend.params")?;
@@ -46,6 +55,7 @@ impl CashierService {
         Ok(Arc::new(CashierService {
             addr,
             wallet,
+            gateway,
             mint_params,
             mint_pvk,
             spend_params,
@@ -66,10 +76,11 @@ impl CashierService {
         protocol.run(executor.clone()).await?;
 
         let _ = handle_request_task.cancel().await;
+
         Ok(())
     }
 
-    fn mint_dbtc(&self, dkey_pub: jubjub::SubgroupPoint, value: u64) -> Result<Vec<u8>> {
+    async fn mint_dbtc(&mut self, dkey_pub: jubjub::SubgroupPoint, value: u64) -> Result<()> {
         // Change to adapter
         let cashier_secret = self.wallet.get_cashier_private().unwrap();
 
@@ -94,12 +105,13 @@ impl CashierService {
             // Now serialize it
             tx.encode(&mut tx_data).expect("encode tx");
         }
-        //Add to blockchain
-        // let slab = Slab::new(tx_data);
 
-        // client.put_slab(slab).await.expect("put slab");
+        //Add to blockchain
+        let slab = Slab::new(tx_data);
+        //let mut gateway = self.gateway.lock().await;
+        self.gateway.put_slab(slab).await.expect("put slab");
 
-        Ok(tx_data)
+        Ok(())
     }
 
     async fn handle_request_loop(