feat: tx sign and new signer

FULL_HELP_DOCS.md

@@ -1291,6 +1291,7 @@ Sign, Simulate, and Send transactions
 
 * `simulate` — Simulate a transaction envelope from stdin
 * `hash` — Calculate the hash of a transaction envelope from stdin
+* `sign` — Sign a transaction envolope appending the signature to the envelope
 
 
 
@@ -1326,6 +1327,26 @@ Calculate the hash of a transaction envelope from stdin
 
 
 
+## `stellar tx sign`
+
+Sign a transaction envolope appending the signature to the envelope
+
+**Usage:** `stellar tx sign [OPTIONS]`
+
+###### **Options:**
+
+* `--sign-with-key <SIGN_WITH_KEY>` — Sign with a local key. Can be an identity (--sign-with-key alice), a secret key (--sign-with-key SC36…), or a seed phrase (--sign-with-key "kite urban…"). If using seed phrase, `--hd-path` defaults to the `0` path
+* `--hd-path <HD_PATH>` — If using a seed phrase to sign, sets which hierarchical deterministic path to use, e.g. `m/44'/148'/{hd_path}`. Example: `--hd-path 1`. Default: `0`
+* `--yes` — If one of `--sign-with-*` flags is provided, don't ask to confirm to sign a transaction
+* `--rpc-url <RPC_URL>` — RPC server endpoint
+* `--network-passphrase <NETWORK_PASSPHRASE>` — Network passphrase to sign the transaction sent to the rpc server
+* `--network <NETWORK>` — Name of network to use from config
+* `--global` — Use global config
+* `--config-dir <CONFIG_DIR>` — Location of config directory, default is "."
+* `--source-account <SOURCE_ACCOUNT>` — Source account of the transaction. By default will be the account that signs the transaction
+
+
+
 ## `stellar xdr`
 
 Decode and encode XDR

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,50 @@ 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 rpc_result = send_manually(sandbox, &tx_env).await;
+
+    println!("Transaction sent: {rpc_result}");
+}
+
+async fn send_manually(sandbox: &TestEnv, tx_env: &TransactionEnvelope) -> String {
+    let client = soroban_rpc::Client::new(&sandbox.rpc_url).unwrap();
+    let res = client.send_transaction_polling(tx_env).await.unwrap();
+    serde_json::to_string_pretty(&res).unwrap()
+}
+
+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

@@ -123,6 +123,7 @@ humantime = "2.1.0"
 phf = { version = "0.11.2", features = ["macros"] }
 semver = "1.0.0"
 glob = "0.3.1"
+crossterm = "0.28.1"
 
 # For hyper-tls
 [target.'cfg(unix)'.dependencies]

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

@@ -3,6 +3,7 @@ use clap::Parser;
 use super::global;
 
 pub mod hash;
+pub mod sign;
 pub mod simulate;
 pub mod xdr;
 
@@ -12,6 +13,8 @@ pub enum Cmd {
     Simulate(simulate::Cmd),
     /// Calculate the hash of a transaction envelope from stdin
     Hash(hash::Cmd),
+    /// Sign a transaction envolope appending the signature to the envelope
+    Sign(sign::Cmd),
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -22,13 +25,16 @@ pub enum Error {
     /// An error during hash calculation
     #[error(transparent)]
     Hash(#[from] hash::Error),
+    #[error(transparent)]
+    Sign(#[from] sign::Error),
 }
 
 impl Cmd {
     pub async fn run(&self, global_args: &global::Args) -> Result<(), Error> {
         match self {
             Cmd::Simulate(cmd) => cmd.run(global_args).await?,
             Cmd::Hash(cmd) => cmd.run(global_args)?,
+            Cmd::Sign(cmd) => cmd.run().await?,
         };
         Ok(())
     }

cmd/soroban-cli/src/commands/tx/sign.rs

@@ -0,0 +1,35 @@
+use crate::{
+    config::sign_with,
+    xdr::{self, Limits, TransactionEnvelope, WriteXdr},
+};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    XdrArgs(#[from] super::xdr::Error),
+    #[error(transparent)]
+    SignWith(#[from] sign_with::Error),
+    #[error(transparent)]
+    Xdr(#[from] xdr::Error),
+}
+
+#[derive(Debug, clap::Parser, Clone)]
+#[group(skip)]
+pub struct Cmd {
+    #[command(flatten)]
+    pub sign_with: sign_with::Args,
+}
+
+impl Cmd {
+    #[allow(clippy::unused_async)]
+    pub async fn run(&self) -> Result<(), Error> {
+        let txn_env = super::xdr::tx_envelope_from_stdin()?;
+        let envelope = self.sign_tx_env(txn_env).await?;
+        println!("{}", envelope.to_xdr_base64(Limits::none())?.trim());
+        Ok(())
+    }
+
+    pub async fn sign_tx_env(&self, tx: TransactionEnvelope) -> Result<TransactionEnvelope, Error> {
+        Ok(self.sign_with.sign_txn_env(tx).await?)
+    }
+}

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

@@ -217,6 +217,14 @@ impl Args {
         KeyType::Identity.read_with_global(name, &self.local_config()?)
     }
 
+    pub fn account(&self, account_str: &str) -> Result<Secret, Error> {
+        if let Ok(signer) = account_str.parse::<Secret>() {
+            Ok(signer)
+        } else {
+            self.read_identity(account_str)
+        }
+    }
+
     pub fn read_network(&self, name: &str) -> Result<Network, Error> {
         let res = KeyType::Network.read_with_global(name, &self.local_config()?);
         if let Err(Error::ConfigMissing(_, _)) = &res {

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

@@ -18,6 +18,7 @@ pub mod data;
 pub mod locator;
 pub mod network;
 pub mod secret;
+pub mod sign_with;
 pub mod upgrade_check;
 
 #[derive(thiserror::Error, Debug)]

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

@@ -3,7 +3,10 @@ use serde::{Deserialize, Serialize};
 use std::{io::Write, str::FromStr};
 use stellar_strkey::ed25519::{PrivateKey, PublicKey};
 
-use crate::utils;
+use crate::{
+    signer::{self, LocalKey},
+    utils,
+};
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -21,6 +24,8 @@ pub enum Error {
     Ed25519(#[from] ed25519_dalek::SignatureError),
     #[error("Invalid address {0}")]
     InvalidAddress(String),
+    #[error(transparent)]
+    Stellar(#[from] signer::Error),
 }
 
 #[derive(Debug, clap::Args, Clone)]
@@ -120,6 +125,14 @@ impl Secret {
         )?)
     }
 
+    pub fn signer(&self, index: Option<usize>, prompt: bool) -> Result<StellarSigner, Error> {
+        match self {
+            Secret::SecretKey { .. } | Secret::SeedPhrase { .. } => Ok(StellarSigner::Local(
+                LocalKey::new(self.key_pair(index)?, prompt),
+            )),
+        }
+    }
+
     pub fn key_pair(&self, index: Option<usize>) -> Result<ed25519_dalek::SigningKey, Error> {
         Ok(utils::into_signing_key(&self.private_key(index)?))
     }
@@ -140,6 +153,19 @@ impl Secret {
     }
 }
 
+pub enum StellarSigner {
+    Local(LocalKey),
+}
+
+#[async_trait::async_trait]
+impl signer::Blob for StellarSigner {
+    async fn sign_blob(&self, blob: &[u8]) -> Result<Vec<u8>, signer::types::Error> {
+        match self {
+            StellarSigner::Local(signer) => signer.sign_blob(blob).await,
+        }
+    }
+}
+
 fn read_password() -> Result<String, Error> {
     std::io::stdout().flush().map_err(|_| Error::PasswordRead)?;
     rpassword::read_password().map_err(|_| Error::PasswordRead)