feat(bens): Added TLD-based fallback for name search in networks

blockscout-ens/bens-logic/src/protocols/protocoler.rs

@@ -66,6 +66,7 @@ pub enum AddressResolveTechnique {
     ReverseRegistry,
     AllDomains,
 }
+const MAX_NAMES_LIMIT: usize = 5;
 
 impl Tld {
     pub fn new(tld: &str) -> Tld {
@@ -203,15 +204,58 @@ impl Protocoler {
         network_id: i64,
         maybe_filter: Option<NonEmpty<String>>,
     ) -> Result<Vec<DomainNameOnProtocol>, ProtocolError> {
-        let tld = Tld::from_domain_name(name)
-            .ok_or_else(|| ProtocolError::InvalidName(name.to_string()))?;
+        let tlds = self
+            .networks
+            .get(&network_id)
+            .ok_or_else(|| ProtocolError::NetworkNotFound(network_id))?
+            .use_protocols
+            .iter()
+            .filter_map(|protocol_name| {
+                self.protocols
+                    .get(protocol_name)
+                    .map(|protocol| protocol.info.tld_list.iter().cloned())
+            })
+            .flatten()
+            .collect::<Vec<Tld>>();
+
+        if name.contains('.') {
+            return self.find_names_with_tld(name, network_id, maybe_filter);
+        }
+
+        let mut all_names_with_protocols = Vec::new();
+        for tld in tlds {
+            if all_names_with_protocols.len() >= MAX_NAMES_LIMIT {
+                break;
+            }
+            let name_with_tld = format!("{}.{}", name, tld.0);
+            if let Ok(mut names) = self.find_names_with_tld(&name_with_tld, network_id, maybe_filter.clone()) {
+                all_names_with_protocols.append(&mut names);
+            }
+        }
+
+        if all_names_with_protocols.is_empty() {
+            return Err(ProtocolError::InvalidName(name.to_string()));
+        }
+
+        Ok(all_names_with_protocols.into_iter().take(MAX_NAMES_LIMIT).collect())
+    }
+
+    fn find_names_with_tld(
+        &self,
+        name_with_tld: &str,
+        network_id: i64,
+        maybe_filter: Option<NonEmpty<String>>,
+    ) -> Result<Vec<DomainNameOnProtocol>, ProtocolError> {
+        let tld = Tld::from_domain_name(name_with_tld)
+            .ok_or_else(|| ProtocolError::InvalidName(name_with_tld.to_string()))?;
         let protocols = self.protocols_of_network_for_tld(network_id, tld, maybe_filter)?;
         let names_with_protocols = protocols
             .into_iter()
-            .filter_map(|p| DomainNameOnProtocol::new(name, p).ok())
+            .filter_map(|p| DomainNameOnProtocol::new(name_with_tld, p).ok())
             .collect();
         Ok(names_with_protocols)
     }
+
 
     pub fn main_name_in_network(
         &self,