feat: add tx sign/send and Stellar trait

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

@@ -31,7 +31,7 @@ use fs_extra::dir::CopyOptions;
 
 use soroban_cli::{
     commands::{contract::invoke, global, keys, NetworkRunnable},
-    config::{self, network},
+    config::{self, network, sign_with},
     CommandParser,
 };
 
@@ -222,17 +222,20 @@ impl TestEnv {
     pub fn clone_config(&self, account: &str) -> config::Args {
         let config_dir = Some(self.dir().to_path_buf());
         config::Args {
-            network: network::Args {
-                rpc_url: Some(self.rpc_url.clone()),
-                network_passphrase: Some(LOCAL_NETWORK_PASSPHRASE.to_string()),
-                network: None,
-            },
             source_account: account.to_string(),
-            locator: config::locator::Args {
-                global: false,
-                config_dir,
+            sign_with: sign_with::Args {
+                network: network::Args {
+                    rpc_url: Some(self.rpc_url.clone()),
+                    network_passphrase: Some(LOCAL_NETWORK_PASSPHRASE.to_string()),
+                    network: None,
+                },
+                locator: config::locator::Args {
+                    global: false,
+                    config_dir,
+                },
+                yes: true,
+                ..Default::default()
             },
-            hd_path: None,
         }
     }
 
@@ -243,9 +246,10 @@ impl TestEnv {
         account: &str,
     ) -> Result<T::Result, T::Error> {
         let config = self.clone_config(account);
+        eprintln!("Running with config: {config:#?}");
         cmd.run_against_rpc_server(
             Some(&global::Args {
-                locator: config.locator.clone(),
+                locator: config.sign_with.locator.clone(),
                 filter_logs: Vec::default(),
                 quiet: false,
                 verbose: false,
@@ -264,9 +268,10 @@ impl TestEnv {
     }
 
     /// Returns the public key corresponding to the test keys's `hd_path`
-    pub fn test_address(&self, hd_path: usize) -> String {
+    pub async fn test_address(&self, hd_path: usize) -> String {
         self.cmd::<keys::address::Cmd>(&format!("--hd-path={hd_path}"))
             .public_key()
+            .await
             .unwrap()
             .to_string()
     }

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

@@ -9,7 +9,13 @@ use super::util::invoke_with_roundtrip;
 
 fn invoke_custom(e: &TestEnv, id: &str, func: &str) -> assert_cmd::Command {
     let mut s = e.new_assert_cmd("contract");
-    s.arg("invoke").arg("--id").arg(id).arg("--").arg(func);
+    s.env("RUST_LOG", "soroban_cli::log::diagnostic_event=off")
+        .arg("invoke")
+        .arg("--id")
+        .arg(id)
+        .arg("--is-view")
+        .arg("--")
+        .arg(func);
     s
 }
 

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

@@ -219,6 +219,7 @@ async fn invoke_auth_with_different_test_account_fail(sandbox: &TestEnv, id: &st
             "--hd-path=0",
             "--id",
             id,
+            "--fee=1000000",
             "--",
             "auth",
             &format!("--addr={addr}"),
@@ -227,8 +228,8 @@ async fn invoke_auth_with_different_test_account_fail(sandbox: &TestEnv, id: &st
         .await;
     let e = res.unwrap_err();
     assert!(
-        matches!(e, contract::invoke::Error::Config(_)),
-        "Expected config error got {e:?}"
+        matches!(e, contract::invoke::Error::Rpc(_)),
+        "Expected rpc error got {e:?}"
     );
 }
 

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

@@ -1,10 +1,10 @@
 use soroban_sdk::xdr::{Limits, ReadXdr, TransactionEnvelope, WriteXdr};
 use soroban_test::{AssertExt, TestEnv};
 
-use crate::integration::util::{deploy_contract, DeployKind, HELLO_WORLD};
+use crate::integration::util::{deploy_contract, deploy_hello, DeployKind, HELLO_WORLD};
 
 #[tokio::test]
-async fn txn_simulate() {
+async fn simulate() {
     let sandbox = &TestEnv::new();
     let xdr_base64_build_only = deploy_contract(sandbox, HELLO_WORLD, DeployKind::BuildOnly).await;
     let xdr_base64_sim_only = deploy_contract(sandbox, HELLO_WORLD, DeployKind::SimOnly).await;
@@ -49,3 +49,49 @@ async fn txn_hash() {
 
     assert_eq!(hash.trim(), expected_hash);
 }
+
+#[tokio::test]
+async fn send() {
+    let sandbox = &TestEnv::new();
+    sandbox
+        .new_assert_cmd("contract")
+        .arg("install")
+        .args(["--wasm", HELLO_WORLD.path().as_os_str().to_str().unwrap()])
+        .assert()
+        .success();
+
+    let xdr_base64 = deploy_contract(sandbox, HELLO_WORLD, DeployKind::SimOnly).await;
+    println!("{xdr_base64}");
+    let tx_env = TransactionEnvelope::from_xdr_base64(&xdr_base64, Limits::none()).unwrap();
+    let tx_env = sign_manually(sandbox, &tx_env);
+
+    println!(
+        "Transaction to send:\n{}",
+        tx_env.to_xdr_base64(Limits::none()).unwrap()
+    );
+
+    let assembled_str = sandbox
+        .new_assert_cmd("tx")
+        .arg("send")
+        .write_stdin(tx_env.to_xdr_base64(Limits::none()).unwrap())
+        .assert()
+        .success()
+        .stdout_as_str();
+    println!("Transaction sent: {assembled_str}");
+}
+
+fn sign_manually(sandbox: &TestEnv, tx_env: &TransactionEnvelope) -> TransactionEnvelope {
+    TransactionEnvelope::from_xdr_base64(
+        sandbox
+            .new_assert_cmd("tx")
+            .arg("sign")
+            .arg("--sign-with-key=test")
+            .arg("--yes")
+            .write_stdin(tx_env.to_xdr_base64(Limits::none()).unwrap().as_bytes())
+            .assert()
+            .success()
+            .stdout_as_str(),
+        Limits::none(),
+    )
+    .unwrap()
+}

cmd/soroban-cli/Cargo.toml

@@ -50,6 +50,7 @@ soroban-ledger-snapshot = { workspace = true }
 stellar-strkey = { workspace = true }
 soroban-sdk = { workspace = true }
 soroban-rpc = { workspace = true }
+
 clap = { workspace = true, features = [
     "derive",
     "env",
@@ -113,15 +114,15 @@ async-compression = { version = "0.4.12", features = [ "tokio", "gzip" ] }
 tempfile = "3.8.1"
 toml_edit = "0.21.0"
 rust-embed = { version = "8.2.0", features = ["debug-embed"] }
-bollard = { workspace=true }
+bollard = { workspace = true }
 futures-util = "0.3.30"
 futures = "0.3.30"
 home = "0.5.9"
 flate2 = "1.0.30"
 bytesize = "1.3.0"
 humantime = "2.1.0"
 phf = { version = "0.11.2", features = ["macros"] }
-
+crossterm = "0.27.0"
 # For hyper-tls
 [target.'cfg(unix)'.dependencies]
 openssl = { version = "=0.10.55", features = ["vendored"] }

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

@@ -97,13 +97,10 @@ impl NetworkRunnable for Cmd {
         client
             .verify_network_passphrase(Some(&network.network_passphrase))
             .await?;
-        let key = config.key_pair()?;
-
         // Get the account sequence number
-        let public_strkey =
-            stellar_strkey::ed25519::PublicKey(key.verifying_key().to_bytes()).to_string();
+        let public_strkey = config.source_account().await?;
         // TODO: use symbols for the method names (both here and in serve)
-        let account_details = client.get_account(&public_strkey).await?;
+        let account_details = client.get_account(&public_strkey.to_string()).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);
@@ -113,7 +110,7 @@ impl NetworkRunnable for Cmd {
             sequence + 1,
             self.fee.fee,
             network_passphrase,
-            &key,
+            &public_strkey,
         )?;
         if self.fee.build_only {
             return Ok(TxnResult::Txn(tx));
@@ -124,7 +121,7 @@ impl NetworkRunnable for Cmd {
             return Ok(TxnResult::Txn(txn));
         }
         let get_txn_resp = client
-            .send_transaction_polling(&self.config.sign_with_local_key(txn).await?)
+            .send_transaction_polling(&self.config.sign(txn).await?)
             .await?
             .try_into()?;
         if args.map_or(true, |a| !a.no_cache) {
@@ -141,7 +138,7 @@ fn build_wrap_token_tx(
     sequence: i64,
     fee: u32,
     _network_passphrase: &str,
-    key: &ed25519_dalek::SigningKey,
+    key: &stellar_strkey::ed25519::PublicKey,
 ) -> Result<Transaction, Error> {
     let contract = ScAddress::Contract(contract_id.clone());
     let mut read_write = vec![
@@ -180,7 +177,7 @@ fn build_wrap_token_tx(
     };
 
     Ok(Transaction {
-        source_account: MuxedAccount::Ed25519(Uint256(key.verifying_key().to_bytes())),
+        source_account: MuxedAccount::Ed25519(Uint256(key.0)),
         fee,
         seq_num: SequenceNumber(sequence),
         cond: Preconditions::None,