From 7d710e894479f2e0390f94e1f6b8a84c9112cd8d Mon Sep 17 00:00:00 2001 From: Willem Wyndham Date: Mon, 2 Dec 2024 09:38:41 -0500 Subject: [PATCH] feat: rename to unresolvedX to make it names clearer --- .../src/commands/contract/arg_parsing.rs | 8 +++--- cmd/soroban-cli/src/config/address.rs | 16 ++++++------ cmd/soroban-cli/src/config/alias.rs | 20 +++++++-------- cmd/soroban-cli/src/config/sc_address.rs | 25 ++++++++++--------- 4 files changed, 35 insertions(+), 34 deletions(-) diff --git a/cmd/soroban-cli/src/commands/contract/arg_parsing.rs b/cmd/soroban-cli/src/commands/contract/arg_parsing.rs index ae068a25b..a223851ca 100644 --- a/cmd/soroban-cli/src/commands/contract/arg_parsing.rs +++ b/cmd/soroban-cli/src/commands/contract/arg_parsing.rs @@ -15,7 +15,7 @@ use crate::xdr::{ use crate::commands::txn_result::TxnResult; use crate::config::{ self, - sc_address::{self, ScAddress}, + sc_address::{self, UnresolvedScAddress}, }; use soroban_spec_tools::Spec; @@ -254,10 +254,10 @@ pub fn output_to_string( } fn resolve_address(addr_or_alias: &str, config: &config::Args) -> Result { - let sc_address: ScAddress = addr_or_alias.parse().unwrap(); + let sc_address: UnresolvedScAddress = addr_or_alias.parse().unwrap(); let account = match sc_address { - ScAddress::Address(addr) => addr.to_string(), - addr @ ScAddress::Alias(_) => { + UnresolvedScAddress::Resolved(addr) => addr.to_string(), + addr @ UnresolvedScAddress::Alias(_) => { let addr = addr.resolve(&config.locator, &config.get_network()?.network_passphrase)?; match addr { xdr::ScAddress::Account(account) => account.to_string(), diff --git a/cmd/soroban-cli/src/config/address.rs b/cmd/soroban-cli/src/config/address.rs index aa3116a13..4aef0b8a8 100644 --- a/cmd/soroban-cli/src/config/address.rs +++ b/cmd/soroban-cli/src/config/address.rs @@ -27,26 +27,26 @@ pub enum Error { CannotSign(xdr::MuxedAccount), } -impl FromStr for Address { +impl FromStr for UnresolvedMuxedAccount { type Err = Error; fn from_str(value: &str) -> Result { Ok(xdr::MuxedAccount::from_str(value).map_or_else( - |_| Address::AliasOrSecret(value.to_string()), - Address::MuxedAccount, + |_| UnresolvedMuxedAccount::AliasOrSecret(value.to_string()), + UnresolvedMuxedAccount::Resolved, )) } } -impl Address { +impl UnresolvedMuxedAccount { pub fn resolve_muxed_account( &self, locator: &locator::Args, hd_path: Option, ) -> Result { match self { - Address::MuxedAccount(muxed_account) => Ok(muxed_account.clone()), - Address::AliasOrSecret(alias) => { + UnresolvedMuxedAccount::Resolved(muxed_account) => Ok(muxed_account.clone()), + UnresolvedMuxedAccount::AliasOrSecret(alias) => { Self::resolve_muxed_account_with_alias(alias, locator, hd_path) } } @@ -66,8 +66,8 @@ impl Address { pub fn resolve_secret(&self, locator: &locator::Args) -> Result { match &self { - Address::MuxedAccount(muxed_account) => Err(Error::CannotSign(muxed_account.clone())), - Address::AliasOrSecret(alias) => Ok(locator.read_identity(alias)?), + UnresolvedMuxedAccount::Resolved(muxed_account) => Err(Error::CannotSign(muxed_account.clone())), + UnresolvedMuxedAccount::AliasOrSecret(alias) => Ok(locator.read_identity(alias)?), } } } diff --git a/cmd/soroban-cli/src/config/alias.rs b/cmd/soroban-cli/src/config/alias.rs index 6d49dd798..734925c4e 100644 --- a/cmd/soroban-cli/src/config/alias.rs +++ b/cmd/soroban-cli/src/config/alias.rs @@ -11,37 +11,37 @@ pub struct Data { /// Address can be either a contract address, C.. or eventually an alias of a contract address. #[derive(Clone, Debug)] -pub enum ContractAddress { - ContractId(stellar_strkey::Contract), +pub enum UnresolvedContract { + Resolved(stellar_strkey::Contract), Alias(String), } -impl Default for ContractAddress { +impl Default for UnresolvedContract { fn default() -> Self { - ContractAddress::Alias(String::default()) + UnresolvedContract::Alias(String::default()) } } -impl FromStr for ContractAddress { +impl FromStr for UnresolvedContract { type Err = Infallible; fn from_str(value: &str) -> Result { Ok(stellar_strkey::Contract::from_str(value).map_or_else( - |_| ContractAddress::Alias(value.to_string()), - ContractAddress::ContractId, + |_| UnresolvedContract::Alias(value.to_string()), + UnresolvedContract::Resolved, )) } } -impl ContractAddress { +impl UnresolvedContract { pub fn resolve_contract_id( &self, locator: &locator::Args, network_passphrase: &str, ) -> Result { match self { - ContractAddress::ContractId(contract) => Ok(*contract), - ContractAddress::Alias(alias) => { + UnresolvedContract::Resolved(contract) => Ok(*contract), + UnresolvedContract::Alias(alias) => { Self::resolve_alias(alias, locator, network_passphrase) } } diff --git a/cmd/soroban-cli/src/config/sc_address.rs b/cmd/soroban-cli/src/config/sc_address.rs index 26eaf9641..ef12dc16b 100644 --- a/cmd/soroban-cli/src/config/sc_address.rs +++ b/cmd/soroban-cli/src/config/sc_address.rs @@ -2,18 +2,19 @@ use std::str::FromStr; use crate::xdr; -use super::{address, locator, ContractAddress}; +use super::{address, locator, UnresolvedContract}; /// `ScAddress` can be either a resolved `xdr::ScAddress` or an alias of a `Contract` or `MuxedAccount`. +#[allow(clippy::module_name_repetitions)] #[derive(Clone, Debug)] -pub enum ScAddress { - Address(xdr::ScAddress), +pub enum UnresolvedScAddress { + Resolved(xdr::ScAddress), Alias(String), } -impl Default for ScAddress { +impl Default for UnresolvedScAddress { fn default() -> Self { - ScAddress::Alias(String::default()) + UnresolvedScAddress::Alias(String::default()) } } @@ -27,27 +28,27 @@ pub enum Error { AccountAliasNotFound(String), } -impl FromStr for ScAddress { +impl FromStr for UnresolvedScAddress { type Err = Error; fn from_str(value: &str) -> Result { Ok(xdr::ScAddress::from_str(value) - .map_or_else(|_| ScAddress::Alias(value.to_string()), ScAddress::Address)) + .map_or_else(|_| UnresolvedScAddress::Alias(value.to_string()), UnresolvedScAddress::Resolved)) } } -impl ScAddress { +impl UnresolvedScAddress { pub fn resolve( self, locator: &locator::Args, network_passphrase: &str, ) -> Result { let alias = match self { - ScAddress::Address(addr) => return Ok(addr), - ScAddress::Alias(alias) => alias, + UnresolvedScAddress::Resolved(addr) => return Ok(addr), + UnresolvedScAddress::Alias(alias) => alias, }; - let contract = ContractAddress::resolve_alias(&alias, locator, network_passphrase); - let muxed_account = super::Address::resolve_muxed_account_with_alias(&alias, locator, None); + let contract = UnresolvedContract::resolve_alias(&alias, locator, network_passphrase); + let muxed_account = super::UnresolvedMuxedAccount::resolve_muxed_account_with_alias(&alias, locator, None); match (contract, muxed_account) { (Ok(contract), _) => Ok(xdr::ScAddress::Contract(xdr::Hash(contract.0))), (_, Ok(muxed_account)) => Ok(xdr::ScAddress::Account(muxed_account.account_id())),