Merge pull request #6 from rooooooooob/txsend

Txsend implementation

Cargo.toml

@@ -4,6 +4,7 @@ version = "0.0.1"
 authors = [ "Nicolas Di Prima <nicolas.diprima@iohk.io>"
           , "Vincent Hanquez <vincent.hanquez@iohk.io>"
           ]
+edition = "2018"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/input-output-hk/cardano-http-bridge"
 homepage = "https://github.com/input-output-hk/cardano-http-bridge#README.md"
@@ -22,13 +23,16 @@ exe-common      = { path = "cardano-deps/exe-common" }
 
 serde = "1.0"
 serde_derive = "1.0"
+serde_json = "1.0"
 serde_yaml = "0.7"
 log = "0.4"
 env_logger = "0.5.9"
 iron = "*"
 router ="*"
+base64 = "0.9"
+cbor_event = "1.0"
 
 [dependencies.clap]
 version = "2.31"
 default-features = false
-features = [ "suggestions", "color", "wrap_help" ]
+features = [ "suggestions", "color", "wrap_help" ]

src/handlers/common.rs

@@ -15,17 +15,22 @@ pub fn validate_epochid(v: &&str) -> Option<EpochId> {
     }
 }
 
-pub fn get_network_and_epoch<'a>(req: &Request, networks: &'a Networks) -> Option<(&'a Network, EpochId)> {
+pub fn get_network<'a>(req: &Request, networks : &'a Networks) -> Option<(String, &'a Network)> {
     let ref network_name = req.extensions.get::<Router>().unwrap().find("network").unwrap();
-    let ref epochid_str = req.extensions.get::<Router>().unwrap().find("epochid").unwrap();
 
     if ! validate_network_name (network_name) {
         return None;
     }
-    let net = match networks.get(network_name.to_owned()) {
-        None => return None,
-        Some(net) => net
-    };
+
+    match networks.get(network_name.to_owned()) {
+        None => None,
+        Some(net) => Some((network_name.to_string(), net))
+    }
+}
+
+pub fn get_network_and_epoch<'a>(req: &Request, networks: &'a Networks) -> Option<(&'a Network, EpochId)> {
+    let (_, net) = get_network(req, networks)?;
+    let ref epochid_str = req.extensions.get::<Router>().unwrap().find("epochid").unwrap();
 
     let epochid = match validate_epochid (epochid_str) {
         None => {
@@ -36,4 +41,4 @@ pub fn get_network_and_epoch<'a>(req: &Request, networks: &'a Networks) -> Optio
     };
 
     Some((net, epochid))
-}
+}

src/handlers/mod.rs

@@ -3,5 +3,6 @@ pub mod block;
 pub mod pack;
 pub mod epoch;
 pub mod tip;
+pub mod tx;
 pub mod utxos;
-pub mod utxos_delta;
+pub mod utxos_delta;

src/handlers/tx.rs

@@ -0,0 +1,68 @@
+use cardano::{block::Verify, tx::TxAux};
+
+use std::{io::Read, sync::Arc};
+
+use iron;
+use iron::{Request, Response, IronResult};
+use iron::status;
+
+use router::{Router};
+
+use serde_json;
+
+use super::super::config::{Networks};
+use super::common;
+use exe_common::{config::net, network::Api, sync};
+
+pub struct Handler {
+    networks: Arc<Networks>
+}
+impl Handler {
+    pub fn new(networks: Arc<Networks>) -> Self {
+        Handler {
+            networks: networks
+        }
+    }
+    pub fn route(self, router: &mut Router) -> &mut Router {
+        router.post(":network/txs/signed", self, "txs_signed_send")
+    }
+}
+
+impl iron::Handler for Handler {
+    fn handle(&self, req: &mut Request) -> IronResult<Response> {
+        fn read_txaux_from_req_str(tx_str: &str) -> Option<TxAux> {
+            let json = serde_json::from_str::<serde_json::Value>(tx_str).ok()?;
+            let base_64 = json.
+                as_object()?.
+                get("signedTx")?.
+                as_str()?;
+            let bytes = base64::decode(&base_64).ok()?;
+            cbor_event::de::RawCbor::from(&bytes).deserialize_complete().ok()
+        }
+        let mut req_body_str = String::new();
+        req.body.read_to_string(&mut req_body_str).unwrap();
+        let txaux = match read_txaux_from_req_str(req_body_str.as_str()) {
+            None => { return Ok(Response::with((status::BadRequest, "Invalid input format for transaction"))); }
+            Some(x) => x
+        };
+
+        let (net_name, net) = match common::get_network(req, &self.networks) {
+            None => { return Ok(Response::with((status::BadRequest, "Invalid network name"))); }
+            Some(x) => x
+        };
+        let netcfg_file = net.storage.config.get_config_file();
+        let net_cfg = net::Config::from_file(&netcfg_file).expect("no network config present");
+
+        if let Err(verify_error) = txaux.verify(net_cfg.protocol_magic) {
+            return Ok(Response::with((status::BadRequest, format!("Transaction failed verification: {}", verify_error))));
+        }
+
+        let mut peer = sync::get_peer(&net_name, &net_cfg, true);
+        match peer.send_transaction(txaux) {
+            Err(e) => return Ok(Response::with((status::InternalServerError, format!("Failed to send to peers: {}", e)))),
+            Ok(value) => assert!(value)
+        };
+
+        Ok(Response::with((status::Ok, "Transaction sent successfully!")))
+    }
+}

src/service.rs

@@ -22,6 +22,7 @@ fn start_http_server(cfg: &Config, networks: Arc<Networks>) -> iron::Listening {
     handlers::pack::Handler::new(networks.clone()).route(&mut router);
     handlers::epoch::Handler::new(networks.clone()).route(&mut router);
     handlers::tip::Handler::new(networks.clone()).route(&mut router);
+    handlers::tx::Handler::new(networks.clone()).route(&mut router);
     handlers::utxos::Handler::new(networks.clone()).route(&mut router);
     handlers::utxos_delta::Handler::new(networks.clone()).route(&mut router);
     info!("listening to port {}", cfg.port);