fix(contracts): resolve clippy errors + wire 3 orphaned contracts into workspace

contracts/Cargo.toml

@@ -3,8 +3,11 @@ members = [
     "attestation-bonding",
     "contribution-rewards",
     "credit-class-voting",
+    "dynamic-supply",
+    "fee-router",
     "integration-tests",
     "marketplace-curation",
+    "reputation-signal",
     "service-escrow",
     "validator-governance",
 ]

contracts/attestation-bonding/src/contract.rs

@@ -542,15 +542,15 @@ fn query_attestations(
     start_after: Option<u64>, limit: Option<u32>,
 ) -> StdResult<AttestationsResponse> {
     let limit = limit.unwrap_or(DEFAULT_QUERY_LIMIT).min(MAX_QUERY_LIMIT) as usize;
-    let start = start_after.map(|s| cw_storage_plus::Bound::exclusive(s));
+    let start = start_after.map(cw_storage_plus::Bound::exclusive);
     let attester_addr = attester.map(|a| deps.api.addr_validate(&a)).transpose()?;
 
     let attestations: Vec<_> = ATTESTATIONS
         .range(deps.storage, start, None, Order::Ascending)
         .filter_map(|item| item.ok())
         .filter(|(_, a)| {
-            status.as_ref().map_or(true, |s| a.status == *s)
-                && attester_addr.as_ref().map_or(true, |addr| a.attester == *addr)
+            status.as_ref().is_none_or(|s| a.status == *s)
+                && attester_addr.as_ref().is_none_or(|addr| a.attester == *addr)
         })
         .take(limit)
         .map(|(_, a)| a)
@@ -568,12 +568,12 @@ fn query_challenges(
     deps: Deps, attestation_id: Option<u64>, start_after: Option<u64>, limit: Option<u32>,
 ) -> StdResult<ChallengesResponse> {
     let limit = limit.unwrap_or(DEFAULT_QUERY_LIMIT).min(MAX_QUERY_LIMIT) as usize;
-    let start = start_after.map(|s| cw_storage_plus::Bound::exclusive(s));
+    let start = start_after.map(cw_storage_plus::Bound::exclusive);
 
     let challenges: Vec<_> = CHALLENGES
         .range(deps.storage, start, None, Order::Ascending)
         .filter_map(|item| item.ok())
-        .filter(|(_, c)| attestation_id.map_or(true, |aid| c.attestation_id == aid))
+        .filter(|(_, c)| attestation_id.is_none_or(|aid| c.attestation_id == aid))
         .take(limit)
         .map(|(_, c)| c)
         .collect();

contracts/contribution-rewards/src/contract.rs

@@ -22,6 +22,18 @@ const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
 /// Seconds per month approximation (30.44 days)
 const SECONDS_PER_MONTH: u64 = 2_629_744;
 
+/// Grouped parameters for `execute_record_activity`. Carries exactly the
+/// fields of `ExecuteMsg::RecordActivity` so the dispatch block can forward
+/// them in one move without tripping clippy's `too_many_arguments` lint.
+struct RecordActivityParams {
+    participant: String,
+    credit_purchase_value: Uint128,
+    credit_retirement_value: Uint128,
+    platform_facilitation_value: Uint128,
+    governance_votes: u32,
+    proposal_credits: u32,
+}
+
 // ── Instantiate ────────────────────────────────────────────────────────
 
 #[cfg_attr(not(feature = "library"), entry_point)]
@@ -98,12 +110,14 @@ pub fn execute(
         } => execute_record_activity(
             deps,
             info,
-            participant,
-            credit_purchase_value,
-            credit_retirement_value,
-            platform_facilitation_value,
-            governance_votes,
-            proposal_credits,
+            RecordActivityParams {
+                participant,
+                credit_purchase_value,
+                credit_retirement_value,
+                platform_facilitation_value,
+                governance_votes,
+                proposal_credits,
+            },
         ),
         ExecuteMsg::TriggerDistribution {
             community_pool_inflow,
@@ -390,12 +404,7 @@ fn execute_claim_matured(
 fn execute_record_activity(
     deps: DepsMut,
     info: MessageInfo,
-    participant: String,
-    credit_purchase_value: Uint128,
-    credit_retirement_value: Uint128,
-    platform_facilitation_value: Uint128,
-    governance_votes: u32,
-    proposal_credits: u32,
+    params: RecordActivityParams,
 ) -> Result<Response, ContractError> {
     let config = CONFIG.load(deps.storage)?;
     require_admin(&config, &info)?;
@@ -408,30 +417,30 @@ fn execute_record_activity(
         });
     }
 
-    let participant_addr = deps.api.addr_validate(&participant)?;
+    let participant_addr = deps.api.addr_validate(&params.participant)?;
     let period = state.current_period;
 
     // Load existing or create new
     let mut score = ACTIVITY_SCORES
         .may_load(deps.storage, (period, &participant_addr))?
         .unwrap_or(ActivityScore {
-            address: participant.clone(),
+            address: params.participant.clone(),
             period,
             ..Default::default()
         });
 
     // Accumulate (additive within a period)
-    score.credit_purchase_value += credit_purchase_value;
-    score.credit_retirement_value += credit_retirement_value;
-    score.platform_facilitation_value += platform_facilitation_value;
-    score.governance_votes += governance_votes;
-    score.proposal_credits += proposal_credits;
+    score.credit_purchase_value += params.credit_purchase_value;
+    score.credit_retirement_value += params.credit_retirement_value;
+    score.platform_facilitation_value += params.platform_facilitation_value;
+    score.governance_votes += params.governance_votes;
+    score.proposal_credits += params.proposal_credits;
 
     ACTIVITY_SCORES.save(deps.storage, (period, &participant_addr), &score)?;
 
     Ok(Response::new()
         .add_attribute("action", "record_activity")
-        .add_attribute("participant", participant)
+        .add_attribute("participant", params.participant)
         .add_attribute("period", period.to_string()))
 }
 

contracts/credit-class-voting/src/contract.rs

@@ -28,6 +28,18 @@ const DEFAULT_AGENT_REVIEW_TIMEOUT: u64 = 86_400;
 /// Default override window: 6 hours
 const DEFAULT_OVERRIDE_WINDOW: u64 = 21_600;
 
+/// Grouped parameters for `execute_update_config`. Carries exactly the
+/// fields of `ExecuteMsg::UpdateConfig` so the dispatch block can forward
+/// them in one move without tripping clippy's `too_many_arguments` lint.
+struct UpdateConfigParams {
+    registry_agent: Option<String>,
+    deposit_amount: Option<Uint128>,
+    voting_period_seconds: Option<u64>,
+    agent_review_timeout_seconds: Option<u64>,
+    override_window_seconds: Option<u64>,
+    community_pool: Option<String>,
+}
+
 /// Slash 20% of deposit on rejection
 const REJECT_SLASH_BPS: u128 = 2000;
 /// Slash 5% of deposit on expiry
@@ -112,12 +124,14 @@ pub fn execute(
         } => execute_update_config(
             deps,
             info,
-            registry_agent,
-            deposit_amount,
-            voting_period_seconds,
-            agent_review_timeout_seconds,
-            override_window_seconds,
-            community_pool,
+            UpdateConfigParams {
+                registry_agent,
+                deposit_amount,
+                voting_period_seconds,
+                agent_review_timeout_seconds,
+                override_window_seconds,
+                community_pool,
+            },
         ),
     }
 }
@@ -560,12 +574,7 @@ fn execute_finalize_proposal(
 fn execute_update_config(
     deps: DepsMut,
     info: MessageInfo,
-    registry_agent: Option<String>,
-    deposit_amount: Option<Uint128>,
-    voting_period_seconds: Option<u64>,
-    agent_review_timeout_seconds: Option<u64>,
-    override_window_seconds: Option<u64>,
-    community_pool: Option<String>,
+    params: UpdateConfigParams,
 ) -> Result<Response, ContractError> {
     let mut config = CONFIG.load(deps.storage)?;
 
@@ -575,22 +584,22 @@ fn execute_update_config(
         });
     }
 
-    if let Some(agent) = registry_agent {
+    if let Some(agent) = params.registry_agent {
         config.registry_agent = deps.api.addr_validate(&agent)?;
     }
-    if let Some(amount) = deposit_amount {
+    if let Some(amount) = params.deposit_amount {
         config.deposit_amount = amount;
     }
-    if let Some(seconds) = voting_period_seconds {
+    if let Some(seconds) = params.voting_period_seconds {
         config.voting_period_seconds = seconds;
     }
-    if let Some(seconds) = agent_review_timeout_seconds {
+    if let Some(seconds) = params.agent_review_timeout_seconds {
         config.agent_review_timeout_seconds = seconds;
     }
-    if let Some(seconds) = override_window_seconds {
+    if let Some(seconds) = params.override_window_seconds {
         config.override_window_seconds = seconds;
     }
-    if let Some(pool) = community_pool {
+    if let Some(pool) = params.community_pool {
         config.community_pool = Some(deps.api.addr_validate(&pool)?);
     }
 
@@ -650,7 +659,7 @@ fn query_proposals(
     limit: Option<u32>,
 ) -> StdResult<ProposalsResponse> {
     let limit = limit.unwrap_or(DEFAULT_QUERY_LIMIT).min(MAX_QUERY_LIMIT) as usize;
-    let start = start_after.map(|s| cw_storage_plus::Bound::exclusive(s));
+    let start = start_after.map(cw_storage_plus::Bound::exclusive);
 
     let proposals: Vec<Proposal> = PROPOSALS
         .range(deps.storage, start, None, Order::Ascending)
@@ -677,7 +686,7 @@ fn query_proposals_by_admin(
 ) -> StdResult<ProposalsResponse> {
     let admin_addr = deps.api.addr_validate(&admin_address)?;
     let limit = limit.unwrap_or(DEFAULT_QUERY_LIMIT).min(MAX_QUERY_LIMIT) as usize;
-    let start = start_after.map(|s| cw_storage_plus::Bound::exclusive(s));
+    let start = start_after.map(cw_storage_plus::Bound::exclusive);
 
     let proposals: Vec<Proposal> = PROPOSALS
         .range(deps.storage, start, None, Order::Ascending)

contracts/marketplace-curation/src/contract.rs

@@ -844,7 +844,7 @@ fn query_collections(
     limit: Option<u32>,
 ) -> StdResult<CollectionsResponse> {
     let limit = limit.unwrap_or(DEFAULT_QUERY_LIMIT).min(MAX_QUERY_LIMIT) as usize;
-    let start = start_after.map(|s| cw_storage_plus::Bound::exclusive(s));
+    let start = start_after.map(cw_storage_plus::Bound::exclusive);
 
     let curator_addr = curator
         .map(|c| deps.api.addr_validate(&c))
@@ -860,7 +860,7 @@ fn query_collections(
                 }
             }
             if let Some(ref c) = curator_addr {
-                if &coll.curator != c {
+                if coll.curator != *c {
                     return None;
                 }
             }