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

[brawlaphant]

Summary

Repairs two pre-existing CI breakages that are blocking every PR against `main`. After this PR, `cargo test --workspace`, `cargo clippy --workspace -- -D warnings`, and `cargo build --release --target wasm32-unknown-unknown --workspace` all succeed locally on Rust 1.94.

• Lands in: `contracts/`
• Changes: fix 17 clippy errors across 6 contracts + add 3 orphaned contracts (`reputation-signal`, `dynamic-supply`, `fee-router`) to `workspace.members`
• Validate: `cd contracts && cargo test --workspace && cargo clippy --workspace -- -D warnings && cargo build --release --target wasm32-unknown-unknown --workspace`

The two problems

1. Contracts CI clippy has been failing

On Rust 1.94 (current `@stable`), the existing contracts fail `cargo clippy --workspace -- -D warnings` with 17 pre-existing lint errors across 6 contracts. The errors fall into four categories:

Category	Count	Example
`redundant_closure`	5	`.map(|s| Bound::exclusive(s))` → `.map(Bound::exclusive)`
`unnecessary_map_or`	3	`.map_or(true, |x| cond)` → `.is_none_or(|x| cond)`
`too_many_arguments`	5	add `#[allow(clippy::too_many_arguments)]` on legit multi-option config functions
`manual_range_contains`	2	`v < MIN || v > MAX` → `!(MIN..=MAX).contains(&v)`
`op_ref`	2	`&a != b` → `*a != *b` / similar

Every fix is a mechanical peephole transformation that clippy itself suggests. No state machine, no fee math, no access control was touched.

2. Three contracts are orphaned from the workspace

`contracts/reputation-signal/`, `contracts/dynamic-supply/`, and `contracts/fee-router/` exist as valid Cargo packages with their own `Cargo.toml` and ~80 unit tests combined (38 + 29 + 13), but they are not listed in `contracts/Cargo.toml`'s `workspace.members`. This puts them in limbo:

• `cargo test` in any of their directories fails with the exact message: "current package believes it's in a workspace when it's not ... this may be fixable by adding `reputation-signal` to the `workspace.members` array of the manifest located at: contracts/Cargo.toml"
• They are invisible to `cargo test --workspace`, `cargo build --workspace`, `cargo clippy --workspace`, and the wasm-size CI job
• Their ~80 unit tests have been running nowhere since they were merged in feat: implement 5 CosmWasm contracts (M008, M001-ENH, M011, M014, M015) #78

Adding them to `workspace.members` closes the gap in one three-line diff.

Fix inventory

Clippy

File	Line	Fix
attestation-bonding/src/contract.rs	545	`start_after.map(|s| Bound::exclusive(s))` → `.map(Bound::exclusive)`
attestation-bonding/src/contract.rs	552	`.map_or(true, ...)` → `.is_none_or(...)`
attestation-bonding/src/contract.rs	553	`.map_or(true, ...)` → `.is_none_or(...)`
attestation-bonding/src/contract.rs	571	`.map(|s| Bound::exclusive(s))` → `.map(Bound::exclusive)`
attestation-bonding/src/contract.rs	576	`.map_or(true, ...)` → `.is_none_or(...)`
credit-class-voting/src/contract.rs	560	`#[allow(clippy::too_many_arguments)]` on `execute_update_config` (8 options)
credit-class-voting/src/contract.rs	653	`.map(|s| Bound::exclusive(s))` → `.map(Bound::exclusive)`
credit-class-voting/src/contract.rs	680	`.map(|s| Bound::exclusive(s))` → `.map(Bound::exclusive)`
contribution-rewards/src/contract.rs	390	`#[allow(clippy::too_many_arguments)]` on `execute_record_activity` (8 params)
marketplace-curation/src/contract.rs	847	redundant closure on `Bound::exclusive`
marketplace-curation/src/contract.rs	863	`&coll.curator != c` → `coll.curator != *c`
service-escrow/src/contract.rs	767	`#[allow(clippy::too_many_arguments)]` on `execute_update_config` (11 params)
service-escrow/src/contract.rs	916	`v < MIN || v > MAX` → `!(MIN..=MAX).contains(&v)`
reputation-signal/src/contract.rs	162	`#[allow(clippy::too_many_arguments)]` on `exec_submit_signal`
reputation-signal/src/contract.rs	173	`level < 1 || level > 5` → `!(1..=5).contains(&level)`
reputation-signal/src/contract.rs	537	`#[allow(clippy::too_many_arguments)]` on `exec_update_config`
reputation-signal/src/contract.rs	632	`retain(|a| a != &addr)` → `retain(|a| *a != addr)`

Workspace wiring

`contracts/Cargo.toml`: three new entries added alphabetically to `workspace.members`:

```diff
members = [
"attestation-bonding",
"contribution-rewards",
"credit-class-voting",

• "dynamic-supply",
• "fee-router",
  "integration-tests",
  "marketplace-curation",
• "reputation-signal",
  "service-escrow",
  "validator-governance",
  ]
  ```

Validation

Run on `rustc 1.94.0 (85eff7c80 2026-01-15)` locally with the same commands CI uses:

Command	Before PR	After PR
`cargo clippy --workspace -- -D warnings`	17 errors (FAIL)	0 errors (PASS)
`cargo test --workspace`	98 passed	178 passed (+80)
`cargo build --release --target wasm32-unknown-unknown --workspace`	6 wasm files	9 wasm files (+3)

Why this is urgent

Every open PR right now shows `failure` on the CI badge — `#80` through `#88` all have red Contracts CI. This blocks merges even when the PR itself is clean. Landing this fix first turns the whole PR queue green.

I verified the same issue by cloning this repo on a fresh machine: the clippy failures and the `npm ci` failure on `agents/` are both reproducible on upstream `main` at commit `36ca7db`. The `agents/` `workspace:*` failure is a separate issue and will come in a follow-up PR.

Test plan

• `cd contracts && cargo clippy --workspace -- -D warnings` — 0 errors
• `cd contracts && cargo test --workspace` — 178 tests passed
• `cd contracts && cargo build --release --target wasm32-unknown-unknown --workspace` — 9 wasm files built
• CI `contracts` job runs all 3 commands on Rust `@stable` against this PR

[gemini-code-assist]

Code Review

This pull request adds new workspace members and implements several code cleanups across multiple contracts, such as simplifying closures, adopting is_none_or, and updating range checks. Feedback suggests refactoring functions that use #[allow(clippy::too_many_arguments)] to use parameter structs instead, which would improve long-term maintainability and readability.

[gemini-code-assist]

While allowing too_many_arguments fixes the immediate clippy error, for better long-term maintainability, consider refactoring this function to accept a struct for its parameters. This makes the function signature cleaner and adding/removing parameters less error-prone.

The ExecuteMsg::RecordActivity variant already groups these parameters. You could define a struct for them and pass that to this function.

Example of a new struct:

pub struct RecordActivityParams {
    pub participant: String,
    pub credit_purchase_value: Uint128,
    pub credit_retirement_value: Uint128,
    pub platform_facilitation_value: Uint128,
    pub governance_votes: u32,
    pub proposal_credits: u32,
}

Then execute_record_activity could be:

fn execute_record_activity(
    deps: DepsMut,
    info: MessageInfo,
    params: RecordActivityParams,
) -> Result<Response, ContractError> {
    // ... use params.participant, etc.
}

This would make the code more readable and easier to maintain.

[gemini-code-assist]

While allowing too_many_arguments fixes the clippy error, it's better for maintainability to group these configuration options into a struct. This would make the function signature for execute_update_config cleaner.

The parameters are all optional, so a struct with #[serde(default)] and Option fields would work well, similar to how they are defined in ExecuteMsg::UpdateConfig.

Example:

pub struct UpdateConfigMsg {
    pub registry_agent: Option<String>,
    pub deposit_amount: Option<Uint128>,
    pub voting_period_seconds: Option<u64>,
    pub agent_review_timeout_seconds: Option<u64>,
    pub override_window_seconds: Option<u64>,
    pub community_pool: Option<String>,
}

fn execute_update_config(
    deps: DepsMut,
    info: MessageInfo,
    params: UpdateConfigMsg,
) -> Result<Response, ContractError> {
    // ... use params.registry_agent, etc.
}

This improves readability and makes it easier to manage configuration updates.

[gemini-code-assist]

While allowing too_many_arguments fixes the clippy error, this function could be refactored for better maintainability by grouping its parameters into a struct.

The ExecuteMsg::SubmitSignal variant already groups these parameters. You could define a struct for them and pass that to this function.

Example:

pub struct SubmitSignalParams {
    pub subject_type: SubjectType,
    pub subject_id: String,
    pub category: String,
    pub endorsement_level: u8,
    pub evidence: Evidence,
}

fn exec_submit_signal(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    params: SubmitSignalParams,
) -> Result<Response, ContractError> {
    // ... use params.subject_type, etc.
}

This would make the code cleaner and easier to maintain.

[gemini-code-assist]

While allowing too_many_arguments fixes the clippy error, it's better for maintainability to group these configuration options into a struct. This would make the function signature for exec_update_config cleaner.

The parameters are all optional, so a struct with #[serde(default)] and Option fields would work well, similar to how they are defined in ExecuteMsg::UpdateConfig.

Example:

pub struct UpdateConfigMsg {
    pub activation_delay_seconds: Option<u64>,
    pub challenge_window_seconds: Option<u64>,
    pub resolution_deadline_seconds: Option<u64>,
    pub challenge_bond_denom: Option<String>,
    pub challenge_bond_amount: Option<Uint128>,
    pub decay_half_life_seconds: Option<u64>,
    pub default_min_stake: Option<Uint128>,
}

fn exec_update_config(
    deps: DepsMut,
    info: MessageInfo,
    params: UpdateConfigMsg,
) -> Result<Response, ContractError> {
    // ... use params.activation_delay_seconds, etc.
}

This improves readability and makes it easier to manage configuration updates.

[gemini-code-assist]

This function has 11 arguments. While allowing too_many_arguments fixes the clippy error, it's a strong indicator that the function could be refactored for better maintainability. Grouping these configuration options into a struct would be a good improvement.

The parameters are all optional, so a struct with #[serde(default)] and Option fields would work well, similar to how they are defined in ExecuteMsg::UpdateConfig.

Example:

pub struct UpdateConfigMsg {
    pub arbiter_dao: Option<String>,
    pub community_pool: Option<String>,
    pub provider_bond_ratio_bps: Option<u64>,
    pub platform_fee_rate_bps: Option<u64>,
    pub cancellation_fee_rate_bps: Option<u64>,
    pub arbiter_fee_rate_bps: Option<u64>,
    pub review_period_seconds: Option<u64>,
    pub max_milestones: Option<u32>,
    pub max_revisions: Option<u32>,
}

fn execute_update_config(
    deps: DepsMut,
    info: MessageInfo,
    params: UpdateConfigMsg,
) -> Result<Response, ContractError> {
    // ... use params.arbiter_dao, etc.
}

This improves readability and makes it easier to manage configuration updates.

[brawlaphant]

Superseded by #106 which combines this fix with #91 and #92 into a single green-CI PR. The three standalone fix PRs each leave 2-3 other CI jobs failing; #106 fixes all four in one shot.

Suggest closing this once #106 lands, or merging this first and letting #106 resolve the remainder.

[glandua]

Superseded by #106, which combined the fixes from this PR with the others needed to make all 4 CI jobs go green. #106 has been merged.