ethl-cli 0.1.31

Tools for capturing, processing, archiving, and replaying Ethereum events
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use anyhow::Result;
use clap::Parser;
use ethl_cli::commands::{
    Commands, ProviderArgs, cat::run_cat_command, extract::extract_events,
    merge::run_merge_command, repair::run_repair_command,
};
use tracing::debug;

#[derive(Debug, Parser)]
#[command(name = "ethlogs")]
#[command(version)]
#[command(about = "Ethereum event stream utilitites", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Enable verbose logging
    #[arg(short, long, global = true)]
    verbose: bool,

    /// Common provider configuration for all commands
    #[command(flatten)]
    provider_args: ProviderArgs,
}

fn setup_logging(verbose: bool) -> Result<()> {
    let mut filter = tracing_subscriber::EnvFilter::from_default_env()
        .add_directive(tracing::Level::INFO.into());

    if verbose {
        filter = filter
            .add_directive("ethl=debug".parse()?)
            .add_directive("ethl_cli=debug".parse()?);
    }

    tracing_subscriber::fmt().with_env_filter(filter).init();

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    dotenvy::dotenv().ok();
    let args = Cli::parse();
    setup_logging(args.verbose)?;

    let providers = args.provider_args.try_into()?;
    debug!("Using providers: {:?}", providers);

    match args.command {
        Commands::Extract(args) => {
            extract_events(&providers, args).await?;
        }
        Commands::Cat(args) => {
            run_cat_command(&providers, args).await?;
        }
        Commands::Merge(args) => {
            run_merge_command(args).await?;
        }
        Commands::Repair(args) => {
            run_repair_command(args).await?;
        }
    }

    Ok(())
}