Merge branch 'main' into ledger-entry-get

Author: elizabethengelman

.github/workflows/binaries.yml

@@ -56,7 +56,7 @@ jobs:
 
     - name: Build
       run: |
-        cargo build --package ${{ matrix.crate.name }} --features opt --release --target ${{ matrix.sys.target }}
+        cargo build --package ${{ matrix.crate.name }} --features opt,additional-libs --release --target ${{ matrix.sys.target }}
     - name: Build provenance for binary attestation (release only)
       if: github.event_name == 'release'
       uses: actions/attest-build-provenance@v2

.github/workflows/ledger-emulator.yml

@@ -26,6 +26,6 @@ jobs:
                   sudo apt update && sudo apt install -y libudev-dev libdbus-1-dev
             - run: |
                   cargo test --manifest-path cmd/crates/stellar-ledger/Cargo.toml --features "emulator-tests" -- --nocapture
-            - run: cargo build --features emulator-tests
+            - run: cargo build --features emulator-tests,additional-libs
             - run: |
                   cargo test --features emulator-tests --package soroban-test --test it -- emulator

Makefile

@@ -49,6 +49,7 @@ generate-full-help-doc:
 
 test: build-test
 	cargo test --workspace --exclude soroban-test
+	cargo test --workspace --exclude soroban-test --features additional-libs
 	cargo test -p soroban-test -- --skip integration::
 
 e2e-test:

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

@@ -64,7 +64,7 @@ fn has_no_path_failure() {
         .unwrap_or_else(|_| assert_cmd::Command::new("stellar"))
         .arg("hello")
         .assert()
-        .stderr(predicates::str::contains("error: no such command: `hello`"));
+        .stderr(predicates::str::contains("unrecognized subcommand 'hello'"));
 }
 
 fn target_bin() -> PathBuf {

cmd/soroban-cli/Cargo.toml

@@ -40,6 +40,7 @@ version_lt_23 = []
 version_gte_23 = []
 opt = ["dep:wasm-opt"]
 emulator-tests = ["stellar-ledger/emulator-tests"]
+additional-libs = ["dep:keyring", "dep:stellar-ledger"]
 
 [dependencies]
 stellar-xdr = { workspace = true, features = ["cli"] }
@@ -52,7 +53,7 @@ soroban-ledger-snapshot = { workspace = true }
 stellar-strkey = { workspace = true }
 soroban-sdk = { workspace = true }
 soroban-rpc = { workspace = true }
-stellar-ledger = { workspace = true }
+stellar-ledger = { workspace = true, optional = true }
 
 clap = { workspace = true, features = [
     "derive",
@@ -131,7 +132,7 @@ open = "5.3.0"
 url = "2.5.2"
 wasm-gen = "0.1.4"
 zeroize = "1.8.1"
-keyring = { version = "3", features = ["apple-native", "windows-native", "sync-secret-service"] }
+keyring = { version = "3", features = ["apple-native", "windows-native", "sync-secret-service"], optional = true }
 whoami = "1.5.2"
 serde_with = "3.11.0"
 

cmd/soroban-cli/src/commands/keys/add.rs

@@ -81,7 +81,8 @@ impl Cmd {
 
             let seed_phrase: SeedPhrase = secret_key.parse()?;
 
-            Ok(secure_store::save_secret(print, &self.name, seed_phrase)?)
+            let secret = secure_store::save_secret(print, &self.name, &seed_phrase)?;
+            Ok(secret.parse()?)
         } else {
             let prompt = "Type a secret key or 12/24 word seed phrase:";
             let secret_key = read_password(print, prompt)?;

cmd/soroban-cli/src/commands/keys/generate.rs

@@ -127,7 +127,8 @@ impl Cmd {
     fn secret(&self, print: &Print) -> Result<Secret, Error> {
         let seed_phrase = self.seed_phrase()?;
         if self.secure_store {
-            Ok(secure_store::save_secret(print, &self.name, seed_phrase)?)
+            let secret = secure_store::save_secret(print, &self.name, &seed_phrase)?;
+            Ok(secret.parse()?)
         } else if self.as_secret {
             let secret: Secret = seed_phrase.into();
             Ok(secret.private_key(self.hd_path)?.into())
@@ -144,7 +145,6 @@ impl Cmd {
 #[cfg(test)]
 mod tests {
     use crate::config::{address::KeyName, key::Key, secret::Secret};
-    use keyring::{mock, set_default_credential_builder};
 
     fn set_up_test() -> (super::locator::Args, super::Cmd) {
         let temp_dir = tempfile::tempdir().unwrap();
@@ -200,8 +200,10 @@ mod tests {
         assert!(matches!(identity, Key::Secret(Secret::SecretKey { .. })));
     }
 
+    #[cfg(feature = "additional-libs")]
     #[tokio::test]
     async fn test_storing_secret_in_secure_store() {
+        use keyring::{mock, set_default_credential_builder};
         set_default_credential_builder(mock::default_credential_builder());
         let (test_locator, mut cmd) = set_up_test();
         cmd.secure_store = true;
@@ -212,4 +214,26 @@ mod tests {
         let identity = test_locator.read_identity("test_name").unwrap();
         assert!(matches!(identity, Key::Secret(Secret::SecureStore { .. })));
     }
+
+    #[cfg(not(feature = "additional-libs"))]
+    #[tokio::test]
+    async fn test_storing_in_secure_store_returns_error_when_additional_libs_not_enabled() {
+        let (test_locator, mut cmd) = set_up_test();
+        cmd.secure_store = true;
+        let global_args = global_args();
+
+        let result = cmd.run(&global_args).await;
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            format!("Secure Store keys are not allowed: additional-libs feature must be enabled")
+        );
+
+        let identity_result = test_locator.read_identity("test_name");
+        assert!(identity_result.is_err());
+        assert_eq!(
+            identity_result.unwrap_err().to_string(),
+            format!("Failed to find config identity for test_name")
+        );
+    }
 }

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

@@ -84,13 +84,16 @@ impl Root {
         Self::try_parse().map_err(|e| {
             if std::env::args().any(|s| s == "--list") {
                 let plugins = plugin::list().unwrap_or_default();
+
                 if plugins.is_empty() {
-                    println!("No Plugins installed. E.g. soroban-hello");
+                    println!("No Plugins installed. E.g. stellar-hello");
                 } else {
                     println!("Installed Plugins:\n    {}", plugins.join("\n    "));
                 }
+
                 std::process::exit(0);
             }
+
             match e.kind() {
                 ErrorKind::InvalidSubcommand => match plugin::run() {
                     Ok(()) => Error::Clap(e),
@@ -108,6 +111,7 @@ impl Root {
     {
         Self::from_arg_matches_mut(&mut Self::command().get_matches_from(itr))
     }
+
     pub async fn run(&mut self) -> Result<(), Error> {
         match &mut self.cmd {
             Cmd::Completion(completion) => completion.run(),

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

@@ -1,82 +1,33 @@
 use std::{path::PathBuf, process::Command};
-
-use clap::CommandFactory;
 use which::which;
 
-use crate::{utils, Root};
+use crate::utils;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
-    #[error("Plugin not provided. Should be `stellar plugin` for a binary `stellar-plugin`")]
-    MissingSubcommand,
     #[error(transparent)]
     IO(#[from] std::io::Error),
-    #[error(
-        r"error: no such command: `{0}`
-        
-        {1}View all installed plugins with `stellar --list`"
-    )]
-    ExecutableNotFound(String, String),
+
     #[error(transparent)]
     Which(#[from] which::Error),
+
     #[error(transparent)]
     Regex(#[from] regex::Error),
 }
 
-const SUBCOMMAND_TOLERANCE: f64 = 0.75;
-const PLUGIN_TOLERANCE: f64 = 0.75;
-const MIN_LENGTH: usize = 4;
-
-/// Tries to run a plugin, if the plugin's name is similar enough to any of the current subcommands return Ok.
-/// Otherwise only errors can be returned because this process will exit with the plugin.
 pub fn run() -> Result<(), Error> {
-    let (name, args) = {
-        let mut args = std::env::args().skip(1);
-        let name = args.next().ok_or(Error::MissingSubcommand)?;
-        (name, args)
-    };
-
-    if Root::command().get_subcommands().any(|c| {
-        let sc_name = c.get_name();
-        sc_name.starts_with(&name)
-            || (name.len() >= MIN_LENGTH && strsim::jaro(sc_name, &name) >= SUBCOMMAND_TOLERANCE)
-    }) {
-        return Ok(());
+    if let Some((plugin_bin, args)) = find_plugin() {
+        std::process::exit(
+            Command::new(plugin_bin)
+                .args(args)
+                .spawn()?
+                .wait()?
+                .code()
+                .unwrap(),
+        );
     }
 
-    let bin = find_bin(&name).map_err(|_| {
-        let suggestion = if let Ok(bins) = list() {
-            let suggested_name = bins
-                .iter()
-                .map(|b| (b, strsim::jaro_winkler(&name, b)))
-                .filter(|(_, i)| *i > PLUGIN_TOLERANCE)
-                .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 {
-                format!(
-                    r"Did you mean `{suggested_name}`?
-        "
-                )
-            }
-        } else {
-            String::new()
-        };
-
-        Error::ExecutableNotFound(name, suggestion)
-    })?;
-
-    std::process::exit(
-        Command::new(bin)
-            .args(args)
-            .spawn()?
-            .wait()?
-            .code()
-            .unwrap(),
-    );
+    Ok(())
 }
 
 const MAX_HEX_LENGTH: usize = 10;
@@ -107,3 +58,31 @@ pub fn list() -> Result<Vec<String>, Error> {
         .map(|s| s.replace("soroban-", "").replace("stellar-", ""))
         .collect())
 }
+
+fn find_plugin() -> Option<(PathBuf, Vec<String>)> {
+    let args_vec: Vec<String> = std::env::args().skip(1).collect();
+    let mut chain: Vec<String> = args_vec
+        .iter()
+        .take_while(|arg| !arg.starts_with("--"))
+        .map(ToString::to_string)
+        .collect();
+
+    while !chain.is_empty() {
+        let name = chain.join("-");
+        let bin = find_bin(&name).ok();
+
+        if let Some(bin) = &bin {
+            let index = chain.len();
+            let args = args_vec[index..]
+                .iter()
+                .map(ToString::to_string)
+                .collect::<Vec<String>>();
+
+            return Some((bin.into(), args));
+        }
+
+        chain.pop();
+    }
+
+    None
+}

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

@@ -48,6 +48,8 @@ pub enum Error {
     InvalidKeyName(String),
     #[error("Ledger not supported in this context")]
     LedgerNotSupported,
+    #[error(transparent)]
+    Ledger(#[from] signer::ledger::Error),
 }
 
 impl FromStr for UnresolvedMuxedAccount {
@@ -85,7 +87,7 @@ impl UnresolvedMuxedAccount {
     ) -> Result<xdr::MuxedAccount, Error> {
         match self {
             UnresolvedMuxedAccount::Ledger(hd_path) => Ok(xdr::MuxedAccount::Ed25519(
-                ledger(*hd_path).await?.public_key().await?.0.into(),
+                ledger::new(*hd_path).await?.public_key().await?.0.into(),
             )),
             UnresolvedMuxedAccount::Resolved(_) | UnresolvedMuxedAccount::AliasOrSecret(_) => {
                 self.resolve_muxed_account_sync(locator, hd_path)