Added api to query wether an address is a module (#329)

* Added api to query wether an address is a module

* update changelog

* Update framework/packages/abstract-sdk/src/error.rs

* Fixed clippy, added support for Accounts and Native

* error not large anymore

---------

Co-authored-by: Buckram <buckram123@gmail.com>
Co-authored-by: Mykhailo Donchenko <91957742+Buckram123@users.noreply.github.com>

Author: Kayanski

framework/docs/src/releases/v0.md

@@ -7,6 +7,7 @@
 - `state.json` now included in binary in release mode, allowing using binaries on a different environment than it's been built.
 - `module_instantiate2_address_raw` for `AbstractClient`, allowing to install a different version than the dependency version.
 - Added helper functions `assert_registered` and `is_registered` to the ANS client API.
+- Added method `module_info` for querying and verifying wether an address is a module to the ModuleRegistry API.
 - Added default IBC-Client installation on remote modules inside Client and Account interfaces
 
 ### Changed

framework/packages/abstract-sdk/src/apis/version_registry.rs

@@ -2,19 +2,20 @@ use abstract_std::{
     objects::{
         module::{Module, ModuleInfo},
         module_reference::ModuleReference,
+        module_version::MODULE,
         namespace::Namespace,
         version_control::VersionControlContract,
         AccountId,
     },
     version_control::{ModuleConfiguration, ModuleResponse, NamespaceResponse, NamespacesResponse},
 };
-use cosmwasm_std::Deps;
+use cosmwasm_std::{Addr, Deps};
 
 use super::{AbstractApi, ApiIdentification};
 use crate::{
     cw_helpers::ApiQuery,
     features::{AbstractRegistryAccess, ModuleIdentification},
-    AbstractSdkResult,
+    AbstractSdkError, AbstractSdkResult,
 };
 
 /// Access the Abstract Version Control and access module information.
@@ -142,4 +143,58 @@ impl<'a, T: ModuleRegistryInterface> ModuleRegistry<'a, T> {
             .query_standalone_info_raw(code_id, &self.deps.querier)
             .map_err(|error| self.wrap_query_error(error))
     }
+
+    /// Queries the Module information for an address.
+    /// This will error if the Address is not an Abstract Module (Native, Account, App, Adapter or Standalone)
+    pub fn module_info(&self, address: Addr) -> AbstractSdkResult<Module> {
+        // We start by testing if the address is a module
+        let module_response = MODULE
+            .query(&self.deps.querier, address.clone())
+            .map_err(|e| AbstractSdkError::NotAModule {
+                addr: address.clone(),
+                err: e.to_string(),
+            })?;
+
+        // We verify the module is indeed registered inside the version registry
+        let module = self.query_module(ModuleInfo::from_id(
+            &module_response.module,
+            module_response.version.into(),
+        )?)?;
+
+        match module.reference.clone() {
+            ModuleReference::Adapter(queried_address)
+            | ModuleReference::Native(queried_address) => {
+                if queried_address == address {
+                    Ok(module)
+                } else {
+                    Err(AbstractSdkError::WrongModuleInfo {
+                        addr: address.clone(),
+                        module: module.to_string(),
+                        err: format!("Expected address {queried_address}, got address {address}",),
+                    })
+                }
+            }
+            ModuleReference::App(queried_code_id)
+            | ModuleReference::Standalone(queried_code_id)
+            | ModuleReference::AccountBase(queried_code_id) => {
+                let request_contract = self.deps.querier.query_wasm_contract_info(&address)?;
+                if queried_code_id == request_contract.code_id {
+                    Ok(module)
+                } else {
+                    Err(AbstractSdkError::WrongModuleInfo {
+                        addr: address,
+                        module: module.to_string(),
+                        err: format!(
+                            "Expected code_id {queried_code_id}, got code_id {}",
+                            request_contract.code_id
+                        ),
+                    })
+                }
+            }
+            _ => Err(AbstractSdkError::NotAModule {
+                addr: address,
+                err: "got an un-implemented module reference".to_string(),
+            }),
+        }
+    }
 }

framework/packages/abstract-sdk/src/error.rs

@@ -65,6 +65,20 @@ pub enum AbstractSdkError {
         module_id: String,
         error: Box<AbstractError>,
     },
+
+    // Queried address is not a module
+    #[error("Queried address {addr} is not a module: {err}")]
+    NotAModule { addr: Addr, err: String },
+
+    // Queried address is not a module
+    #[error(
+        "Queried address {addr} is a module ({module}) but has the wrong stored address : {err}"
+    )]
+    WrongModuleInfo {
+        addr: Addr,
+        module: String,
+        err: String,
+    },
 }
 
 impl AbstractSdkError {