feat: improve asset parsing to use named keys as issuer

cmd/crates/soroban-test/tests/it/integration/tx/operations.rs

@@ -1,4 +1,5 @@
 use soroban_cli::{
+    config::locator,
     tx::{builder, ONE_XLM},
     utils::contract_id_hash_from_asset,
     xdr::{self, ReadXdr, SequenceNumber},
@@ -89,6 +90,71 @@ async fn create_account() {
     invoke_hello_world(sandbox, &id);
 }
 
+#[tokio::test]
+async fn create_account_with_alias() {
+    let sandbox = &TestEnv::new();
+    sandbox
+        .new_assert_cmd("keys")
+        .args(["generate", "--no-fund", "new"])
+        .assert()
+        .success();
+    let test = test_address(sandbox);
+    let client = sandbox.client();
+    let test_account = client.get_account(&test).await.unwrap();
+    println!("test account has a balance of {}", test_account.balance);
+    let starting_balance = ONE_XLM * 100;
+    sandbox
+        .new_assert_cmd("tx")
+        .args([
+            "new",
+            "create-account",
+            "--destination",
+            "new",
+            "--starting-balance",
+            starting_balance.to_string().as_str(),
+        ])
+        .assert()
+        .success();
+    let test_account_after = client.get_account(&test).await.unwrap();
+    assert!(test_account_after.balance < test_account.balance);
+    let id = deploy_contract(sandbox, HELLO_WORLD, DeployKind::Normal, Some("new")).await;
+    println!("{id}");
+    invoke_hello_world(sandbox, &id);
+}
+
+#[tokio::test]
+async fn payment_with_alias() {
+    let sandbox = &TestEnv::new();
+    let client = sandbox.client();
+    let (test, test1) = setup_accounts(sandbox);
+    let test_account = client.get_account(&test).await.unwrap();
+    println!("test account has a balance of {}", test_account.balance);
+
+    let before = client.get_account(&test).await.unwrap();
+    let test1_account_entry_before = client.get_account(&test1).await.unwrap();
+
+    sandbox
+        .new_assert_cmd("tx")
+        .args([
+            "new",
+            "payment",
+            "--destination",
+            "test1",
+            "--amount",
+            ONE_XLM.to_string().as_str(),
+        ])
+        .assert()
+        .success();
+    let test1_account_entry = client.get_account(&test1).await.unwrap();
+    assert_eq!(
+        ONE_XLM,
+        test1_account_entry.balance - test1_account_entry_before.balance,
+        "Should have One XLM more"
+    );
+    let after = client.get_account(&test).await.unwrap();
+    assert_eq!(before.balance - 10_000_100, after.balance);
+}
+
 #[tokio::test]
 async fn payment() {
     let sandbox = &TestEnv::new();
@@ -172,23 +238,54 @@ async fn account_merge() {
     assert_eq!(before.balance + before1.balance - fee, after.balance);
 }
 
+#[tokio::test]
+async fn account_merge_with_alias() {
+    let sandbox = &TestEnv::new();
+    let client = sandbox.client();
+    let (test, test1) = setup_accounts(sandbox);
+    let before = client.get_account(&test).await.unwrap();
+    let before1 = client.get_account(&test1).await.unwrap();
+    let fee = 100;
+    sandbox
+        .new_assert_cmd("tx")
+        .args([
+            "new",
+            "account-merge",
+            "--source",
+            "test1",
+            "--account",
+            "test",
+            "--fee",
+            fee.to_string().as_str(),
+        ])
+        .assert()
+        .success();
+    let after = client.get_account(&test).await.unwrap();
+    assert!(client.get_account(&test1).await.is_err());
+    assert_eq!(before.balance + before1.balance - fee, after.balance);
+}
+
 #[tokio::test]
 async fn set_trustline_flags() {
     let sandbox = &TestEnv::new();
-    let (test, issuer) = setup_accounts(sandbox);
-    let asset = format!("usdc:{issuer}");
-    issue_asset(sandbox, &test, &asset, 100_000, 100).await;
+    let (test, test1) = setup_accounts(sandbox);
+    let asset = "usdc:test1";
+    issue_asset(sandbox, &test, asset, 100_000, 100).await;
     sandbox
         .new_assert_cmd("contract")
         .arg("asset")
         .arg("deploy")
         .arg("--asset")
-        .arg(&asset)
+        .arg(asset)
         .assert()
         .success();
     let id = contract_id_hash_from_asset(
-        asset.parse::<builder::Asset>().unwrap(),
-        &sandbox.network.network_passphrase,
+        &format!("usdc:{test1}")
+            .parse::<builder::Asset>()
+            .unwrap()
+            .resolve(&locator::Args::default())
+            .unwrap(),
+        &sandbox.network_passphrase,
     );
     // sandbox
     //     .new_assert_cmd("contract")
@@ -450,8 +547,12 @@ async fn change_trust() {
 
     // wrap_cmd(&asset).run().await.unwrap();
     let id = contract_id_hash_from_asset(
-        asset.parse::<builder::Asset>().unwrap(),
-        &sandbox.network.network_passphrase,
+        &asset
+            .parse::<builder::Asset>()
+            .unwrap()
+            .resolve(&locator::Args::default())
+            .unwrap(),
+        &sandbox.network_passphrase,
     );
     sandbox
         .new_assert_cmd("contract")

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

@@ -1,4 +1,4 @@
-use soroban_cli::{tx::builder, utils::contract_id_hash_from_asset};
+use soroban_cli::{config::locator, tx::builder, utils::contract_id_hash_from_asset};
 use soroban_test::{AssertExt, TestEnv, LOCAL_NETWORK_PASSPHRASE};
 
 #[tokio::test]
@@ -12,21 +12,23 @@ async fn burn() {
         .arg("test")
         .assert()
         .stdout_as_str();
-    let asset = format!("native:{address}");
+    let asset = "native";
     sandbox
         .new_assert_cmd("contract")
         .arg("asset")
         .arg("deploy")
         .arg("--source=test")
         .arg("--asset")
-        .arg(&asset)
+        .arg(asset)
         .assert()
         .success();
-    // wrap_cmd(&asset).run().await.unwrap();
-    let asset: builder::Asset = asset.parse().unwrap();
+    let asset = asset
+        .parse::<builder::Asset>()
+        .unwrap()
+        .resolve(&locator::Args::default())
+        .unwrap();
     let hash = contract_id_hash_from_asset(&asset, &network_passphrase);
     let id = stellar_strkey::Contract(hash.0).to_string();
-    println!("{id}, {address}");
     sandbox
         .new_assert_cmd("contract")
         .args([

cmd/soroban-cli/Cargo.toml

@@ -128,6 +128,7 @@ wasm-gen = "0.1.4"
 zeroize = "1.8.1"
 keyring = { version = "3", features = ["apple-native", "windows-native", "sync-secret-service"] }
 whoami = "1.5.2"
+serde_with = "3.11.0"
 
 
 [build-dependencies]

cmd/soroban-cli/src/commands/contract/arg_parsing.rs

@@ -269,5 +269,11 @@ fn resolve_address(addr_or_alias: &str, config: &config::Args) -> Result<String,
 }
 
 fn resolve_signer(addr_or_alias: &str, config: &config::Args) -> Option<SigningKey> {
-    config.locator.key(addr_or_alias).ok()?.key_pair(None).ok()
+    config
+        .locator
+        .read_key(addr_or_alias)
+        .ok()?
+        .private_key(None)
+        .ok()
+        .map(|pk| SigningKey::from_bytes(&pk.0))
 }

cmd/soroban-cli/src/commands/contract/deploy/asset.rs

@@ -43,6 +43,8 @@ pub enum Error {
     #[error(transparent)]
     Builder(#[from] builder::Error),
     #[error(transparent)]
+    Asset(#[from] builder::asset::Error),
+    #[error(transparent)]
     Locator(#[from] locator::Error),
 }
 
@@ -107,7 +109,7 @@ impl NetworkRunnable for Cmd {
     ) -> Result<Self::Result, Error> {
         let config = config.unwrap_or(&self.config);
         // Parse asset
-        let asset = &self.asset;
+        let asset = self.asset.resolve(&config.locator)?;
 
         let network = config.get_network()?;
         let client = network.rpc_client()?;
@@ -122,7 +124,7 @@ impl NetworkRunnable for Cmd {
             .await?;
         let sequence: i64 = account_details.seq_num.into();
         let network_passphrase = &network.network_passphrase;
-        let contract_id = contract_id_hash_from_asset(asset, network_passphrase);
+        let contract_id = contract_id_hash_from_asset(&asset, network_passphrase);
         let tx = build_wrap_token_tx(
             asset,
             &contract_id,

cmd/soroban-cli/src/commands/contract/id/asset.rs

@@ -21,6 +21,8 @@ pub enum Error {
     ConfigError(#[from] config::Error),
     #[error(transparent)]
     Xdr(#[from] crate::xdr::Error),
+    #[error(transparent)]
+    Asset(#[from] builder::asset::Error),
 }
 impl Cmd {
     pub fn run(&self) -> Result<(), Error> {
@@ -30,7 +32,10 @@ impl Cmd {
 
     pub fn contract_address(&self) -> Result<stellar_strkey::Contract, Error> {
         let network = self.config.get_network()?;
-        let contract_id = contract_id_hash_from_asset(&self.asset, &network.network_passphrase);
+        let contract_id = contract_id_hash_from_asset(
+            &self.asset.resolve(&self.config.locator)?,
+            &network.network_passphrase,
+        );
         Ok(stellar_strkey::Contract(contract_id.0))
     }
 }

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

@@ -2,15 +2,16 @@ use clap::command;
 
 use crate::{
     commands::global,
-    config::{address::KeyName, locator, secret},
+    config::{address::KeyName, key, locator, secret},
     print::Print,
 };
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error(transparent)]
     Secret(#[from] secret::Error),
-
+    #[error(transparent)]
+    Key(#[from] key::Error),
     #[error(transparent)]
     Config(#[from] locator::Error),
 }
@@ -26,13 +27,21 @@ pub struct Cmd {
 
     #[command(flatten)]
     pub config_locator: locator::Args,
+
+    /// Add a public key, ed25519, or muxed account, e.g. G1.., M2..
+    #[arg(long, conflicts_with = "seed_phrase", conflicts_with = "secret_key")]
+    pub public_key: Option<String>,
 }
 
 impl Cmd {
     pub fn run(&self, global_args: &global::Args) -> Result<(), Error> {
+        let key = if let Some(key) = self.public_key.as_ref() {
+            key.parse()?
+        } else {
+            self.secrets.read_secret()?.into()
+        };
         let print = Print::new(global_args.quiet);
-        let secret = self.secrets.read_secret()?;
-        let path = self.config_locator.write_identity(&self.name, &secret)?;
+        let path = self.config_locator.write_key(&self.name, &key)?;
         print.checkln(format!("Key saved with alias {:?} in {path:?}", self.name));
         Ok(())
     }

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

@@ -5,6 +5,7 @@ use super::super::config::{
     locator, network,
     secret::{self, Secret},
 };
+
 use crate::{
     commands::global,
     config::address::KeyName,
@@ -178,7 +179,7 @@ impl Cmd {
 
 #[cfg(test)]
 mod tests {
-    use crate::config::{address::KeyName, secret::Secret};
+    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) {
@@ -220,7 +221,7 @@ mod tests {
         let result = cmd.run(&global_args).await;
         assert!(result.is_ok());
         let identity = test_locator.read_identity("test_name").unwrap();
-        assert!(matches!(identity, Secret::SeedPhrase { .. }));
+        assert!(matches!(identity, Key::Secret(Secret::SeedPhrase { .. })));
     }
 
     #[tokio::test]
@@ -232,7 +233,7 @@ mod tests {
         let result = cmd.run(&global_args).await;
         assert!(result.is_ok());
         let identity = test_locator.read_identity("test_name").unwrap();
-        assert!(matches!(identity, Secret::SecretKey { .. }));
+        assert!(matches!(identity, Key::Secret(Secret::SecretKey { .. })));
     }
 
     #[tokio::test]
@@ -245,6 +246,6 @@ mod tests {
         let result = cmd.run(&global_args).await;
         assert!(result.is_ok());
         let identity = test_locator.read_identity("test_name").unwrap();
-        assert!(matches!(identity, Secret::SecureStore { .. }));
+        assert!(matches!(identity, Key::Secret(Secret::SecureStore { .. })));
     }
 }

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

@@ -1,17 +1,14 @@
 use clap::arg;
 
-use crate::config::{locator, secret};
+use crate::config::{key, locator};
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error(transparent)]
     Config(#[from] locator::Error),
 
     #[error(transparent)]
-    Secret(#[from] secret::Error),
-
-    #[error(transparent)]
-    StrKey(#[from] stellar_strkey::DecodeError),
+    Key(#[from] key::Error),
 }
 
 #[derive(Debug, clap::Parser, Clone)]

cmd/soroban-cli/src/commands/snapshot/create.rs

@@ -328,7 +328,9 @@ impl Cmd {
                                             get_name_from_stellar_asset_contract_storage(storage)
                                         {
                                             let asset: builder::Asset = name.parse()?;
-                                            if let Some(issuer) = match asset.into() {
+                                            if let Some(issuer) = match asset
+                                                .resolve(&global_args.locator)?
+                                            {
                                                 Asset::Native => None,
                                                 Asset::CreditAlphanum4(a4) => Some(a4.issuer),
                                                 Asset::CreditAlphanum12(a12) => Some(a12.issuer),