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/utils.rs

@@ -6,6 +6,7 @@
 	address::{AddressVersion, StacksAddress},
 	codec::Codec,
 	contract_name::ContractName,
+	StacksError,
 };
 
 #[derive(PartialEq, Eq, Debug, Clone)]
@@ -111,6 +112,36 @@
 	}
 }
 
+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("Invalid contract name")
+					})?;
+
+				Ok(Self::Contract(
+					StandardPrincipalData::from(address),
+					contract_name,
+				))
+			}
+			_ => Err(StacksError::InvalidData(
+				"Principal data may contain at most 1 dot character",
+			)),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -212,4 +243,47 @@
 
 		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(),
+			"Could not crackford32 encode or decode: Invalid C32 address: ST123"
+		);
+
+		// try contract name with a space
+		result = PrincipalData::try_from(
+			"ST000000000000000000002AMW42H.hello contract".to_string(),
+		);
+
+		assert_eq!(
+			result.unwrap_err().to_string(),
+			"Invalid data: Invalid contract name"
+		);
+	}
 }