fix: add From<&String> ValidatorId, remove uneeded closure

Author: samparsky

adapter/src/ethereum.rs

@@ -66,10 +66,10 @@ impl EthereumAdapter {
             }
         };
 
-        let identity = ValidatorId::try_from(address.as_str())?;
+        let address = ValidatorId::try_from(&address)?;
 
         Ok(Self {
-            address: identity,
+            address,
             keystore_json,
             keystore_pwd: opts.keystore_pwd.into(),
             session_tokens: HashMap::new(),
@@ -118,7 +118,7 @@ impl Adapter for EthereumAdapter {
     fn verify(&self, signer: &ValidatorId, state_root: &str, sig: &str) -> AdapterResult<bool> {
         let decoded_signature = hex::decode(sig)
             .map_err(|_| AdapterError::Signature("invalid signature".to_string()))?;
-        let address = Address::from_slice(&signer.inner());
+        let address = Address::from_slice(signer.inner());
         let signature = Signature::from_electrum(&decoded_signature);
         let message = Message::from_slice(&hash_message(state_root));
 
@@ -222,7 +222,7 @@ impl Adapter for EthereumAdapter {
                 }
                 Session {
                     era: verified.payload.era,
-                    uid: ValidatorId::try_from(identity.as_str())?,
+                    uid: ValidatorId::try_from(identity)?,
                 }
             }
             None => Session {
@@ -374,7 +374,7 @@ pub fn ewt_verify(
     let payload: Payload = serde_json::from_str(&payload_string)?;
 
     let verified_payload = VerifyPayload {
-        from: ValidatorId::try_from(format!("{:?}", address).as_str())?,
+        from: ValidatorId::try_from(&format!("{:?}", address))?,
         payload,
     };
 

primitives/src/channel_validator.rs

@@ -7,7 +7,7 @@ use std::convert::TryFrom;
 pub trait ChannelValidator {
     fn is_channel_valid(config: &Config, channel: &Channel) -> Result<(), ChannelError> {
         let identity = &config.clone().identity.unwrap_or_else(|| "".to_string());
-        let validator_identity = ValidatorId::try_from(&identity[..]).map_err(|_| {
+        let validator_identity = ValidatorId::try_from(identity).map_err(|_| {
             ChannelError::InvalidArgument("Failed to deserialize identity".to_string())
         })?;
         let adapter_channel_validator = match channel.spec.validators.find(&validator_identity) {
@@ -50,8 +50,7 @@ pub fn all_validators_listed(validators: &SpecValidators, whitelist: &[String])
     } else {
         let found_validators = whitelist
             .iter()
-            .map(|identity| ValidatorId::try_from(&identity[..]))
-            .filter_map(Result::ok)
+            .filter_map(|identity| ValidatorId::try_from(identity).ok())
             .filter(|allowed| {
                 allowed == &validators.leader().id || allowed == &validators.follower().id
             })

primitives/src/validator.rs

@@ -24,8 +24,8 @@ pub type ValidatorFuture<T> = Pin<Box<dyn Future<Output = Result<T, ValidatorErr
 pub struct ValidatorId(#[serde(with = "SerHex::<StrictPfx>")] [u8; 20]);
 
 impl ValidatorId {
-    pub fn inner(&self) -> [u8; 20] {
-        self.0
+    pub fn inner(&self) -> &[u8; 20] {
+        &self.0
     }
 
     pub fn to_hex_non_prefix_string(&self) -> String {
@@ -54,6 +54,15 @@ impl TryFrom<&str> for ValidatorId {
     }
 }
 
+impl TryFrom<&String> for ValidatorId {
+    type Error = DomainError;
+    fn try_from(value: &String) -> Result<Self, Self::Error> {
+        ValidatorId::try_from(value.as_str()).map_err(|_| {
+            DomainError::InvalidArgument("Failed to deserialize validator id".to_string())
+        })
+    }
+}
+
 impl fmt::Display for ValidatorId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", format!("0x{}", hex::encode(self.0)))

validator_worker/src/lib.rs

@@ -31,11 +31,11 @@ pub(crate) fn get_state_root_hash<A: Adapter + 'static>(
     // Note: MerkleTree takes care of deduplicating and sorting
     let elems: Vec<[u8; 32]> = balances
         .iter()
-        .map(|(acc, amount)| get_balance_leaf(&ValidatorId::try_from(acc.as_str())?, amount))
+        .map(|(acc, amount)| get_balance_leaf(&ValidatorId::try_from(acc)?, amount))
         .collect::<Result<_, _>>()?;
 
     let tree = MerkleTree::new(&elems);
-    // keccak256(channelId, balanceRoot)
+    // keccak256(channelId, balanceRoot
     get_signable_state_root(&iface.channel.id, &tree.root())
 }