src:args:lib.rs:--block_raw --blocks_timestamp

Author: RandyMcMillan

src/args.rs

@@ -220,6 +220,7 @@ impl Args {
         opts.optopt("", "block_header", "block-header api call", "BLOCK_HEADER");
         opts.optopt("", "block_height", "block-height api call", "BLOCK_HEIGHT");
         opts.optopt("", "blocks_timestamp", "blocks-timestamp api call", "BLOCKS_TIMESTAMP");
+        opts.optopt("", "block_raw", "block-raw api call", "BLOCK_RAW");
 
         //OPTOPT
         opts.optopt("c", "config", "sets the configuration file", "CONFIG");
@@ -319,6 +320,11 @@ impl Args {
             generic_sys_call("blocks_timestamp", &blocks_timestamp.unwrap());
             std::process::exit(0);
         }
+        if matches.opt_present("block_raw") {
+            let block_raw = matches.opt_str("block_raw");
+            generic_sys_call("block_raw", &block_raw.unwrap());
+            std::process::exit(0);
+        }
 
         if matches.opt_present("h")
             || (matches.free.is_empty()

src/bin/mempool-space_block_raw.rs

@@ -4,13 +4,13 @@ use std::env;
 fn main() {
     {
         let args: Vec<String> = env::args().collect();
-        let mut address = &String::from("");
+        let mut block_hash = &String::from("");
         if args.len() > 1 {
-            address = &args[1];
+            block_hash = &args[1];
         } else {
             // silence is golden
             std::process::exit(0);
         }
-        let _res = blocking(&format!("/address/{}", &address));
+        let _res = blocking(&format!("/block/{}/raw", &block_hash));
     }
 }

src/lib.rs

@@ -19,18 +19,31 @@ const URL: &str = "https://mempool.space/api";
 
 ///  `pub fn blocking(api: &String) -> Result<&str>`
 pub fn blocking(api: &String) -> Result<&str> {
+    //print!("api={}", api);
     let call = format!("{}/{}", URL, api);
     let mut body = ureq::get(&call)
         .call()
         .expect("calls to blocking(api: &String) needs to include /v1/<api_endpoint> in some cases.")
         .into_reader();
     let mut buf = Vec::new();
     body.read_to_end(&mut buf).unwrap();
-    let text = match std::str::from_utf8(&buf) {
-        Ok(s) => s,
-        Err(_) => panic!("Invalid ASCII data"),
-    };
-    print!("{}", text);
+    if !api.ends_with("raw") {
+        //print!("!api.ends_with raw");
+        let text = match std::str::from_utf8(&buf) {
+            Ok(s) => s,
+            Err(_) => panic!("Invalid ASCII data"),
+        };
+        print!("{}", text);
+    } else {
+        if api.ends_with("raw") {
+            //print!("api.ends_with raw");
+            print!("{:?}", &buf);
+        }
+        if api.ends_with("something_else") {
+            //print!("api.ends_with something_else");
+            print!("{:?}", &buf);
+        }
+    }
     Ok(api)
 }
 
@@ -302,22 +315,26 @@ mod tests {
         // GET /api/block-height:height
         let binding = format!("block-height/615615").clone();
         let block_height: &str = blocking(&binding).expect("an existing block hash is needed");
-        let block_height= generic_sys_call(
-            "block_height",
-            "615615",
-        );
+        let block_height = generic_sys_call("block_height", "615615");
         wait("1");
     }
-    fn test_timestamp() {
+    fn test_blocks_timestamp() {
         // GET /api/v1/mining/blocks/timestamp/:timestamp
         let binding = format!("v1/mining/blocks/timestamp/1672531200").clone();
         let timestamp: &str = blocking(&binding).expect("an existing block hash is needed");
-        let timestamp= generic_sys_call(
-            "timestamp",
-            "1672531200",
-        );
+        let timestamp = generic_sys_call("blocks_timestamp", "1672531200");
         wait("1");
     }
+    fn test_block_raw() {
+        // GET /api/block/:hash/raw
+        let binding = format!("block/0000000000000000000065bda8f8a88f2e1e00d9a6887a43d640e52a4c7660f2").clone();
+        let block_raw: &str = blocking(&binding).expect("an existing block hash is needed");
+        let block_raw = generic_sys_call(
+            "block_raw",
+            "0000000000000000000065bda8f8a88f2e1e00d9a6887a43d640e52a4c7660f2",
+        );
+        wait("100");
+    }
 
     #[test]
     fn test_blockheight() {