Fix/standalone modules

framework/contracts/account/manager/tests/common/mock_modules.rs

@@ -128,3 +128,58 @@ pub mod app_1 {
         );
     }
 }
+
+// standalone 1 have cw2
+pub mod standalone_1 {
+    pub use super::*;
+    pub const MOCK_STANDALONE_ID: &str = "tester:mock-standalone1";
+
+    #[cosmwasm_schema::cw_serde]
+    pub struct MockMsg;
+
+    pub fn mock_instantiate(
+        deps: ::cosmwasm_std::DepsMut,
+        env: ::cosmwasm_std::Env,
+        info: ::cosmwasm_std::MessageInfo,
+        msg: MockInitMsg,
+    ) -> cosmwasm_std::StdResult<cosmwasm_std::Response> {
+        cw2::set_contract_version(deps.storage, MOCK_STANDALONE_ID, V1);
+        Ok(cosmwasm_std::Response::new())
+    }
+
+    /// Execute entrypoint
+    pub fn mock_execute(
+        deps: ::cosmwasm_std::DepsMut,
+        env: ::cosmwasm_std::Env,
+        info: ::cosmwasm_std::MessageInfo,
+        msg: MockMsg,
+    ) -> cosmwasm_std::StdResult<cosmwasm_std::Response> {
+        Ok(cosmwasm_std::Response::new())
+    }
+
+    /// Query entrypoint
+    pub fn mock_query(
+        deps: ::cosmwasm_std::Deps,
+        env: ::cosmwasm_std::Env,
+        msg: MockMsg,
+    ) -> cosmwasm_std::StdResult<cosmwasm_std::Binary> {
+        Ok(cosmwasm_std::Binary::default())
+    }
+}
+
+// standalone 2 does not have cw2
+pub mod standalone_2 {
+    pub use super::*;
+    pub const MOCK_STANDALONE_ID: &str = "tester:mock-standalone2";
+
+    pub use super::standalone_1::{mock_execute, mock_query, MockMsg};
+
+    pub fn mock_instantiate(
+        deps: ::cosmwasm_std::DepsMut,
+        env: ::cosmwasm_std::Env,
+        info: ::cosmwasm_std::MessageInfo,
+        msg: MockInitMsg,
+    ) -> cosmwasm_std::StdResult<cosmwasm_std::Response> {
+        Ok(cosmwasm_std::Response::new())
+    }
+}

framework/contracts/account/manager/tests/proxy.rs

@@ -1,14 +1,20 @@
 mod common;
 use abstract_adapter::mock::MockExecMsg;
 use abstract_core::adapter::AdapterRequestMsg;
+use abstract_core::objects::module::{ModuleInfo, ModuleVersion};
+use abstract_core::objects::module_reference::ModuleReference;
+use abstract_core::objects::namespace::Namespace;
 use abstract_core::{manager::ManagerModuleInfo, PROXY};
 use abstract_interface::*;
 use abstract_manager::contract::CONTRACT_VERSION;
 use abstract_testing::prelude::{TEST_ACCOUNT_ID, TEST_MODULE_ID};
-use common::{create_default_account, init_mock_adapter, install_adapter, AResult, TEST_COIN};
+use common::{
+    create_default_account, init_mock_adapter, install_adapter, mock_modules, AResult, TEST_COIN,
+};
 use cosmwasm_std::{wasm_execute, Addr, Coin, CosmosMsg};
 use cw_orch::deploy::Deploy;
 use cw_orch::prelude::*;
+use module_factory::error::ModuleFactoryError;
 use speculoos::prelude::*;
 
 #[test]
@@ -162,3 +168,106 @@ fn with_response_data() -> AResult {
 
     Ok(())
 }
+
+#[test]
+fn install_standalone_modules() -> AResult {
+    let sender = Addr::unchecked(common::OWNER);
+    let chain = Mock::new(&sender);
+    let deployment = Abstract::deploy_on(chain.clone(), sender.to_string())?;
+    let account = AbstractAccount::new(&deployment, Some(0));
+
+    let standalone1_contract = Box::new(ContractWrapper::new(
+        mock_modules::standalone_1::mock_execute,
+        mock_modules::standalone_1::mock_instantiate,
+        mock_modules::standalone_1::mock_query,
+    ));
+    let standalone1_id = chain.app.borrow_mut().store_code(standalone1_contract);
+
+    let standalone2_contract = Box::new(ContractWrapper::new(
+        mock_modules::standalone_2::mock_execute,
+        mock_modules::standalone_2::mock_instantiate,
+        mock_modules::standalone_2::mock_query,
+    ));
+    let standalone2_id = chain.app.borrow_mut().store_code(standalone2_contract);
+
+    // install first standalone
+    deployment.version_control.propose_modules(vec![(
+        ModuleInfo {
+            namespace: Namespace::new("abstract")?,
+            name: "standalone1".to_owned(),
+            version: ModuleVersion::Version(mock_modules::V1.to_owned()),
+        },
+        ModuleReference::Standalone(standalone1_id),
+    )])?;
+
+    account.install_module(
+        "abstract:standalone1",
+        &mock_modules::standalone_1::MockMsg,
+        None,
+    )?;
+
+    // install second standalone
+    deployment.version_control.propose_modules(vec![(
+        ModuleInfo {
+            namespace: Namespace::new("abstract")?,
+            name: "standalone2".to_owned(),
+            version: ModuleVersion::Version(mock_modules::V1.to_owned()),
+        },
+        ModuleReference::Standalone(standalone2_id),
+    )])?;
+
+    account.install_module(
+        "abstract:standalone2",
+        &mock_modules::standalone_2::MockMsg,
+        None,
+    )?;
+    Ok(())
+}
+
+#[test]
+fn install_standalone_versions_not_met() -> AResult {
+    let sender = Addr::unchecked(common::OWNER);
+    let chain = Mock::new(&sender);
+    let deployment = Abstract::deploy_on(chain.clone(), sender.to_string())?;
+    let account = AbstractAccount::new(&deployment, Some(0));
+
+    let standalone1_contract = Box::new(ContractWrapper::new(
+        mock_modules::standalone_1::mock_execute,
+        mock_modules::standalone_1::mock_instantiate,
+        mock_modules::standalone_1::mock_query,
+    ));
+    let standalone1_id = chain.app.borrow_mut().store_code(standalone1_contract);
+
+    // install first standalone
+    deployment.version_control.propose_modules(vec![(
+        ModuleInfo {
+            namespace: Namespace::new("abstract")?,
+            name: "standalone1".to_owned(),
+            version: ModuleVersion::Version(mock_modules::V2.to_owned()),
+        },
+        ModuleReference::Standalone(standalone1_id),
+    )])?;
+
+    let err = account
+        .install_module(
+            "abstract:standalone1",
+            &mock_modules::standalone_1::MockMsg,
+            None,
+        )
+        .unwrap_err();
+
+    if let AbstractInterfaceError::Orch(err) = err {
+        let err: ModuleFactoryError = err.downcast()?;
+        assert_eq!(
+            err,
+            ModuleFactoryError::Abstract(abstract_core::AbstractError::UnequalModuleData {
+                cw2: mock_modules::V1.to_owned(),
+                module: mock_modules::V2.to_owned(),
+            })
+        );
+    } else {
+        panic!("wrong error type")
+    };
+
+    Ok(())
+}

framework/contracts/native/module-factory/src/lib.rs

@@ -1,6 +1,6 @@
 mod commands;
 pub mod contract;
-mod error;
+pub mod error;
 mod querier;
 mod response;
 

framework/packages/abstract-core/src/objects/module.rs

@@ -370,8 +370,28 @@ pub fn assert_module_data_validity(
         }
     };
 
+    let ModuleVersion::Version(version) = &module_claim.info.version else {
+        panic!("Module version is not versioned, context setting is wrong")
+    };
+
     // verify that the contract's data is equal to its registered data
-    let cw_2_data = cw2::CONTRACT.query(querier, module_address.clone())?;
+    let cw_2_data_res = cw2::CONTRACT.query(querier, module_address.clone());
+
+    // For standalone we only check the version if cw2 exists
+    if let ModuleReference::Standalone(_) = module_claim.reference {
+        if let Ok(cw_2_data) = cw_2_data_res {
+            ensure_eq!(
+                version,
+                &cw_2_data.version,
+                AbstractError::UnequalModuleData {
+                    cw2: cw_2_data.version,
+                    module: version.to_owned()
+                }
+            );
+        }
+        return Ok(());
+    }
+    let cw_2_data = cw_2_data_res?;
 
     // Assert that the contract name is equal to the module name
     ensure_eq!(
@@ -383,10 +403,6 @@ pub fn assert_module_data_validity(
         }
     );
 
-    let ModuleVersion::Version(version) = &module_claim.info.version else {
-    panic!("Module version is not versioned, context setting is wrong")
-    };
-
     // Assert that the contract version is equal to the module version
     ensure_eq!(
         version,
@@ -400,7 +416,6 @@ pub fn assert_module_data_validity(
     match module_claim.reference {
         ModuleReference::AccountBase(_) => return Ok(()),
         ModuleReference::Native(_) => return Ok(()),
-        ModuleReference::Standalone(_) => return Ok(()),
         _ => {}
     }
 
@@ -751,4 +766,28 @@ mod test {
             assert_that!(actual).is_err();
         }
     }
+
+    mod standalone_modules_valid {
+        use cosmwasm_std::testing::MOCK_CONTRACT_ADDR;
+
+        use super::*;
+
+        #[test]
+        fn no_cw2_contract() {
+            let deps = mock_dependencies();
+            let res = assert_module_data_validity(
+                &deps.as_ref().querier,
+                &Module {
+                    info: ModuleInfo {
+                        namespace: Namespace::new("counter").unwrap(),
+                        name: "counter".to_owned(),
+                        version: ModuleVersion::Version("1.1.0".to_owned()),
+                    },
+                    reference: ModuleReference::Standalone(0),
+                },
+                Some(Addr::unchecked(MOCK_CONTRACT_ADDR)),
+            );
+            assert!(res.is_ok());
+        }
+    }
 }