explorer command (#94)

* explorer command explorer get -k <address> explorer get <label> * match cluster with cli config * newlines * /address
clockwork-xyz · Nov 23, 2022 · 01374c2 · 01374c2
1 parent f775cf8
commit 01374c2
Show file tree

Hide file tree

Showing 11 changed files with 159 additions and 5 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/cli/src/cli.rs b/cli/src/cli.rs
@@ -41,6 +41,11 @@ pub enum CliCommand {
         worker_id: u64,
     },
 
+    ExplorerGetThread {
+        id: Option<String>,
+        address: Option<Pubkey>,
+    },
+
     Initialize {
         mint: Pubkey,
     },
@@ -228,6 +233,31 @@ pub fn app() -> Command<'static> {
                         ),
                 ),
         )
+        .subcommand(
+            Command::new("explorer")
+                .about("Prints Explorer Urls")
+                .arg_required_else_help(true)
+                .subcommand(
+                    Command::new("get")
+                        .about("Prints thread explorer url")
+                        .arg_required_else_help(true)
+                        .arg(
+                            Arg::new("id")
+                                .index(1)
+                                .takes_value(true)
+                                .required(false)
+                                .help("The label of the thread to lookup (only works if you \
+                                are the signer of that thread)")
+                        )
+                        .arg(
+                            Arg::new("address")
+                                .short('k')
+                                .long("address")
+                                .takes_value(true)
+                                .help("The address of the thread to lookup"),
+                        ),
+                )
+        )
         .subcommand(
             Command::new("initialize")
                 .about("Initialize the Clockwork network program")
@@ -374,7 +404,8 @@ pub fn app() -> Command<'static> {
                             .index(1)
                             .takes_value(true)
                             .required(false)
-                            .help("The label of the thread to lookup")
+                            .help("The label of the thread to lookup (only works if you \
+                                are the signer of that thread)")
                         )
                         .arg(
                             Arg::new("address")

diff --git a/cli/src/parser.rs b/cli/src/parser.rs
@@ -21,6 +21,7 @@ impl TryFrom<&ArgMatches> for CliCommand {
             Some(("config", matches)) => parse_config_command(matches),
             Some(("crontab", matches)) => parse_crontab_command(matches),
             Some(("delegation", matches)) => parse_delegation_command(matches),
+            Some(("explorer", matches)) => parse_explorer_command(matches),
             Some(("initialize", matches)) => parse_initialize_command(matches),
             Some(("localnet", matches)) => parse_bpf_command(matches),
             Some(("pool", matches)) => parse_pool_command(matches),
@@ -123,6 +124,18 @@ fn parse_delegation_command(matches: &ArgMatches) -> Result<CliCommand, CliError
     }
 }
 
+fn parse_explorer_command(matches: &ArgMatches) -> Result<CliCommand, CliError> {
+    match matches.subcommand() {
+        Some(("get", matches)) => Ok(CliCommand::ExplorerGetThread {
+            id: parse_string("id", matches).ok(),
+            address: parse_pubkey("address", matches).ok(),
+        }),
+        _ => Err(CliError::CommandNotRecognized(
+            matches.subcommand().unwrap().0.into(),
+        )),
+    }
+}
+
 fn parse_initialize_command(matches: &ArgMatches) -> Result<CliCommand, CliError> {
     Ok(CliCommand::Initialize {
         mint: parse_pubkey("mint", matches)?,

diff --git a/cli/src/processor/explorer.rs b/cli/src/processor/explorer.rs
@@ -0,0 +1,17 @@
+use {
+    crate::errors::CliError,
+    crate::config::CliConfig,
+    clockwork_utils::explorer::Explorer,
+
+};
+
+pub fn thread_url<T: std::fmt::Display>(thread: T, config: CliConfig) -> Result<(),
+    CliError> {
+    println!("thread: {}", explorer(config).thread_url(thread,
+                                                 clockwork_client::thread::ID));
+    Ok(())
+}
+
+fn explorer(config: CliConfig) -> Explorer {
+   Explorer::from(config.json_rpc_url)
+}
diff --git a/cli/src/processor/mod.rs b/cli/src/processor/mod.rs
@@ -3,6 +3,7 @@ mod config;
 mod crontab;
 mod delegation;
 mod initialize;
+mod explorer;
 mod localnet;
 mod pool;
 mod process;

diff --git a/cli/src/processor/process.rs b/cli/src/processor/process.rs
@@ -24,9 +24,9 @@ pub fn process(matches: &ArgMatches) -> Result<(), CliError> {
 
     // Build the RPC client
     let payer = read_keypair_file(&config.keypair_path)
-        .map_err(|_| CliError::KeypairNotFound(config.keypair_path))?;
+        .map_err(|_| CliError::KeypairNotFound(config.keypair_path.clone()))?;
 
-    let client = Client::new(payer, config.json_rpc_url);
+    let client = Client::new(payer, config.json_rpc_url.clone());
 
     // Process the command
     match command {
@@ -51,6 +51,10 @@ pub fn process(matches: &ArgMatches) -> Result<(), CliError> {
             delegation_id,
             worker_id,
         } => super::delegation::get(&client, delegation_id, worker_id),
+        CliCommand::ExplorerGetThread { id, address } => {
+            let pubkey = parse_pubkey_from_id_or_address(client.payer_pubkey(), id, address)?;
+            super::explorer::thread_url(pubkey, config)
+        }
         CliCommand::Initialize { mint } => super::initialize::initialize(&client, mint),
         CliCommand::Localnet { program_infos } => super::localnet::start(&client, program_infos),
         CliCommand::PoolGet { id } => super::pool::get(&client, id),

diff --git a/sdk/Cargo.toml b/sdk/Cargo.toml
@@ -15,6 +15,7 @@ name = "clockwork_sdk"
 
 [dependencies]
 chrono = { version = "0.4.19", default-features = false, features = ["alloc"] }
+clockwork-utils = { path = "../utils", version = "1.3.8", optional = true }
 clockwork-client = { path = "../client", version = "1.3.8", optional = true }
 clockwork-thread-program = { path = "../programs/thread", features = ["cpi"], version = "1.3.8" }
 nom = "~7"
@@ -23,4 +24,5 @@ once_cell = "1.5.2"
 [features]
 default = []
 client = ["clockwork-client"]
-thread = []
+utils = ["clockwork-utils"]
+thread = []
diff --git a/sdk/src/lib.rs b/sdk/src/lib.rs
@@ -21,3 +21,8 @@ pub mod thread_program {
         };
     }
 }
+
+#[cfg(feature = "utils")]
+pub mod utils {
+    pub use clockwork_utils::{explorer};
+}
diff --git a/utils/Cargo.toml b/utils/Cargo.toml
@@ -15,6 +15,6 @@ name = "clockwork_utils"
 
 [dependencies]
 anchor-lang = "0.25.0"
-base64 = "0.13.1"
+base64 = "~0.13"
 static-pubkey = "1.0.3"
 
diff --git a/utils/src/explorer.rs b/utils/src/explorer.rs
@@ -0,0 +1,78 @@
+const EXPLORER_URL: &str = "https://explorer.solana.com";
+const CK_EXPLORER_URL: &str = "https://explorer.clockwork.xyz";
+
+
+#[derive(Default)]
+pub struct Explorer {
+    cluster: String,
+    custom_rpc: Option<String>,
+}
+
+impl From<String> for Explorer {
+    fn from(json_rpc_url: String) -> Self {
+        match &json_rpc_url.to_lowercase() {
+            url if url.contains("devnet") => Explorer::devnet(),
+            url if url.contains("testnet") => Explorer::testnet(),
+            url if url.contains("mainnet") => Explorer::mainnet(),
+            _ => {
+                Explorer::custom(json_rpc_url)
+            }
+        }
+    }
+}
+
+impl Explorer {
+    pub fn mainnet() -> Self {
+        Self {
+            cluster: "mainnet-beta".into(),
+            ..Default::default()
+        }
+    }
+
+    pub fn testnet() -> Self {
+        Self {
+            cluster: "testnet".into(),
+            ..Default::default()
+        }
+    }
+
+    pub fn devnet() -> Self {
+        Self {
+            cluster: "devnet".into(),
+            ..Default::default()
+        }
+    }
+
+    pub fn custom(custom_rpc: String) -> Self {
+        Self {
+            cluster: "custom".into(),
+            custom_rpc: Some(custom_rpc),
+        }
+    }
+
+    /// Ex: https://explorer.solana.com/tx/{tx}
+    ///     ?cluster=custom
+    ///     &customUrl=http://localhost:8899
+    pub fn tx_url<T: std::fmt::Display>(&self, tx: T) -> String {
+        let url = format!("{}/tx/{}?cluster={}", EXPLORER_URL, tx, self.cluster);
+        if self.cluster == "custom" {
+            url + "&customUrl=" + self.custom_rpc.as_ref().unwrap()
+        } else {
+            url
+        }
+    }
+
+    /// Ex: https://explorer.clockwork.xyz/thread/{thread}
+    ///     ?network=custom
+    ///     &customRPC=http://localhost:8899
+    pub fn thread_url<T: std::fmt::Display, U: std::fmt::Display>(&self, thread: T, program_id: U) -> String {
+        let url = format!("{}/address/{}?programID={}&network={}", CK_EXPLORER_URL,
+                          thread, program_id, self
+            .cluster);
+        if self.cluster == "custom" {
+            url + "&customRPC=" + self.custom_rpc.as_ref().unwrap()
+        } else {
+            url
+        }
+    }
+}
diff --git a/utils/src/lib.rs b/utils/src/lib.rs
@@ -1,3 +1,5 @@
+pub mod explorer;
+
 use {
     anchor_lang::{
         prelude::borsh::BorshSchema,