add decode-tx and decode-block

Author: jcnelson

src/blockstack_cli.rs

@@ -24,13 +24,13 @@ extern crate blockstack_lib;
 use blockstack_lib::address::AddressHashMode;
 use blockstack_lib::burnchains::Address;
 use blockstack_lib::chainstate::stacks::{
-    StacksAddress, StacksPrivateKey, StacksPublicKey, StacksTransaction, StacksTransactionSigner,
+    StacksAddress, StacksBlock, StacksPrivateKey, StacksPublicKey, StacksTransaction, StacksTransactionSigner,
     TokenTransferMemo, TransactionAuth, TransactionContractCall, TransactionPayload,
     TransactionSmartContract, TransactionSpendingCondition, TransactionVersion,
     C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use blockstack_lib::net::{Error as NetError, StacksMessageCodec};
-use blockstack_lib::util::{hash::hex_bytes, hash::to_hex, log, strings::StacksString};
+use blockstack_lib::util::{hash::hex_bytes, hash::to_hex, log, strings::StacksString, retry::LogReader};
 use blockstack_lib::vm;
 use blockstack_lib::vm::{
     errors::{Error as ClarityError, RuntimeErrorType},
@@ -116,6 +116,18 @@ The addresses command calculates both the Bitcoin and Stacks addresses from a se
 If successful, this command outputs both the Bitcoin and Stacks addresses to stdout, formatted
 as JSON, and exits with code 0";
 
+const DECODE_TRANSACTION_USAGE: &str = "blockstack-cli (options) decode-tx [transaction-hex-or-stdin]
+
+The decode-tx command decodes a serialized Stacks transaction and prints it to stdout as JSON.
+The transaction, if given, must be a hex string.  Alternatively, you may pass - instead, and the
+raw binary transaction will be read from stdin";
+
+const DECODE_BLOCK_USAGE: &str = "blockstack-cli (options) decode-block [block-path-or-stdin]
+
+The decode-tx command decodes a serialized Stacks block and prints it to stdout as JSON.
+The block, if given, must be a hex string.  Alternatively, you may pass - instead, and the
+raw binary block will be read from stdin";
+
 #[derive(Debug)]
 enum CliError {
     ClarityRuntimeError(RuntimeErrorType),
@@ -518,6 +530,81 @@ fn get_addresses(args: &[String], version: TransactionVersion) -> Result<String,
     ))
 }
 
+fn decode_transaction(args: &[String], _version: TransactionVersion) -> Result<String, CliError> {
+    if (args.len() >= 1 && args[0] == "-h") || args.len() != 1 {
+        return Err(CliError::Message(format!("Usage: {}\n", DECODE_TRANSACTION_USAGE)));
+    }
+
+    let tx_str =
+        if args[0] == "-" {
+            // read from stdin
+            let mut tx_str = Vec::new();
+            io::stdin().read_to_end(&mut tx_str).expect("Failed to read transaction from stdin");
+            tx_str
+        }
+        else {
+            // given as a command-line arg
+            hex_bytes(&args[0].clone())
+                .expect("Failed to decode transaction: must be a hex string")
+        };
+
+    let mut cursor = io::Cursor::new(&tx_str);
+    let mut debug_cursor = LogReader::from_reader(&mut cursor);
+
+    match StacksTransaction::consensus_deserialize(&mut debug_cursor) {
+        Ok(tx) => {
+            Ok(serde_json::to_string(&tx).expect("Failed to serialize transaction to JSON"))
+        },
+        Err(e) => {
+            let mut ret = String::new();
+            ret.push_str(&format!("Failed to decode transaction: {:?}\n", &e));
+            ret.push_str("Bytes consumed:\n");
+            for buf in debug_cursor.log().iter() {
+                ret.push_str(&format!("   {}", to_hex(buf)));
+            }
+            ret.push_str("\n");
+            Ok(ret)
+        }
+    }
+}
+
+fn decode_block(args: &[String], _version: TransactionVersion) -> Result<String, CliError> {
+    if (args.len() >= 1 && args[0] == "-h") || args.len() != 1 {
+        return Err(CliError::Message(format!("Usage: {}\n", DECODE_BLOCK_USAGE)));
+    }
+    let block_data =
+        if args[0] == "-" {
+            // read from stdin
+            let mut block_str = Vec::new();
+            io::stdin().read_to_end(&mut block_str).expect("Failed to read block from stdin");
+            block_str
+        }
+        else {
+            // given as a command-line arg
+            hex_bytes(&args[0].clone())
+                .expect("Failed to decode block: must be a hex string")
+        };
+
+    let mut cursor = io::Cursor::new(&block_data);
+    let mut debug_cursor = LogReader::from_reader(&mut cursor);
+
+    match StacksBlock::consensus_deserialize(&mut debug_cursor) {
+        Ok(block) => {
+            Ok(serde_json::to_string(&block).expect("Failed to serialize block to JSON"))
+        },
+        Err(e) => {
+            let mut ret = String::new();
+            ret.push_str(&format!("Failed to decode block: {:?}\n", &e));
+            ret.push_str("Bytes consumed:\n");
+            for buf in debug_cursor.log().iter() {
+                ret.push_str(&format!("   {}", to_hex(buf)));
+            }
+            ret.push_str("\n");
+            Ok(ret)
+        }
+    }
+}
+
 fn main() {
     log::set_loglevel(log::LOG_DEBUG).unwrap();
     let mut argv: Vec<String> = env::args().collect();
@@ -556,6 +643,8 @@ fn main_handler(mut argv: Vec<String>) -> Result<String, CliError> {
             "token-transfer" => handle_token_transfer(args, tx_version, chain_id),
             "generate-sk" => generate_secret_key(args, tx_version),
             "addresses" => get_addresses(args, tx_version),
+            "decode-tx" => decode_transaction(args, tx_version),
+            "decode-block" => decode_block(args, tx_version),
             _ => Err(CliError::Usage),
         }
     } else {
@@ -830,4 +919,26 @@ mod test {
         assert!(result.contains("mzGHS7KN25DEtXipGxjo1tFebb7Fw5aAkp"));
         assert!(result.contains("ST36T883PDD2EK4PHVTA5GFHC8NQW6558XJQX6Q3K"));
     }
+
+    #[test]
+    fn simple_decode_tx() {
+        let tx_args = [
+            "decode-tx",
+            "8080000000040021a3c334fc0ee50359353799e8b2605ac6be1fe4000000000000000100000000000000000100c90ae0235365f3a73c595f8c6ab3c529807feb3cb269247329c9a24218d50d3f34c7eef5d28ba26831affa652a73ec32f098fec4bf1decd1ceb3fde4b8ce216b030200000000021a21a3c334fc0ee50359353799e8b2605ac6be1fe40573746f7265096765742d76616c7565000000010d00000003666f6f"
+        ];
+
+        let result = main_handler(to_string_vec(&tx_args)).unwrap();
+        eprintln!("result:\n{}", result);
+    }
+
+    #[test]
+    fn simple_decode_block() {
+        let block_args = [
+            "decode-block",
+            "000000000000395f800000000000000179cb51f6bbd6d90cb257616e77a495919667c3772dd08ea7c4f5c372739490bc91da6609c5c95c96f612dbc8cab2f7a0d8bfb83abdb630167579ccc36b66c03c1d0d250cd3b3615c03afcdaef313dbd30d3d5b0fd10ed5acbc35d042abfba66cdfc32881c5a665ad9685a2eb6e0c131fb400000000000000000000000000000000000000000000000000000000000000000000e87f28593f66d77ae3c57abd4e5ae0e632b837b2596be14c2b2572cd4d0015229976eb5c4a5b08816b31f485513d2e6501f6cd29ee240a2c4056b1f7cc32c2e118ef6499e0fcc575da75fca8cc409e5c884eb3450000000180800000000400403e2ff80a8a8ecacfb827dcf6adddd21fdd4c3c000000000000017800000000000000000000f3f497268f8a12e318f96ba4f1ad3ed2485e87cefe75b88bf735bb1bbb7db754746e6a244ba869183a2ab73002c6465936b7d9b059ffc5a94488bee7b5afb33c010200000000040000000000000000000000000000000000000000000000000000000000000000",
+        ];
+
+        let result = main_handler(to_string_vec(&block_args)).unwrap();
+        eprintln!("result:\n{}", result);
+    }
 }