node: More debugging.

bin/darkfid2/src/main.rs

@@ -166,6 +166,7 @@ impl RequestHandler for Darkfid {
         match req.method.as_str() {
             Some("ping") => return self.pong(req.id, params).await,
             Some("blockchain.get_slot") => return self.get_slot(req.id, params).await,
+            Some("blockchain.merkle_roots") => return self.merkle_roots(req.id, params).await,
             Some("tx.transfer") => return self.transfer(req.id, params).await,
             Some("wallet.keygen") => return self.keygen(req.id, params).await,
             Some("wallet.get_key") => return self.get_key(req.id, params).await,

bin/darkfid2/src/rpc_blockchain.rs

@@ -1,11 +1,14 @@
 use log::{debug, error};
 use serde_json::{json, Value};
 
-use darkfi::rpc::{
-    jsonrpc,
-    jsonrpc::{
-        ErrorCode::{InternalError, InvalidParams},
-        JsonResult,
+use darkfi::{
+    crypto::merkle_node::MerkleNode,
+    rpc::{
+        jsonrpc,
+        jsonrpc::{
+            ErrorCode::{InternalError, InvalidParams},
+            JsonResult,
+        },
     },
 };
 
@@ -45,4 +48,21 @@ impl Darkfid {
         debug!("{:#?}", blocks[0]);
         jsonrpc::response(json!(true), id).into()
     }
+
+    // RPCAPI:
+    // Queries the blockchain database for all available merkle roots.
+    // --> {"jsonrpc": "2.0", "method": "blockchain.merkle_roots", "params": [], "id": 1}
+    // <-- {"jsonrpc": "2.0", "result": [..., ..., ...], "id": 1}
+    pub async fn merkle_roots(&self, id: Value, _params: &[Value]) -> JsonResult {
+        let roots: Vec<MerkleNode> =
+            match self.validator_state.read().await.blockchain.merkle_roots.get_all() {
+                Ok(v) => v.iter().map(|x| x.unwrap()).collect(),
+                Err(e) => {
+                    error!("Failed getting merkle roots from rootstore: {}", e);
+                    return jsonrpc::error(InternalError, None, id).into()
+                }
+            };
+
+        jsonrpc::response(json!(roots), id).into()
+    }
 }

src/consensus/state.rs

@@ -505,12 +505,9 @@ impl ValidatorState {
 
         let mut encoded_proposal = vec![];
 
-        match vote.proposal.encode(&mut encoded_proposal) {
-            Ok(_) => (),
-            Err(e) => {
-                error!(target: "consensus", "Proposal encoding failed: {:?}", e);
-                return Ok((false, None))
-            }
+        if let Err(e) = vote.proposal.encode(&mut encoded_proposal) {
+            error!(target: "consensus", "Proposal encoding failed: {:?}", e);
+            return Ok((false, None))
         };
 
         if !vote.public_key.verify(&encoded_proposal, &vote.vote) {
@@ -665,11 +662,11 @@ impl ValidatorState {
 
         chain.proposals.drain(0..(consecutive - 1));
 
-        info!(target: "consensus", "Adding {} finalized block to canonical chain", finalized.len());
+        info!("consensus: Adding {} finalized block to canonical chain", finalized.len());
         let blockhashes = match self.blockchain.add(&finalized) {
             Ok(v) => v,
             Err(e) => {
-                error!(target: "consensus", "Failed appending finalized blocks to canonical chain: {}", e);
+                error!("consensus: Failed appending finalized blocks to canonical chain: {}", e);
                 return Err(e)
             }
         };
@@ -682,7 +679,6 @@ impl ValidatorState {
             let mem_st = MemoryState::new(canon_state_clone);
             let state_updates = ValidatorState::validate_state_transitions(mem_st, &proposal.txs)?;
             self.update_canon_state(state_updates, None).await?;
-
             self.remove_txs(proposal.txs.clone())?;
         }
 

src/node/state.rs

@@ -142,15 +142,21 @@ impl State {
         tokenlist: Arc<DrkTokenList>,
     ) -> Result<()> {
         debug!(target: "state_apply", "Extend nullifier set");
+        debug!("Existing nullifiers: {:#?}", self.nullifiers.get_all()?);
+        debug!("Update's nullifiers: {:#?}", update.nullifiers);
         self.nullifiers.insert(&update.nullifiers)?;
 
         debug!(target: "state_apply", "Update Merkle tree and witnesses");
         for (coin, enc_note) in update.coins.into_iter().zip(update.enc_notes.iter()) {
             // Add the new coins to the Merkle tree
             let node = MerkleNode(coin.0);
+            debug!("Current merkle tree: {:#?}", self.tree);
             self.tree.append(&node);
+            debug!("Merkle tree after append: {:#?}", self.tree);
 
             // Keep track of all Merkle roots that have existed
+            debug!("Existing merkle roots: {:#?}", self.merkle_roots.get_all()?);
+            debug!("New merkle root: {:#?}", self.tree.root());
             self.merkle_roots.insert(&[self.tree.root()])?;
 
             for secret in secret_keys.iter() {