#![warn(missing_docs)]
pub mod cli;
pub mod command;
use std::{
fmt,
fmt::Debug,
marker::PhantomData,
str::FromStr,
};
use codec::{Encode, Decode};
use tc_client_api::BlockBackend;
use tp_blockchain::HeaderBackend;
use tet_core::hexdisplay::HexDisplay;
use tp_runtime::{
generic::BlockId,
traits::{Block, HashFor, NumberFor, Hash}
};
pub type BlockAddressFor<TBlock> = BlockAddress<
<HashFor<TBlock> as Hash>::Output,
NumberFor<TBlock>
>;
pub trait PrettyPrinter<TBlock: Block> {
fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result;
fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result;
}
#[derive(Default)]
pub struct DebugPrinter;
impl<TBlock: Block> PrettyPrinter<TBlock> for DebugPrinter {
fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result {
writeln!(fmt, "Header:")?;
writeln!(fmt, "{:?}", block.header())?;
writeln!(fmt, "Block bytes: {:?}", HexDisplay::from(&block.encode()))?;
writeln!(fmt, "Extrinsics ({})", block.extrinsics().len())?;
for (idx, ex) in block.extrinsics().iter().enumerate() {
writeln!(fmt, "- {}:", idx)?;
<DebugPrinter as PrettyPrinter<TBlock>>::fmt_extrinsic(self, fmt, ex)?;
}
Ok(())
}
fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic) -> fmt::Result {
writeln!(fmt, " {:?}", extrinsic)?;
writeln!(fmt, " Bytes: {:?}", HexDisplay::from(&extrinsic.encode()))?;
Ok(())
}
}
#[derive(Debug, derive_more::From, derive_more::Display)]
pub enum Error {
Codec(codec::Error),
Blockchain(tp_blockchain::Error),
NotFound(String),
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match *self {
Self::Codec(ref e) => Some(e),
Self::Blockchain(ref e) => Some(e),
Self::NotFound(_) => None,
}
}
}
pub trait ChainAccess<TBlock: Block>:
HeaderBackend<TBlock> +
BlockBackend<TBlock>
{}
impl<T, TBlock> ChainAccess<TBlock> for T where
TBlock: Block,
T: tp_blockchain::HeaderBackend<TBlock> + tc_client_api::BlockBackend<TBlock>,
{}
pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrinter> {
printer: TPrinter,
chain: Box<dyn ChainAccess<TBlock>>,
_block: PhantomData<TBlock>,
}
impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter> {
pub fn new(
chain: impl ChainAccess<TBlock> + 'static,
) -> Self where TPrinter: Default {
Self::with_printer(chain, Default::default())
}
pub fn with_printer(
chain: impl ChainAccess<TBlock> + 'static,
printer: TPrinter,
) -> Self {
Inspector {
chain: Box::new(chain) as _,
printer,
_block: Default::default(),
}
}
pub fn block(&self, input: BlockAddressFor<TBlock>) -> Result<String, Error> {
struct BlockPrinter<'a, A, B>(A, &'a B);
impl<'a, A: Block, B: PrettyPrinter<A>> fmt::Display for BlockPrinter<'a, A, B> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
self.1.fmt_block(fmt, &self.0)
}
}
let block = self.get_block(input)?;
Ok(format!("{}", BlockPrinter(block, &self.printer)))
}
fn get_block(&self, input: BlockAddressFor<TBlock>) -> Result<TBlock, Error> {
Ok(match input {
BlockAddress::Bytes(bytes) => {
TBlock::decode(&mut &*bytes)?
},
BlockAddress::Number(number) => {
let id = BlockId::number(number);
let not_found = format!("Could not find block {:?}", id);
let body = self.chain.block_body(&id)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
let header = self.chain.header(id)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
TBlock::new(header, body)
},
BlockAddress::Hash(hash) => {
let id = BlockId::hash(hash);
let not_found = format!("Could not find block {:?}", id);
let body = self.chain.block_body(&id)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
let header = self.chain.header(id)?
.ok_or_else(|| Error::NotFound(not_found.clone()))?;
TBlock::new(header, body)
},
})
}
pub fn extrinsic(
&self,
input: ExtrinsicAddress<<HashFor<TBlock> as Hash>::Output, NumberFor<TBlock>>,
) -> Result<String, Error> {
struct ExtrinsicPrinter<'a, A: Block, B>(A::Extrinsic, &'a B);
impl<'a, A: Block, B: PrettyPrinter<A>> fmt::Display for ExtrinsicPrinter<'a, A, B> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
self.1.fmt_extrinsic(fmt, &self.0)
}
}
let ext = match input {
ExtrinsicAddress::Block(block, index) => {
let block = self.get_block(block)?;
block.extrinsics()
.get(index)
.cloned()
.ok_or_else(|| Error::NotFound(format!(
"Could not find extrinsic {} in block {:?}", index, block
)))?
},
ExtrinsicAddress::Bytes(bytes) => {
TBlock::Extrinsic::decode(&mut &*bytes)?
}
};
Ok(format!("{}", ExtrinsicPrinter(ext, &self.printer)))
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum BlockAddress<Hash, Number> {
Hash(Hash),
Number(Number),
Bytes(Vec<u8>),
}
impl<Hash: FromStr, Number: FromStr> FromStr for BlockAddress<Hash, Number> {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if let Ok(hash) = s.parse() {
return Ok(Self::Hash(hash))
}
if let Ok(number) = s.parse() {
return Ok(Self::Number(number))
}
tet_core::bytes::from_hex(s)
.map(Self::Bytes)
.map_err(|e| format!(
"Given string does not look like hash or number. It could not be parsed as bytes either: {}",
e
))
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum ExtrinsicAddress<Hash, Number> {
Block(BlockAddress<Hash, Number>, usize),
Bytes(Vec<u8>),
}
impl<Hash: FromStr + Debug, Number: FromStr + Debug> FromStr for ExtrinsicAddress<Hash, Number> {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if let Ok(bytes) = tet_core::bytes::from_hex(s).map(Self::Bytes) {
return Ok(bytes)
}
let mut it = s.split(|c| c == '.' || c == ':' || c == ' ');
let block = it.next()
.expect("First element of split iterator is never empty; qed")
.parse()?;
let index = it.next()
.ok_or_else(|| format!("Extrinsic index missing: example \"5:0\""))?
.parse()
.map_err(|e| format!("Invalid index format: {}", e))?;
Ok(Self::Block(block, index))
}
}
#[cfg(test)]
mod tests {
use super::*;
use tet_core::hash::H160 as Hash;
#[test]
fn should_parse_block_strings() {
type BlockAddress = super::BlockAddress<Hash, u64>;
let b0 = BlockAddress::from_str("3BfC20f0B9aFcAcE800D73D2191166FF16540258");
let b1 = BlockAddress::from_str("1234");
let b2 = BlockAddress::from_str("0");
let b3 = BlockAddress::from_str("0x0012345f");
assert_eq!(b0, Ok(BlockAddress::Hash(
"3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()
)));
assert_eq!(b1, Ok(BlockAddress::Number(1234)));
assert_eq!(b2, Ok(BlockAddress::Number(0)));
assert_eq!(b3, Ok(BlockAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
}
#[test]
fn should_parse_extrinsic_address() {
type BlockAddress = super::BlockAddress<Hash, u64>;
type ExtrinsicAddress = super::ExtrinsicAddress<Hash, u64>;
let e0 = ExtrinsicAddress::from_str("1234");
let b0 = ExtrinsicAddress::from_str("3BfC20f0B9aFcAcE800D73D2191166FF16540258:5");
let b1 = ExtrinsicAddress::from_str("1234:0");
let b2 = ExtrinsicAddress::from_str("0 0");
let b3 = ExtrinsicAddress::from_str("0x0012345f");
assert_eq!(e0, Err("Extrinsic index missing: example \"5:0\"".into()));
assert_eq!(b0, Ok(ExtrinsicAddress::Block(
BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
5
)));
assert_eq!(b1, Ok(ExtrinsicAddress::Block(
BlockAddress::Number(1234),
0
)));
assert_eq!(b2, Ok(ExtrinsicAddress::Block(
BlockAddress::Number(0),
0
)));
assert_eq!(b3, Ok(ExtrinsicAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
}
}