Improve handlers

src/io/network/server/handler/create.rs

@@ -4,6 +4,7 @@ use mitrid_core::base::Serializable;
 use mitrid_core::io::Storable;
 
 use crypto::Hasher;
+use model::{UTxO, Transaction, Block, BlockNode, BlockChain};
 use io::Store;
 use io::network::{Message, Request, Response};
 use io::network::message::request::transaction::*;
@@ -18,14 +19,72 @@ pub fn create(store: &mut Store,
 
     if TransactionRequest::verify_create(request)? {
         let transaction = TransactionRequest::parse_create(request)?;
+        transaction.check()?;
+
+        if Transaction::store_lookup(store, &transaction.id)? {
+            return error(store, request, "already found");
+        }
+
+        let mut new_utxos: Vec<UTxO> = Vec::new();
+
+        for ref input in transaction.inputs.iter() {
+            let coin = &input.coin;
+            if !UTxO::store_lookup(store, &coin.id)? {
+                if Transaction::store_lookup(store, &coin.tx_id)? {
+                    return error(store, request, &format!("unknown transaction: {:?}", coin.tx_id));
+                }
+                new_utxos.push(coin.to_owned());
+            }
+        }
+
+        for utxo in new_utxos {
+            utxo.store_create(store)?;
+        }
+
         transaction.store_create(store)?;
-        // TODO: store input coins per transaction
     } else if BlockRequest::verify_create(request)? {
         let block = BlockRequest::parse_create(request)?;
+        block.check()?;
+
+        if Block::store_lookup(store, &block.id)? {
+            return error(store, request, "already found");
+        }
+
+        for tx in block.transactions.iter() {
+            if !Transaction::store_lookup(store, &tx.id)? {
+                return error(store, request, &format!("transaction not found: {:?}", tx.id));
+            }
+        }
+
+        let blockchains = BlockChain::store_list(store, None, None, None, 0)?;
+        if blockchains.len() > 1 {
+            return error(store, request, "internal server error");
+        }
+
+        let mut blockchain = blockchains[0].to_owned();
+
+        if blockchain.tip_idx != Some(0) {
+            return error(store, request, "internal server error");
+        }
+
+        if blockchain.frontier_len != 1 {
+            return error(store, request, "internal server error");
+        }
+
+        let mut hasher = Hasher{};
+
+        if blockchain.height < block.height {
+            blockchain.height = block.height;
+            let blocknode = BlockNode::new()
+                                .meta(&block.meta)?
+                                .block_data(&block.id, block.height)?
+                                .finalize(&mut hasher)?;
+
+            blockchain.frontier = vec![blocknode];
+            blockchain = blockchain.finalize(&mut hasher)?;
+            blockchain.store_create(store)?;
+        } 
 
-        // TODO: check if txs exist
-        //       check if tx input coins are in store
-        //       whatever: make a list
         block.store_create(store)?;
     } else {
         return error(store, request, "invalid resource");

src/io/network/server/handler/handler.rs

@@ -16,6 +16,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
       -> Result<Response>
     {
         ping(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_session(&mut self,
@@ -24,6 +25,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         session(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_count(&mut self,
@@ -32,6 +34,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         count(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_list(&mut self,
@@ -40,6 +43,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         list(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_lookup(&mut self,
@@ -48,6 +52,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         lookup(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_get(&mut self,
@@ -56,6 +61,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         get(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_create(&mut self,
@@ -64,6 +70,7 @@ impl HandlerBase<Store, (), (), Digest, Vec<u8>> for Handler {
         -> Result<Response>
     {
         create(store, request)
+          .or_else(|e| error(store, request, &format!("{}", e)))
     }
 
     fn handle_update(&mut self,