Merge branch 'main' into remap-path

.github/workflows/binaries.yml

@@ -27,8 +27,6 @@ jobs:
         crate:
           - name: stellar-cli
             binary: stellar
-          - name: soroban-cli
-            binary: soroban
         sys:
           - os: ubuntu-20.04 # Use 20.04 to get an older version of glibc for increased compat
             target: x86_64-unknown-linux-gnu

Cargo.toml

@@ -6,9 +6,10 @@ members = [
     "cmd/crates/*",
     "cmd/crates/soroban-test/tests/fixtures/test-wasms/*",
     "cmd/crates/soroban-test/tests/fixtures/hello",
+    "cmd/crates/soroban-test/tests/fixtures/bye",
 ]
 default-members = ["cmd/soroban-cli", "cmd/crates/soroban-spec-tools", "cmd/crates/soroban-test"]
-exclude = ["cmd/crates/soroban-test/tests/fixtures/hello"]
+exclude = ["cmd/crates/soroban-test/tests/fixtures/hello", "cmd/crates/soroban-test/tests/fixtures/bye"]
 
 [workspace.package]
 version = "21.5.0"

FULL_HELP_DOCS.md

@@ -1517,7 +1517,7 @@ Creates and funds a new account with the specified starting balance
 * `--destination <DESTINATION>` — Account Id to create, e.g. `GBX...`
 * `--starting-balance <STARTING_BALANCE>` — Initial balance in stroops of the account, default 1 XLM
 
-  Default value: `10_000_000`
+  Default value: `10000000`
 
 
 

Makefile

@@ -31,6 +31,7 @@ install_rust: install
 install:
 	cargo install --force --locked --path ./cmd/stellar-cli --debug
 	cargo install --force --locked --path ./cmd/crates/soroban-test/tests/fixtures/hello --root ./target --debug --quiet
+	cargo install --force --locked --path ./cmd/crates/soroban-test/tests/fixtures/bye --root ./target --debug --quiet
 
 # regenerate the example lib in `cmd/crates/soroban-spec-typsecript/fixtures/ts`
 build-snapshot: typescript-bindings-fixtures

cmd/crates/soroban-test/tests/fixtures/bye/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "stellar-bye"
+version = "21.5.0"
+edition = "2021"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

cmd/crates/soroban-test/tests/fixtures/bye/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Bye, world!");
+}

cmd/crates/soroban-test/tests/it/config.rs

@@ -1,4 +1,5 @@
 use assert_fs::TempDir;
+use predicates::prelude::predicate;
 use soroban_test::{AssertExt, TestEnv};
 use std::{fs, path::Path};
 
@@ -288,3 +289,54 @@ fn use_env() {
         .success()
         .stdout("SDIY6AQQ75WMD4W46EYB7O6UYMHOCGQHLAQGQTKHDX4J2DYQCHVCQYFD\n");
 }
+
+#[test]
+fn config_dirs_precedence() {
+    let sandbox = TestEnv::default();
+
+    sandbox
+        .new_assert_cmd("keys")
+        .env(
+            "SOROBAN_SECRET_KEY",
+            "SC4ZPYELVR7S7EE7KZDZN3ETFTNQHHLTUL34NUAAWZG5OK2RGJ4V2U3Z",
+        )
+        .arg("add")
+        .arg("alice")
+        .assert()
+        .success();
+
+    fs::rename(
+        sandbox.dir().join(".stellar"),
+        sandbox.dir().join("_soroban"),
+    )
+    .unwrap();
+
+    sandbox
+        .new_assert_cmd("keys")
+        .env(
+            "SOROBAN_SECRET_KEY",
+            "SAQMV6P3OWM2SKCK3OEWNXSRYWK5RNNUL5CPHQGIJF2WVT4EI2BZ63GG",
+        )
+        .arg("add")
+        .arg("alice")
+        .assert()
+        .success();
+
+    fs::rename(
+        sandbox.dir().join("_soroban"),
+        sandbox.dir().join(".soroban"),
+    )
+    .unwrap();
+
+    sandbox
+        .new_assert_cmd("keys")
+        .arg("show")
+        .arg("alice")
+        .arg("--verbose")
+        .assert()
+        .success()
+        .stderr(predicate::str::contains(
+            "WARN soroban_cli::utils: the .stellar and .soroban config directories exist at path",
+        ))
+        .stdout("SAQMV6P3OWM2SKCK3OEWNXSRYWK5RNNUL5CPHQGIJF2WVT4EI2BZ63GG\n");
+}

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

@@ -74,7 +74,7 @@ async fn invoke() {
         .assert()
         .stdout_as_str();
     let dir = sandbox.dir();
-    let seed_phrase = std::fs::read_to_string(dir.join(".soroban/identity/test.toml")).unwrap();
+    let seed_phrase = std::fs::read_to_string(dir.join(".stellar/identity/test.toml")).unwrap();
     let s = toml::from_str::<secret::Secret>(&seed_phrase).unwrap();
     let secret::Secret::SeedPhrase { seed_phrase } = s else {
         panic!("Expected seed phrase")
@@ -113,7 +113,7 @@ async fn invoke() {
             },
         )
         .unwrap();
-    let sk_from_file = std::fs::read_to_string(dir.join(".soroban/identity/testone.toml")).unwrap();
+    let sk_from_file = std::fs::read_to_string(dir.join(".stellar/identity/testone.toml")).unwrap();
 
     assert_eq!(sk_from_file, format!("secret_key = \"{secret_key_1}\"\n"));
     let secret_key_1_readin = sandbox

cmd/crates/soroban-test/tests/it/plugin.rs

@@ -1,7 +1,7 @@
 /*
-This function calls the soroban executable via cargo and checks that the output
+This function calls the stellar executable via cargo and checks that the output
 is correct. The PATH environment variable is set to include the target/bin
-directory, so that the soroban executable can be found.
+directory, so that the stellar executable can be found.
 */
 
 use std::{ffi::OsString, path::PathBuf};
@@ -11,31 +11,45 @@ fn soroban_hello() {
     // Add the target/bin directory to the iterator of paths
     let paths = get_paths();
     // Call soroban with the PATH variable set to include the target/bin directory
-    assert_cmd::Command::cargo_bin("soroban")
+    assert_cmd::Command::cargo_bin("stellar")
         .unwrap_or_else(|_| assert_cmd::Command::new("soroban"))
         .arg("hello")
         .env("PATH", &paths)
         .assert()
         .stdout("Hello, world!\n");
 }
 
+#[test]
+fn stellar_bye() {
+    // Add the target/bin directory to the iterator of paths
+    let paths = get_paths();
+    // Call soroban with the PATH variable set to include the target/bin directory
+    assert_cmd::Command::cargo_bin("stellar")
+        .unwrap_or_else(|_| assert_cmd::Command::new("stellar"))
+        .arg("bye")
+        .env("PATH", &paths)
+        .assert()
+        .stdout("Bye, world!\n");
+}
+
 #[test]
 fn list() {
     // Call `soroban --list` with the PATH variable set to include the target/bin directory
-    assert_cmd::Command::cargo_bin("soroban")
-        .unwrap_or_else(|_| assert_cmd::Command::new("soroban"))
+    assert_cmd::Command::cargo_bin("stellar")
+        .unwrap_or_else(|_| assert_cmd::Command::new("stellar"))
         .arg("--list")
         .env("PATH", get_paths())
         .assert()
-        .stdout(predicates::str::contains("hello"));
+        .stdout(predicates::str::contains("hello"))
+        .stdout(predicates::str::contains("bye"));
 }
 
 #[test]
 #[cfg(not(unix))]
 fn has_no_path() {
     // Call soroban with the PATH variable set to include just target/bin directory
-    assert_cmd::Command::cargo_bin("soroban")
-        .unwrap_or_else(|_| assert_cmd::Command::new("soroban"))
+    assert_cmd::Command::cargo_bin("stellar")
+        .unwrap_or_else(|_| assert_cmd::Command::new("stellar"))
         .arg("hello")
         .env("PATH", target_bin())
         .assert()
@@ -45,8 +59,8 @@ fn has_no_path() {
 #[test]
 fn has_no_path_failure() {
     // Call soroban with the PATH variable set to include just target/bin directory
-    assert_cmd::Command::cargo_bin("soroban")
-        .unwrap_or_else(|_| assert_cmd::Command::new("soroban"))
+    assert_cmd::Command::cargo_bin("stellar")
+        .unwrap_or_else(|_| assert_cmd::Command::new("stellar"))
         .arg("hello")
         .assert()
         .stderr(predicates::str::contains("error: no such command: `hello`"));

cmd/soroban-cli/src/cli.rs

@@ -2,8 +2,9 @@ use clap::CommandFactory;
 use dotenvy::dotenv;
 use tracing_subscriber::{fmt, EnvFilter};
 
+use crate::print::Print;
 use crate::upgrade_check::upgrade_check;
-use crate::{commands, print, Root};
+use crate::{commands, Root};
 
 #[tokio::main]
 pub async fn main() {
@@ -42,6 +43,7 @@ pub async fn main() {
             std::process::exit(1);
         }
     });
+
     // Now use root to setup the logger
     if let Some(level) = root.global_args.log_level() {
         let mut e_filter = EnvFilter::from_default_env()
@@ -78,7 +80,7 @@ pub async fn main() {
         upgrade_check(root.global_args.quiet).await;
     });
 
-    let printer = print::Print::new(root.global_args.quiet);
+    let printer = Print::new(root.global_args.quiet);
     if let Err(e) = root.run().await {
         printer.errorln(format!("error: {e}"));
         std::process::exit(1);

cmd/soroban-cli/src/commands/plugin.rs

@@ -1,4 +1,4 @@
-use std::process::Command;
+use std::{path::PathBuf, process::Command};
 
 use clap::CommandFactory;
 use which::which;
@@ -44,7 +44,7 @@ pub fn run() -> Result<(), Error> {
         return Ok(());
     }
 
-    let bin = which(format!("soroban-{name}")).map_err(|_| {
+    let bin = find_bin(&name).map_err(|_| {
         let suggestion = if let Ok(bins) = list() {
             let suggested_name = bins
                 .iter()
@@ -53,6 +53,7 @@ pub fn run() -> Result<(), Error> {
                 .min_by(|a, b| a.1.total_cmp(&b.1))
                 .map(|(a, _)| a.to_string())
                 .unwrap_or_default();
+
             if suggested_name.is_empty() {
                 suggested_name
             } else {
@@ -64,8 +65,10 @@ pub fn run() -> Result<(), Error> {
         } else {
             String::new()
         };
+
         Error::ExecutableNotFound(name, suggestion)
     })?;
+
     std::process::exit(
         Command::new(bin)
             .args(args)
@@ -78,19 +81,29 @@ pub fn run() -> Result<(), Error> {
 
 const MAX_HEX_LENGTH: usize = 10;
 
+fn find_bin(name: &str) -> Result<PathBuf, which::Error> {
+    if let Ok(path) = which(format!("stellar-{name}")) {
+        Ok(path)
+    } else {
+        which(format!("soroban-{name}"))
+    }
+}
+
 pub fn list() -> Result<Vec<String>, Error> {
     let re_str = if cfg!(target_os = "windows") {
-        r"^soroban-.*.exe$"
+        r"^(soroban|stellar)-.*.exe$"
     } else {
-        r"^soroban-.*"
+        r"^(soroban|stellar)-.*"
     };
+
     let re = regex::Regex::new(re_str)?;
+
     Ok(which::which_re(re)?
         .filter_map(|b| {
             let s = b.file_name()?.to_str()?;
             Some(s.strip_suffix(".exe").unwrap_or(s).to_string())
         })
         .filter(|s| !(utils::is_hex_string(s) && s.len() > MAX_HEX_LENGTH))
-        .map(|s| s.replace("soroban-", ""))
+        .map(|s| s.replace("soroban-", "").replace("stellar-", ""))
         .collect())
 }

cmd/soroban-cli/src/commands/tx/new/create_account.rs

@@ -11,7 +11,7 @@ pub struct Cmd {
     #[arg(long)]
     pub destination: xdr::AccountId,
     /// Initial balance in stroops of the account, default 1 XLM
-    #[arg(long, default_value = "10_000_000")]
+    #[arg(long, default_value = "10000000")]
     pub starting_balance: i64,
 }
 

cmd/soroban-cli/src/config/locator.rs

@@ -145,7 +145,7 @@ impl Args {
 
     pub fn local_config(&self) -> Result<PathBuf, Error> {
         let pwd = self.current_dir()?;
-        Ok(find_config_dir(pwd.clone()).unwrap_or_else(|_| pwd.join(".soroban")))
+        Ok(find_config_dir(pwd.clone()).unwrap_or_else(|_| pwd.join(".stellar")))
     }
 
     pub fn current_dir(&self) -> Result<PathBuf, Error> {
@@ -468,14 +468,32 @@ impl KeyType {
 }
 
 pub fn global_config_path() -> Result<PathBuf, Error> {
-    Ok(if let Ok(config_home) = std::env::var("XDG_CONFIG_HOME") {
+    let config_dir = if let Ok(config_home) = std::env::var("XDG_CONFIG_HOME") {
         PathBuf::from_str(&config_home).map_err(|_| Error::XdgConfigHome(config_home))?
     } else {
         dirs::home_dir()
             .ok_or(Error::HomeDirNotFound)?
             .join(".config")
+    };
+
+    let soroban_dir = config_dir.join("soroban");
+    let stellar_dir = config_dir.join("stellar");
+    let soroban_exists = soroban_dir.exists();
+    let stellar_exists = stellar_dir.exists();
+
+    if stellar_exists && soroban_exists {
+        tracing::warn!("the .stellar and .soroban config directories exist at path {config_dir:?}, using the .stellar");
+    }
+
+    if stellar_exists {
+        return Ok(stellar_dir);
     }
-    .join("soroban"))
+
+    if soroban_exists {
+        return Ok(soroban_dir);
+    }
+
+    Ok(stellar_dir)
 }
 
 impl Pwd for Args {

cmd/soroban-cli/src/print.rs

@@ -8,6 +8,7 @@ use crate::{
 
 const TERMS: &[&str] = &["Apple_Terminal", "vscode"];
 
+#[derive(Clone)]
 pub struct Print {
     pub quiet: bool,
 }

cmd/soroban-cli/src/utils.rs

@@ -95,10 +95,12 @@ pub fn find_config_dir(mut pwd: std::path::PathBuf) -> std::io::Result<std::path
         if soroban_exists {
             return Ok(soroban_dir);
         }
+
         if !pwd.pop() {
             break;
         }
     }
+
     Err(std::io::Error::new(
         std::io::ErrorKind::Other,
         "stellar directory not found",

cmd/soroban-cli/src/utils/contract-workspace-template/.gitignore

@@ -1,5 +1,6 @@
 # Rust's output directory
 target
 
-# Local Soroban settings
+# Local settings
 .soroban
+.stellar