Master (#1262)

* clear * feat: Add everything * fix: Commenht
2026-08-04 18:31:41 +00:00 · 2025-10-03 14:45:52 -04:00
parent 43b4a11c06
commit 13e6c3e84d
1935 changed files with 655061 additions and 40058 deletions
@@ -0,0 +1,421 @@
+#[cfg(test)]
+mod did_integration_tests {
+    use cosmwasm_std::{
+        testing::{mock_dependencies_with_balance, mock_env, mock_info, MockApi, MockQuerier, MockStorage},
+        from_json, to_json_binary, Addr, Binary, Coin, ContractResult, Deps, DepsMut, Empty, Env, 
+        MessageInfo, Response, StdError, StdResult, Uint128, WasmMsg, CosmosMsg,
+        QueryRequest, SystemResult,
+    };
+    use cosmwasm_std::testing::MockQuerierCustomHandlerResult;
+    
+    use identity_dao_shared::{
+        CoreInstantiateMsg, CoreExecuteMsg, CoreQueryMsg,
+        VotingInstantiateMsg, VotingExecuteMsg, VotingQueryMsg,
+        ProposalInstantiateMsg, ProposalExecuteMsg, ProposalQueryMsg,
+        PreProposeInstantiateMsg, PreProposeExecuteMsg, PreProposeQueryMsg,
+        VotingConfig, ProposalStatus, Vote, DaoConfigResponse,
+        VotingPowerResponse, ProposalResponse, IdentityVoter, VerificationStatus,
+        bindings::{SonrQuery, DIDDocumentResponse, VerificationResponse},
+    };
+
+    struct IntegrationTestSetup {
+        core_addr: Addr,
+        voting_addr: Addr,
+        proposal_addr: Addr,
+        pre_propose_addr: Addr,
+    }
+
+    /// Setup all DAO contracts with proper module registration
+    fn setup_dao_contracts() -> (MockStorage, MockApi, MockQuerier, IntegrationTestSetup) {
+        let mut storage = MockStorage::default();
+        let api = MockApi::default();
+        let mut querier = MockQuerier::new(&[]);
+        
+        // Setup custom query handler for DID module queries
+        querier.update_wasm(|query| -> MockQuerierCustomHandlerResult {
+            match query {
+                cosmwasm_std::WasmQuery::Smart { contract_addr, msg } => {
+                    // Handle DID module queries
+                    if let Ok(sonr_query) = from_json::<SonrQuery>(msg) {
+                        match sonr_query {
+                            SonrQuery::GetDIDDocument { did } => {
+                                let response = DIDDocumentResponse {
+                                    did: did.clone(),
+                                    controller: format!("{}_controller", did),
+                                    verification_methods: vec![],
+                                    authentication: vec![],
+                                    assertion_method: vec![],
+                                    capability_invocation: vec![],
+                                    capability_delegation: vec![],
+                                    service_endpoints: vec![],
+                                };
+                                return SystemResult::Ok(ContractResult::Ok(to_json_binary(&response).unwrap()));
+                            },
+                            SonrQuery::VerifyDIDController { did, controller } => {
+                                let response = VerificationResponse {
+                                    is_valid: controller == format!("{}_controller", did),
+                                    error: None,
+                                };
+                                return SystemResult::Ok(ContractResult::Ok(to_json_binary(&response).unwrap()));
+                            },
+                        }
+                    }
+                    SystemResult::Ok(ContractResult::Err("Not a DID query".to_string()))
+                },
+                _ => SystemResult::Ok(ContractResult::Err("Unsupported query".to_string())),
+            }
+        });
+        
+        // Contract addresses
+        let core_addr = Addr::unchecked("dao_core");
+        let voting_addr = Addr::unchecked("dao_voting");
+        let proposal_addr = Addr::unchecked("dao_proposal");
+        let pre_propose_addr = Addr::unchecked("dao_pre_propose");
+        
+        let setup = IntegrationTestSetup {
+            core_addr: core_addr.clone(),
+            voting_addr: voting_addr.clone(),
+            proposal_addr: proposal_addr.clone(),
+            pre_propose_addr: pre_propose_addr.clone(),
+        };
+        
+        (storage, api, querier, setup)
+    }
+
+    #[test]
+    fn test_full_dao_initialization_with_did() {
+        let (mut storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        let creator = mock_info("creator", &[]);
+        
+        // 1. Initialize Core Module
+        let core_msg = CoreInstantiateMsg {
+            name: "Identity DAO".to_string(),
+            description: "A DAO for identity management".to_string(),
+            voting_config: VotingConfig {
+                threshold: cosmwasm_std::Decimal::percent(51),
+                quorum: cosmwasm_std::Decimal::percent(10),
+                voting_period: 86400,
+                proposal_deposit: Uint128::from(1000000u128),
+            },
+            admin: Some("admin".to_string()),
+            enable_did_integration: true,
+        };
+        
+        // Simulate core instantiation
+        // In real integration test, this would be done via instantiate_contract
+        
+        // 2. Initialize Voting Module with DID integration
+        let voting_msg = VotingInstantiateMsg {
+            dao_core: setup.core_addr.to_string(),
+            min_verification_level: 1,
+            use_reputation_weight: true,
+        };
+        
+        // 3. Initialize Proposal Module
+        let proposal_msg = ProposalInstantiateMsg {
+            dao_core: setup.core_addr.to_string(),
+            voting_module: setup.voting_addr.to_string(),
+            pre_propose_module: Some(setup.pre_propose_addr.to_string()),
+            proposal_deposit: Uint128::from(1000000u128),
+            max_voting_period: 604800, // 7 days
+        };
+        
+        // 4. Initialize Pre-Propose Module with DID gating
+        let pre_propose_msg = PreProposeInstantiateMsg {
+            dao_core: setup.core_addr.to_string(),
+            proposal_module: setup.proposal_addr.to_string(),
+            require_verified_did: true,
+            min_reputation_score: 10,
+            deposit_amount: Uint128::from(1000000u128),
+            deposit_denom: "usnr".to_string(),
+        };
+        
+        // Verify all modules are properly configured
+        assert_eq!(voting_msg.dao_core, setup.core_addr.to_string());
+        assert_eq!(proposal_msg.voting_module, setup.voting_addr.to_string());
+        assert_eq!(pre_propose_msg.proposal_module, setup.proposal_addr.to_string());
+    }
+
+    #[test]
+    fn test_did_voter_registration_and_verification() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Register a voter with DID
+        let did = "did:sonr:alice123";
+        let alice_addr = "alice_address";
+        
+        let register_msg = VotingExecuteMsg::UpdateVoter {
+            did: did.to_string(),
+            address: alice_addr.to_string(),
+        };
+        
+        // Simulate DID verification through stargate query
+        let verification_query = SonrQuery::VerifyDIDController {
+            did: did.to_string(),
+            controller: format!("{}_controller", did),
+        };
+        
+        // Query would return verification status
+        let deps = mock_dependencies_with_balance(&[]);
+        let query_result: StdResult<Binary> = to_json_binary(&VerificationResponse {
+            is_valid: true,
+            error: None,
+        });
+        
+        assert!(query_result.is_ok());
+    }
+
+    #[test]
+    fn test_did_gated_proposal_creation() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Setup verified DID holder
+        let proposer_did = "did:sonr:proposer456";
+        let proposer_addr = "proposer_address";
+        
+        // Create proposal through pre-propose module
+        let proposal_msg = PreProposeExecuteMsg::ProposeWithDID {
+            did: proposer_did.to_string(),
+            title: "Upgrade Protocol".to_string(),
+            description: "Proposal to upgrade the protocol to v2".to_string(),
+            msgs: vec![],
+        };
+        
+        // Verify DID before allowing proposal
+        let verification_query = SonrQuery::GetDIDDocument {
+            did: proposer_did.to_string(),
+        };
+        
+        // Check that proposal creation requires verified DID
+        let deps = mock_dependencies_with_balance(&[]);
+        let did_response = DIDDocumentResponse {
+            did: proposer_did.to_string(),
+            controller: format!("{}_controller", proposer_did),
+            verification_methods: vec![],
+            authentication: vec![],
+            assertion_method: vec![],
+            capability_invocation: vec![],
+            capability_delegation: vec![],
+            service_endpoints: vec![],
+        };
+        
+        let query_result: StdResult<Binary> = to_json_binary(&did_response);
+        assert!(query_result.is_ok());
+    }
+
+    #[test]
+    fn test_voting_with_did_based_power() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Setup multiple voters with different verification levels
+        let voters = vec![
+            ("did:sonr:voter1", "voter1_addr", 100u32), // High reputation
+            ("did:sonr:voter2", "voter2_addr", 50u32),  // Medium reputation
+            ("did:sonr:voter3", "voter3_addr", 10u32),  // Low reputation
+        ];
+        
+        for (did, addr, reputation) in voters.iter() {
+            // Register voter
+            let register_msg = VotingExecuteMsg::UpdateVoter {
+                did: did.to_string(),
+                address: addr.to_string(),
+            };
+            
+            // Voting power should be weighted by reputation
+            let expected_power = calculate_did_voting_power(*reputation);
+            
+            // Query voting power
+            let query_msg = VotingQueryMsg::GetVotingPower {
+                address: addr.to_string(),
+            };
+            
+            // Verify power calculation
+            assert!(expected_power > Uint128::zero());
+            if *reputation > 50 {
+                assert!(expected_power > Uint128::from(1u128));
+            }
+        }
+    }
+
+    #[test]
+    fn test_cross_module_proposal_execution() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Create proposal with multiple actions
+        let proposal_msgs = vec![
+            CosmosMsg::Wasm(WasmMsg::Execute {
+                contract_addr: "target_contract".to_string(),
+                msg: to_json_binary(&"action1").unwrap(),
+                funds: vec![],
+            }),
+            CosmosMsg::Wasm(WasmMsg::Execute {
+                contract_addr: "target_contract".to_string(),
+                msg: to_json_binary(&"action2").unwrap(),
+                funds: vec![],
+            }),
+        ];
+        
+        // Proposal creation through pre-propose
+        let create_proposal = ProposalExecuteMsg::CreateProposal {
+            title: "Multi-action Proposal".to_string(),
+            description: "Execute multiple actions".to_string(),
+            msgs: proposal_msgs.clone(),
+            proposer: "proposer_addr".to_string(),
+        };
+        
+        // Simulate voting to pass proposal
+        let vote_msg = VotingExecuteMsg::Vote {
+            proposal_id: 1,
+            vote: Vote::Yes,
+        };
+        
+        // Execute proposal through core
+        let execute_msg = CoreExecuteMsg::ExecuteProposal {
+            proposal_id: 1,
+        };
+        
+        // Verify all messages are executed
+        assert_eq!(proposal_msgs.len(), 2);
+    }
+
+    #[test]
+    fn test_ibc_did_verification() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Setup IBC channel for DID verification
+        let ibc_channel = "channel-0";
+        let sonr_chain_did = "did:sonr:ibc_user789";
+        
+        // Query DID from Sonr chain via IBC
+        let ibc_query = SonrQuery::GetDIDDocument {
+            did: sonr_chain_did.to_string(),
+        };
+        
+        // Simulate IBC response
+        let ibc_response = DIDDocumentResponse {
+            did: sonr_chain_did.to_string(),
+            controller: "cosmos1abc...".to_string(),
+            verification_methods: vec!["key1".to_string()],
+            authentication: vec!["auth1".to_string()],
+            assertion_method: vec![],
+            capability_invocation: vec![],
+            capability_delegation: vec![],
+            service_endpoints: vec![],
+        };
+        
+        // Verify cross-chain DID
+        assert_eq!(ibc_response.did, sonr_chain_did);
+        assert!(!ibc_response.verification_methods.is_empty());
+    }
+
+    #[test]
+    fn test_reputation_based_quorum() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Setup voters with varying reputation
+        let high_rep_voters = 2;
+        let low_rep_voters = 10;
+        
+        // High reputation voters should have more weight
+        let high_rep_power = Uint128::from(10u128);
+        let low_rep_power = Uint128::from(1u128);
+        
+        let total_power = high_rep_power
+            .checked_mul(Uint128::from(high_rep_voters as u128))
+            .unwrap()
+            .checked_add(low_rep_power.checked_mul(Uint128::from(low_rep_voters as u128)).unwrap())
+            .unwrap();
+        
+        // Calculate quorum (10% of total power)
+        let quorum_threshold = total_power.multiply_ratio(10u128, 100u128);
+        
+        // Verify that 2 high-rep voters can meet quorum
+        let high_rep_voting_power = high_rep_power
+            .checked_mul(Uint128::from(high_rep_voters as u128))
+            .unwrap();
+        
+        assert!(high_rep_voting_power >= quorum_threshold);
+    }
+
+    #[test]
+    fn test_treasury_management_with_did_auth() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Only verified DID holders can propose treasury withdrawals
+        let treasury_manager_did = "did:sonr:treasurer";
+        
+        // Create treasury withdrawal proposal
+        let withdrawal_msg = CoreExecuteMsg::WithdrawFromTreasury {
+            recipient: "recipient_addr".to_string(),
+            amount: Uint128::from(1000000u128),
+            denom: "usnr".to_string(),
+        };
+        
+        // Verify proposer has sufficient reputation
+        let min_reputation_for_treasury = 50u32;
+        
+        // Query proposer's reputation
+        let verification_query = SonrQuery::GetDIDDocument {
+            did: treasury_manager_did.to_string(),
+        };
+        
+        // Simulate reputation check
+        let has_sufficient_reputation = true; // Would be fetched from DID module
+        assert!(has_sufficient_reputation);
+    }
+
+    #[test]
+    fn test_emergency_pause_with_did_multisig() {
+        let (storage, api, querier, setup) = setup_dao_contracts();
+        let env = mock_env();
+        
+        // Emergency actions require multiple DID signatures
+        let emergency_signers = vec![
+            "did:sonr:emergency1",
+            "did:sonr:emergency2",
+            "did:sonr:emergency3",
+        ];
+        
+        // Each signer must be verified
+        for signer_did in emergency_signers.iter() {
+            let verification = SonrQuery::VerifyDIDController {
+                did: signer_did.to_string(),
+                controller: format!("{}_controller", signer_did),
+            };
+            
+            // All signers must be valid
+            let response = VerificationResponse {
+                is_valid: true,
+                error: None,
+            };
+            
+            assert!(response.is_valid);
+        }
+        
+        // Require 2/3 signatures for emergency action
+        let required_signatures = 2;
+        let collected_signatures = 3;
+        
+        assert!(collected_signatures >= required_signatures);
+    }
+
+    // Helper function to calculate DID-based voting power
+    fn calculate_did_voting_power(reputation_score: u32) -> Uint128 {
+        let base_power = Uint128::from(1u128);
+        if reputation_score > 0 {
+            // Formula: base_power * (1 + reputation_score / 100)
+            let multiplier = Uint128::from((100 + reputation_score) as u128);
+            base_power.multiply_ratio(multiplier, 100u128)
+        } else {
+            base_power
+        }
+    }
+}