Add support for contract id alias name when deploying and invoking contracts.

FULL_HELP_DOCS.md

@@ -452,6 +452,7 @@ Deploy a wasm contract
 
   Possible values: `true`, `false`
 
+* `--alias <ALIAS>` — The alias that will be used to save the contract's id
 
 
 

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

@@ -1,9 +1,13 @@
-use std::array::TryFromSliceError;
 use std::fmt::Debug;
+use std::fs::create_dir_all;
+use std::io::Write;
 use std::num::ParseIntError;
+use std::path::PathBuf;
+use std::{array::TryFromSliceError, fs::OpenOptions};
 
 use clap::{arg, command, Parser};
 use rand::Rng;
+use regex::Regex;
 use soroban_env_host::{
     xdr::{
         AccountId, ContractExecutable, ContractIdPreimage, ContractIdPreimageFromAddress,
@@ -54,6 +58,9 @@ pub struct Cmd {
     #[arg(long, short = 'i', default_value = "false")]
     /// Whether to ignore safety checks when deploying contracts
     pub ignore_checks: bool,
+    /// The alias that will be used to save the contract's id.
+    #[arg(long)]
+    pub alias: Option<String>,
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -100,19 +107,85 @@ pub enum Error {
     Network(#[from] network::Error),
     #[error(transparent)]
     Wasm(#[from] wasm::Error),
+    #[error("cannot access config dir for alias file")]
+    CannotAccessConfigDir,
+    #[error("cannot create alias file")]
+    CannotCreateAliasFile,
+    #[error(
+        "alias must be 1-30 chars long, and have only letters, numbers, underscores and dashes"
+    )]
+    InvalidAliasFormat { alias: String },
 }
 
 impl Cmd {
     pub async fn run(&self) -> Result<(), Error> {
+        self.validate_alias()?;
+
         let res = self.run_against_rpc_server(None, None).await?.to_envelope();
         match res {
             TxnEnvelopeResult::TxnEnvelope(tx) => println!("{}", tx.to_xdr_base64(Limits::none())?),
             TxnEnvelopeResult::Res(contract) => {
+                self.save_contract_id(&contract)?;
                 println!("{contract}");
             }
         }
         Ok(())
     }
+
+    fn validate_alias(&self) -> Result<(), Error> {
+        let alias = self.alias();
+
+        if alias.is_empty() {
+            return Ok(());
+        }
+
+        let regex = Regex::new(r"^[a-zA-Z0-9_-]{1,30}$").unwrap();
+
+        if regex.is_match(&alias) {
+            Ok(())
+        } else {
+            Err(Error::InvalidAliasFormat { alias })
+        }
+    }
+
+    fn alias(&self) -> String {
+        self.alias.as_ref().map(Clone::clone).unwrap_or_default()
+    }
+
+    fn alias_path(&self) -> Result<PathBuf, Error> {
+        let config_dir = self.config.config_dir()?;
+        let network = self.config.network.network.clone().expect("must be set");
+
+        Ok(self
+            .alias
+            .as_ref()
+            .map(|alias| config_dir.join("contract-ids").join(network).join(alias))
+            .expect("must be set"))
+    }
+
+    fn save_contract_id(&self, contract: &String) -> Result<(), Error> {
+        let file_path = self.alias_path()?;
+
+        let Some(dir) = file_path.parent() else {
+            return Err(Error::CannotAccessConfigDir);
+        };
+
+        match create_dir_all(dir) {
+            Ok(()) => {}
+            _ => return Err(Error::CannotAccessConfigDir),
+        };
+
+        let mut to_file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .open(file_path)
+            .expect("cannot open file");
+
+        match to_file.write_all(contract.as_bytes()) {
+            Ok(()) => Ok(()),
+            Err(_) => Err(Error::CannotCreateAliasFile),
+        }
+    }
 }
 
 #[async_trait::async_trait]

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

@@ -152,6 +152,10 @@ pub enum Error {
     Network(#[from] network::Error),
     #[error(transparent)]
     GetSpecError(#[from] get_spec::Error),
+    #[error("unable to read alias file")]
+    UnableToReadAliasFile,
+    #[error("alias file not found")]
+    NoAliasFileFound,
 }
 
 impl From<Infallible> for Error {
@@ -305,8 +309,32 @@ impl Cmd {
 
 impl Cmd {
     fn contract_id(&self) -> Result<[u8; 32], Error> {
-        soroban_spec_tools::utils::contract_id_from_str(&self.contract_id)
-            .map_err(|e| Error::CannotParseContractId(self.contract_id.clone(), e))
+        let contract_id = match self.load_contract_id() {
+            Ok(Some(id)) => id,
+            _ => self.contract_id.clone(),
+        };
+
+        soroban_spec_tools::utils::contract_id_from_str(&contract_id)
+            .map_err(|e| Error::CannotParseContractId(contract_id.clone(), e))
+    }
+
+    fn alias_path(&self) -> Result<PathBuf, Error> {
+        let config_dir = self.config.config_dir()?;
+        let network = self.config.network.network.clone().expect("must be set");
+
+        Ok(config_dir
+            .join("contract-ids")
+            .join(network)
+            .join(&self.contract_id))
+    }
+
+    fn load_contract_id(&self) -> Result<Option<String>, Error> {
+        let file_path = self.alias_path()?;
+
+        Ok(file_path
+            .exists()
+            .then(|| fs::read_to_string(file_path))
+            .transpose()?)
     }
 }