feat: add tx::builder module and initial classic commands

cmd/crates/soroban-test/Cargo.toml

@@ -43,6 +43,7 @@ tokio = "1.28.1"
 walkdir = "2.4.0"
 ulid.workspace = true
 ed25519-dalek = { workspace = true }
+hex = { workspace = true }
 
 [features]
 it = []

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

@@ -59,6 +59,7 @@ pub enum Error {
 pub struct TestEnv {
     pub temp_dir: TempDir,
     pub rpc_url: String,
+    pub network_passphrase: String,
 }
 
 impl Default for TestEnv {
@@ -67,6 +68,7 @@ impl Default for TestEnv {
         Self {
             temp_dir,
             rpc_url: "http://localhost:8889/soroban/rpc".to_string(),
+            network_passphrase: LOCAL_NETWORK_PASSPHRASE.to_string(),
         }
     }
 }
@@ -100,10 +102,13 @@ impl TestEnv {
     }
 
     pub fn with_rpc_url(rpc_url: &str) -> TestEnv {
-        let env = TestEnv {
+        let mut env = TestEnv {
             rpc_url: rpc_url.to_string(),
             ..Default::default()
         };
+        if let Ok(network_passphrase) = std::env::var("STELLAR_NETWORK_PASSPHRASE") {
+            env.network_passphrase = network_passphrase;
+        };
         env.generate_account("test", None).assert().success();
         env
     }
@@ -112,6 +117,9 @@ impl TestEnv {
         if let Ok(rpc_url) = std::env::var("SOROBAN_RPC_URL") {
             return Self::with_rpc_url(&rpc_url);
         }
+        if let Ok(rpc_url) = std::env::var("STELLAR_RPC_URL") {
+            return Self::with_rpc_url(&rpc_url);
+        }
         let host_port = std::env::var("SOROBAN_PORT")
             .as_deref()
             .ok()
@@ -193,7 +201,7 @@ impl TestEnv {
         command_str: &[I],
         source: &str,
     ) -> Result<String, invoke::Error> {
-        let cmd = self.cmd_with_config::<I, invoke::Cmd>(command_str);
+        let cmd = self.cmd_with_config::<I, invoke::Cmd>(command_str, None);
         self.run_cmd_with(cmd, source)
             .await
             .map(|r| r.into_result().unwrap())
@@ -203,12 +211,15 @@ impl TestEnv {
     pub fn cmd_with_config<I: AsRef<str>, T: CommandParser<T> + NetworkRunnable>(
         &self,
         command_str: &[I],
+        source_account: Option<&str>,
     ) -> T {
+        let source = source_account.unwrap_or("test");
+        let source_str = format!("--source-account={source}");
         let mut arg = vec![
             "--network=local",
             "--rpc-url=http",
             "--network-passphrase=AA",
-            "--source-account=test",
+            source_str.as_str(),
         ];
         let input = command_str
             .iter()
@@ -227,7 +238,7 @@ impl TestEnv {
                 network_passphrase: Some(LOCAL_NETWORK_PASSPHRASE.to_string()),
                 network: None,
             },
-            source_account: account.to_string(),
+            source_account: account.parse().unwrap(),
             locator: config::locator::Args {
                 global: false,
                 config_dir,

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

@@ -12,7 +12,8 @@ fn parse_command(command: &str) -> Vec<String> {
         .collect()
 }
 
-async fn run_command(
+#[allow(clippy::too_many_lines, clippy::too_many_arguments)]
+fn run_command(
     sandbox: &TestEnv,
     command: &str,
     wasm_path: &str,
@@ -133,7 +134,8 @@ async fn run_command(
     Ok(())
 }
 
-async fn test_mdx_file(
+#[allow(clippy::too_many_arguments)]
+fn test_mdx_file(
     sandbox: &TestEnv,
     file_path: &str,
     wasm_path: &str,
@@ -145,15 +147,15 @@ async fn test_mdx_file(
     key_xdr: &str,
 ) -> Result<(), String> {
     let content = fs::read_to_string(file_path)
-        .map_err(|e| format!("Failed to read file {}: {}", file_path, e))?;
+        .map_err(|e| format!("Failed to read file {file_path}: {e}"))?;
 
     let commands: Vec<&str> = content
         .split("```bash")
         .skip(1)
         .filter_map(|block| block.split("```").next())
         .collect();
 
-    println!("Testing commands from file: {}", file_path);
+    println!("Testing commands from file: {file_path}");
 
     for (i, command) in commands.iter().enumerate() {
         println!("Running command {}: {}", i + 1, command);
@@ -167,8 +169,7 @@ async fn test_mdx_file(
             bob_id,
             native_id,
             key_xdr,
-        )
-        .await?;
+        )?;
     }
 
     Ok(())
@@ -260,9 +261,7 @@ mod tests {
         let key_xdr = read_xdr.split(',').next().unwrap_or("").trim();
         let repo_root = get_repo_root();
         let docs_dir = repo_root.join("cookbook");
-        if !docs_dir.is_dir() {
-            panic!("docs directory not found");
-        }
+        assert!(docs_dir.is_dir(), "docs directory not found");
 
         for entry in fs::read_dir(docs_dir).expect("Failed to read docs directory") {
             let entry = entry.expect("Failed to read directory entry");
@@ -273,18 +272,16 @@ mod tests {
                 match test_mdx_file(
                     &sandbox,
                     file_path,
-                    &wasm_path.to_str().unwrap(),
+                    wasm_path.to_str().unwrap(),
                     &wasm_hash,
                     source,
                     &contract_id,
                     &bob_id,
                     &native_id,
-                    &key_xdr,
-                )
-                .await
-                {
-                    Ok(_) => println!("Successfully tested all commands in {}", file_path),
-                    Err(e) => panic!("Error testing {}: {}", file_path, e),
+                    key_xdr,
+                ) {
+                    Ok(()) => println!("Successfully tested all commands in {file_path}"),
+                    Err(e) => panic!("Error testing {file_path}: {e}"),
                 }
             }
         }

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

@@ -4,7 +4,7 @@ use soroban_cli::{
         contract::{self, fetch},
         txn_result::TxnResult,
     },
-    config::{locator, secret},
+    config::{address::Address, locator, secret},
 };
 use soroban_rpc::GetLatestLedgerResponse;
 use soroban_test::{AssertExt, TestEnv, LOCAL_NETWORK_PASSPHRASE};
@@ -20,7 +20,7 @@ async fn invoke_view_with_non_existent_source_account() {
     let id = deploy_hello(sandbox).await;
     let world = "world";
     let mut cmd = hello_world_cmd(&id, world);
-    cmd.config.source_account = String::new();
+    cmd.config.source_account = Address::default();
     cmd.is_view = true;
     let res = sandbox.run_cmd_with(cmd, "test").await.unwrap();
     assert_eq!(res, TxnResult::Res(format!(r#"["Hello",{world:?}]"#)));
@@ -94,7 +94,7 @@ async fn invoke() {
     sandbox
         .new_assert_cmd("events")
         .arg("--start-ledger")
-        .arg(&sequence.to_string())
+        .arg(sequence.to_string())
         .arg("--id")
         .arg(id)
         .assert()
@@ -144,7 +144,7 @@ async fn invoke() {
     invoke_log(sandbox, id);
 }
 
-fn invoke_hello_world(sandbox: &TestEnv, id: &str) {
+pub(crate) fn invoke_hello_world(sandbox: &TestEnv, id: &str) {
     sandbox
         .new_assert_cmd("contract")
         .arg("invoke")
@@ -324,7 +324,7 @@ async fn half_max_instructions() {
         .arg("--fee")
         .arg("1000000")
         .arg("--instructions")
-        .arg(&(u32::MAX / 2).to_string())
+        .arg((u32::MAX / 2).to_string())
         .arg("--wasm")
         .arg(wasm.path())
         .arg("--ignore-checks")

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

@@ -3,11 +3,15 @@ use soroban_test::{AssertExt, TestEnv};
 
 use crate::integration::util::{deploy_contract, DeployKind, HELLO_WORLD};
 
+mod operations;
+
 #[tokio::test]
 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;
+    let xdr_base64_build_only =
+        deploy_contract(sandbox, HELLO_WORLD, DeployKind::BuildOnly, None).await;
+    let xdr_base64_sim_only =
+        deploy_contract(sandbox, HELLO_WORLD, DeployKind::SimOnly, None).await;
     let tx_env =
         TransactionEnvelope::from_xdr_base64(&xdr_base64_build_only, Limits::none()).unwrap();
     let tx = soroban_cli::commands::tx::xdr::unwrap_envelope_v1(tx_env).unwrap();
@@ -60,7 +64,7 @@ async fn build_simulate_sign_send() {
         .assert()
         .success();
 
-    let tx_simulated = deploy_contract(sandbox, HELLO_WORLD, DeployKind::SimOnly).await;
+    let tx_simulated = deploy_contract(sandbox, HELLO_WORLD, DeployKind::SimOnly, None).await;
     dbg!("{tx_simulated}");
 
     let tx_signed = sandbox