xc-tool: Initial commit (#366)

Author: Stanisław Drozd

xc-tool/Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "pyth-xc-tool"
+authors = ["Pyth Network Contributors"]
+description = "The cross-chain priest for the Pyth oracle (it knows all the rituals)"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clap = {version = "4.0", features = ["derive", "cargo"]}
+shell-words = "1.1.0"

xc-tool/Cargo.toml

@@ -0,0 +1,41 @@
+use clap::{Parser, Subcommand, ValueEnum};
+
+#[derive(Parser)]
+#[clap(
+    about = "Pyth Tool - the admin swiss army knife",
+    author = "Pyth Network Contributors"
+)]
+pub struct Cli {
+    #[clap(subcommand)]
+    pub action: Action,
+    /// Mainnet/testnet
+    #[clap(default_value = "testnet")]
+    pub net: Net,
+}
+
+/// This struct helps reuse action parsing logic for interactive mode.
+#[derive(Parser)]
+#[clap(
+    about = "Pyth Tool - the admin swiss army knife",
+    author = "Pyth Network Contributors"
+)]
+pub struct CliInteractive {
+    #[clap(subcommand)]
+    pub action: Action,
+}
+
+#[derive(Subcommand, PartialEq)]
+pub enum Action {
+    #[clap(about = "Attempt sanity-check access for all known blockchains")]
+    PingAll,
+    #[clap(about = "Fires up a repl letting user directly perform all other actions")]
+    Interactive,
+}
+
+/// For most chains, we pick a production blockchain network and a
+/// testing one, closely following Wormhole's choices.
+#[derive(ValueEnum, Clone)]
+pub enum Net {
+    Mainnet,
+    Testnet,
+}

xc-tool/src/cli.rs

@@ -0,0 +1,72 @@
+mod cli;
+mod util;
+
+use clap::Parser;
+
+use std::io::{self, Write};
+
+use cli::{Action, Cli, CliInteractive};
+
+use util::ErrBox;
+
+pub const PROMPT: &'static str = concat!(env!("CARGO_PKG_NAME"), "> ");
+
+fn main() -> Result<(), ErrBox> {
+    let cli = Cli::parse();
+
+    // Handle interactive mode separately
+    if cli.action == Action::Interactive {
+        start_cli_interactive(cli)?;
+    } else {
+        handle_action_noninteractive(&cli)?;
+    }
+    Ok(())
+}
+
+pub fn start_cli_interactive(mut cli: Cli) -> Result<(), ErrBox> {
+    let stdin = io::stdin();
+    loop {
+        print!("{}", PROMPT);
+        io::stdout().flush()?;
+        let mut ln = String::new();
+        stdin.read_line(&mut ln)?;
+
+        if ln.trim().is_empty() {
+            continue;
+        }
+
+        match shell_words::split(&ln)
+            .map_err(|e| -> ErrBox { e.into() })
+            .and_then(|mut shell_split| {
+                // Trick clap into thinking there's a binary name
+                let mut with_name = vec!["".to_owned()];
+                with_name.append(&mut shell_split);
+                Ok(CliInteractive::try_parse_from(with_name)?)
+            })
+            .and_then(|cmd| {
+                // We just swap out the action, preserving the top-level arguments
+                cli.action = cmd.action;
+                Ok(handle_action_noninteractive(&cli)?)
+            }) {
+            Err(e) => {
+                println!("Could not understand that! Error:\n{}", e.to_string());
+            }
+            Ok(()) => {}
+        };
+    }
+}
+
+/// The following code is reused by interactive mode. Interactive mode
+/// is assumed to already be detected at top-level in main, making it an invalid action.
+pub fn handle_action_noninteractive(cli: &Cli) -> Result<(), ErrBox> {
+    match &cli.action {
+        // It makes no sense starting interactive already inside it
+        Action::Interactive => {
+            return Err(format!("Bruh...?").into());
+        }
+        Action::PingAll => {
+            println!("Pinging all blockchains...");
+        }
+    }
+    Ok(())
+}

xc-tool/src/main.rs

@@ -0,0 +1 @@
+pub type ErrBox = Box<dyn std::error::Error>;