wip: milestone 2

src/node.rs

@@ -0,0 +1,169 @@
+use crate::config::ServerConfig;
+use crate::error::{ErrorKind, Result};
+use crate::secp::Commitment;
+
+use grin_api::client;
+use grin_api::json_rpc::{build_request, Request, Response};
+use grin_api::{BlockPrintable, LocatedTxKernel, OutputPrintable, OutputType, Tip};
+use grin_core::consensus::COINBASE_MATURITY;
+use grin_core::core::{Input, OutputFeatures, Transaction};
+use grin_util::ToHex;
+
+use serde_json::json;
+use std::net::SocketAddr;
+
+const ENDPOINT: &str = "/v2/foreign";
+
+#[derive(Clone)]
+pub struct HTTPNodeClient {
+    node_url: SocketAddr,
+    node_api_secret: Option<String>,
+}
+
+impl HTTPNodeClient {
+    /// Create a new client that will communicate with the given grin node
+    pub fn new(node_url: &SocketAddr, node_api_secret: Option<String>) -> HTTPNodeClient {
+        HTTPNodeClient {
+            node_url: node_url.to_owned(),
+            node_api_secret: node_api_secret,
+        }
+    }
+
+    fn send_json_request<D: serde::de::DeserializeOwned>(
+        &self,
+        method: &str,
+        params: &serde_json::Value,
+    ) -> Result<D> {
+        let url = format!("http://{}{}", self.node_url, ENDPOINT);
+        let req = build_request(method, params);
+        let res =
+            client::post::<Request, Response>(url.as_str(), self.node_api_secret.clone(), &req)?;
+        let parsed = res.clone().into_result()?;
+        Ok(parsed)
+    }
+}
+
+#[derive(Clone)]
+pub struct GrinNode {
+    client: HTTPNodeClient,
+}
+
+impl GrinNode {
+    pub fn new(server_config: &ServerConfig) -> GrinNode {
+        GrinNode { 
+            client: HTTPNodeClient::new(&server_config.grin_node_url, None),
+        }
+    }
+
+    // Checks whether a commitment is spendable at the block height provided
+    pub fn is_spendable(&self, output_commit: &Commitment, next_block_height: u64) -> Result<bool> {
+        let output = self.get_output(&output_commit)?;
+        if let Some(out) = output {
+            let is_coinbase = match out.output_type {
+                OutputType::Coinbase => true,
+                OutputType::Transaction => false,
+            };
+
+            if is_coinbase {
+                if let Some(block_height) = out.block_height {
+                    if block_height + COINBASE_MATURITY < next_block_height {
+                        return Ok(false);
+                    }
+                } else {
+                    return Ok(false);
+                }
+            }
+
+            return Ok(true);
+        }
+
+        Ok(false)
+    }
+
+    /// Builds an input for an unspent output commitment
+    pub fn build_input(&self, output_commit: &Commitment) -> Result<Option<Input>> {
+        let output = self.get_output(&output_commit)?;
+
+        if let Some(out) = output {
+            let features = match out.output_type {
+                OutputType::Coinbase => OutputFeatures::Coinbase,
+                OutputType::Transaction => OutputFeatures::Plain,
+            };
+
+            let input = Input::new(features, out.commit);
+            return Ok(Some(input));
+        }
+
+        Ok(None)
+    }
+
+    fn get_output(&self, output_commit: &Commitment) -> Result<Option<OutputPrintable>> {
+        let commits : Vec<String> = vec![output_commit.to_hex()];
+        let start_height : Option<u64> = None;
+        let end_height : Option<u64> = None;
+        let include_proof : Option<bool> = Some(false);
+        let include_merkle_proof : Option<bool> = Some(false);
+
+        let params = json!([Some(commits), start_height, end_height, include_proof, include_merkle_proof]);
+        let outputs = self.client.send_json_request::<Vec<OutputPrintable>>("get_outputs", &params)?;
+        if outputs.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(outputs[0].clone()))
+    }
+
+    /// Gets the height of the chain tip
+    pub fn get_chain_height(&self) -> Result<u64> {
+        let params = json!([]);
+        let tip_json = self.client.send_json_request::<serde_json::Value>("get_tip", &params)?;
+
+        let tip: Result<Tip> = serde_json::from_value(tip_json["Ok"].clone())
+            .map_err(|_| ErrorKind::SerdeJsonError.into());
+        
+        Ok(tip?.height)
+    }
+
+    /// Posts a transaction to the grin node
+    pub fn post_tx(&self, tx: &Transaction) -> Result<()> {
+        let params = json!([tx, true]);
+        self.client.send_json_request::<serde_json::Value>("push_transaction", &params)?;
+        Ok(())
+    }
+
+    // milestone 3: needed to handle chain reorgs
+    pub fn chain_has_kernel(
+        &self,
+        kernel_excess: &Commitment,
+        start_height: Option<u64>,
+        end_height: Option<u64>,
+    ) -> Result<bool> {
+        let params = json!([kernel_excess, start_height, end_height]);
+        let located_kernel_json = self.client.send_json_request::<serde_json::Value>("get_kernel", &params)?;
+
+        let located_kernel : Result<LocatedTxKernel> = serde_json::from_value(located_kernel_json["Ok"].clone())
+            .map_err(|_| ErrorKind::SerdeJsonError.into());
+
+        Ok(located_kernel.is_ok())
+    }
+
+    // milestone 3: needed to handle chain reorgs
+    pub fn block_has_kernel(&self, block_hash: &String, kernel_excess: &Commitment) -> Result<bool> {
+        let block = self.get_block(None, Some(block_hash.clone()), None)?;
+
+        let found = block.kernels.into_iter()
+            .any(|kern| kern.excess == kernel_excess.to_hex());
+        Ok(found)
+    }
+
+    // milestone 3: needed to handle chain reorgs
+    fn get_block(&self,
+        height: Option<u64>,
+        hash: Option<String>,
+        commit: Option<String>,
+    ) -> Result<BlockPrintable> {
+        let params = json!([height, hash, commit]);
+        let block_printable = self.client.send_json_request::<BlockPrintable>("get_block", &params)?;
+        Ok(block_printable)
+    }
+}