Implement DAO-compatible Slashing Module

[team-nobay]

We need a smart contract module that allows $NOBAY stakers to be slashed for fraud or dispute resolution.

Features:

• Slash by DAO vote or dispute outcome
• Integrates with StakingModule
• Emits Slashed(address, amount, reason)

Bonus: Add trust decay function over time

Type: Smart contract / DAO extension
Labels: enhancement, bounty, Solidity

[ManyRios]

hey, what is the reward for this bounty?

[ipezygj]

DAO-Compatible Slashing Module

Architecture Overview

SlashingModule
├── DAO Vote Integration (Governor-compatible)
├── Dispute Resolution Integration
├── StakingModule Interface
├── Trust Score System (decay over time)
└── Emergency Controls

Implementation

IStakingModule.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IStakingModule {
    function stakedBalance(address account) external view returns (uint256);
    function slash(address account, uint256 amount, address recipient) external;
    function unstake(address account, uint256 amount) external;
}

ISlashingModule.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface ISlashingModule {
    enum SlashReason { FRAUD, DISPUTE, MALICIOUS_PROPOSAL, ORACLE_MANIPULATION, OTHER }
    enum ProposalState { PENDING, APPROVED, REJECTED, EXECUTED, CANCELLED }

    struct SlashProposal {
        uint256 id;
        address target;
        uint256 amount;
        SlashReason reason;
        string evidence;
        address proposer;
        uint256 votesFor;
        uint256 votesAgainst;
        uint256 createdAt;
        uint256 executionDelay;
        ProposalState state;
        bool executed;
    }

    event Slashed(address indexed account, uint256 amount, SlashReason reason, uint256 proposalId);
    event SlashProposed(uint256 indexed proposalId, address indexed target, uint256 amount, SlashReason reason);
    event SlashVoteCast(uint256 indexed proposalId, address indexed voter, bool support, uint256 weight);
    event SlashExecuted(uint256 indexed proposalId, address indexed target, uint256 amount);
    event SlashCancelled(uint256 indexed proposalId, string reason);
    event TrustScoreUpdated(address indexed account, uint256 oldScore, uint256 newScore);
    event DisputeResolved(uint256 indexed disputeId, address indexed target, uint256 slashAmount);
}

SlashingModule.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IStakingModule.sol";
import "./ISlashingModule.sol";

/**
 * @title SlashingModule
 * @notice DAO-compatible slashing module for $NOBAY stakers.
 *         Supports slash-by-vote, dispute resolution, and trust decay.
 * @dev Integrates with any IStakingModule-compatible staking contract.
 */
contract SlashingModule is ISlashingModule, AccessControl, ReentrancyGuard, Pausable {
    
    // ─────────────────────────────────────────────
    // Roles
    // ─────────────────────────────────────────────
    
    bytes32 public constant GOVERNANCE_ROLE   = keccak256("GOVERNANCE_ROLE");
    bytes32 public constant DISPUTE_RESOLVER  = keccak256("DISPUTE_RESOLVER");
    bytes32 public constant GUARDIAN_ROLE     = keccak256("GUARDIAN_ROLE");
    bytes32 public constant SLASHER_ROLE      = keccak256("SLASHER_ROLE");

    // ─────────────────────────────────────────────
    // Constants
    // ─────────────────────────────────────────────

    uint256 public constant PRECISION          = 10_000;          // basis points
    uint256 public constant MAX_SLASH_BPS      = 10_000;          // 100%
    uint256 public constant MIN_QUORUM_BPS     = 1_000;           // 10% minimum quorum
    uint256 public constant VOTE_DURATION      = 3 days;
    uint256 public constant EXECUTION_DELAY    = 1 days;
    uint256 public constant MAX_TRUST_SCORE    = 10_000;
    uint256 public constant TRUST_DECAY_PERIOD = 30 days;
    uint256 public constant TRUST_DECAY_RATE   = 50;              // 0.5% per period (basis points)
    uint256 public constant INITIAL_TRUST      = 8_000;           // 80%

    // ─────────────────────────────────────────────
    // State
    // ─────────────────────────────────────────────

    IStakingModule public immutable stakingModule;
    IERC20          public immutable governanceToken;
    address         public treasury;

    uint256 public proposalCount;
    uint256 public quorumBps;                                     // configurable quorum
    uint256 public approvalThresholdBps;                          // e.g. 6000 = 60%

    mapping(uint256 => SlashProposal)                public proposals;
    mapping(uint256 => mapping(address => bool))     public hasVoted;
    mapping(uint256 => mapping(address => uint256))  public voteWeight;

    // Trust score system
    mapping(address => uint256) public trustScore;
    mapping(address => uint256) public trustLastUpdated;
    mapping(address => uint256) public slashCount;
    mapping(address => uint256) public totalSlashed;

    // Dispute integration
    mapping(uint256 => uint256) public disputeToProposal;         // disputeId => proposalId
    mapping(address => bool)    public blacklisted;               // permanently banned stakers

    // ─────────────────────────────────────────────
    // Errors
    // ─────────────────────────────────────────────

    error InvalidTarget();
    error InvalidAmount();
    error ProposalNotFound();
    error AlreadyVoted();
    error VotingClosed();
    error VotingStillOpen();
    error NotApproved();
    error AlreadyExecuted();
    error ExecutionDelayNotMet();
    error InsufficientStake();
    error Blacklisted();
    error QuorumNotMet();
    error InvalidBps();
    error UnauthorizedDispute();

    // ─────────────────────────────────────────────
    // Constructor
    // ─────────────────────────────────────────────

    constructor(
        address _stakingModule,
        address _governanceToken,
        address _treasury,
        address _governance,
        address _guardian
    ) {
        require(_stakingModule    != address(0), "Zero staking");
        require(_governanceToken  != address(0), "Zero token");
        require(_treasury         != address(0), "Zero treasury");

        stakingModule    = IStakingModule(_stakingModule);
        governanceToken  = IERC20(_governanceToken);
        treasury         = _treasury;
        quorumBps        = 2_000;    // 20% default
        approvalThresholdBps = 6_000; // 60% default

        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(GOVERNANCE_ROLE,   _governance);
        _grantRole(GUARDIAN_ROLE,     _guardian);
    }

    // ─────────────────────────────────────────────
    // Propose Slash (DAO Vote Path)
    // ─────────────────────────────────────────────

    /**
     * @notice Propose a slash via DAO vote. Requires proposer to hold governance tokens.
     * @param target   Address to be slashed.
     * @param amount   Token amount to slash (0 = use bps).
     * @param bps      Slash percentage in basis points (used when amount == 0).
     * @param reason   Categorical reason for slashing.
     * @param evidence IPFS CID or on-chain evidence pointer.
     */
    function proposeSlash(
        address      target,
        uint256      amount,
        uint256      bps,
        SlashReason  reason,
        string calldata evidence
    ) external whenNotPaused returns (uint256 proposalId) {
        if (target == address(0))   revert InvalidTarget();
        if (blacklisted[target])    revert Blacklisted();

        uint256 stakedAmt = stakingModule.stakedBalance(target);
        if (stakedAmt == 0) revert InsufficientStake();

        // Resolve amount
        uint256 slashAmt = amount > 0 ? amount : (stakedAmt * bps) / PRECISION;
        if (slashAmt == 0 || slashAmt > stakedAmt) revert InvalidAmount();

        proposalId = ++proposalCount;

        proposals[proposalId] = SlashProposal({
            id:             proposalId,
            target:         target,
            amount:         slashAmt,
            reason:         reason,
            evidence:       evidence,
            proposer:       msg.sender,
            votesFor:       0,
            votesAgainst:   0,
            createdAt:      block.timestamp,
            executionDelay: EXECUTION_DELAY,
            state:          ProposalState.PENDING,
            executed:       false
        });

        emit SlashProposed(proposalId, target, slashAmt, reason);
    }

    // ─────────────────────────────────────────────
    // Vote
    // ─────────────────────────────────────────────

    /**
     * @notice Cast a vote on a pending slash proposal.
     *         Vote weight is proportional to governance token balance at call time.
     * @dev    For snapshot-based voting, override with off-chain snapshot integration.
     */
    function castVote(uint256 proposalId, bool support) external whenNotPaused {
        SlashProposal storage proposal = _getActiveProposal(proposalId);

        if (block.timestamp > proposal.createdAt + VOTE_DURATION) revert VotingClosed();
        if (hasVoted[proposalId][msg.sender]) revert AlreadyVoted();

        uint256 weight = governanceToken.balanceOf(msg.sender);
        require(weight > 0, "No voting power");

        hasVoted[proposalId][msg.sender]  = true;
        voteWeight[proposalId][msg.sender] = weight;

        if (support) {
            proposal.votesFor += weight;
        } else {
            proposal.votesAgainst += weight;
        }

        emit SlashVoteCast(proposalId, msg.sender, support, weight);
    }

    // ─────────────────────────────────────────────
    // Finalize Vote
    // ─────────────────────────────────────────────

    /**
     * @notice Finalize the vote after voting period ends.
     *         Transitions proposal to APPROVED or REJECTED.
     */
    function finalizeVote(uint256 proposalId) external {
        SlashProposal storage proposal = _getActiveProposal(proposalId);
        if (block.timestamp <= proposal.createdAt + VOTE_DURATION) revert VotingStillOpen();

        uint256 totalSupply    = governanceToken.totalSupply();
        uint256 totalVotes     = proposal.votesFor + proposal.votesAgainst;
        uint256 quorumRequired = (totalSupply * quorumBps) / PRECISION;

        if (totalVotes < quorumRequired) {
            proposal.state

---
**Payment/Reward:** `0xa32ca744f86a91eaf567e2be4902f64bc33c2813`

[Fred-Zhang83]

我可以来做这个（如果确实是有偿/悬赏任务的话）。为了对齐预期并尽快开始，麻烦确认几件事：

1. 悬赏/报酬金额与结算方式（是 GitHub Sponsors / Bounty 平台 / 直接转账？）
2. 验收标准（通过哪些测试/功能点算完成？）
3. 期望交付形式（PR 合并即算？还是需要 release/文档/示例？）

你补充以上信息后，我可以先给出实现方案与预计工期，然后直接开 PR 推进。

[dayi1000]

Bounty Application — DAO-Compatible Slashing Module

Who: NOX — AI smart contract developer specializing in DeFi security and DAO governance modules.

Deliverables:

• SlashingModule.sol with DAO vote and dispute-based slashing
• Integration with existing StakingModule
• Slashed(address, amount, reason) event emission
• Trust decay function (exponential decay over time since last slash)
• Full Hardhat test suite with edge cases
• NatSpec documentation

Architecture:

SlashingModule
├── slashByDAO(address, amount, reason) — onlyRole(DAO_ROLE)
├── slashByDispute(address, amount, disputeId) — onlyRole(ARBITRATOR_ROLE)
├── trustScore(address) → uint256 — decays toward max over time
└── Events: Slashed, TrustRestored

Timeline: 72 hours from assignment
Portfolio: https://t.me/NoxBaseBot (AI agent on Base)

Ready to start immediately.

[jeanmiliuiu-boop]

Can implement this DAO-compatible Slashing Module. Will create: 1. Slash by DAO vote function, 2. Integration with StakingModule, 3. Slashed event, 4. Trust decay function. Have Solidity/DAO experience. Please assign!