feat: add cache sub commands and allow for proper transaction data logging

Cargo.toml

@@ -85,6 +85,8 @@ tracing-subscriber = "0.3.16"
 tracing-appender = "0.2.2"
 which = "4.4.0"
 wasmparser = "0.90.0"
+directories = "5.0.1"
+ulid = { version = "1.1" }
 termcolor = "1.1.3"
 termcolor_output = "1.0.1"
 ed25519-dalek = "2.0.0"

cmd/crates/soroban-test/Cargo.toml

@@ -41,6 +41,7 @@ serde_json = "1.0.93"
 which = { workspace = true }
 tokio = "1.28.1"
 walkdir = "2.4.0"
+ulid.workspace = true
 
 [features]
 it = []

cmd/crates/soroban-test/src/lib.rs

@@ -126,7 +126,8 @@ impl TestEnv {
             .env("SOROBAN_ACCOUNT", TEST_ACCOUNT)
             .env("SOROBAN_RPC_URL", &self.rpc_url)
             .env("SOROBAN_NETWORK_PASSPHRASE", LOCAL_NETWORK_PASSPHRASE)
-            .env("XDG_CONFIG_HOME", self.temp_dir.as_os_str())
+            .env("XDG_CONFIG_HOME", self.temp_dir.join("config").as_os_str())
+            .env("XDG_DATA_HOME", self.temp_dir.join("data").as_os_str())
             .current_dir(&self.temp_dir);
         cmd
     }
@@ -246,6 +247,7 @@ impl TestEnv {
                 verbose: false,
                 very_verbose: false,
                 list: false,
+                no_cache: false,
             }),
             Some(&config),
         )

cmd/crates/soroban-test/tests/it/integration/hello_world.rs

@@ -10,6 +10,7 @@ use crate::integration::util::extend_contract;
 
 use super::util::{deploy_hello, extend, HELLO_WORLD};
 
+#[allow(clippy::too_many_lines)]
 #[tokio::test]
 async fn invoke() {
     let sandbox = &TestEnv::new();
@@ -63,6 +64,12 @@ async fn invoke() {
     };
     let id = &deploy_hello(sandbox).await;
     extend_contract(sandbox, id).await;
+    let uid = sandbox
+        .new_assert_cmd("cache")
+        .arg("ls")
+        .assert()
+        .stdout_as_str();
+    ulid::Ulid::from_string(&uid).expect("invalid ulid");
     // Note that all functions tested here have no state
     invoke_hello_world(sandbox, id);
 

cmd/soroban-cli/Cargo.toml

@@ -95,6 +95,8 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] }
 cargo_metadata = "0.15.4"
 pathdiff = "0.2.1"
 dotenvy = "0.15.7"
+directories = { workspace = true }
+ulid = { workspace = true, features = ["serde"] }
 strum = "0.17.1"
 strum_macros = "0.17.1"
 gix = { version = "0.58.0", default-features = false, features = [

cmd/soroban-cli/src/commands/cache/clean.rs

@@ -0,0 +1,27 @@
+use std::fs;
+
+use super::super::config::locator;
+use crate::commands::config::data;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Config(#[from] locator::Error),
+    #[error(transparent)]
+    Data(#[from] data::Error),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+}
+
+#[derive(Debug, clap::Parser, Clone)]
+#[group(skip)]
+pub struct Cmd {}
+
+impl Cmd {
+    pub fn run(&self) -> Result<(), Error> {
+        let binding = data::project_dir()?;
+        let dir = binding.data_dir();
+        fs::remove_dir_all(dir)?;
+        Ok(())
+    }
+}

cmd/soroban-cli/src/commands/cache/info.rs

@@ -0,0 +1,21 @@
+use super::super::config::locator;
+use crate::commands::config::data;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Config(#[from] locator::Error),
+    #[error(transparent)]
+    Data(#[from] data::Error),
+}
+
+#[derive(Debug, clap::Parser, Clone)]
+#[group(skip)]
+pub struct Cmd {}
+
+impl Cmd {
+    pub fn run(&self) -> Result<(), Error> {
+        println!("{:?}", data::data_local_dir()?);
+        Ok(())
+    }
+}

cmd/soroban-cli/src/commands/cache/ls.rs

@@ -0,0 +1,44 @@
+use clap::command;
+
+use super::super::config::locator;
+use crate::commands::config::data;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Config(#[from] locator::Error),
+    #[error(transparent)]
+    Data(#[from] data::Error),
+}
+
+#[derive(Debug, clap::Parser, Clone)]
+#[group(skip)]
+pub struct Cmd {
+    #[command(flatten)]
+    pub config_locator: locator::Args,
+
+    #[arg(long, short = 'l')]
+    pub long: bool,
+}
+
+impl Cmd {
+    pub fn run(&self) -> Result<(), Error> {
+        let res = if self.long { self.ls_l() } else { self.ls() }?.join("\n");
+        println!("{res}");
+        Ok(())
+    }
+
+    pub fn ls(&self) -> Result<Vec<String>, Error> {
+        Ok(data::list_ulids()?
+            .iter()
+            .map(ToString::to_string)
+            .collect())
+    }
+
+    pub fn ls_l(&self) -> Result<Vec<String>, Error> {
+        Ok(data::list_actions()?
+            .iter()
+            .map(ToString::to_string)
+            .collect())
+    }
+}

cmd/soroban-cli/src/commands/cache/mod.rs

@@ -0,0 +1,42 @@
+use clap::Parser;
+
+pub mod clean;
+pub mod info;
+pub mod ls;
+pub mod read;
+
+#[derive(Debug, Parser)]
+pub enum Cmd {
+    /// List cached actions (transactions, simulations)
+    Ls(ls::Cmd),
+    /// Show location of cache
+    Info(info::Cmd),
+    /// Delete all cached actions
+    Clean(clean::Cmd),
+    /// Read cached action
+    Read(read::Cmd),
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Info(#[from] info::Error),
+    #[error(transparent)]
+    Ls(#[from] ls::Error),
+    #[error(transparent)]
+    Clean(#[from] clean::Error),
+    #[error(transparent)]
+    Read(#[from] read::Error),
+}
+
+impl Cmd {
+    pub fn run(&self) -> Result<(), Error> {
+        match self {
+            Cmd::Ls(cmd) => cmd.run()?,
+            Cmd::Info(cmd) => cmd.run()?,
+            Cmd::Clean(cmd) => cmd.run()?,
+            Cmd::Read(cmd) => cmd.run()?,
+        };
+        Ok(())
+    }
+}

cmd/soroban-cli/src/commands/cache/read.rs

@@ -0,0 +1,73 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use clap::ValueEnum;
+use ulid::Ulid;
+
+use super::super::config::locator;
+use crate::commands::config::data;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Config(#[from] locator::Error),
+    #[error(transparent)]
+    Data(#[from] data::Error),
+    #[error(transparent)]
+    Ulid(#[from] ulid::DecodeError),
+    #[error("failed to find cache entry {0}")]
+    NotFound(String),
+    #[error(transparent)]
+    SerdeJson(#[from] serde_json::Error),
+}
+
+#[derive(Debug, clap::Parser, Clone)]
+#[group(skip)]
+pub struct Cmd {
+    /// ULID of the cache entry
+    #[arg(long)]
+    pub id: String,
+    #[arg(long)]
+    pub output: Option<OutputType>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, ValueEnum, Default)]
+pub enum OutputType {
+    // Status,
+    #[default]
+    Envelope,
+    // ResultMeta,
+    // Result,
+}
+
+impl Cmd {
+    pub fn run(&self) -> Result<(), Error> {
+        let file = self.file()?;
+        tracing::debug!("reading file {}", file.display());
+        let (action, _) = data::read(&self.ulid()?)?;
+        let output = if self.output.is_some() {
+            match action {
+                data::Action::Transaction(sim) => sim.envelope_xdr.expect("missing envelope"),
+                data::Action::Simulation(_) => todo!("Only read transactions"),
+            }
+        } else {
+            serde_json::to_string_pretty(&action)?
+        };
+        println!("{output}");
+        Ok(())
+    }
+
+    pub fn file(&self) -> Result<PathBuf, Error> {
+        Ok(data::actions_dir()?.join(&self.id).with_extension("json"))
+    }
+
+    pub fn read_file(&self, file: &Path) -> Result<String, Error> {
+        fs::read_to_string(file).map_err(|_| Error::NotFound(self.id.clone()))
+    }
+
+    pub fn ulid(&self) -> Result<Ulid, Error> {
+        Ok(Ulid::from_string(&self.id)?)
+    }
+}