Implement TryFrom<String> for PrincipalData

devenv/README.md

@@ -103,7 +103,7 @@ You can access the [Stacks Explorer](https://github.com/hirosystems/explorer)
 at:
 
 ```
-http://127.0.0.1:3020/?chain=testnet
+http://127.0.0.1:3020/?chain=testnet&api=http://127.0.0.1:3999
 ```
 It's important to use the above URL, as it can parse blocks properly.
 

sbtc-cli/src/commands/deposit.rs

@@ -14,7 +14,7 @@
 };
 use clap::Parser;
 use sbtc_core::operations::op_return::deposit::build_deposit_transaction;
-use stacks_core::address::StacksAddress;
+use stacks_core::utils::PrincipalData;
 use url::Url;
 
 use crate::commands::utils;
@@ -68,13 +68,12 @@
 
 	wallet.sync(&blockchain, SyncOptions::default())?;
 
-	let recipient_address =
-		StacksAddress::try_from(deposit.recipient.as_str())?;
+	let stx_recipient = PrincipalData::try_from(deposit.recipient.to_string())?;
 	let sbtc_wallet_address = BitcoinAddress::from_str(&deposit.sbtc_wallet)?;
 
 	let tx = build_deposit_transaction(
 		wallet,
-		recipient_address.into(),
+		stx_recipient,
 		sbtc_wallet_address,
 		deposit.amount,
 		deposit.network,

stacks-core/src/crypto/wif.rs

@@ -53,7 +53,7 @@
 		{
 			Ok(())
 		} else {
-			Err(StacksError::InvalidData("WIF is invalid"))
+			Err(StacksError::InvalidData("WIF is invalid".into()))
 		}
 	}
 
@@ -62,7 +62,7 @@
 		match WIFPrefix::from_repr(self.0[0]) {
 			Some(WIFPrefix::Mainnet) => Ok(Network::Mainnet),
 			Some(WIFPrefix::Testnet) => Ok(Network::Testnet),
-			_ => Err(StacksError::InvalidData("Unknown network byte")),
+			_ => Err(StacksError::InvalidData("Unknown network byte".into())),
 		}
 	}
 

stacks-core/src/lib.rs

@@ -51,7 +51,7 @@ pub enum StacksError {
 	CodecError(#[from] CodecError),
 	#[error("Invalid data: {0}")]
 	/// Invalid data
-	InvalidData(&'static str),
+	InvalidData(String),
 	/// BIP32 Error
 	#[error("BIP32 error: {0}")]
 	BIP32(#[from] bdk::bitcoin::util::bip32::Error),

stacks-core/src/utils.rs

@@ -6,6 +6,7 @@
 	address::{AddressVersion, StacksAddress},
 	codec::Codec,
 	contract_name::ContractName,
+	StacksError,
 };
 
 #[derive(PartialEq, Eq, Debug, Clone)]
@@ -111,6 +112,38 @@
 	}
 }
 
+impl TryFrom<String> for PrincipalData {
+	type Error = StacksError;
+
+	fn try_from(value: String) -> Result<Self, Self::Error> {
+		let parts: Vec<&str> = value.split('.').collect();
+
+		match parts.len() {
+			1 => {
+				let address = StacksAddress::try_from(parts[0])?;
+				Ok(Self::Standard(StandardPrincipalData::from(address)))
+			}
+			2 => {
+				let address = StacksAddress::try_from(parts[0])?;
+				let contract_name =
+					ContractName::new(parts[1]).map_err(|err| {
+						StacksError::InvalidData(format!(
+							"Invalid contract name from {value}: {err}"
+						))
+					})?;
+
+				Ok(Self::Contract(
+					StandardPrincipalData::from(address),
+					contract_name,
+				))
+			}
+			_ => Err(StacksError::InvalidData(format!(
+				"Principal data from {value} may contain at most 1 dot character"
+			))),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -212,4 +245,50 @@
 
 		assert_eq!(deserialized, expected_principal_data);
 	}
+
+	#[test]
+	fn should_principal_data_try_from_string() {
+		// addr = ST000000000000000000002AMW42H
+		let addr = StacksAddress::new(
+			AddressVersion::TestnetSingleSig,
+			Hash160Hasher::default(),
+		);
+		let principal_data: PrincipalData = PrincipalData::try_from(
+			"ST000000000000000000002AMW42H.helloworld".to_string(),
+		)
+		.unwrap();
+
+		assert_eq!(
+			principal_data,
+			PrincipalData::Contract(
+				StandardPrincipalData(addr.version(), addr.clone()),
+				ContractName::new("helloworld").unwrap(),
+			)
+		);
+	}
+
+	#[test]
+	fn should_fail_to_convert_invalid_string_to_principal_data() {
+		// try invalid address
+		let mut result =
+			PrincipalData::try_from("ST123.helloworld".to_string());
+
+		assert_eq!(
+			result.unwrap_err().to_string(),
+			StacksError::C32Error(crate::c32::C32Error::InvalidAddress(
+				"ST123".into()
+			))
+			.to_string()
+		);
+
+		// try contract name with a space
+		result = PrincipalData::try_from(
+			"ST000000000000000000002AMW42H.hello contract".to_string(),
+		);
+
+		assert_eq!(
+			result.unwrap_err().to_string(),
+			StacksError::InvalidData("Invalid contract name from ST000000000000000000002AMW42H.hello contract: Format should follow the contract name specification".into()).to_string()
+		);
+	}
 }