Merge pull request #6 from gskapka/update-license-and-rust-version

feat(repo): update license and rust version

Author: techcircus

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rusty-receipt-proof-maker"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Greg Kapka <greg@oraclize.it>"]
 edition = "2018"
 

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Greg Kapka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.md

@@ -12,14 +12,14 @@ A Maker of Merkle-Proofs for Transaction Receipts in Ethereum using Rust.
 
 ### :point_right: Usage:
 
-__>__ To generate a proof for a given transaction hash:
+__>__ To generate a proof for a given transaction hash, first you'll need RPC access to an ETH node on the network your transaction exists on. Once you have that, set it as an environment variable and run the tool thusly::
 
-__`❍ rusty-receipt-proof-maker <your-tx-hash-here>`__
+__`❍ ENDPOINT=<ETH-mainnet-rpc-endpoint> rusty-receipt-proof-maker <your-tx-hash-here>`__
 
 
 ```
 
-rusty-receipt-proof-maker 0x5d761b001c4d69bf14c94b8e8a604d97e008a8a7dfb74a6459823b2178ffc033 -v`
+ENDPOINT=<redacted> rusty-receipt-proof-maker 0x5d761b001c4d69bf14c94b8e8a604d97e008a8a7dfb74a6459823b2178ffc033 -v`
 12:02:21 [ INFO] ✔ CLI Args parsed successfully!
 12:02:21 [ INFO] ✔ Verbose mode: true
 12:02:21 [ INFO] ✔ Transaction hash: 0x5d76…c033
@@ -39,7 +39,6 @@ rusty-receipt-proof-maker 0x5d761b001c4d69bf14c94b8e8a604d97e008a8a7dfb74a645982
 
 f90264f8b1a0dc1a1b7bc9f38fc6710af9abdf1da874fa708573431381908b8b6a25bd1f2b55a0701833ef4ede796d9c96b1ae7c66830b0126f106ea0bfe99864e679e8b0dfeafa00db067f1c8ee75d8a563038903eb5129ee1d73beeea9380ca58d1920c15fe84ba0a55d0852ba77dbcc2824337150c123ccde62699b0c6eaddf735c1b2638bb85ba80808080a04937e058ea19511f92f803c23f4e9a4eceaaf2246c86da0f1b2241316be8a34d8080808080808080f901ae30b901aaf901a701837ab31ab9010000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000002000000080000000000000000200000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000020000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000004000000000000010200000000000000000000000000000000000000000000000000000000000f89df89b94c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2f863a08c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925a0000000000000000000000000539efb706852838c51905d3d31966c296e034000a0000000000000000000000000a2881a90bf33f03e7a3f803765cd2ed5c8928dfba0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 
-
 ```
 
 By default, the tool's full tracing logs for each run are output to a file in __`./logs/<utc-timestamp>.log`__
@@ -76,33 +75,6 @@ Options:
     <txhash>            ❍ A transaction hash of an Ethereum transaction
                         ➔ Format: A 32-byte long, prefixed hex string.
 
-❍ Rusty Receipt Proof Maker ❍
-
-    Copyright Provable 2019
-    Questions: greg@oraclize.it
-
-❍ Info ❍
-
-This tool generates a merkle receipt proof of the receipt pertaining to the given transaction hash.
-
-***
-
-Usage:  rusty-receipt-proof-maker [-h | --help]
-        rusty-receipt-proof-maker <txhash> [-t | --trace]
-        rusty-receipt-proof-maker <txhash> [-v | --verbose]
-
-Options:
-
-    -h, --help          ❍ Show this message.
-
-    -v, --verbose       ❍ Enable verbose mode for additional output.
-
-    -t, --trace         ❍ Enable tracing for debugging/bug reporting.
-
-    <txhash>            ❍ A transaction hash of an Ethereum transaction
-                        ➔ Format: A 32-byte long, prefixed hex string.
-
-
 ```
 
 &nbsp;
@@ -151,7 +123,7 @@ rusty-receipt-proof-maker -v 0x5d761b001c4d69bf14c94b8e8a604d97e008a8a7dfb74a645
 
 To run the tests:
 
-__`❍ cargo +nightly test`__
+__`❍ cargo test`__
 
 __Note:__ Some expensive tests are ignored by default. To run all test, including those ignored, add the __`--ignored`__ flag.
 

README.md

@@ -1,53 +1,46 @@
+use crate::get_block::get_block_by_number;
 use crate::state::State;
 use crate::types::Result;
-use crate::get_block::get_block_by_number;
 
 pub fn connect_to_node(state: State) -> Result<State> {
     info!("✔ Connecting to node...");
-    get_block_by_number(State::get_endpoint_from_state(&state)?, "latest")
-        .and_then(|block| {
-            info!(
-                "✔ Connection successful! Latest block number: {:?}",
-                block.number
-            );
-            Ok(state)
-        })
+    get_block_by_number(State::get_endpoint_from_state(&state)?, "latest").map(|block| {
+        info!(
+            "✔ Connection successful! Latest block number: {:?}",
+            block.number
+        );
+        state
+    })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{
-        WORKING_ENDPOINT,
-        get_valid_tx_hash_h256,
-        get_valid_initial_state,
-    };
+    use crate::test_utils::{get_valid_initial_state, get_valid_tx_hash_h256, WORKING_ENDPOINT};
 
     #[test]
     fn should_connect_to_node_and_return_state_when_endpoint_works() {
         let state = State::set_endpoint_in_state(
             get_valid_initial_state().unwrap(),
-            WORKING_ENDPOINT.to_string()
-        ).unwrap();
-        let expected_tx_hash = get_valid_tx_hash_h256()
-            .unwrap();
+            WORKING_ENDPOINT.to_string(),
+        )
+        .unwrap();
+        let expected_tx_hash = get_valid_tx_hash_h256().unwrap();
         match connect_to_node(state) {
-            Ok(returned_state) =>
-                assert!(returned_state.tx_hash == expected_tx_hash),
-            Err(e) => panic!("Error connecting to node: {}", e)
+            Ok(returned_state) => assert!(returned_state.tx_hash == expected_tx_hash),
+            Err(e) => panic!("Error connecting to node: {}", e),
         }
     }
 
     #[test]
     fn should_fail_to_connect_to_node_to_non_working_endpoint() {
         let non_working_endpoint = "non-working-endpoint".to_string();
-        let state = State::set_endpoint_in_state(
-            get_valid_initial_state().unwrap(),
-            non_working_endpoint
-        ).unwrap();
+        let state =
+            State::set_endpoint_in_state(get_valid_initial_state().unwrap(), non_working_endpoint)
+                .unwrap();
         match connect_to_node(state) {
             Ok(_) => panic!("Should not connect to non-working endpoint!"),
-            Err(_) => assert!(true)
+            Err(_) => assert!(true),
         }
     }
 }

src/connect_to_node.rs

@@ -1,27 +1,28 @@
+use crate::nibble_utils::Nibbles;
 use crate::types::Byte;
 use ethereum_types::H256;
-use crate::nibble_utils::Nibbles;
 
 pub const ZERO_BYTE: u8 = 0u8;
-pub const HASH_LENGTH: usize  = 32;
-pub const HASH_HEX_CHARS: usize  = 64;
+pub const HASH_LENGTH: usize = 32;
+pub const HASH_HEX_CHARS: usize = 64;
 pub const HEX_PREFIX_LENGTH: usize = 2;
 pub const NUM_BITS_IN_NIBBLE: usize = 4;
 pub const REQWEST_TIMEOUT_TIME: u64 = 5;
 pub const NUM_NIBBLES_IN_BYTE: usize = 2;
 pub const HIGH_NIBBLE_MASK: Byte = 15u8; // NOTE: 15u8 == [0,0,0,0,1,1,1,1]
-pub static DOT_ENV_PATH: &'static str = "./.env";
-pub static LOG_FILE_PATH: &'static str = "logs/";
-pub static LEAF_NODE_STRING: &'static str = "leaf";
-pub static BRANCH_NODE_STRING: &'static str = "branch";
-pub static EXTENSION_NODE_STRING: &'static str = "extension";
+pub static DOT_ENV_PATH: &str = "./.env";
+pub static LEAF_NODE_STRING: &str = "leaf";
+pub static BRANCH_NODE_STRING: &str = "branch";
+pub static EXTENSION_NODE_STRING: &str = "extension";
 pub const HASHED_NULL_NODE: H256 = H256(HASHED_NULL_NODE_BYTES);
-pub static DEFAULT_ENDPOINT: &'static str = "http://localhost:8545/";
-pub const EMPTY_NIBBLES: Nibbles = Nibbles { data: Vec::new(), offset: 0 };
+pub static DEFAULT_ENDPOINT: &str = "http://localhost:8545/";
+pub const EMPTY_NIBBLES: Nibbles = Nibbles {
+    data: Vec::new(),
+    offset: 0,
+};
 
-const HASHED_NULL_NODE_BYTES: [u8; 32] = [ // NOTE: keccak hash of the RLP of null
-    0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6,
-    0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e,
-    0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0,
-    0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21
+const HASHED_NULL_NODE_BYTES: [u8; 32] = [
+    // NOTE: keccak hash of the RLP of null
+    0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e,
+    0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21,
 ];

src/constants.rs

@@ -1,42 +1,31 @@
-use hex;
-use log;
-use reqwest;
-use std::fmt;
-use serde_json;
-use std::error::Error;
+use std::{error::Error, fmt};
 
 #[derive(Debug)]
 pub enum AppError {
     Custom(String),
+    NoneError(String),
     IOError(std::io::Error),
     HexError(hex::FromHexError),
     ReqwestError(reqwest::Error),
     SerdeJsonError(serde_json::Error),
-    NoneError(std::option::NoneError),
     SetLoggerError(log::SetLoggerError),
+    TermLogError(simplelog::TermLogError),
 }
 
 impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let msg = match *self {
-            AppError::Custom(ref msg) =>
-                format!("{}", msg),
-            AppError::HexError(ref e) =>
-                format!("✘ Hex Error!\n✘ {}", e),
-            AppError::IOError(ref e) =>
-                format!("✘ I/O Error!\n✘ {}", e),
-            AppError::SerdeJsonError(ref e) =>
-                format!("✘ Serde-Json Error!\n✘ {}", e),
-            AppError::NoneError(ref e) =>
-                format!("✘ Nothing to unwrap!\n✘ {:?}", e),
-            AppError::SetLoggerError(ref e) =>
-                format!("✘ Error setting up logger!\n✘ {}", e),
-            AppError::ReqwestError(ref e) =>
-                format!(
-                    "\n✘ HTTP Reqwest Error!\n✘ {}\n{}",
-                    e,
-                    "✘ Please check your node & port settings and retry.\n"
-                ),
+            AppError::Custom(ref msg) => msg.to_string(),
+            AppError::HexError(ref e) => format!("✘ Hex Error!\n✘ {}", e),
+            AppError::IOError(ref e) => format!("✘ I/O Error!\n✘ {}", e),
+            AppError::NoneError(ref e) => format!("✘ Nothing to unwrap!\n✘ {:?}", e),
+            AppError::SerdeJsonError(ref e) => format!("✘ Serde-Json Error!\n✘ {}", e),
+            AppError::TermLogError(ref e) => format!("✘ Terminal logger error: {}", e),
+            AppError::SetLoggerError(ref e) => format!("✘ Error setting up logger!\n✘ {}", e),
+            AppError::ReqwestError(ref e) => format!(
+                "\n✘ HTTP Reqwest Error!\n✘ {}\n{}",
+                e, "✘ Please check your node & port settings and retry.\n"
+            ),
         };
         f.write_fmt(format_args!("{}", msg))
     }
@@ -60,12 +49,6 @@ impl From<std::io::Error> for AppError {
     }
 }
 
-impl From<std::option::NoneError> for AppError {
-    fn from(e: std::option::NoneError) -> AppError {
-        AppError::NoneError(e)
-    }
-}
-
 impl From<reqwest::Error> for AppError {
     fn from(e: reqwest::Error) -> AppError {
         AppError::ReqwestError(e)
@@ -83,3 +66,9 @@ impl From<log::SetLoggerError> for AppError {
         AppError::SetLoggerError(e)
     }
 }
+
+impl From<simplelog::TermLogError> for AppError {
+    fn from(e: simplelog::TermLogError) -> AppError {
+        AppError::TermLogError(e)
+    }
+}